ADD DESCRIPTION HERE https://javaserverfaces.dev.java.net/issues/show_bug.cgi?id=XXXX >>
SECTION: Modified Files
----------------------------
M jsf-ri/conf/share/facelets_jsf_core.taglib.xml
M jsf-ri/conf/share/composite.taglib.xml
M jsf-ri/conf/share/jstl-core.taglib.xml
M jsf-ri/conf/share/html_basic.taglib.xml
M jsf-ri/conf/share/ui.taglib.xml
SECTION: Diffs
----------------------------
Index: jsf-ri/conf/share/facelets_jsf_core.taglib.xml
===================================================================
--- jsf-ri/conf/share/facelets_jsf_core.taglib.xml (revision 8720)
+++ jsf-ri/conf/share/facelets_jsf_core.taglib.xml (working copy)
@@ -45,97 +45,97 @@
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-facelettaglibrary_2_0.xsd"
version="2.0">
-
The String value for ids
specified for execute and render may be specified as a search
expression as outlined in the JavaDocs for
- <code>UIComponent.findComponent()</code>. The implementation
+ UIComponent.findComponent()
. The implementation
must resolve these ids as specified for
- <code>UIComponent.findComponent()</code>.
- </p>
+ UIComponent.findComponent()
.
+
@this clientIdOne
- clientIdTwo
.</p>
-
- @this clientIdOne
- clientIdTwo
.</p>
-
- ComponentSystemEventListener
instances
- on a component in a page.</p>
+ on a component in a page.
- <div class="changed_added_2_0">
+ value for "type " tag
+ attribute |
- <th>Type of event sent to listener method
- </th>
+ Type of event sent to listener method + | - </tr> +
---|---|
preRenderComponent + | - <td>javax.faces.event.PreRenderComponentEvent - </td> +javax.faces.event.PreRenderComponentEvent + | - </tr> +
postAddToView + | - <td>javax.faces.event.PostAddToViewEvent - </td> +javax.faces.event.PostAddToViewEvent + | - </tr> +
preValidate + | - <td>javax.faces.event.PreValidateEvent - </td> +javax.faces.event.PreValidateEvent + | - </tr> +
postValidate + | - <td>javax.faces.event.PostValidateEvent - </td> +javax.faces.event.PostValidateEvent + | - </tr> +
In addition to these values, the fully qualified class
name of any
java class that extends
- <code>javax.faces.event.ComponentSystemEvent</code>
+ javax.faces.event.ComponentSystemEvent
may be used as the
- value of the "type" attribute.</p>
+ value of the "type" attribute.
Also, the @javax.faces.event.NamedEvent
annotation may
be attached to any java class that extends
- <code>javax.faces.event.ComponentSystemEvent</code>.
+ javax.faces.event.ComponentSystemEvent
.
This enables that
event to be referenced from this attribute, as descibed in the
javadocs
- for <code>@NamedEvent</code>.</p>
+ for @NamedEvent
.
<f:view>
. This tag
must reside within the top level XHTML file for the given
viewId, or in a
template client, but not in a template. The
implementation must insure that the direct child of the
- facet is a <code>UIPanel</code>, even if there
+ facet is a UIPanel
, even if there
is only one child of the facet. The implementation must set
- the id of the <code>UIPanel</code> to be the
+ the id of the UIPanel
to be the
value of the
- <code>UIViewRoot.METADATA_FACET_NAME</code>
- symbolic constant.</p>
+ UIViewRoot.METADATA_FACET_NAME
+ symbolic constant.
- <div class="changed_added_2_0">
+ The implementation must allow templating for this element according - to the following pattern.</p> + to the following pattern.
- <p>template client XHTML view, view01.xhtml</p> +template client XHTML view, view01.xhtml
- </div> +Note line 4. The page author must ensure that the
+ <f:metadata>
element does not
appear on a template or
included page. It must reside on the root page that corresponds to
the
- viewId.</p>
+ viewId.
The template page, template.xhtml
- </div> +The page author is not required to use
templating, but if
they do, it must be done as shown above, (or with
- <code><ui:include></code> in a similar
- manner).</p>
+ <ui:include>
in a similar
+ manner).
UIParameter
component associated with this
+
during their rendering.
+ Such renderers include javax.faces.Output
+ javax.faces.Link
and
+ javax.faces.OutcomeTarget
+ javax.faces.Link
.
]]>
@@ -902,82 +897,82 @@
UIViewParameter
extends UIInput
all of the attributes and nested child content for any
- <code>UIInput</code> tags are valid on this tag as well.</p>
+ UIInput
tags are valid on this tag as well.
- ValueChangeEvent
parameter,
- with a return type of void, <span class="changed_added_2_0">or
+ with a return type of void, or
to a public method that takes no arguments with a return type
of void. In the latter case, the method has no way of easily
knowing what the new value is, but this can be useful in cases
where a notification is needed that "this value
- changed".</span>
+ changed".
- </p>
- When iterating over the
+ select items, toString()
must be called on
the
- string rendered attribute values.</p>
+ string rendered attribute values.
Version 2 of the specification introduces several new attributes, described below. These are: var, itemValue, - itemLabel, itemDescription, itemDisabled, and itemLabelEscaped.</p> + itemLabel, itemDescription, itemDisabled, and itemLabelEscaped.
-Collection
+ or array. The member elements may be instances of
+ SelectItem
or any Java Object. In the
case where the member elements are plain Java Objects,
several additional attributes must be used by the page
author to correctly identify the data to the enclosing
- <code>UISelectOne</code> or <code>UISelectMany</code>
- component, as shown in the following example.</span>
+ UISelectOne
or UISelectMany
+ component, as shown in the following example.
- <div class="syntax"><div class="html4strict"
- style="font-family: monospace;"><ol><li class="li1"><div
- class="de1"><span class="sc2"><h:selectOneListbox
- <span class="kw3">size</span>=<span class="st0">"1"</span>
- <span class="kw3">id</span>=<span class="st0">"escape02"</span>
- <span class="kw3">value</span>=<span class="st0">"#{select05NoSelection.initialCollectionValues}"</span><span
- class="kw2">></span></span></div></li>
- <li class="li2"><div class="de2"> <span
- class="sc2"><f:selectItems <span class="kw3">value</span>=<span
- class="st0">"#{select05NoSelection.hobbitList}"</span></div></li>
- <li class="li1"><div class="de1">
+ In the preceding example, the
+ value
attribute on line 1 points to a
+ Collection<HobbitBean>
.
+ HobbitBean
is
just a regular Java Object (POJO) that conforms to JavaBeans
naming
- conventions for its properties. The <code>value</code>
+ conventions for its properties. The value
attribute on
- line 2 points to a <code>List<HobbitBean></code>,
+ line 2 points to a List<HobbitBean>
,
though it could
- just as well point to a <code>Collection</code>,
+ just as well point to a Collection
,
array, or
- <code>javax.faces.model.DataModel</code>. The
+ javax.faces.model.DataModel
. The
attributes on lines 3
through 9, inclusive, leverage the fact that the value is a
collection
of POJOs.
- </p>
+
value
attribute under this request
scoped key so that it
- may be referred to in EL for the value of other attributes.</p>
+ may be referred to in EL for the value of other attributes.
- Collection
, array, or Map
from which the items
- to be shown will be rendered.</p>
+ to be shown will be rendered.
- The implementation of this tag creates a special
+ ActionListener
instance and registers it on
the
- <code>ActionSource</code> associated with our most
+ ActionSource
associated with our most
immediate surrounding
instance of a tag whose implementation class is a subclass of
- <code>UIComponentTag</code>. This tag creates no output
+ UIComponentTag
. This tag creates no output
to the page
- currently being created.</p>
+ currently being created.
The ActionListener
instance
created and installed by
- this tag has the following behavior and contract.</p>
+ this tag has the following behavior and contract.
ActionListener
instance
- the first time the component for this tag is created</li>
+ the first time the component for this tag is createdUsage outside of an EditableValueHolder
+ parent
If this element is nested within a
+ UIComponent
tag that has other
+ UIComponent
children, the validator will be
automatically added to all the child components as well as
this one. The implementation must ensure this occurs even if
the parent of this element is not an instance of
- <code>EditableValueHolder</code>.</p>
+ EditableValueHolder
.
Describes the Facelets2 tag library used for declaring and defining the usage contract for composite UI Components. When authoring a composite component, use of this tag library is largely optional, @@ -64,915 +64,915 @@ PENDING: the limit of what one can do without declaring and defining a usage contract must be cleary specified and documented. PENDING: The implementation team must help discover these limits. - </p> +
- <h2>Creating a Composite Component</h2> +The default implementation must support authoring A composite component is declared by creating a Facelets2 file inside of a resource library. (See section JSF.2.6 of the specification prose document for more information about resource libraries.) A composite component must reside within a resource library. It is not possible to create a composite component without putting it inside of a resource - library.</p> + library.
- <p>The default XML namespace URI of the taglib that contains the - composite component, for use in <em>the using page</em>, is - <code>http://java.sun.com/jsf/composite/<composite-library-name></code>, - where <code><composite-library-name></code> is +The default XML namespace URI of the taglib that contains the
+ composite component, for use in the using page, is
+ http://java.sun.com/jsf/composite/<composite-library-name>
,
+ where <composite-library-name>
is
the name of the
- resource library. For example:</p>
+ resource library. For example:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- <br />
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><br
- />
- <html xmlns="http://www.w3.org/1999/xhtml"<br />
- xmlns:h="http://java.sun.com/jsf/html"<br />
- xmlns:f="http://java.sun.com/jsf/core"<br />
- xmlns:ui="http://java.sun.com/jsf/facelets"<br />
- xmlns:ez="<i>http://java.sun.com/jsf/composite/<b>ezcomp</b></i>"><br
- />
- ...<br />
- </code></pre>
+
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+ <html xmlns="http://www.w3.org/1999/xhtml"
+ xmlns:h="http://java.sun.com/jsf/html"
+ xmlns:f="http://java.sun.com/jsf/core"
+ xmlns:ui="http://java.sun.com/jsf/facelets"
+ xmlns:ez="http://java.sun.com/jsf/composite/ezcomp">
+ ...
+
- <p>This declares that any Facelets2 file in the resource
- library called <code>ezcomp</code> can be used as a regular
+ This declares that any Facelets2 file in the resource
+ library called ezcomp
can be used as a regular
JSF UI
component in a view with the above namespace declaration by using the
- "<code>ez</code>" prefix. For example, placing a file called
- <code>foo.xhtml</code> in a resource library called <code>ezcomp</code>
- would make that file accessible like this.</p>
+ "ez
" prefix. For example, placing a file called
+ foo.xhtml
in a resource library called ezcomp
+ would make that file accessible like this.
<ez:foo />
- </code></pre>
+
- <p>The implementation must also support declaring the
+ The implementation must also support declaring the namespace of the tag library in a JSF VDL tag library descriptor. This descriptor file is optional and is useful for component vendors that do not want to use the default XML namespace. This version of the proposal currently uses the facelet taglib descriptor syntax. For - example: </p> + example:
- <pre><code> - <facelet-taglib><br /> +
+ <facelet-taglib>
<namespace>http://domain.com/path</namespace>
- <br />
+
<composite-library-name>compositeTest</composite-library-name>
- <br />
- </facelet-taglib> <br />
- </code></pre>
+
+ </facelet-taglib>
+
- <p>Components from that taglibrary may be used in a using page by
- declaring them in the XML namespace for that view:</p>
+ Components from that taglibrary may be used in a using page by + declaring them in the XML namespace for that view:
- <pre><code> +
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- <br />
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><br
- />
- <html xmlns="http://www.w3.org/1999/xhtml"<br />
- xmlns:h="http://java.sun.com/jsf/html"<br />
- xmlns:f="http://java.sun.com/jsf/core"<br />
- xmlns:ui="http://java.sun.com/jsf/facelets"<br />
- xmlns:ez="<i><b>http://domain.com/path/namespace</b></i>"><br
- />
- ...<br />
- </code></pre>
+
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+ <html xmlns="http://www.w3.org/1999/xhtml"
+ xmlns:h="http://java.sun.com/jsf/html"
+ xmlns:f="http://java.sun.com/jsf/core"
+ xmlns:ui="http://java.sun.com/jsf/facelets"
+ xmlns:ez="http://domain.com/path/namespace">
+ ...
+
- <p><a name="composite_example">Below is an example of a
+
- <div class="syntax"><div class="html4strict"
- style="font-family: monospace;"><ol><li class="li1"><div
- class="de1"><span class="sc2"><<a
- href="interface.html">composite:interface</a> <span
- class="kw3">name</span>=<span class="st0">"foo"</span></div></li>
- <li class="li2"><div class="de2">
+ The values for attributes in a composite component VDL file can
be
fully localized by putting them inside a ResourceBundle in the same
directory as the VDL view and accessing them with the per-component
- resource bundle syntax. Consider the file <code>foo.xhtml</code>,
+ resource bundle syntax. Consider the file foo.xhtml
,
in
- the resource library <code>ezcomp</code>. The
- <code>shortDescription</code> element could be changed to
- be:</p>
+ the resource library ezcomp
. The
+ shortDescription
element could be changed to
+ be:
<composite:interface
shortDescription="#{cc.resourceBundleMap.shortDescription}" >
- </code></pre>
+
- <p>In this case, In the same <code>ezcomp</code>
+ In this case, In the same ezcomp
directory as
- <code>foo.xhtml</code>, there would be a <code>foo.properties</code>
- file that would contain this entry:</p>
+ foo.xhtml
, there would be a foo.properties
+ file that would contain this entry:
shortDescription=A really nifty login panel.
- </code></pre>
+
- <p>The normal localization rules for <code>ResourceBundle</code>
+ The normal localization rules for ResourceBundle
would
- apply.</p>
+ apply.
-
This element declares the usage contract for a composite component. Optionally, and at the component author's discretion, this contract exposes the features of one or more inner components to the page author. The page author can work with the composite component as a single component whose feature set is the union of the features declared in - the usage contract.</p> + the usage contract.
- <p>For example, consider a composite component that +For example, consider a composite component that implements the functionality of a "login panel". Such a component would likely have two text fields and one button. The user of such a component might like to do one or more of - the following.</p> + the following.
- <ul> +Be able to listen for the ActionEvent
+ on the button.
In this case, a
+ <composite:actionSource>
element is
included in the usage contract that refers to the inner
- button in the <code><composite:implementation></code>
- section.</p>
+ button in the <composite:implementation>
+ section.
Provide an "action" to invoke when the button is pressed. - </p> +
- <p>In this case, a - <code><composite:attribute></code> element +In this case, a
+ <composite:attribute>
element
is included
in the usage contract that refers to the inner button in the
- <code><composite:implementation></code>
+ <composite:implementation>
section and
- declares the proper method signature for an "action".</p>
+ declares the proper method signature for an "action".
Provide parameters to the composite component for labels and other rendering specific aspects of the composite - component.</p> + component.
- <p>In this case, one or more - <code><composite:attribute></code> +In this case, one or more
+ <composite:attribute>
elements are included
in the usage contract and those parameters are referred to in
- the <code><composite:implementation></code>
+ the <composite:implementation>
section
using EL expressions like
- <code>#{cc.attrs.usernameLabel}</code>,
- assuming <code>usernameLabel</code> is the <code>name</code>
- of one of the <code><composite:attribute></code>
- elements in the usage contract.</p>
+ #{cc.attrs.usernameLabel}
,
+ assuming usernameLabel
is the name
+ of one of the <composite:attribute>
+ elements in the usage contract.
Add ValueChangeListener
s,
+ Converter
s, or Validator
s
to either
or both text fields.
- </p>
+
In this case, a
+ <composite:editableValueHolder>
element is
included in the usage contract that refers to the inner text
- field in the <code><composite:implementation></code>
+ field in the <composite:implementation>
section. In the case of wanting to enable only adding a
- <code>Converter</code> (and not a
- <code>ValueChangeListener</code> or <code>Validator</code>,
+ Converter
(and not a
+ ValueChangeListener
or Validator
,
a
- <code><composite:valueHolder></code>
+ <composite:valueHolder>
element would be
- used.</p>
+ used.
Add facet children to the login panel.
- <p>In this case, a <code><composite:facet></code> +In this case, a <composite:facet>
element is included in the usage contract that refers to the
- inner <code><composite:renderFacet></code>
+ inner <composite:renderFacet>
element in
- the <code><composite:implementation></code>
+ the <composite:implementation>
section.
- </p>
+
For each of the behaviorial interfaces in Section JSF.3.2
of
the specification, there is a tag in the
- <code>composite:</code> library to nest inside of the
- <code><composite:interface></code>
+ composite:
library to nest inside of the
+ <composite:interface>
section.
- </p>
+
If the <composite:interface>
section
- is not present in a <em>VDL view</em>, the contract will
+ is not present in a VDL view, the contract will
be
inferred as described in the specification. There must be
zero or one of these elements in a composite component VDL
- file. If a <code><composite:interface></code>
+ file. If a <composite:interface>
element
does appear, there must be an accompanying
- <code><composite:implementation></code>
+ <composite:implementation>
element in the
- same VDL file. </p>
+ same VDL file.
Nesting of composite components
- <p>The implementation must support nesting of composite +The implementation must support nesting of composite
components. Specifically, it must be possible for the
- <code><composite:implementation></code>
+ <composite:implementation>
section of a
- composite component to act as the <em>using page</em>
+ composite component to act as the using page
for
another composite component. When a composite component
- exposes a behavioral interface to the <em>using page</em>,
- such as a <code><composite:actionSource></code>,
- <code><composite:editableValueHolder></code>,
- <code><composite:valueHolder></code> or
+ exposes a behavioral interface to the using page,
+ such as a <composite:actionSource>
,
+ <composite:editableValueHolder>
,
+ <composite:valueHolder>
or
other
behavioral interface, it must be possible to
“propogate” the exposure of such an interface in
the case of a nested composite component. The composite
component author must ensure that the value of the
- <code>name</code> attributes exactly match at all levels
+ name
attributes exactly match at all levels
of
the nesting to enable this exposure to work. The
implementation is not required to support
“re-mapping” of names in a nested composite
- component.</p>
+ component.
For example, consider this nested composite component.
- <p>Using page</p> +Using page
- <div class="syntax"><div class="html4strict" - style="font-family: monospace;"><ol><li class="li1"><div - class="de1"><span class="sc2"><ez:actionSourceOuter></span></div></li> - <li class="li2"><div class="de2"> <span - class="sc2"><f:actionListener <span class="kw3">for</span>=<span - class="st0">"button1"</span> /<span - class="kw2">></span></span></div></li> - <li class="li1"><div class="de1"><span class="sc2"><span - class="kw2"><</span>/ez:actionSourceOuter></span> - </div></li></ol></div></div> +actionSourceOuter.xhtml: Outer composite component
- <div class="syntax"><div class="html4strict" - style="font-family: monospace;"><ol><li class="li1"><div - class="de1"><span class="sc2"><composite:interface></span></div></li> - <li class="li2"><div class="de2"> <span - class="sc2"><composite:actionSource <span class="kw3">name</span>=<span - class="st0">"button1"</span> /<span - class="kw2">></span></span></div></li> - <li class="li1"><div class="de1"><span class="sc2"><span - class="kw2"><</span>/composite:interface></span></div></li> - <li class="li2"><div class="de2"> </div></li> - <li class="li1"><div class="de1"><span class="sc2"><composite:implementation></span></div></li> - <li class="li2"><div class="de2"> <span - class="sc2"><ez:actionSourceInner /<span class="kw2">></span></span></div></li> - <li class="li1"><div class="de1"><span class="sc2"><span - class="kw2"><</span>/composite:implementation></span> - </div></li></ol></div></div> +actionSourceInner.xhtml: the composite component used within a - composite component.</p> + composite component.
- <div class="syntax"><div class="html4strict" - style="font-family: monospace;"><ol><li class="li1"><div - class="de1"><span class="sc2"><composite:interface></span></div></li> - <li class="li2"><div class="de2"> <span - class="sc2"><composite:actionSource <span class="kw3">name</span>=<span - class="st0">"button1"</span> /<span - class="kw2">></span></span></div></li> - <li class="li1"><div class="de1"><span class="sc2"><span - class="kw2"><</span>/composite:interface></span></div></li> - <li class="li2"><div class="de2"> </div></li> - <li class="li1"><div class="de1"><span class="sc2"><composite:implementation></span></div></li> - <li class="li2"><div class="de2"> <span - class="sc2"><h:commandButton <span class="kw3">id</span>=<span - class="st0">"button1"</span> <span - class="kw3">value</span>=<span class="st0">"the - real button"</span> /<span class="kw2">></span></span></div></li> - <li class="li1"><div class="de1"><span class="sc2"><span - class="kw2"><</span>/composite:implementation></span> - </div></li></ol></div></div> +The id
of the <h:commandButton>
on
- line 6 of actionSourceInner.xhtml must match the <code>name</code>
+ line 6 of actionSourceInner.xhtml must match the name
on
line 2 of that file (this is a standard requirement for all
composite
- components, nested or not). That <code>id</code> must
+ components, nested or not). That id
must
also match the
- <code>name</code> on line 2 of actionSourceOuter.xhtml,
+ name
on line 2 of actionSourceOuter.xhtml,
and the
- <code>for</code> on line 2 of the using page.</p>
+ for
on line 2 of the using page.
The implementation must support any level of nesting as
long as the
- <code>for</code>, <code>name</code>, and
- <code>id</code> values match
- up. Furthermore, the <code>targets</code> attribute is
+ for
, name
, and
+ id
values match
+ up. Furthermore, the targets
attribute is
also valid for
- use in this nested fashion.</p>
+ use in this nested fashion.
Naming containers within composite components
- <p>Composite components are themselves naming containers so +Composite components are themselves naming containers so
that any
possible id conflicts between inner components and components in the
using page are avoided. However, special care must be taken when
using
- naming containers in the <code><composite:implementation></code>
+ naming containers in the <composite:implementation>
section. In such cases the value of the “name”
attribute,
or the values of the “targets” attribute must be
used with a
- clientId relative to the <em>top level component</em> to
+ clientId relative to the top level component to
expose any
- attached object targets to the using page. For example:</p>
+ attached object targets to the using page. For example:
Using page
- <div class="syntax"><div class="html4strict" - style="font-family: monospace;"><ol><li class="li1"><div - class="de1"><span class="sc2"><ez:loginButton></span></div></li> - <li class="li2"><div class="de2"> <span - class="sc2"><f:actionListener <span class="kw3">for</span>=<span - class="st0">"button"</span> <span - class="kw3">binding</span>=<span class="st0">"#{foo.actionListener}"</span> - /<span class="kw2">></span></span></div></li> - <li class="li1"><div class="de1"><span class="sc2"><span - class="kw2"><</span>/ez:loginButton></span> - </div></li></ol></div></div> +loginButton.xhtml
- <div class="syntax"><div class="html4strict" - style="font-family: monospace;"><ol><li class="li1"><div - class="de1"><span class="sc2"><composite:interface></span></div></li> - <li class="li2"><div class="de2"> <span - class="sc2"><composite:actionSource <span class="kw3">name</span>=<span - class="st0">"button"</span> targets=<span - class="st0">"form:button"</span> /<span - class="kw2">></span></span></div></li> - <li class="li1"><div class="de1"><span class="sc2"><span - class="kw2"><</span>/composite:interface></span></div></li> - <li class="li2"><div class="de2"> </div></li> - <li class="li1"><div class="de1"><span class="sc2"><composite:implementation></span></div></li> - <li class="li2"><div class="de2"> </div></li> - <li class="li1"><div class="de1"> <span - class="sc2"><h:form <span class="kw3">id</span>=<span - class="st0">"form"</span><span - class="kw2">></span></span></div></li> - <li class="li2"><div class="de2"> - <span class="sc2"><h:commandButton <span class="kw3">id</span>=<span - class="st0">"button"</span> <span - class="kw3">value</span>=<span class="st0">"Submit"</span> - /<span class="kw2">></span></span></div></li> - <li class="li1"><div class="de1"> <span - class="sc2"><span class="kw2"><</span>/h:form></span></div></li> - <li class="li2"><div class="de2"><span class="sc2"><span - class="kw2"><</span>/composite:implementation></span> - </div></li></ol></div></div> +Because the button on line 8 resides within a form, it must
be
- referred to using a client id, relative to the <em>top level
- component</em>, in the "targets" attribute on line 2. Using a
+ referred to using a client id, relative to the top level
+ component, in the "targets" attribute on line 2. Using a
relative
clientId is required due to the semantics of
- <code>UIComponent.findComponent()</code>.</p>
+ UIComponent.findComponent()
.
The name of this composite component. Advisory only. The real name is taken from the filename. The value of this attribute will be set as - the value for this property on the <em>composite - component bean descriptor</em>.</p></div> + the value for this property on the composite + component bean descriptor.
-The component-type
of the UIComponent
that
- will serve as the <em>composite component root</em>
+ will serve as the composite component root
for this composite
- component. The declared <code>component-family</code>
+ component. The declared component-family
for this
- component must be <code>javax.faces.NamingContainer</code>.</p></div>
+ component must be javax.faces.NamingContainer
.
The name to display in a tool palette containing this component. The value of this attribute will be set as - the value for this property on the <em>composite - component bean descriptor</em>.</p></div> + the value for this property on the composite + component bean descriptor.
-Is this a "preferred" component. The value of this attribute will be set as the value for this - property on the <em>composite component bean - descriptor</em>.</p></div> + property on the composite component bean + descriptor.
-Is this component only for expert users? The value of this attribute will be set as the value for - this property on the <em>composite component bean - descriptor</em>.</p></div> + this property on the composite component bean + descriptor.
-A short description of the purpose of this component. The value of this attribute will be set as - the value for this property on the <em>composite - component bean descriptor</em>.</p></div> + the value for this property on the composite + component bean descriptor.
-Defines the implementation of the composite
component. There must be zero or one of these in a
composite component markup file. If a
- <code><composite:interface></code> element
+ <composite:interface>
element
appears,
there must be a corresponding
- <code><composite-implementation></code>
+ <composite-implementation>
element. If no
- <code><composite:interface></code> element
+ <composite:interface>
element
appears,
- the <code><composite-implementation></code>
+ the <composite-implementation>
element is
- optional. </p> </div>
-
Declares an attribute that may be given to an instance of
the
- <em>composite component</em> tag for this composite
+ composite component tag for this composite
component. There
may be zero or many of these inside of the
- <code><composite:interface</code>>
+ <composite:interface
>
section. This element may be
- nested within other <code><composite:attribute></code>
+ nested within other <composite:attribute>
elements to
- convey a usage contract that includes nested properties.</p>
+ convey a usage contract that includes nested properties.
Please see summary + page for a usage example.
- <p>The <em>top level component</em> in which this +The top level component in which this
element is
- ultimately nested must be a <code>NamingContainer</code>.
+ ultimately nested must be a NamingContainer
.
There are certain component properties that must not be
exposed using this element. The motivation for this
restriction is that the mapping of markup attributes to
component properties/attributes does not allow for these
attributes to be set. The following properties must not be
- exposed using this element.</p>
+ exposed using this element.
binding
id
inView
parent
rendered
rendererType
transient
The name of the attribute as it must appear on the composite
+ component tag in the using page.
If the value of the
- <em>name</em> attribute is equal to (without the
+ name attribute is equal to (without the
quotes)
“action”, ”actionListener”,
“validator”, or “valueChangeListener”,
the
- action described in <a target="_"
- href="../../../javadocs/javax/faces/application/ViewHandler.html#retargetMethodExpressions(javax.faces.context.FacesContext,%20javax.faces.component.UIComponent)">ViewHandler.retargetMethodExpressions()</a>
+ action described in ViewHandler.retargetMethodExpressions()
must be taken to handle the attribute. In these cases, the
- <code>method-signature</code> attribute, if present,
+ method-signature
attribute, if present,
must be ignored as
its value is derived as described in
- <code>retargetMethodExpressions()</code>.</div>
+ retargetMethodExpressions()
.
-
If this element has a method-signature
attribute, the
- value of the <code>targets</code> attribute must be
+ value of the targets
attribute must be
interpreted as a
space (not tab) separated list of client ids (relative to the
- <em>top
- level component</em>) of components within the
- <code><composite:implementation></code>
+ top
+ level component) of components within the
+ <composite:implementation>
section. Space is used as
the delimiter for compatibility with the IDREFS and NMTOKENS
data types
from the XML Schema. Each entry in the list must be interpreted
as the
- id of an inner component to which the <code>MethodExpression</code>
+ id of an inner component to which the MethodExpression
from
- the <em>composite component tag</em> in the <em>using
- page</em> must be
- applied. If this element has a <code>method-signature</code>
+ the composite component tag in the using
+ page must be
+ applied. If this element has a method-signature
attribute,
- but no <code>targets</code> attribute, the value of
+ but no targets
attribute, the value of
the
- <code>name</code> attribute is used as the single
+ name
attribute is used as the single
entry in the list. If
- the value of the <code>name</code> attribute is <strong>not</strong>
+ the value of the name
attribute is not
one
- of the special values listed in the description of the <code>name
- attribute</code>, <code>targets</code> (or its
+ of the special values listed in the description of the name
+ attribute
, targets
(or its
derived value) need not
- correspond to the id of an inner component.</p>
+ correspond to the id of an inner component.
If this attribute is not required, and a value is not supplied by the page author, use this as - the default value.</p></div> + the default value.
-The name to display in a tool palette containing this component. The value of this attribute will be set as - the value for this property on the <em>composite - component bean descriptor</em>.</p></div> + the value for this property on the composite + component bean descriptor.
-True if the page author must supply a value + for this attribute.
-Is this a "preferred" component. The value of this attribute will be set as the value for this - property on the <em>composite component bean - descriptor</em>.</p></div> + property on the composite component bean + descriptor.
-Is this component only for expert users? The value of this attribute will be set as the value for - this property on the <em>composite component bean - descriptor</em>.</p></div> + this property on the composite component bean + descriptor.
-A short description of the purpose of this component. The value of this attribute will be set as - the value for this property on the <em>composite - component bean descriptor</em>.</p></div> + the value for this property on the composite + component bean descriptor.
-Declares that this attribute must be a MethodExpression
whose method signature is described by the value of this
attribute. The
signature must be described using fully qualified class names
@@ -981,733 +981,733 @@
"type"
attribute. If both attributes are present, the
"method-signature"
- attribute is ignored.</p>
+ attribute is ignored.
PENDING: when this file is generated from the web-facesuicomponent_2_0.xsd, we will not need to copy the content here - manually.</p> + manually.
- <p>Provides the signature of the Java method. The syntax +Provides the signature of the Java method. The syntax of the method-signature element is as follows (taken from - function-signature in web-jsptaglibrary_2_1.xsd):</p> + function-signature in web-jsptaglibrary_2_1.xsd):
- <p>MethodSignature ::= ReturnType S MethodName S? - '(' S? Parameters? S? ')'</p> +MethodSignature ::= ReturnType S MethodName S? + '(' S? Parameters? S? ')'
- <p>ReturnType ::= Type</p> +ReturnType ::= Type
- <p>MethodName ::= Identifier</p> +MethodName ::= Identifier
- <p>Parameters ::= Parameter - | ( Parameter S? ',' S? Parameters )</p> +Parameters ::= Parameter + | ( Parameter S? ',' S? Parameters )
- <p>Parameter ::= Type</p> +Parameter ::= Type
- <p>Where:</p> +Where:
- <ul> +Type is a basic type or a fully qualified Java class name (including package name), as per the 'Type' production in the Java Language Specification, Second Edition, - Chapter 18.</p></li> + Chapter 18.
Identifier is a Java identifier, as per the 'Identifier' production in the Java Language Specification, Second - Edition, Chapter 18.</p></li> + Edition, Chapter 18.
Example:
- <p><code>java.lang.String nickName( - java.lang.String, int )</code></p> +java.lang.String nickName(
+ java.lang.String, int )
Declares that this attribute must be a ValueExpression
whose expected type is given by the value of this attribute. If
not
specified, and no "method-signature" attribute is present,
- <code>java.lang.Object</code> is assumed. This
+ java.lang.Object
is assumed. This
attribute is mutually
exclusive with the "method-signature" attribute. If both attributes are
present, the
- "method-signature" attribute is ignored. </p> </div>
+ "method-signature" attribute is ignored.
Declares that this composite component supports a facet with the - name given by the value of the "name" attribute. </p> + name given by the value of the "name" attribute.
- <p>Please see <code><<a - href="interface.html">composite:interface</a>></code> +Please see <composite:interface>
for a usage
- example.</p>
+ example.
The name of the attribute as it must appear + on the composite component tag in the + using page.
-The name to display in a tool palette containing this component. The value of this attribute will be set as - the value for this property on the <em>composite - component bean descriptor</em>.</p></div> + the value for this property on the composite + component bean descriptor.
-True if the page author must supply a facet with this + name.
-Is this a "preferred" facet. The value of this attribute will be set as the value for this - property on the <em>composite component bean - descriptor</em>.</p></div> + property on the composite component bean + descriptor.
-Is this facet only for expert users? The value of this attribute will be set as the value for - this property on the <em>composite component bean - descriptor</em>.</p></div> + this property on the composite component bean + descriptor.
-A short description of the purpose of this facet. The value of this attribute will be set as - the value for this property on the <em>composite - component bean descriptor</em>.</p></div> + the value for this property on the composite + component bean descriptor.
-This element is used in the
+ <composite:implementation>
section. The facet with
the name equal to the value of the name attribute, given by the page
author in the using page, will be rendered at this point in the
- composite component VDL view. </p>
+ composite component VDL view.
The implementation of this tag handler must insert a
+ component with component-type
+ javax.faces.Output
and renderer-type
+ javax.faces.CompositeFacet
as a
+ child at this point in the component tree.
The implementation of this tag handler must store an
attribute into
the created component's attribute map under the key given by the
value
- of the symbolic constant <code>UIComponent.FACETS_KEY</code>.
+ of the symbolic constant UIComponent.FACETS_KEY
.
The value
- for this key must be the evaluated value of the "name" attribute.</p>
+ for this key must be the evaluated value of the "name" attribute.
The value of the name attribute as it must appear on an
+ <f:facet>
tag nested
+ within the composite
+ component tag in the using page.
If true
, and there is no such
facet present on the top
- level component, a <code>TagException</code> must be
+ level component, a TagException
must be
thrown, containing
- the <code>Location</code>, the facet name, and a
+ the Location
, the facet name, and a
localized descriptive
- error message.</p>
+ error message.
This element is used in the
+ <composite:implementation>
section. Any child
components or template text within the composite component tag in
the
using page will be re-parented into the composite component at the
point
indicated by this tag's placement within the
- <code><composite:implementation></code>
+ <composite:implementation>
section. The normal
use-case for this element is to have only one occurrence within the
- <code><composite:implementation></code>
+ <composite:implementation>
section. Inserting
multiple occurrences may cause duplicate id errors. The results are
undefined if there are multiple occurrences of this element in the
- <code><composite:implementation></code>
- section.</p>
+ <composite:implementation>
+ section.
Declares that the composite component whose
contract is declared by the
- <code><composite:interface></code> in
+ <composite:interface>
in
which this
element is nested exposes an implementation of
- <code>ValueHolder</code> suitable for use as the target
+ ValueHolder
suitable for use as the target
of
- <em>attached objects</em> in <em>the using page</em>.
+ attached objects in the using page.
Any attached objects suitable for implementations of
- <code>ValueHolder</code> may be attached to the
+ ValueHolder
may be attached to the
composite
- component. Consider this excerpt from <em>the using
- page</em>:
- </p>
+ component. Consider this excerpt from the using
+ page:
+
Line 2 refers to the
+ <composite:valueHolder>
declaration on
- line 2 of <code>foo.xhtml</code>:</p>
+ line 2 of foo.xhtml
:
It is possible to declare that a single
+ <composite:valueHolder>
element should cause multiple
- components within the <code><composite:implementation></code>
- section to be the targets of an <em>attached object</em>
+ components within the <composite:implementation>
+ section to be the targets of an attached object
in the
- using page. Assuming the same <em>using page</em>
+ using page. Assuming the same using page
excerpt as
- above, the revised <em>VDL view</em> is:</p>
+ above, the revised VDL view is:
In this case, the "targets" attribute on the
+ <composite:valueHolder>
element, on line 2 above,
replaces the "name" attribute in the previous example. "targets" is
a
- list of ids of client ids (relative to the <em>top level
- component</em>)
- within the <code><composite:implementation></code>
+ list of ids of client ids (relative to the top level
+ component)
+ within the <composite:implementation>
section. In
- this case, "targets" refers to the <code><h:inputText></code>
- components on lines 6 and 7 above.</p>
+ this case, "targets" refers to the <h:inputText>
+ components on lines 6 and 7 above.
Please see <composite:interface>
for a usage
- example.</p>
+ example.
The value of this attribute maps back to the "for" attribute on
an attachable object
nested within a composite component. If the "targets" attribute
is not specified,
this value also represents the component ID of the target
component within the
- that the <code><composite:implementation></code>
+ that the <composite:implementation>
ActionListener should be mapped to.
- </p>
- </div>
+
If present, this must be a space (not tab) separated
list of client
- ids (relative to the <em>top level component</em>)
+ ids (relative to the top level component)
of components within
- the <code><composite:implementation></code>
+ the <composite:implementation>
section. Space is
used as the delimiter for compatibility with the IDREFS and
NMTOKENS
- data types from the XML Schema. </p></div>
+ data types from the XML Schema.
Declares that the composite component whose
contract is declared by the
- <code><composite:interface></code> in
+ <composite:interface>
in
which this
element is nested exposes an implementation of
- <code>EditableValueHolder</code> suitable for use as the
- target of <em>attached objects</em> in <em>the
+ EditableValueHolder
suitable for use as the
+ target of attached objects in the
using
- page</em>. Any attached objects suitable for
- implementations of <code>EditableValueHolder</code> may
+ page. Any attached objects suitable for
+ implementations of EditableValueHolder
may
be
- attached to the composite component.The example from <a
- href="valueHolder.html"><code><composite:valueHolder></code></a>
+ attached to the composite component.The example from <composite:valueHolder>
still applies.
- </p>
+
Please see <composite:interface>
for a usage
- example.</p>
+ example.
The value of this attribute maps back to the "for" attribute on
an attachable object
nested within a composite component. If the "targets" attribute
is not specified,
this value also represents the component ID of the target
component within the
- that the <code><composite:implementation></code>
+ that the <composite:implementation>
ActionListener should be mapped to.
- </p>
- </div>
+
If present, this must be a space (not tab) separated
list of client
- ids (relative to the <em>top level component</em>)
+ ids (relative to the top level component)
of components within
- the <code><composite:implementation></code>
+ the <composite:implementation>
section. Space is
used as the delimiter for compatibility with the IDREFS and
NMTOKENS
- data types from the XML Schema.</p></div>
+ data types from the XML Schema.
Declares that the composite component whose
contract is declared by the
- <code><composite:interface></code> in
+ <composite:interface>
in
which this
element is nested exposes an implementation of
- <code>ActionSource2</code> suitable for use as the
+ ActionSource2
suitable for use as the
target of
- <em>attached objects</em> in <em>the using page</em>.
+ attached objects in the using page.
Any attached objects suitable for implementations of
- <code>ActionSource2</code> may be attached to the
+ ActionSource2
may be attached to the
composite
- component. Consider this excerpt from <em>the using
- page</em>:
- </p>
+ component. Consider this excerpt from the using
+ page:
+
The <f:actionListener>
elements on lines 4, 7, and 10
- refer to the <em>attached objects</em> declared on lines
- 2, 3 and 4 below.</p>
+ refer to the attached objects declared on lines
+ 2, 3 and 4 below.
Most of the concepts from example content from <composite:valueHolder>
also applies in the case of
- <code><composite:actionSource></code>.</p>
+ <composite:actionSource>
.
Please see <composite:interface>
for a usage
- example.</p>
+ example.
The value of this attribute maps back to the "for" attribute on
an attachable object
nested within a composite component. If the "targets" attribute
is not specified,
this value also represents the component ID of the target
component within the
- that the <code><composite:implementation></code>
+ that the <composite:implementation>
ActionListener should be mapped to.
- </p>
- </div>
+
If present, this must be a space (not tab) separated
list of client
- ids (relative to the <em>top level component</em>)
+ ids (relative to the top level component)
of components within
- the <code><composite:implementation></code>
+ the <composite:implementation>
section. Space is
used as the delimiter for compatibility with the IDREFS and
NMTOKENS
- data types from the XML Schema.</p></div>
+ data types from the XML Schema.
Used within a <composite:interface>
section,
within any sub-element of that section, to include XML content not
defined by this specification. This element can be used to
incorporate
- <a target="_" href="http://jcp.org/en/jsr/detail?id=276">JSR-276</a>
- metadata into a composite component.</p>
+ JSR-276
+ metadata into a composite component.
The presence of this tag in a
+ <composite:implementation>
section must cause the
- named facet to be taken from the facet map of the <em>top
+ named facet to be taken from the facet map of the top
level
- component</em> and inserted as a facet child of the component
+ component and inserted as a facet child of the component
in which
- this element is nested.</p>
+ this element is nested.
The name of the facet child on the top level + component which must be inserted as a facet child of the component in which this element - is nested.</p> + is nested.
- </div> + -If true
, and there is no such
facet present on the top
- level component, a <code>TagException</code> must be
+ level component, a TagException
must be
thrown, containing
- the <code>Location</code>, the facet name, and a
+ the Location
, the facet name, and a
localized descriptive
- error message.</p>
+ error message.
The pre JSF 2.0 version of Facelets incorrectly declared the taglib
+uri to be http://java.sun.com/jstl/core
. For backwards
compatibility implementations must correctly handle inclusions with the
-incorrect uri, and the correct uri, declared here.</p>
+incorrect uri, and the correct uri, declared here.
TagException
is
thrown with an informative error message, ensuring page location
- information is saved.</p>
+ information is saved.
- <p>This handler operates in one of two ways.
+ This handler operates in one of two ways. - <ol> +
The user has set "var", "value" and (optionally) + "scope" attributes.
The user has set "target", "property", and "value" - attributes.</p></li> + attributes.
The first case takes precedence over the second.
-The tags in this library add templating—a powerful view composition technique—to JSF. Templating is so useful that there are entire frameworks, such as Tiles and SiteMesh, that are built around the concept of templating. So what is templating, how can you benefit from it, and how does this tag library implement it? - </p> +
- <p>If you've used JSP before, you've probably used <code>jsp:include</code>. +If you've used JSP before, you've probably used jsp:include
.
The prototypical example for
- <code>jsp:include</code> is a header on each page in a web
+ jsp:include
is a header on each page in a web
application. One JSP page, say header.jsp,
encapsulates the header content, and the header is included by each
- page. You <em>encapsulate and reuse
- content</em>, so that changes to one file, header.jsp, affect the
+ page. You encapsulate and reuse
+ content, so that changes to one file, header.jsp, affect the
header on every page.
- </p>
+
This tab library contains a tag—ui:include
—
+ that's analagous to jsp:include
,
but encapsulating and reusing content is only half the templating story,
because templating also lets you
- <em>encapsulate and reuse <b>layout</b></em>.
- You define a single <em>template</em> (meaning layout), and
+ encapsulate and reuse layout.
+ You define a single template (meaning layout), and
you reuse
- that template with multiple <em>compositions</em>. So now
+ that template with multiple compositions. So now
you can control the layout of many pages with a single
template (layout). Let's take a look at an example.
- </p>
+
First, we define a template: - </p> - <div class="syntax"><div class="html4strict" - style="font-family: monospace;"><ol><li class="li1"><div - class="de1"><span class="sc0"><!DOCTYPE html PUBLIC - "-//W3C//DTD XHTML 1.0 Transitional//EN"</div></li> +
+
In the preceeding listing, we've defined a layout, also known as a
template. That template uses the
- <code>ui:insert</code> tag to insert pieces of a page —namely,
+ ui:insert
tag to insert pieces of a page —namely,
title, heading, and content—
- defined in a <em>composition</em>. Notice that on line 8, we
+ defined in a composition. Notice that on line 8, we
define a default title, in case one isn't provided
- by the composition. Also note that on line 12 we have the <code>ui:debug</code>
+ by the composition. Also note that on line 12 we have the ui:debug
tag, which lets the user activate
a popup window with debugging information by typing CTRL + Shift + d.
- </p>
+
The title, heading, and content pieces of the page referenced in the template are defined in a separate XHTML file in a composition, like this: - </p> +
- <div class="syntax"><div class="html4strict" - style="font-family: monospace;"><ol><li class="li1"><div - class="de1"><span class="sc0"><!DOCTYPE html PUBLIC - "-//W3C//DTD XHTML 1.0 Transitional//EN"</div></li> +
At runtime, JSF synthesizes the two previous XHTML pages to create a
single JSF view by inserting the
pieces defined in the composition into the template (that template is
layout.xhtml, which is the first
- listing above). JSF also disregards everything outside of the <code>composition</code>
+ listing above). JSF also disregards everything outside of the composition
tag so that we don't
- wind up with two <code>body</code> elements in the view.
- Also, note that we use the <code>ui:include</code>
+ wind up with two body
elements in the view.
+ Also, note that we use the ui:include
tag on line 14 to include content (which happens to be a table) from
another XHTML page, so that we can reuse
that table in other views.
- </p>
+
So why do we have two XHTML pages to define a single view? Why not simply take the pieces and manually insert them into the layout so that we have only a single XHTML page? The answer is simple: we have separated layout - from the content so that we can <em>reuse that layout</em> + from the content so that we can reuse that layout among multiple compositions. For example, now we can define another composition that uses the same layout: - </p> +
- <div class="syntax"><div class="html4strict" - style="font-family: monospace;"><ol><li class="li1"><div - class="de1"><span class="sc0"><!DOCTYPE html PUBLIC - "-//W3C//DTD XHTML 1.0 Transitional//EN"</div></li> +
By encapsulating the layout, we can reuse that layout among multiple
compositions. Just like
- <code>ui:include</code> lets us encapsulate and reuse
+ ui:include
lets us encapsulate and reuse
conent, JSF compositions let us encapsulate and reuse
layout, so that changes to a single layout can affect multiple views.
Fundamentally, that's what this
tag library is all about.
- </p>
+
-
+ This tag is the same as the ui:composition
,
except for two things:
JSF creates a component and adds it directly to the tree, and
there's no associated
template.
- </p>
+
Use this tag to create a component and specify a filename for the
- component as either the source of a <code>ui:include</code>,
+ component as either the source of a ui:include
,
or the source of a Facelets tag.
- </p>
- </div>
+
The identifier of the component that JSF inserts into the component tree. If an identifier is not explicitly specified by the page author, JSF will assign an identifier based on the algorithm that it uses for all components. - </p> - </div> +
+ -Binds the component to a backing bean property, as specified in the JSF specification. - </p> - </div> +
+ -
Defines a composition that optionally uses a template, as outlined
in the description of the ui tag library. Multiple
compositions can use the same template, thus encapsulating and
@@ -414,107 +412,107 @@
composition, which lets developers embed compositions in well-formed
XHTML pages that can be viewed in an XHTML viewer,
such as Dreamweaver or a browser, without including extraneous
- elements such as <code>head</code> and <code>body</code>.
- </p>
- <div class="syntax"><div class="html4strict"
- style="font-family: monospace;"><ol><li class="li1"><div
- class="de1"><span class="sc0"><!DOCTYPE html PUBLIC
- "-//W3C//DTD XHTML 1.0 Transitional//EN"</div></li>
+ elements such as head
and body
.
+
A URI that points to a template, also known as a layout, that inserts pieces of the page defined in the composition. - </p> - </div> +
+ -
+ When the ui:debug
tag is placed in an XHTML
page, it creates a component and adds it to the
component tree. That debug component captures debugging information,
namely the current state of the component
@@ -522,509 +520,509 @@
is rendered. If the user presses CTRL + SHIFT + d,
JSF opens a window that shows the debugging information captured by
the debug component.
- </p>
+
+ Typically, the best place to put the ui:debug
tag is in an application's main template, which
lets developers enable or disable viewing of debugging information
in one central location. Additionally, page
authors can change the hotkey (which by default is CTRL + SHIFT + d,
where the d stands for debug) to CTRL + SHIFT + ?,
- where ? represents the key specified as the value of the <code>hotkey</code>
+ where ? represents the key specified as the value of the hotkey
attribute.
- </p>
+
+ You can use the rendered
attribute to
control whether the debug component is rendered.
- Using an EL expression as the value for the <code>rendered</code>
+ Using an EL expression as the value for the rendered
attribute lets you control whether
debug output is enabled for multiple views based on a single bean
property.
- </p>
- </div>
+
Defines a single character, that, pressed in conjunction with CTRL and SHIFT, will display the JSF debug window. - By default, the hotkey is 'd'. <em>The value for the - hotkey attribute cannot be an EL expression.</em> - </p> + By default, the hotkey is 'd'. The value for the + hotkey attribute cannot be an EL expression. +
- </div> + -Controls whether the debug component is rendered. Valid values for this attribute are either the strings "true" or "false" or - an EL expression that evaluates to either "true" or "false".<p>If + an EL expression that evaluates to either "true" or "false".
If this attribute's value is "false" or the value is an EL expression that evaluates to "false", the debug component is not rendered in the page, the hotkey attribute is disregarded, and users cannot open the debugging information window with a - hotkey.</p> - </p> + hotkey.
+ - </div> + -The define
tag defines content
+ that is inserted into a page by a template. The define
+ tag can be used inside ui:composition
, ui:component
,
+ ui:decorate
, and ui:fragment
+ tags.
Content defined by the define
tag
+ can be inserted into a page by using ui:insert
.
+
Assigns a name to the content inside a define
+ tag. That name is used by corresponding ui:insert
+ tags in a template that insert the named content into a page.
+ The decorate
tag is identical to the composition
+ tag, except that ui:decorate
, unlike ui:composition
,
+ does not disregard all content outside of the tag. The decorate
is useful when you want to decorate some content in a page, for
example, you might want to decorate a list of items, like this:
- <div class="syntax"><div class="html4strict"
- style="font-family: monospace;"><ol><li class="li1"><div
- class="de1">
+
ui:decorate
+ tag, ui:decorate
can
be used to decorate pieces of a page.
- </div>
+
- The fragment
tag is identical to
+ the component
tag, except that ui:fragment
,
+ unlike ui:component
, JSF does not disregard
+ all content outside of the tag.
Use this tag—which is very similar to JSP's jsp:include
—to
encapsulate and reuse content among
multiple XHTML pages. There are three things this tag can include:
- plain XHTML, and XHTML pages that have either a <code>composition</code>
- tag or a <code>component</code> tag.
- </p>
- <p>You supply a filename, through <code>ui:include</code>'s
- <code>src</code> attribute for JSF to include. That
+ plain XHTML, and XHTML pages that have either a composition
+ tag or a component
tag.
+
You supply a filename, through ui:include
's
+ src
attribute for JSF to include. That
filename is relative to the XHTML file that was rendered as a result
of the last request. So, for example, if JSF loaded
- the view <code>login.xhtml</code>, and that file
- included <code>pageDecorations/header.xhtml</code>, and
- <code>
- pageDecorations/header.xhtml</code> included <code>companyLogo.xhtml</code>,
- then <code>companyLogo.xhtml</code> will
- not be found if it's in the <code>pageDecorations</code>
- directory, because <code>companyLogo.xhtml</code> has to
+ the view login.xhtml
, and that file
+ included pageDecorations/header.xhtml
, and
+
+ pageDecorations/header.xhtml
included companyLogo.xhtml
,
+ then companyLogo.xhtml
will
+ not be found if it's in the pageDecorations
+ directory, because companyLogo.xhtml
has to
be
- in the same directory as <code>login.xhtml</code>.
- </p>
+ in the same directory as login.xhtml
.
+
Inserts content into a template. That content is defined—with
+ the ui:define
tag— in either a
+ ui:composition
, ui:component
,
+ ui:decorate
, or ui:fragment
.
Use this tag to pass parameters to an included file (using
+ ui:include
), or a template
+ (linked to either a composition or decorator). Embed ui:param
+ tags in either ui:include
,
+ ui:composition
, or ui:decorate
to pass the parameters.
- </div>
+
-
Use this tag as an alternative to h:dataTable
or
- <code>c:forEach</code>, especially when you are using
+ c:forEach
, especially when you are using
the
- <code>jsfc</code> feature of Facelets. You can specify
+ jsfc
feature of Facelets. You can specify
this component as
- the value of the <code>jsfc</code> attribute, like this:
+ the value of the jsfc
attribute, like this:
<div... jsfc="ui:repeat" value="#{contacts}" var="contact">...
- </p>
- </div>
+
Read-write property setting the offset from the beginning of the collection from which to start the iteration. If not set, this offset is not considered and iteration will start at the beginning of the - collection.</p> + collection.
- </div> + -Read-write property setting the size of the collection
to iterate.
If this value is less than the actual size of the collection, a
- <code>FacesException</code> must be thrown.</p>
+ FacesException
must be thrown.
Iteration will only process every step items of the collection, - starting with the first one.</p></div> + starting with the first one.
-The name of a collection of items that this tag
iterates over. The
- collection may be a <code>List</code>, <code>array</code>,
- <code>java.sql.ResultSet</code>, or an individual
+ collection may be a List
, array
,
+ java.sql.ResultSet
, or an individual
java Object. If the
- collection is null, this tag does nothing.</p>
+ collection is null, this tag does nothing.
Name of the exported scoped variable for the current item of the iteration. This scoped variable has nested visibility. Its type depends on the object of the - underlying collection</p></div> + underlying collection
-Name of the exported request scoped variable for the status of the iteration. Object is a POJO with the following read-only JavaBeans properties. This scoped variable has nested - visibility.</p> + visibility.
- <p><code>begin</code> of type Integer</p> +begin
of type Integer
end
of type Integer
index
of type int
step
of type Integer
even
of type boolean
odd
of type boolean
first
of type boolean
last
of type boolean
Remove content from a page. This tag is often used in
+ conjunction with the jsfc
feature of
Facelets,
to wrap additional markup. When Facelets removes markup from a page
by substituting markup items that have
- a <code>jsfc</code> attribute with the specified
+ a jsfc
attribute with the specified
component, Facelets also removes anything in the page that
- is contained in a <code>ui:remove</code> tag.</p>
- </div>
+ is contained in a ui:remove
tag.