All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.sun.faces.web-facesconfig_1_1.xsd Maven / Gradle / Ivy

Go to download

Jakarta Faces defines an MVC framework for building user interfaces for web applications, including UI components, state management, event handing, input validation, page navigation, and support for internationalization and accessibility.

There is a newer version: 4.1.0
Show newest version





    
        
            faces config 1.1
        
    

    
        

    DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

    Copyright (c) 2010 Oracle and/or its affiliates. All rights reserved.

    The contents of this file are subject to the terms of either the GNU
    General Public License Version 2 only ("GPL") or the Common Development
    and Distribution License("CDDL") (collectively, the "License").  You
    may not use this file except in compliance with the License.  You can
    obtain a copy of the License at
    https://glassfish.java.net/public/CDDL+GPL_1_1.html
    or packager/legal/LICENSE.txt.  See the License for the specific
    language governing permissions and limitations under the License.

    When distributing the software, include this License Header Notice in each
    file and include the License file at packager/legal/LICENSE.txt.

    GPL Classpath Exception:
    Oracle designates this particular file as subject to the "Classpath"
    exception as provided by Oracle in the GPL Version 2 section of the License
    file that accompanied this code.

    Modifications:
    If applicable, add the following below the License Header, with the fields
    enclosed by brackets [] replaced by your own identifying information:
    "Portions Copyright [year] [name of copyright owner]"

    Contributor(s):
    If you wish your version of this file to be governed by only the CDDL or
    only the GPL Version 2, indicate your decision by adding "[Contributor]
    elects to include this software in this distribution under the [CDDL or GPL
    Version 2] license."  If you don't indicate a single choice of license, a
    recipient has the option to distribute your version of this file under
    either the CDDL, the GPL Version 2 or to extend the choice of license to
    its licensees as provided above.  However, if you add GPL Version 2 code
    and therefore, elected the GPL Version 2 license, then the option applies
    only if the new code is made subject to such option by the copyright
    holder.

        
    

    
        

            

        
    

    

    

    
        
            

                The "faces-config" element is the root of the configuration
                information hierarchy, and contains nested elements for all
                of the other configuration settings.

            
        

        
            
                

                    Converter IDs must be unique within a document.

                
            

            
            
        

        
            
                

                    'converter-for-class' element values must be unique
                    within a document.

                
            

            
            
        

        
            
                

                    Validator IDs must be unique within a document.

                
            

            
            
        

        
            
                

                    Managed bean names must be unique within a document.

                
            

            
            
        
    

    

    
        
            

                The "faces-config" element is the root of the configuration
                information hierarchy, and contains nested elements for all
                of the other configuration settings.

            
        
        
            
            
            
            
            
            
            
            
            
            
            
        
            
            
    

    

    
        
            

                Extension element for faces-config.  It may contain
                implementation specific content.

            
        

        
            
         
         
    


    

    
        
            

                The "application" element provides a mechanism to define the
                various per-application-singleton implementation artifacts for
                a particular web application that is utilizing 
                JavaServer Faces.  For nested elements that are not specified, 
                the JSF implementation must provide a suitable default.

            
        

        
            
                
                    
                            
                            The "action-listener" element contains the fully 
                            qualified class name of the concrete 
                            ActionListener implementation class that will be 
                            called during the Invoke Application phase of the 
                            request processing lifecycle.
                            
                    
                
            
            
                
                    
                            
                            The "default-render-kit-id" element allows the 
                            application to define a renderkit to be used other 
                            than the standard one. 
                            
                    
                
            
            
                
                    
                            
                            The base name of a resource bundle representing 
                            the message resources for this application.  See 
                            the JavaDocs for the "java.util.ResourceBundle" 
                            class for more information on the syntax of 
                            resource bundle names.
                            
                    
                
            
            
                
                    
                            
                            The "navigation-handler" element contains the 
                            fully qualified class name of the concrete 
                            NavigationHandler implementation class that will 
                            be called during the Invoke Application phase 
                            of the request processing lifecycle, if the 
                            default ActionListener (provided by the JSF 
                            implementation) is used.
                            
                    
                
            
            
                
                    
                            
                            The "view-handler" element contains the fully 
                            qualified class name of the concrete ViewHandler 
                            implementation class that will be called during 
                            the Restore View and Render Response phases of the 
                            request processing lifecycle.  The faces 
                            implementation must provide a default 
                            implementation of this class.
                            
                    
                
            
            
                
                    
                            
                            The "state-manager" element contains the fully 
                            qualified class name of the concrete StateManager 
                            implementation class that will be called during 
                            the Restore View and Render Response phases of the 
                            request processing lifecycle.  The faces 
                            implementation must provide a default 
                            implementation of this class.
                            
                    
                
            
            
                
                    
                            
                            The "el-resolver" element contains the fully
                            qualified class name of the concrete
                            javax.el.ELResolver implementation class
                            that will be used during the processing of
                            EL expressions.
                            
                    
                
            
            
                
                    
                            
                            The "property-resolver" element contains the fully 
                            qualified class name of the concrete 
                            PropertyResolver implementation class that will 
                            be used during the processing of value binding 
                            expressions.
                            
                    
                
            
            
                
                    

                            The "variable-resolver" element contains the fully
                            qualified class name of the concrete 
                            VariableResolver implementation class that will 
                            be used during the processing of value binding 
                            expressions.

                    
                
            
            

            
            
        
       

    

    
        
            

                Extension element for application.  It may contain
                implementation specific content.

            
        

        
            
         
         
    


    

    
        
            

                The "factory" element provides a mechanism to define the 
                various Factories that comprise parts of the implementation 
                of JavaServer Faces.  For nested elements that are not 
                specified, the JSF implementation must provide a suitable 
                default.

            
        

        
            
                
                    
                            
                        The "application-factory" element contains the 
                        fully qualified class name of the concrete 
                        ApplicationFactory implementation class that will 
                        be called when 
                        FactoryFinder.getFactory(APPLICATION_FACTORY) is
                        called.
                            
                    
                
            
            
                
                    
                            
                        The "faces-context-factory" element contains the
                        fully qualified class name of the concrete
                        FacesContextFactory implementation class that will
                        be called when 
                        FactoryFinder.getFactory(FACES_CONTEXT_FACTORY) 
                        is called.
                            
                    
                
            
            
                
                    
                            
                        The "lifecycle-factory" element contains the fully
                        qualified class name of the concrete LifecycleFactory
                        implementation class that will be called when
                        FactoryFinder.getFactory(LIFECYCLE_FACTORY) is called.
                            
                    
                
            
            
                
                    

                        The "render-kit-factory" element contains the fully
                        qualified class name of the concrete RenderKitFactory
                        implementation class that will be called when
                        FactoryFinder.getFactory(RENDER_KIT_FACTORY) is 
                        called.

                    
                
            
            
        
        
    

    

    
        
            

                Extension element for factory.  It may contain
                implementation specific content.

            
        

        
            
         
         
    


    

    
        
            

                The "attribute" element represents a named, typed, value
                associated with the parent UIComponent via the generic
                attributes mechanism.

                Attribute names must be unique within the scope of the parent
                (or related) component.

            
        

        
            
            
                
                    
                        
                        The "attribute-name" element represents the name under 
                        which the corresponding value will be stored, in the 
                        generic attributes of the UIComponent we are related 
                        to.
                        
                    
                
            
            
                
                    

                        The "attribute-class" element represents the Java type
                        of the value associated with this attribute name.

                    
                
            
            
            
            
        
        
    

    

    
        
            

                Extension element for attribute.  It may contain 
                implementation specific content.

            
        

        
            
         
         
    

    

    
        
            

                The "component" element represents a concrete UIComponent
                implementation class that should be registered under the
                specified type identifier, along with its associated 
                properties and attributes.  Component types must be unique 
                within the entire web application.

                Nested "attribute" elements identify generic attributes that 
                are recognized by the implementation logic of this component.
                Nested "property" elements identify JavaBeans properties of 
                the component class that may be exposed for manipulation 
                via tools.

            
        

        
            
            
                
                    
                        
                        The "component-type" element represents the name under 
                        which the corresponding UIComponent class should be 
                        registered.
                        
                    
                
            
            
                
                    
                        
                        The "component-class" element represents the fully 
                        qualified class name of a concrete UIComponent 
                        implementation class.
                        
                    
                
            
            
            
            
            
        
        
    

    

    
        
            
                Extension element for component.  It may contain 
                implementation specific content.
            
        

        
            
         
         
    

    

    
        
            

                The "default-locale" element declares the default locale 
                for this application instance.

                It must be specified as :language:[_:country:[_:variant:]]
                without the colons, for example "ja_JP_SJIS".  The
                separators between the segments may be '-' or '_'.

            
        
        
            
                                
            
        
    

    


    
        
            

                The "default-value" contains the value for the property or
                attribute in which this element resides.  This value differs
                from the "suggested-value" in that the property or attribute
                must take the value, whereas in "suggested-value" taking the
                value is optional.

            
        
        
            
        
    

    

    
        
            

                EL expressions present within a faces config file
                must start with the character sequence of '#{' and
                end with '}'.

            
        
        
            
        
    

    

    
        
            

                Define the name and other design-time information for a facet
                that is associated with a renderer or a component.

            
        

        
            
            
                
                    

                        The "facet-name" element represents the facet name 
                        under which a UIComponent will be added to its parent.  
                        It must be of type "Identifier".

                    
                
            
            
        
        
    

    

    
         
            

                Extension element for facet.  It may contain implementation
                specific content.

            
        

        
            
         
         
    

    

    
        
            

                The value of from-view-id must contain one of the following 
                values:

                  - The exact match for a view identifier that is recognized
                    by the the ViewHandler implementation being used (such as
                    "/index.jsp" if you are using the default ViewHandler).

                  - A proper prefix of a view identifier, plus a trailing 
                    "*" character.  This pattern indicates that all view 
                    identifiers that match the portion of the pattern up to 
                    the asterisk will match the surrounding rule.  When more 
                    than one match exists, the match with the longest pattern 
                    is selected.

                  - An "*" character, which means that this pattern applies 
                    to all view identifiers.

            
        
        
            
        
    

    

    
        
            

                The "from-action" element contains an action reference 
                expression that must have been executed (by the default 
                ActionListener for handling application level events) 
                in order to select the navigation rule.  If not specified, 
                this rule will be relevant no matter which action reference 
                was executed (or if no action reference was executed).

            
        
        
            
                
            
        
    

    

    
        
            

                The "converter" element represents a concrete Converter
                implementation class that should be registered under the
                specified converter identifier.  Converter identifiers must 
                be unique within the entire web application.

                Nested "attribute" elements identify generic attributes that
                may be configured on the corresponding UIComponent in order 
                to affect the operation of the Converter.  Nested "property"
                elements identify JavaBeans properties of the Converter
                implementation class that may be configured to affect the
                operation of the Converter.  "attribute" and "property" 
                elements are intended to allow component developers to 
                more completely describe their components to tools and users.
                These elements have no required runtime semantics.

            
        

        
            
            
                
                    
                        

                            The "converter-id" element represents the 
                            identifier under which the corresponding 
                            Converter class should be registered.

                        
                    
                
                
                
                    
                        

                            The "converter-for-class" element represents the 
                            fully qualified class name for which a Converter 
                            class will be registered.

                        
                    
                
            
            
            
                
                    

                        The "converter-class" element represents the fully
                        qualified class name of a concrete Converter 
                        implementation class.

                    
                
            
            
                
                    

                       Nested "attribute" elements identify generic
                       attributes that may be configured on the
                       corresponding UIComponent in order to affect the
                       operation of the Converter.  This attribute is
                       primarily for design-time tools and is not
                       specified to have any meaning at runtime.

                    
                
            
            
                
                    

                       Nested "property" elements identify JavaBeans
                       properties of the Converter implementation class
                       that may be configured to affect the operation of
                       the Converter.  This attribute is primarily for
                       design-time tools and is not specified to have
                       any meaning at runtime.

                    
                
            
            
        
        
    

    

    
        
            

                Extension element for converter.  It may contain
                implementation specific content.

            
        

        
            
         
         
    



    

    
        
            
                
                The "lifecycle" element provides a mechanism to specify
                modifications to the behaviour of the default Lifecycle
                implementation for this web application.
                
            
        

        
            
                
                
                    
                    
                        The "phase-listener" element contains the fully 
                        qualified class name of the concrete PhaseListener 
                        implementation class that will be registered on 
                        the Lifecycle.
                    
                    
                            
            
            

        
        

    

    

    
        
            

                Extension element for lifecycle.  It may contain
                implementation specific content.

            
        

        
            
         
         
    

    
    
    
    
        
            

                The localeType defines valid locale defined by ISO-639-1
                and ISO-3166.

            
        

        
            
        
  

    

    
        
            

                The "locale-config" element allows the app developer to 
                declare the supported locales for this application.

            
        
        
        
            
            
                            
            
        
        
    

    

    
        
            
                
                The "managed-bean" element represents a JavaBean, of a 
                particular class, that will be dynamically instantiated 
                at runtime (by the default VariableResolver implementation) 
                if it is referenced as the first element of a value binding 
                expression, and no corresponding bean can be identified in 
                any scope.  In addition to the creation of the managed bean, 
                and the optional storing of it into the specified scope, 
                the nested managed-property elements can be used to 
                initialize the contents of settable JavaBeans properties of 
                the created instance.
                
            
        

        
            
            
                
                    

                        The "managed-bean-name" element represents the 
                        attribute name under which a managed bean will 
                        be searched for, as well as stored (unless the 
                        "managed-bean-scope" value is "none").

                    
                
            
            
                
                    

                        The "managed-bean-class" element represents the fully
                        qualified class name of the Java class that will be 
                        used`to instantiate a new instance if creation of the 
                        specified`managed bean is requested.

                        The specified class must conform to standard JavaBeans
                        conventions.  In particular, it must have a public
                        zero-arguments constructor, and zero or more public
                        property setters.

                    
                
            
            
                
                    

                        The "managed-bean-scope" element represents the scope 
                        into which a newly created instance of the specified 
                        managed bean will be stored (unless the value is 
                        "none").

                    
                
            
            
                
                
                
            
            
        
        
    

    

    
        
            

                Extension element for managed-bean.  It may contain
                implementation specific content.

            
        

        
            
         
         
    


    
    
    
        
            

                
                element's body content, which includes all of the scopes
                normally used in a web application, plus the "none" value
                indicating that a created bean should not be stored into
                any scope.
                ]]>

            
        

        
            
                
                
                
                
            
        
    

    

    
        
            
                
                The "managed-property" element represents an individual 
                property of a managed bean that will be configured to the 
                specified value (or value set) if the corresponding 
                managed bean is automatically created.
                
            
        
        
            
            
                
                    
                        
                        The "property-name" element represents the JavaBeans 
                        property name under which the corresponding value may 
                        be stored.
                        
                    
                
            
            
                
                    
                    
                        The "property-class" element represents the Java type 
                        of the value associated with this property name.  
                        If not specified, it can be inferred from existing 
                        classes; however, this element should be specified 
                        if the configuration file is going to be the source 
                        for generating the corresponding classes.
                        
                    
                
            
            
                
                
                
                
                
            
        
        
    

    

    
        
            
                
                The "map-entry" element reprsents a single key-entry pair 
                that will be added to the computed value of a managed 
                property of type java.util.Map.
                
            
        
        
            
                
                    

                        The "key" element is the String representation of a 
                        map key that will be stored in a managed property of 
                        type java.util.Map.

                    
                
            
            
                
                
            
        
        
    

    

    
        
            
                
                The "map-entries' element represents a set of key-entry pairs 
                that will be added to the computed value of a managed property 
                of type java.util.Map.  In addition, the Java class types 
                of the key and entry values may be optionally declared.
                
            
        

        
            
                
                    
                        
                        The "key-class" element defines the Java type to which 
                        each "key" element in a set of "map-entry" elements 
                        will be converted to.  If omitted, "java.lang.String" 
                        is assumed.
                        
                    
                
            
                            
            
        
        
    

    

    
        
            
                
                The "navigation-case" element describes a particular 
                combination of conditions that must match for this case to 
                be executed, and the view id of the component tree that 
                should be selected next.
                
            
        
        
            
            
            
            
                
                    

                        The "from-outcome" element contains a logical outcome
                        string returned by the execution of an application
                        action method selected via an "actionRef" property
                        (or a literal value specified by an "action" property)
                        of a UICommand component.  If specified, this rule 
                        will be relevant only if the outcome value matches 
                        this element's value.  If not specified, this rule 
                        will be relevant no matter what the outcome value was.

                    
                
            
            
                
                    

                        The "to-view-id" element contains the view identifier 
                        of the next view that should be displayed if this
                        navigation rule is matched.

                    
                
            
            
        
        
    

    

    
        
            

                The "navigation-rule" element represents an individual 
                decision rule that will be utilized by the default 
                NavigationHandler implementation to make decisions on 
                what view should be displayed next, based on the 
                view id being processed.

            
        
        
            
            
            
            
        
        
    

    

    
        
            

                Extension element for navigation-rule.  It may contain
                implementation specific content.

            
        

        
            
         
         
    


    

    
        
            

                The "null-value" element indicates that the managed
                property in which we are nested will be explicitly
                set to null if our managed bean is automatically
                created.  This is different from omitting the managed
                property element entirely, which will cause no
                property setter to be called for this property.

                The "null-value" element can only be used when the
                associated "property-class" identifies a Java class,
                not a Java primitive.

            
        
        
    
    
    

    
        
            
                
                The "property" element represents a JavaBean property of the 
                Java class represented by our parent element.

                Property names must be unique within the scope of the Java 
                class that is represented by the parent element, and must 
                correspond to property names that will be recognized when 
                performing introspection against that class via 
                java.beans.Introspector.
                
            
        
        
            
            
                
                    
                        
                        The "property-name" element represents the JavaBeans 
                        property name under which the corresponding value 
                        may be stored.
                        
                    
                
            
            
                
                    
                        
                        The "property-class" element represents the Java type 
                        of the value associated with this property name.  
                        If not specified, it can be inferred from existing 
                        classes; however, this element should be specified if 
                        the configuration file is going to be the source for 
                        generating the corresponding classes.
                        
                    
                
            
                           
            
            
        
        

    

    

    
        
            

                Extension element for property.  It may contain 
                implementation specific content.

            
        

        
            
         
         
    

    

    
        
            

                    The "redirect" element indicates that navigation to the
                    specified "to-view-id" should be accomplished by 
                    performing an HTTP redirect rather than the usual 
                    ViewHandler mechanisms.

            
        
        
    

    

    
        
            
                
                The "referenced-bean" element represents at design time the 
                promise that a Java object of the specified type will exist at 
                runtime in some scope, under the specified key.  This can be 
                used by design time tools to construct user interface dialogs 
                based on the properties of the specified class.  The presence 
                or absence of a referenced bean element has no impact on the 
                JavaServer Faces runtime environment inside a web application.
                
            
        
        
            
            
                
                    
                        
                        The "referenced-bean-name" element represents the 
                        attribute name under which the corresponding 
                        referenced bean may be assumed to be stored, in one 
                        of 'request', 'session', or 'application' scopes.
                        
                    
                
            
            
                
                    

                        The "referenced-bean-class" element represents the 
                        fully qualified class name of the Java class 
                        (either abstract or concrete) or Java interface 
                        implemented by the corresponding referenced bean. 

                    
                
            
        
        
    

    

    
        
            
                
                The "render-kit" element represents a concrete RenderKit 
                implementation that should be registered under the specified 
                render-kit-id.  If no render-kit-id is specified, the 
                identifier of the default RenderKit 
                (RenderKitFactory.DEFAULT_RENDER_KIT) is assumed.
                
            
        
        
        
            
            
                
                    
                        
                        The "render-kit-id" element represents an identifier 
                        for the RenderKit represented by the parent 
                        "render-kit" element.
                        
                    
                
            
            
                
                    
                        
                        The "render-kit-class" element represents the fully 
                        qualified class name of a concrete RenderKit 
                        implementation class.
                        
                    
                
            
            
            
        
        
    

    

    
        
            
                
                The "renderer" element represents a concrete Renderer 
                implementation class that should be registered under the 
                specified component family and renderer type identifiers, 
                in the RenderKit associated with the parent "render-kit" 
                element.  Combinations of component family and 
                renderer type must be unique within the RenderKit 
                associated with the parent "render-kit" element.

                Nested "attribute" elements identify generic component 
                attributes that are recognized by this renderer.
                
            
        
        
        
            
            
                
                    
                        
                        The "component-family" element represents the 
                        component family for which the Renderer represented 
                        by the parent "renderer" element will be used.
                        
                    
                                    
            
            
                
                    
                        
                        The "renderer-type" element represents a renderer type 
                        identifier for the Renderer represented by the parent 
                        "renderer" element.
                        
                    
                
            
            
                
                    

                        The "renderer-class" element represents the fully
                        qualified class name of a concrete Renderer
                        implementation class.

                    
                
            
            
            
            
        
        
    

    

    
        
            

                Extension element for renderer.  It may contain implementation
                specific content.

            
        

        
            
         
         
    

    

    
        
            

                Extension element for render-kit.  It may contain
                implementation specific content.

            
        

        
            
         
         
    


    

    
        
            

                The "suggested-value" contains the value for the property or
                attribute in which this element resides.  This value is 
                advisory only and is intended for tools to use when 
                populating pallettes.

            
        
        
            
        
    

    

    
        
            

                The "supported-locale" element allows authors to declare
                which locales are supported in this application instance.

                It must be specified as :language:[_:country:[_:variant:]]
                without the colons, for example "ja_JP_SJIS".  The
                separators between the segments may be '-' or '_'.

            
        
        
            
                 
            
        
    

    

    
        
            

                The "validator" element represents a concrete Validator
                implementation class that should be registered under the
                specified validator identifier.  Validator identifiers must 
                be unique within the entire web application.

                Nested "attribute" elements identify generic attributes that 
                may be configured on the corresponding UIComponent in order 
                to affect the operation of the Validator.  Nested "property"
                elements identify JavaBeans properties of the Validator
                implementation class that may be configured to affect the
                operation of the Validator.  "attribute" and "property" 
                elements are intended to allow component developers to 
                more completely describe their components to tools and users.
                These elements have no required runtime semantics.

            
        
        
            
            
                
                    
                        
                        The "validator-id" element represents the identifier 
                        under which the corresponding Validator class should 
                        be registered.
                        
                    
                                
            
            
                
                    
                        
                        The "validator-class" element represents the fully 
                        qualified class name of a concrete Validator 
                        implementation class.  
                        
                    
                
            
            
                
                    
                        
                       Nested "attribute" elements identify generic
                       attributes that may be configured on the
                       corresponding UIComponent in order to affect the
                       operation of the Validator.  This attribute is
                       primarily for design-time tools and is not
                       specified to have any meaning at runtime.

                    
                

            
            
                
                    

                       Nested "property" elements identify JavaBeans
                       properties of the Validator implementation class
                       that may be configured to affect the operation of
                       the Validator.  This attribute is primarily for
                       design-time tools and is not specified to have
                       any meaning at runtime.

                    
                
            
            
        
        
    

    

    
        
            

                Extension element for validator.  It may contain
                implementation specific content.

            
        

        
            
         
         
    

    

    
        
            

                The "value" element is the String representation of
                a literal value to which a scalar managed property
                will be set, or a value binding expression ("#{...}")
                that will be used to calculate the required value.
                It will be converted as specified for the actual
                property type.

            
        
        
    
    
    
    
    
        
            
                
                The "value-class" element defines the Java type to which each
                "value" element's value will be converted to, prior to adding 
                it to the "list-entries" list for a managed property that is 
                a java.util.List, or a "map-entries" map for a managed 
                property that is a java.util.Map.  
                
            
        
        
            
        
    

    

    
        
            
                
                The "list-entries" element represents a set of initialization
                elements for a managed property that is a java.util.List or an
                array.  In the former case, the "value-class" element can 
                optionally be used to declare the Java type to which each 
                value should be converted before adding it to the Collection.
                
            
        
        
            
            
                
                
            
        
        
    

    

    
        
            

                This type contains the recognized versions of
                faces-config supported.

            
        
        
            
        
    

    






© 2015 - 2024 Weber Informatics LLC | Privacy Policy