Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## javax.faces.webapp
Class UIComponentClassicTagBase

    java.lang.Object
      javax.faces.webapp.UIComponentTagBase
          javax.faces.webapp.UIComponentClassicTagBase

All Implemented Interfaces:
  javax.servlet.jsp.tagext.BodyTag, javax.servlet.jsp.tagext.IterationTag, javax.servlet.jsp.tagext.JspIdConsumer, javax.servlet.jsp.tagext.JspTag, javax.servlet.jsp.tagext.Tag

Direct Known Subclasses:
  UIComponentELTag, UIComponentTag

    public abstract class UIComponentClassicTagBase

extends UIComponentTagBase
implements javax.servlet.jsp.tagext.JspIdConsumer, javax.servlet.jsp.tagext.BodyTag

`UIComponentTagBase` is the base class for all JSP tags that use the "classic" JSP tag interface that correspond to a `UIComponent` instance in the view. In Faces 1.2, all component tags are `BodyTag` instances to allow for the execution of the page to build the component tree, but not render it. Rendering happens only after the component tree is completely built.

`UIComponentTag` extends `UIComponentClassicTagBase` to add support for properties that conform to the Faces 1.1 EL.

`UIComponentELTag` extends `UIComponentClassicTagBase` class to add support for properties that conform to the EL API.

The default implementation allows the proper interweaving of template text, non-Faces JSP tag output, and Faces component tag output in the same page, as expected by the page author.

The CASE markers in the following example will be cited in the method descriptions of this class.

- CASE 1 describes template text and/or non-component custom tag output occurring as the child of a component tag, but before the first component tag child of that component tag.

- CASE 2 describes template text and/or non-component custom tag output occurring between two sibling component tags.

- CASE 3 describes template text and/or non-component custom tag output occurring as the child content of an <f:verbatim> tag at any point in the page.

- CASE 4 describes template text and/or non-component custom tag output occurring between the last child component tag and its enclosing parent component tag's end tag.

`

     <h:panelGrid style="color:red" border="4" columns="2">
     CASE 1
     <h:outputText value="component 1"/>
     CASE 2
     <h:outputText value="component 2"/>
     <f:verbatim>CASE 3</f:verbatim>
     <c:out value="${pageScope.CASE4}" />
     </h:panelGrid>

`

The preceding arrangement of faces component tags, must yield markup that will render identically to the following (assuming that `${pageScope.CASE4}` evaluates to "`CASE 4`" without the quotes).

`

     <table border="4" style="color:red">

     <tbody>

     <tr><td>CASE 1</td></tr> <tr><td>component 1</td></tr>

     <tr><td>CASE 2</td> <tr><td>component 2</td></tr>

     <tr><td>CASE 3</td> <td>CASE 4</td></tr>

     </tbody>

     </table>

`

Field Summary
`protected javax.servlet.jsp.tagext.BodyContent` | `bodyContent` The `bodyContent` for this tag handler.
`protected javax.servlet.jsp.PageContext` | `pageContext` The JSP `PageContext` for the page we are embedded in.
`protected static java.lang.String` | `UNIQUE_ID_PREFIX` Used as the prefix for ids.

Fields inherited from class javax.faces.webapp.UIComponentTagBase
`log`

Fields inherited from interface javax.servlet.jsp.tagext.BodyTag
`EVAL_BODY_BUFFERED, EVAL_BODY_TAG`

Fields inherited from interface javax.servlet.jsp.tagext.IterationTag
`EVAL_BODY_AGAIN`

Fields inherited from interface javax.servlet.jsp.tagext.Tag
`EVAL_BODY_INCLUDE, EVAL_PAGE, SKIP_BODY, SKIP_PAGE`

Constructor Summary
`UIComponentClassicTagBase()`

