o

Only children of type TreeNode are allowed and processed by this component.

This component does not have a renderer since it does not render any markup by itself. This allows the developers to have full control over the markup of the tree by declaring the appropriate JSF components or HTML elements in the markup. Here is a basic usage example:

<o:tree value="#{bean.treeModel}" var="item" varNode="node">
  <o:treeNode>
    <ul>
      <o:treeNodeItem>
        <li>
          #{node.index} #{item.someProperty}
          <o:treeInsertChildren />
        </li>
      </o:treeNodeItem>
    </ul>
  </o:treeNode>
</o:tree>
				

This component allows a child component of type TreeInsertChildren which indicates the place to insert the children of the current child tree node recursively by a TreeNode component associated with the children's level in the same parent Tree component.

<h:form>
  <h:inputText value="#{bean.input1}" required="true" />
  <h:inputText value="#{bean.input1}" required="true" />
  <h:commandButton value="Submit" action="#{bean.submit}" />
</h:form>
<o:highlight />
				

The default error style class name is error. You need to specify a CSS style associated with the class yourself. For example,

label.error {
  color: #f00;
}
input.error, select.error, textarea.error {
  background-color: #fee;
}
				

You can override the default error style class by the styleClass attribute:

<o:highlight styleClass="invalid" />
				

You can disable the default focus on the first invalid input element setting the focus attribute.

<o:highlight styleClass="invalid" focus="false" />
				

{0}: Please fill out all of those fields

General usage of all multiple field validators

This validator must be placed inside the same UIForm as the UIInput components in question. The UIInput components must be referenced by a space separated collection of their client IDs in the components attribute. This validator can be placed anywhere in the form, but keep in mind that the components will be validated in the order as they appear in the form. So if this validator is been placed before all of the components, then it will be executed before any of the component's own validators. If this validator fails, then the component's own validators will not be fired. If this validator is been placed after all of the components, then it will be executed after any of the component's own validators. If any of them fails, then this validator will not be exeucted. It is not recommended to put this validator somewhere in between the referenced components as the resulting behaviour may be confusing. Put this validator either before or after all of the components, depending on how you would like to prioritize the validation.

<o:validateMultipleFields id="myId" components="foo bar baz" />
<h:message for="myId" />
<h:inputText id="foo" />
<h:inputText id="bar" />
<h:inputText id="baz" />
				

In an invalidating case, all of the referenced components will be marked invalid and a faces message will be added on the client ID of this validator component. The default message can be changed by the message attribute. Any "{0}" placeholder in the message will be substituted with a comma separated string of labels of the referenced input components.

<o:validateMultipleFields components="foo bar baz" message="{0} are wrong!" />
				

The faces message can also be shown for all of the referenced components using showMessageFor="@all".

<o:validateMultipleFields components="foo bar baz" message="This is wrong!" showMessageFor="@all" />
<h:inputText id="foo" />
<h:message for="foo" />
<h:inputText id="bar" />
<h:message for="bar" />
<h:inputText id="baz" />
<h:message for="baz" />
				

The showMessageFor attribute defaults to @this. Other values than @this or @all are not allowed.

The validator can be disabled by the disabled attribute. It accepts a request based EL expression.

<o:validateMultipleFields components="foo bar baz" disabled="#{param.validationDisabled}" />
				

There is a read-only validationFailed attribute which can be used to determine if the validation by this component has failed.

<o:validateMultipleFields id="myId" binding="#{myId}" components="foo bar baz" />
<h:panelGroup rendered="#{myId.validationFailed}">
    Validation has failed! <h:message for="myId" />
</h:panelGroup>
				

{0}: Please fill out at least one of those fields

For general usage instructions, refer validateAll tag documentation.

{0}: Please fill out only one or none of those fields

For general usage instructions, refer validateAll tag documentation.

{0}: Please fill out an unique value for all of those fields

For general usage instructions, refer validateAll tag documentation.

<o:validator validatorId="someValidatorId" disabled="#{param.disableValidation}" />
				

Note that not all available attributes are listed. This depends on the validator you're specifying. When you specify for example the standard <f:validateLongRange> by validatorId="javax.faces.LongRange", then you'll be able to use all its attributes such as minimum and maximum as per its documentation, but then with the possibility to supply request based value expressions.

<o:validator validatorId="javax.faces.LongRange" minimum="#{item.minimum}" maximum="#{item.maximum}" />
				

The standard UIViewParameter implementation calls the model setter again after postback. This is not always desired when being bound to a view scoped beans and can lead to performance problems when combined with an expensive converter.

To solve this, this component by default stores the submitted value as a component property instead of in the model (and thus in the view state in case the binding is to a view scoped bean).