Method Summary
`protected void` | `addChild(UIComponent child)` Add the component identifier of the specified `UIComponent` to the list of component identifiers created or located by nested `UIComponentTag`s processing this request.
`protected void` | `addFacet(java.lang.String name)` Add the facet name of the specified facet to the list of facet names created or located by nested `UIComponentTag`s processing this request.
`protected void` | `addVerbatimAfterComponent(UIComponentClassicTagBase parentTag, UIComponent verbatim, UIComponent component)` Add verbatim as a sibling of component in component in the parent's child list.
`protected void` | `addVerbatimBeforeComponent(UIComponentClassicTagBase parentTag, UIComponent verbatim, UIComponent component)` Add verbatim as a sibling of component in component in the parent's child list.
`protected abstract UIComponent` | `createComponent(FacesContext context, java.lang.String newId)` Create and return a new child component of the type returned by calling `getComponentType()`.
`protected UIOutput` | `createVerbatimComponent()` Use the `Application` instance to create a new component with the following characteristics.
`protected UIComponent` | `createVerbatimComponentFromBodyContent()` Create a transient UIOutput component from the body content, of this tag instance or return null if there is no body content, the body content is whitespace, or the body content is a comment.
`int` | `doAfterBody()` Perform any processing necessary to handle the content implications of CASE 4 in the class description.
`int` | `doEndTag()` Perform any processing necessary to handle the content implications of CASE 3 in the class description.
`void` | `doInitBody()` Prepare for evaluation of the body.
`int` | `doStartTag()` Perform any processing necessary to find (or create) the `UIComponent` instance in the view corresponding to this tag instance in the page and, if and only if a component was created, insert it into the tree at the proper location as expected by the page author.
`protected void` | `encodeBegin()` Deprecated. No encoding is done during JSP page execution. Encoding is deferred until the page has completed executing to allow the entire tree to be built before any encoding occurs.
`protected void` | `encodeChildren()` Deprecated. No encoding is done during JSP page execution. Encoding is deferred until the page has completed executing to allow the entire tree to be built before any encoding occurs.
`protected void` | `encodeEnd()` Deprecated. No encoding is done during JSP page execution. Encoding is deferred until the page has completed executing to allow the entire tree to be built before any encoding occurs.
`protected UIComponent` | `findComponent(FacesContext context)` Find and return the `UIComponent`, from the component tree, that corresponds to this tag handler instance.
`javax.servlet.jsp.tagext.BodyContent` | `getBodyContent()`
`UIComponent` | `getComponentInstance()` Return the `UIComponent` instance that is associated with this tag instance.
`boolean` | `getCreated()` Return `true` if we dynamically created a new component instance during execution of this tag.
`protected java.util.List<java.lang.String>` | `getCreatedComponents()` Returns the `List` of `UIComponent` ids created or located by nested `UIComponentTag`s while processing the current request.
`protected int` | `getDoAfterBodyValue()` Return the flag value that should be returned from the `doAfterBody()` method when it is called.
`protected int` | `getDoEndValue()` Return the flag value that should be returned from the `doEnd()` method when it is called.
`protected int` | `getDoStartValue()` Return the flag value that should be returned from the `doStart()` method when it is called.
`protected FacesContext` | `getFacesContext()` Return the `FacesContext` instance for the current request.
`protected java.lang.String` | `getFacesJspId()` If this method has been called before on this tag's useful lifetime (before `release()` was called), return the previously returned value.
`protected java.lang.String` | `getFacetName()` Return the facet name that we should be stored under, if any; otherwise, return null (indicating that we will be a child component).
`protected java.lang.String` | `getId()` Return the `id` value assigned by the page author.
`protected int` | `getIndexOfNextChildTag()` Return the index of the next child to be added as a child of this tag.
`java.lang.String` | `getJspId()`
`javax.servlet.jsp.tagext.Tag` | `getParent()` Return the `Tag` that is the parent of this instance.
`static UIComponentClassicTagBase` | `getParentUIComponentClassicTagBase(javax.servlet.jsp.PageContext context)` Locate and return the nearest enclosing `UIComponentClassicTagBase` if any; otherwise, return `null`.
`javax.servlet.jsp.JspWriter` | `getPreviousOut()` Get the `JspWriter` from our `BodyContent`.
`protected abstract boolean` | `hasBinding()` Return `true` if this component has a non-`null` binding attribute.
`void` | `release()` Release any resources allocated during the execution of this tag handler.
`void` | `setBodyContent(javax.servlet.jsp.tagext.BodyContent bodyContent)` Set the `bodyContent` for this tag handler.
`void` | `setId(java.lang.String id)` Set the component identifier for our component.
`void` | `setJspId(java.lang.String id)` Defined on `JspIdConsumer`.
`void` | `setPageContext(javax.servlet.jsp.PageContext pageContext)` Set the `PageContext` of the page containing this tag instance.
`void` | `setParent(javax.servlet.jsp.tagext.Tag parent)` Set the `Tag` that is the parent of this instance.
`protected abstract void` | `setProperties(UIComponent component)` Override properties and attributes of the specified component, if the corresponding properties of this tag handler instance were explicitly set.
`protected void` | `setupResponseWriter()` Set up the `ResponseWriter` for the current response, if this has not been done already.

Methods inherited from class javax.faces.webapp.UIComponentTagBase
`getComponentType, getELContext, getRendererType`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### UNIQUE_ID_PREFIX

    protected static final java.lang.String UNIQUE_ID_PREFIX

  Used as the prefix for ids. This is necessary to avoid uniqueness conflicts with the transient verbatim components.

  See Also:
    Constant Field Values

### bodyContent

    protected javax.servlet.jsp.tagext.BodyContent bodyContent

  The `bodyContent` for this tag handler.

### pageContext

    protected javax.servlet.jsp.PageContext pageContext

  The JSP `PageContext` for the page we are embedded in.

Constructor Detail

### UIComponentClassicTagBase

    public UIComponentClassicTagBase()

Method Detail

### getDoStartValue

    protected int getDoStartValue()
                           throws javax.servlet.jsp.JspException

  Return the flag value that should be returned from the `doStart()` method when it is called. Subclasses may override this method to return the appropriate value.

  Throws:
    `javax.servlet.jsp.JspException` - to cause `doStart()` to throw an exception

### getDoEndValue

    protected int getDoEndValue()
                         throws javax.servlet.jsp.JspException

  Return the flag value that should be returned from the `doEnd()` method when it is called. Subclasses may override this method to return the appropriate value.

  Throws:
    `javax.servlet.jsp.JspException` - to cause `doEnd()` to throw an exception

### encodeBegin

    protected void encodeBegin()
                        throws java.io.IOException

  Deprecated. No encoding is done during JSP page execution. Encoding is deferred until the page has completed executing to allow the entire tree to be built before any encoding occurs.

  Delegate to the `encodeBegin()` method of our corresponding `UIComponent`. This method is called from `doStartTag()`. Normally, delegation occurs unconditionally; however, this method is abstracted out so that advanced tags can conditionally perform this call.

  Throws:
    `java.io.IOException` - if an input/output error occurs

### encodeChildren

    protected void encodeChildren()
                           throws java.io.IOException

  Deprecated. No encoding is done during JSP page execution. Encoding is deferred until the page has completed executing to allow the entire tree to be built before any encoding occurs.

  Delegate to the `encodeChildren()` method of our corresponding `UIComponent`. This method is called from `doStartTag()`. Normally, delegation occurs unconditionally; however, this method is abstracted out so that advanced tags can conditionally perform this call.

  Throws:
    `java.io.IOException` - if an input/output error occurs

### encodeEnd

    protected void encodeEnd()
                      throws java.io.IOException

  Deprecated. No encoding is done during JSP page execution. Encoding is deferred until the page has completed executing to allow the entire tree to be built before any encoding occurs.

  Delegate to the `encodeEnd()` method of our corresponding `UIComponent`. This method is called from `doStartTag()`. Normally, delegation occurs unconditionally; however, this method is abstracted out so that advanced tags can conditionally perform this call.

  Throws:
    `java.io.IOException` - if an input/output error occurs