You can use it the same way as <f:viewParam>, you only need to change f: by o:.

Both simple component ids as well as client ids are supported. Components can be rendered without their parents having to be rendered. As such, e.g. single rows appearing in a table can be rendered without any of the surrounding markup appearing in the response.

The intended usage of this component is to allow client-side scripts to request markup for specific components via a GET request (as opposed to AJAX based post-backs).

This component is used in the same way view parameters are and needs to be put into the metadata section of a Facelet.

It renders an HTML "label" element. If a "for" attribute is specified, the component specified by the value of the "for" attribute is queried for its client id, which is then rendered as the value of the "for" attribute of the HTML label element.

By default the viewid concatenated to the component id via an underscore is used as the cache key.

Note that this component does not support a cache loader and locking mechanism. This mean several simultaenous page requests may render the same content and it's undetermined which of those will end up being cached.

An optional caching provider (see below) can be set to control the caching implementation that is used for the actual caching. If no such provider is installed, a default caching implementation is used that's based on http://code.google.com/p/concurrentlinkedhashmap in case a maximum cache capacity is set, or on a plain ConcurrentMap if no capacity is set.

Setting a custom caching provider

<context-param>
	<param-name>org.omnifaces.CACHE_PROVIDER</param-name>
	<param-value>com.example.MyProvider</param-value>
</context-param>
				

The default provider, org.omnifaces.component.output.cache.DefaultCacheProvider can be used as an example.

Global settings

Servlet 2.5 configuration

<listener>
	<listener-class>org.omnifaces.component.output.cache.CacheInitializerListener</listener-class>
</listener>
				

The <o:importConstants> allows the developer to have a mapping of all constant field values of the given type in the EL scope. The constant field values are those public static final fields. This works for classes, interfaces and enums. For example:

public class Foo {
    public static final String FOO1 = "foo1";
    public static final String FOO2 = "foo2";
}

public interface Bar {
    public static final String BAR1 = "bar1";
    public static final String BAR2 = "bar2";
}

public enum Baz {
    BAZ1, BAZ2;
}
				

The constant field values of the above types can be mapped into the EL scope as follows:

<o:importConstants type="com.example.Foo" />
<o:importConstants type="com.example.Bar" />
<o:importConstants type="com.example.Baz" var="Bazzz" />
...
#{Foo.FOO1}, #{Foo.FOO2}, #{Bar.BAR1}, #{Bar.BAR2}, #{Bazzz.BAZ1}, #{Bazzz.BAZ2}
				

The map is by default stored in the EL scope by the simple name of the type as variable name. You can override this by explicitly specifying the var attribute, as demonstrated for com.example.Baz in the above example.

The resolved constants are by reference stored in the cache to improve retrieving performance.

Any validation errors will be ignored and thus not be displayed. Note that the model values will (obviously) only be updated for components which have passed the validation.

<h:commandButton>
    <o:validateBean groups="javax.validation.groups.Default,com.example.MyGroup"/>
</h:commandButton>
		        

CommandScript is an extension to <h:commandXxx> which generates a JavaScript function in the global JavaScript scope which allows the enduser to execute a JSF ajax request by a just function call functionName() in the JavaScript context.

The <o:commandScript> component is required to be enclosed in an UIForm component. The name attribute is required and it represents the JavaScript function name. The execute and render attributes work exactly the same as in <f:ajax>. The onbegin and oncomplete attributes must represent (valid!) JavaScript code which will be executed before sending the ajax request and after processing the ajax response respectively. The action, actionListener and immediate attributes work exactly the same as in <h:commandXxx>.

Basic usage example of <o:commandScript> which submits the entire form on click of a plain HTML button:

<h:form>
  <h:inputText value="#{bean.input1}" ... />
  <h:inputText value="#{bean.input2}" ... />
  <h:inputText value="#{bean.input3}" ... />
  <o:commandScript name="submitForm" action="#{bean.submit}" render="@form" />
</h:form>
<input type="button" value="submit" onclick="submitForm()" />
				

Usage example which uses the <o:commandScript> as a poll function which updates every 3 seconds:

<h:form>
  <h:dataTable id="data" value="#{bean.data}" ...>...</h:dataTable>
  <o:commandScript name="updateData" action="#{bean.reloadData}" render="data" />
</h:form>
<h:outputScript target="body">setInterval(updateData, 3000);</h:outputScript>
				

functionName({ name1: "value1", name2: "value2" });
				

With the above example, the parameters are in the action method available as follows:

String name1 = Faces.getRequestParameter("name1"); // value1
String name2 = Faces.getRequestParameter("name2"); // value2