### setPageContext

    public void setPageContext(javax.servlet.jsp.PageContext pageContext)

  Set the `PageContext` of the page containing this tag instance.

  Specified by:
    `setPageContext` in interface `javax.servlet.jsp.tagext.Tag`
  Parameters:
    `pageContext` - The enclosing `PageContext`

### getParent

    public javax.servlet.jsp.tagext.Tag getParent()

  Return the `Tag` that is the parent of this instance.

  Specified by:
    `getParent` in interface `javax.servlet.jsp.tagext.Tag`

### setParent

    public void setParent(javax.servlet.jsp.tagext.Tag parent)

  Set the `Tag` that is the parent of this instance.

  Specified by:
    `setParent` in interface `javax.servlet.jsp.tagext.Tag`
  Parameters:
    `parent` - The new parent `Tag`

### setupResponseWriter

    protected void setupResponseWriter()

  Set up the `ResponseWriter` for the current response, if this has not been done already.

  @deprecated. `ViewHandler.renderView(javax.faces.context.FacesContext, javax.faces.component.UIViewRoot)` is now responsible for setting up the response writer. This method is now a no-op.

### findComponent

    protected UIComponent findComponent(FacesContext context)
                                 throws javax.servlet.jsp.JspException

  Find and return the `UIComponent`, from the component tree, that corresponds to this tag handler instance. If there is no such `UIComponent`, create one and add it as a child or facet of the `UIComponent` associated with our nearest enclosing `UIComponentTag`. The process for locating or creating the component is:

  1. If we have previously located this component, return it.
  2. Locate the parent component by looking for a parent `UIComponentTag` instance, and ask it for its component. If there is no parent `UIComponentTag` instance, this tag represents the root component, so get it from the current `Tree` and return it.
  3. If this `UIComponentTag` instance has the `facetName` attribute set, ask the parent `UIComponent` for a facet with this name. If not found, create one, call `setProperties()` with the new component as a parameter, and register it under this name. Return the found or created facet `UIComponent`.
  4. Determine the component id to be assigned to the new component, as follows: if this `UIComponentTag` has an `id` attribute set, use that value; otherwise, generate an identifier that is guaranteed to be the same for this `UIComponent` every time this page is processed (i.e. one based on the location of all `UIComponentTag` instances without an `id` attribute set).
  5. Ask the parent `UIComponent` for a child with this identifier. If not found, create one, call `setProperties()` with the new component as a parameter, and register it as a child with this identifier. Return the found or created child `UIComponent`.

  When creating a component, the process is:

  1. Retrieve the component type by calling `UIComponentTagBase.getComponentType()`
  2. If the component has a `binding` attribute, create an expression from it, and call `Application.createComponent(java.lang.String)` with that expression, the `FacesContext`, and the component type. Store the expression using the key `"binding"`.
  3. Otherwise, call `Application.createComponent(java.lang.String)` with only the component type.
  4. Call `setProperties()`.
  5. Add the new component as a child or facet of its parent

  Throws:
    `javax.servlet.jsp.JspException`

### getParentUIComponentClassicTagBase

    public static UIComponentClassicTagBase getParentUIComponentClassicTagBase(javax.servlet.jsp.PageContext context)

  Locate and return the nearest enclosing `UIComponentClassicTagBase` if any; otherwise, return `null`.

  Parameters:
    `context` - `PageContext` for the current page

### getIndexOfNextChildTag

    protected int getIndexOfNextChildTag()

  Description copied from class: `UIComponentTagBase`

  Return the index of the next child to be added as a child of this tag. The default implementation maintains a list of created components and returns the size of the list.

  Specified by:
    `getIndexOfNextChildTag` in class `UIComponentTagBase`

### addChild

    protected void addChild(UIComponent child)

  Description copied from class: `UIComponentTagBase`

  Add the component identifier of the specified `UIComponent` to the list of component identifiers created or located by nested `UIComponentTag`s processing this request.

  Specified by:
    `addChild` in class `UIComponentTagBase`
  Parameters:
    `child` - New child whose identifier should be added

### addFacet

    protected void addFacet(java.lang.String name)

  Description copied from class: `UIComponentTagBase`

  Add the facet name of the specified facet to the list of facet names created or located by nested `UIComponentTag`s processing this request.

  Specified by:
    `addFacet` in class `UIComponentTagBase`
  Parameters:
    `name` - Facet name to be added

### createVerbatimComponentFromBodyContent

    protected UIComponent createVerbatimComponentFromBodyContent()

  Create a transient UIOutput component from the body content, of this tag instance or return null if there is no body content, the body content is whitespace, or the body content is a comment.

### createVerbatimComponent

    protected UIOutput createVerbatimComponent()

  Use the `Application` instance to create a new component with the following characteristics.

  `componentType` is `javax.faces.HtmlOutputText`.

  `transient` is `true`.

  `escape` is `false`.

  `id` is `FacesContext.getViewRoot().createUniqueId()`

### addVerbatimBeforeComponent

    protected void addVerbatimBeforeComponent(UIComponentClassicTagBase parentTag,
                                              UIComponent verbatim,
                                              UIComponent component)

  Add verbatim as a sibling of component in component in the parent's child list. verbatim is added to the list at the position immediatly preceding component.

### addVerbatimAfterComponent

    protected void addVerbatimAfterComponent(UIComponentClassicTagBase parentTag,
                                             UIComponent verbatim,
                                             UIComponent component)

  Add verbatim as a sibling of component in component in the parent's child list. verbatim is added to the list at the position immediatly following component.

### doStartTag

    public int doStartTag()
                   throws javax.servlet.jsp.JspException

  Perform any processing necessary to find (or create) the `UIComponent` instance in the view corresponding to this tag instance in the page and, if and only if a component was created, insert it into the tree at the proper location as expected by the page author. Secondarily, cause a transient `UIOutput` component to be created and placed in the tree before the `UIComponent` instance for this tag. The value of this `UIOutput` component must include anything covered by `CASE 1` or `CASE 2` in the class description.

  The default implementation, which is intended to be sufficient for most components, implements this secondary requirement by calling `getParentUIComponentClassicTagBase(javax.servlet.jsp.PageContext)`, and calling `createVerbatimComponentFromBodyContent()` on the result. It then adds the returned component to the tree before the actual component for this tag instance instance by calling `addVerbatimBeforeComponent(javax.faces.webapp.UIComponentClassicTagBase, javax.faces.component.UIComponent, javax.faces.component.UIComponent)`.

  Before returning, the component is pushed onto the component stack for this response to enable the `getParentUIComponentClassicTagBase(javax.servlet.jsp.PageContext)` method to work properly.

  The flag value to be returned is acquired by calling the `getDoStartValue()` method, which tag subclasses may override if they do not want the default value.

  Specified by:
    `doStartTag` in interface `javax.servlet.jsp.tagext.Tag`
  Throws:
    `javax.servlet.jsp.JspException` - if an error occurs

### doEndTag

    public int doEndTag()
                 throws javax.servlet.jsp.JspException

  Perform any processing necessary to handle the content implications of CASE 3 in the class description.

  The default implementation, which is intended to be sufficient for most components, calls `createVerbatimComponentFromBodyContent()` on this instance and adds it as a child of the component for this tag's component at the end of the child list. In addition, the following housekeeping steps are taken.

  - Retrieve from the `UIComponent` the set of component ids of child components created by `UIComponentTag` instances the last time this page was processed (if any). Compare it to the list of children created during this page processing pass, and remove all children present in the old list but not the new. Save the new list as a component attribute so that it gets saved as part of the component's state.
  - Retrieve from the `UIComponent` the set of facet names of facets created by `UIComponentTag` instances the last time this page was processed (if any). Compare it to the list of facets created during this page processing pass, and remove all facets present in the old list but not the new. Save the new list as a component attribute so that it gets saved as part of the component's state.
  - Release all references to the component, and pop it from the component stack for this response, removing the stack if this was the outermost component.

  The flag value to be returned is acquired by calling the `getDoEndValue()` method, which tag subclasses may override if they do not want the default value.

  Specified by:
    `doEndTag` in interface `javax.servlet.jsp.tagext.Tag`
  Throws:
    `javax.servlet.jsp.JspException` - if an error occurs

### release

    public void release()

  Release any resources allocated during the execution of this tag handler.

  Specified by:
    `release` in interface `javax.servlet.jsp.tagext.Tag`

### getDoAfterBodyValue

    protected int getDoAfterBodyValue()
                               throws javax.servlet.jsp.JspException

  Return the flag value that should be returned from the `doAfterBody()` method when it is called. Subclasses may override this method to return the appropriate value.

  Throws:
    `javax.servlet.jsp.JspException`

### setBodyContent

    public void setBodyContent(javax.servlet.jsp.tagext.BodyContent bodyContent)

  Set the `bodyContent` for this tag handler. This method is invoked by the JSP page implementation object at most once per action invocation, before `doInitiBody()`. This method will not be invoked for empty tags or for non-empty tags whose `doStartTag()` method returns `SKIP_BODY` or `EVAL_BODY_INCLUDE`.

  Specified by:
    `setBodyContent` in interface `javax.servlet.jsp.tagext.BodyTag`
  Parameters:
    `bodyContent` - The new `BodyContent` for this tag

### getPreviousOut

    public javax.servlet.jsp.JspWriter getPreviousOut()

  Get the `JspWriter` from our `BodyContent`.

### getBodyContent

    public javax.servlet.jsp.tagext.BodyContent getBodyContent()

### doInitBody

    public void doInitBody()
                    throws javax.servlet.jsp.JspException

  Prepare for evaluation of the body. This method is invoked by the JSP page implementation object after `setBodyContent()` and before the first time the body is to be evaluated. This method will not be invoked for empty tags or for non-empty tags whose `doStartTag()` method returns `SKIP_BODY` or `EVAL_BODY_INCLUDE`.

  Specified by:
    `doInitBody` in interface `javax.servlet.jsp.tagext.BodyTag`
  Throws:
    `javax.servlet.jsp.JspException` - if an error is encountered

### doAfterBody

    public int doAfterBody()
                    throws javax.servlet.jsp.JspException

  Perform any processing necessary to handle the content implications of CASE 4 in the class description.

  Return result from `getDoAfterBodyValue()`

  Specified by:
    `doAfterBody` in interface `javax.servlet.jsp.tagext.IterationTag`
  Throws:
    `javax.servlet.jsp.JspException` - if an error is encountered

### setId

    public void setId(java.lang.String id)

  Set the component identifier for our component. If the argument begins with `UIViewRoot.UNIQUE_ID_PREFIX` throw an `IllegalArgumentException`

  Specified by:
    `setId` in class `UIComponentTagBase`
  Parameters:
    `id` - The new component identifier. This may not start with `UIViewRoot.UNIQUE_ID_PREFIX`.
  Throws:
    `java.lang.IllegalArgumentException` - if the argument is non-`null` and starts with `UIViewRoot.UNIQUE_ID_PREFIX`.

### getId

    protected java.lang.String getId()

  Return the `id` value assigned by the page author.

### getFacesJspId

    protected java.lang.String getFacesJspId()

  If this method has been called before on this tag's useful lifetime (before `release()` was called), return the previously returned value. Otherwise, if `getJspId()` returns non-`null`, prepend `UNIQUE_ID_PREFIX` to the `jspId` and return the result.

### getCreatedComponents

    protected java.util.List<java.lang.String> getCreatedComponents()

  Returns the `List` of `UIComponent` ids created or located by nested `UIComponentTag`s while processing the current request.

### setJspId

    public void setJspId(java.lang.String id)

  Defined on `JspIdConsumer`. This method is called by the container before `doStartTag()`. The argument is guaranteed to be unique within the page.

  IMPLEMENTATION NOTE: This method will detect where we are in an include and assign a unique ID for each include in a particular 'logical page'. This allows us to avoid possible duplicate ID situations for included pages that have components without explicit IDs.

  Specified by:
    `setJspId` in interface `javax.servlet.jsp.tagext.JspIdConsumer`
  Parameters:
    `id` - the container generated id for this tag, guaranteed to be unique within the page.

### getJspId

    public java.lang.String getJspId()

### setProperties

    protected abstract void setProperties(UIComponent component)

  Override properties and attributes of the specified component, if the corresponding properties of this tag handler instance were explicitly set. This method must be called ONLY if the specified `UIComponent` was in fact created during the execution of this tag handler instance, and this call will occur BEFORE the `UIComponent` is added to the view.

  Tag subclasses that want to support additional set properties must ensure that the base class `setProperties()` method is still called. A typical implementation that supports extra properties `foo` and `bar` would look something like this:

       protected void setProperties(UIComponent component) {
         super.setProperties(component);
         if (foo != null) {
           component.setAttribute("foo", foo);
         }
         if (bar != null) {
           component.setAttribute("bar", bar);
         }
       }

  The default implementation overrides the following properties:

  - `rendered` - Set if a value for the `rendered` property is specified for this tag handler instance.
  - `rendererType` - Set if the `getRendererType()` method returns a non-null value.

  Parameters:
    `component` - `UIComponent` whose properties are to be overridden

### createComponent

    protected abstract UIComponent createComponent(FacesContext context,
                                                   java.lang.String newId)
                                            throws javax.servlet.jsp.JspException

  Create and return a new child component of the type returned by calling `getComponentType()`. If this `UIComponentTag` has a non-null `binding` attribute, this is done by call `Application.createComponent(java.lang.String)` with the expression created for the `binding` attribute, and the expression will be stored on the component. Otherwise, `Application.createComponent(java.lang.String)` is called with only the component type. Finally, initialize the components id and other properties.

  Parameters:
    `context` - `FacesContext` for the current request
    `newId` - id of the component
  Throws:
    `javax.servlet.jsp.JspException`

### hasBinding

    protected abstract boolean hasBinding()

  Return `true` if this component has a non-`null` binding attribute. This method is necessary to allow subclasses that expose the `binding` property as an Faces 1.1 style EL property as well as subclasses that expose it as an EL API property.

### getComponentInstance

    public UIComponent getComponentInstance()

  Return the `UIComponent` instance that is associated with this tag instance. This method is designed to be used by tags nested within this tag, and only returns useful results between the execution of `doStartTag()` and `doEndTag()` on this tag instance.

  Specified by:
    `getComponentInstance` in class `UIComponentTagBase`

### getCreated

    public boolean getCreated()

  Return `true` if we dynamically created a new component instance during execution of this tag. This method is designed to be used by tags nested within this tag, and only returns useful results between the execution of `doStartTag()` and `doEndTag()` on this tag instance.

  Specified by:
    `getCreated` in class `UIComponentTagBase`

### getFacesContext

    protected FacesContext getFacesContext()

  Description copied from class: `UIComponentTagBase`

  Return the `FacesContext` instance for the current request. This value will be non-`null` only from the beginning of `doStartTag()` through the end of `doEndTag()` for each tag instance.

  Specified by:
    `getFacesContext` in class `UIComponentTagBase`

### getFacetName

    protected java.lang.String getFacetName()

  Return the facet name that we should be stored under, if any; otherwise, return null (indicating that we will be a child component).

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright 2002-2010 Oracle America Inc, Inc. All Rights Reserved.