/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.myfaces.trinidad.component;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectOutputStream;
import java.net.URL;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import javax.el.ELContext;
import javax.el.ELException;
import javax.el.MethodExpression;
import javax.el.ValueExpression;
import javax.faces.FacesException;
import javax.faces.application.ProjectStage;
import javax.faces.component.ContextCallback;
import javax.faces.component.NamingContainer;
import javax.faces.component.StateHolder;
import javax.faces.component.UIComponent;
import javax.faces.component.behavior.ClientBehavior;
import javax.faces.component.behavior.ClientBehaviorHolder;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.faces.el.EvaluationException;
import javax.faces.el.MethodBinding;
import javax.faces.el.ValueBinding;
import javax.faces.event.AbortProcessingException;
import javax.faces.event.ComponentSystemEvent;
import javax.faces.event.ComponentSystemEventListener;
import javax.faces.event.FacesEvent;
import javax.faces.event.FacesListener;
import javax.faces.event.PostAddToViewEvent;
import javax.faces.event.PreRemoveFromViewEvent;
import javax.faces.event.PreRenderComponentEvent;
import javax.faces.event.SystemEvent;
import javax.faces.event.SystemEventListener;
import javax.faces.render.RenderKit;
import javax.faces.render.Renderer;
import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFComponent;
import org.apache.myfaces.trinidad.bean.AttachedObjects;
import org.apache.myfaces.trinidad.bean.FacesBean;
import org.apache.myfaces.trinidad.bean.FacesBeanFactory;
import org.apache.myfaces.trinidad.bean.PropertyKey;
import org.apache.myfaces.trinidad.bean.util.StateUtils;
import org.apache.myfaces.trinidad.bean.util.ValueMap;
import org.apache.myfaces.trinidad.change.AttributeComponentChange;
import org.apache.myfaces.trinidad.change.ComponentChange;
import org.apache.myfaces.trinidad.change.RowKeySetAttributeChange;
import org.apache.myfaces.trinidad.component.ComponentProcessingContext.ProcessingHint;
import org.apache.myfaces.trinidad.context.RenderingContext;
import org.apache.myfaces.trinidad.context.RequestContext;
import org.apache.myfaces.trinidad.event.AttributeChangeEvent;
import org.apache.myfaces.trinidad.event.AttributeChangeListener;
import org.apache.myfaces.trinidad.logging.TrinidadLogger;
import org.apache.myfaces.trinidad.model.RowKeySet;
import org.apache.myfaces.trinidad.render.ExtendedRenderer;
import org.apache.myfaces.trinidad.render.LifecycleRenderer;
import org.apache.myfaces.trinidad.util.CollectionUtils;
import org.apache.myfaces.trinidad.util.ThreadLocalUtils;
/**
* Base implementation of components for all of Trinidad. UIXComponentBase
* offers a number of features not supplied by the standard UIComponentBase
* class:
* <ul>
* <li>Use of FacesBean for better and easier state saving</li>
* <li>Support of the LifecycleRenderer class for greater Renderer
* control over the lifecycle</li>
* <li>Built-in support for both the "partialTriggers" attribute
* (declarative support for being a PPR target) and for triggering
* such components (for being a the source of a PPR-causing event).</li>
* </ul>
* <h3>FacesBean and UIXComponentBase</h3>
* <p>
* UIXComponentBase differs from UIXComponent most particularly
* in its use of FacesBeans to store all state. This offers
* a number of advantages:
* <ul>
* <li>Subclassers - if they use FacesBean for their state as well -
* do not need to write overrides of saveState() and restoreState().
* </li>
* <li>State is optimized by default</li>
* <li>Future optimizations - partly exposed today with
* markInitialState() - can offer major state saving improvements.
* </ul>
* </p>
*/
// TODO Write Class Javadoc
// TODO Thorough review against UIComponentBase
@JSFComponent
abstract public class UIXComponentBase extends UIXComponent
{
// Created up top to ensure it's present while we're processing
// class initialization code.
static private final TrinidadLogger _LOG = TrinidadLogger.createTrinidadLogger(UIXComponentBase.class);
static public final FacesBean.Type TYPE = _createType();
static public final PropertyKey ID_KEY =
TYPE.registerKey("id", String.class, PropertyKey.CAP_NOT_BOUND);
static public final PropertyKey RENDERED_KEY =
TYPE.registerKey("rendered", Boolean.class, Boolean.TRUE);
static public final PropertyKey BINDING_KEY =
TYPE.registerKey("binding");
static public final PropertyKey TRANSIENT_KEY =
TYPE.registerKey("transient", Boolean.class,
PropertyKey.CAP_NOT_BOUND |
PropertyKey.CAP_TRANSIENT);
static public final PropertyKey RENDERER_TYPE_KEY =
TYPE.registerKey("rendererType", String.class, PropertyKey.CAP_NOT_BOUND);
static private final PropertyKey _LISTENERS_KEY =
TYPE.registerKey("listeners", FacesListener[].class, PropertyKey.CAP_LIST);
static private final PropertyKey _ATTRIBUTE_CHANGE_LISTENER_KEY =
TYPE.registerKey("attributeChangeListener", MethodExpression.class);
static private final PropertyKey _CLIENT_BEHAVIORS_KEY =
TYPE.registerKey("clientBehaviors", AttachedObjects.class,
PropertyKey.CAP_NOT_BOUND|PropertyKey.CAP_PARTIAL_STATE_HOLDER|PropertyKey.CAP_STATE_HOLDER);
static private final PropertyKey _SYSTEM_EVENT_LISTENERS_KEY =
TYPE.registerKey("systemEventListeners", AttachedObjects.class,
PropertyKey.CAP_NOT_BOUND|PropertyKey.CAP_PARTIAL_STATE_HOLDER|PropertyKey.CAP_STATE_HOLDER);
// =-=AEW "parent", "rendersChildren", "childCount", "children",
// "facets", "facetsAndChildren", "family" all are technically
// bean properties, but they aren't exposed here...
static
{
// Register a couple of PropertyKeys against names that
// the RI's UIComponentTag implementation is shoving
// into all components. This is purely an optimization, but
// a very useful one.
TYPE.registerKey("javax.faces.webapp.COMPONENT_IDS",
List.class,
PropertyKey.CAP_NOT_BOUND);
TYPE.registerKey("javax.faces.webapp.FACET_NAMES",
List.class,
PropertyKey.CAP_NOT_BOUND);
TYPE.lock();
}
public UIXComponentBase()
{
}
public UIXComponentBase(String rendererType)
{
setRendererType(rendererType);
}
protected FacesBean createFacesBean(
String rendererType)
{
FacesBean bean = FacesBeanFactory.createFacesBean(getClass(),
rendererType);
UIXFacesBean uixBean = (UIXFacesBean) bean;
uixBean.init(this, getBeanType());
return uixBean;
}
protected PropertyKey getPropertyKey(String name)
{
PropertyKey key = getBeanType().findKey(name);
if (key == null)
key = PropertyKey.createPropertyKey(name);
return key;
}
protected FacesBean.Type getBeanType()
{
return TYPE;
}
@Override
public FacesBean getFacesBean()
{
if (_facesBean == null)
_init(null);
return _facesBean;
}
@Override
public String getContainerClientId(FacesContext context, UIComponent child)
{
return getContainerClientId(context);
}
@Override
public void addAttributeChangeListener(AttributeChangeListener acl)
{
addFacesListener(acl);
}
@Override
public void removeAttributeChangeListener(AttributeChangeListener acl)
{
removeFacesListener(acl);
}
@Override
public AttributeChangeListener[] getAttributeChangeListeners()
{
return (AttributeChangeListener[])
getFacesListeners(AttributeChangeListener.class);
}
@Override
public void setAttributeChangeListener(MethodExpression mb)
{
setProperty(_ATTRIBUTE_CHANGE_LISTENER_KEY, mb);
}
@Deprecated
public void setAttributeChangeListener(MethodBinding mb)
{
setAttributeChangeListener(adaptMethodBinding(mb));
}
@Override
public MethodExpression getAttributeChangeListener()
{
return (MethodExpression) getProperty(_ATTRIBUTE_CHANGE_LISTENER_KEY);
}
@Override
public ValueExpression getValueExpression(String name)
{
if (name == null)
throw new NullPointerException();
PropertyKey key = getPropertyKey(name);
// Support standard RI behavior where getValueBinding()
// doesn't complain about being asked for a ValueBinding -
// but continue supporting strict behavior at FacesBean layer.
if (!key.getSupportsBinding())
return null;
return getFacesBean().getValueExpression(key);
}
@Override
public void setValueExpression(String name,
ValueExpression expression)
{
if (name == null)
throw new NullPointerException();
if ((expression != null) && expression.isLiteralText())
{
ELContext context =
FacesContext.getCurrentInstance().getELContext();
getAttributes().put(name, expression.getValue(context));
}
else
{
PropertyKey key = getPropertyKey(name);
getFacesBean().setValueExpression(key, expression);
}
}
/**
*/
@Override
public ValueBinding getValueBinding(String name)
{
if (name == null)
throw new NullPointerException();
PropertyKey key = getPropertyKey(name);
// Support standard RI behavior where getValueBinding()
// doesn't complain about being asked for a ValueBinding -
// but continue supporting strict behavior at FacesBean layer.
if (!key.getSupportsBinding())
return null;
return getFacesBean().getValueBinding(key);
}
@Override
public void setValueBinding(String name, ValueBinding binding)
{
if (name == null)
throw new NullPointerException();
PropertyKey key = getPropertyKey(name);
getFacesBean().setValueBinding(key, binding);
}
@Override
public Map<String, Object> getAttributes()
{
if (_attributes == null)
_init(null);
return _attributes;
}
@Override
protected Iterator<UIComponent> getRenderedFacetsAndChildren(
FacesContext facesContext)
{
_cacheRenderer(facesContext);
return super.getRenderedFacetsAndChildren(facesContext);
}
/**
* Convenience method for implementors of {@link FlattenedComponent} to setup either the
* visiting context or the encoding context based on if the {@link ComponentProcessingContext}
* is processing for encoding or not.
* @param facesContext The faces context
* @param cpContext The component processing context passed to
* {@link FlattenedComponent#processFlattenedChildren}
*/
protected void setupFlattenedContext(
FacesContext facesContext,
ComponentProcessingContext cpContext
)
{
if (cpContext.getHints().contains(ProcessingHint.PROCESS_FOR_ENCODING))
{
setupEncodingContext(facesContext, RenderingContext.getCurrentInstance());
}
else
{
setupVisitingContext(facesContext);
}
}
/**
* Convenience method for implementors of {@link FlattenedComponent} to setup either the
* visiting context or the encoding context based on if the {@link ComponentProcessingContext}
* is processing for encoding or not.
* @param facesContext The faces context
* @param cpContext The component processing context passed to
* {@link FlattenedComponent#processFlattenedChildren}
*/
protected void setupFlattenedChildrenContext(
FacesContext facesContext,
ComponentProcessingContext cpContext
)
{
if (cpContext.getHints().contains(ProcessingHint.PROCESS_FOR_ENCODING))
{
setupChildrenEncodingContext(facesContext, RenderingContext.getCurrentInstance());
}
else
{
setupChildrenVisitingContext(facesContext);
}
}
/**
* Convenience method for implementors of {@link FlattenedComponent} to tear down either the
* visiting context or the encoding context based on if the {@link ComponentProcessingContext}
* is processing for encoding or not.
* @param facesContext The faces context
* @param cpContext The component processing context passed to
* {@link FlattenedComponent#processFlattenedChildren}
*/
protected void tearDownFlattenedContext(
FacesContext facesContext,
ComponentProcessingContext cpContext
)
{
if (cpContext.getHints().contains(ProcessingHint.PROCESS_FOR_ENCODING))
{
tearDownEncodingContext(facesContext, RenderingContext.getCurrentInstance());
}
else
{
tearDownVisitingContext(facesContext);
}
}
/**
* Convenience method for implementors of {@link FlattenedComponent} to tear down either the
* visiting context or the encoding context based on if the {@link ComponentProcessingContext}
* is processing for encoding or not.
* @param facesContext The faces context
* @param cpContext The component processing context passed to
* {@link FlattenedComponent#processFlattenedChildren}
*/
protected void tearDownFlattenedChildrenContext(
FacesContext facesContext,
ComponentProcessingContext cpContext
)
{
if (cpContext.getHints().contains(ProcessingHint.PROCESS_FOR_ENCODING))
{
tearDownChildrenEncodingContext(facesContext, RenderingContext.getCurrentInstance());
}
else
{
tearDownChildrenVisitingContext(facesContext);
}
}
// ------------------------------------------------------------- Properties
/**
* Calculates the clientId for the component
*/
private String _calculateClientId(FacesContext context)
{
// the clientId is always at least the id of the current component
// our implementation of getId() guarantees that this always
// returns a non-null value
String clientId = getId();
// Search for an ancestor that is a naming container
UIComponent containerComponent = getParent();
while (null != containerComponent)
{
if (containerComponent instanceof NamingContainer)
{
String contClientId;
// Pass additional context information to naming containers which extend UIXComponent:
if (containerComponent instanceof UIXComponent)
contClientId = ((UIXComponent)containerComponent).getContainerClientId(context, this);
else
contClientId = containerComponent.getContainerClientId(context);
StringBuilder bld = __getSharedStringBuilder();
bld.append(contClientId).append(NamingContainer.SEPARATOR_CHAR).append(clientId);
clientId = bld.toString();
break;
}
containerComponent = containerComponent.getParent();
}
Renderer renderer = getRenderer(context);
if (null != renderer)
clientId = renderer.convertClientId(context, clientId);
return clientId;
}
@Override
public String getClientId(FacesContext context)
{
if (_isClientIdCachingEnabled())
{
String clientId = _clientId;
if (clientId == null)
{
// This should not be called when the parent has not been set. Should it be
// called, the value will not be re-calculated correctly. This will be the case
// if someone attempts to invoke this function during facelets view construction.
if (_parent == null)
{
_LOG.warning("INVALID_CALL_TO_GETCLIENTID", getId());
// Return the value, even if not valid, for backward compatibility
return _calculateClientId(context);
}
clientId = _calculateClientId(context);
if (_usesFacesBeanImpl)
{
_clientId = clientId;
}
}
else if (_isClientIdDebuggingEnabled())
{
_warnClientIdCachingConfig(context);
// for now validate success by checking the cached result against the dynamically
// generated result
String realID = _calculateClientId(context);
if (!clientId.equals(realID))
throw new IllegalStateException(
String.format("Cached client id %s for %s doesn't match client id: %s",
clientId, this, realID));
}
return clientId;
}
else
{
_warnClientIdCachingConfig(context);
return _calculateClientId(context);
}
}
/**
* Gets the identifier for the component. This implementation
* never returns a null id.
*/
@Override
public String getId()
{
// determine whether we can use the optimized code path or not
if (_usesFacesBeanImpl)
{
// optimized path
// make sure that we always have an id
if (_id == null)
{
_id = FacesContext.getCurrentInstance().getViewRoot().createUniqueId();
}
return _id;
}
else
{
// unoptimized path
FacesBean facesBean = getFacesBean();
String id = (String)facesBean.getProperty(ID_KEY);
// make sure that we always have an id
if (id == null)
{
id = FacesContext.getCurrentInstance().getViewRoot().createUniqueId();
facesBean.setProperty(ID_KEY, id);
}
return id;
}
}
/**
* Sets the identifier for the component. The identifier
* must follow a subset of the syntax allowed in HTML:
* <ul>
* <li>Must not be a zero-length String.</li>
* <li>First character must be an ASCII letter (A-Za-z) or an underscore ('_').</li>
* <li>Subsequent characters must be an ASCII letter or digit (A-Za-z0-9), an underscore ('_'), or a dash ('-').
* </ul>
*/
@Override
public void setId(String id)
{
FacesBean facesBean = getFacesBean();
// if we are using a FacesBeanImpl, then the FacesBean will
// delegate all calls to set the id back to us and we can store
// the value localy. Otehrwise,w e need to store it in
// the FacesBean
if (_usesFacesBeanImpl)
{
// only validate if the id has actually changed
if ((_id == null) || !_id.equals(id))
{
_validateId(id);
_id = id;
// if we're a NamingContainer then changing our id will invalidate the clientIds of all
// of our children
if ((_clientId != null) && (this instanceof NamingContainer))
{
clearCachedClientIds(this);
}
}
}
else
{
_validateId(id);
facesBean.setProperty(ID_KEY, id);
}
_clientId = null;
}
@Override
abstract public String getFamily();
@Override
public UIComponent getParent()
{
return _parent;
}
/**
* <p>Set the parent <code>UIComponent</code> of this
* <code>UIComponent</code>.</p>
*
* @param parent The new parent, or <code>null</code> for the root node
* of a component tree
*/
@Override
public void setParent(UIComponent parent)
{
// do we add this component ?
if (parent != _parent)
{
if (parent != null)
{
// set the reference
_parent = parent;
_resetClientId();
if (parent.isInView())
{
// trigger the ADD_EVENT and call setInView(true)
// recursive for all kids/facets...
// Application.publishEvent(java.lang.Class, java.lang.Object) must be called, passing
// PostAddToViewEvent.class as the first argument and the newly added component as the second
// argument.
_publishPostAddToViewEvent(getFacesContext(), this);
}
}
else
{
if (_parent != null && _parent.isInView())
{
// trigger the "remove event" lifecycle
// and call setInView(false) for all children/facets
// doing this => recursive
_publishPreRemoveFromViewEvent(getFacesContext(), this);
}
// (un)set the reference
_parent = parent;
_resetClientId();
}
}
}
private void _resetClientId()
{
// clear cached client ids if necessary
if (_clientId != null)
{
String newClientId = _calculateClientId(FacesContext.getCurrentInstance());
// if our clientId changed as a result of being reparented (because we moved
// between NamingContainers for instance) then we need to clear out
// all of the cached client ids for our subtree
if (!_clientId.equals(newClientId))
{
clearCachedClientIds();
_clientId = newClientId;
}
}
}
@Override
public boolean isRendered()
{
return getBooleanProperty(RENDERED_KEY, true);
}
@Override
public void setRendered(boolean rendered)
{
setBooleanProperty(RENDERED_KEY, rendered);
}
public boolean isTransient()
{
return getBooleanProperty(TRANSIENT_KEY, false);
}
public void setTransient(boolean newTransient)
{
setBooleanProperty(TRANSIENT_KEY, newTransient);
}
@Override
public String getRendererType()
{
// Don't create the FacesBean just to get the renderer type;
// Generally, rendererType will be the first property
// set, which will trigger the code below in setRendererType()
// to run correctly.
if (_facesBean == null)
return null;
return (String) getProperty(RENDERER_TYPE_KEY);
}
@Override
public void setRendererType(String rendererType)
{
String oldRendererType = getRendererType();
if (oldRendererType == null)
{
if (rendererType == null)
return;
}
else if (oldRendererType.equals(rendererType))
{
return;
}
// prepare the faces bean
_init(rendererType);
setProperty(RENDERER_TYPE_KEY, rendererType);
}
@Override
public boolean getRendersChildren()
{
Renderer renderer = getRenderer(getFacesContext());
if (renderer == null)
return false;
return renderer.getRendersChildren();
}
// ------------------------------------------------ Tree Management Methods
@Override
public UIComponent findComponent(String id)
{
if (id == null)
throw new NullPointerException();
if ("".equals(id))
throw new IllegalArgumentException();
UIComponent from = this;
// If it starts with the separator character, it's
// an absolute path: start at the top
if (id.charAt(0) == NamingContainer.SEPARATOR_CHAR)
{
id = id.substring(1);
while (from.getParent() != null)
from = from.getParent();
}
// If it's a NamingContainer, start right here
else if (this instanceof NamingContainer)
{
;
}
// Otherwise, go up to look for NamingContainer (or the top)
else
{
while (from.getParent() != null)
{
from = from.getParent();
if (from instanceof NamingContainer)
break;
}
}
// Evaluate each part of the expression
String searchId;
int separatorIndex = id.indexOf(NamingContainer.SEPARATOR_CHAR);
if (separatorIndex < 0)
searchId = id;
else
searchId = id.substring(0, separatorIndex);
if (searchId.equals(from.getId()))
{
// Don't need to look inside if we're already there
;
}
else
{
from = _findInsideOf(from, searchId);
}
// Final ID: break, and return whatever we've found
if (separatorIndex < 0)
{
return from;
}
// Just an intermediate step. Make sure we're at a NamingContainer,
// and then ask it to find the rest of the expression.
else
{
if (from == null)
return null;
if (!(from instanceof NamingContainer))
throw new IllegalArgumentException();
return from.findComponent(id.substring(separatorIndex + 1));
}
}
/**
* <p>Create (if necessary) and return a List of the children associated
* with this component.</p>
*/
@Override
public List<UIComponent> getChildren()
{
if (_children == null)
_children = new ChildArrayList(this);
return _children;
}
@Override
public int getChildCount()
{
if (_children == null)
return 0;
else
return getChildren().size();
}
/**
* <p>Create (if necessary) and return a Map of the facets associated
* with this component.</p>
*/
@Override
public Map<String, UIComponent> getFacets()
{
if (_facets == null)
_facets = new FacetHashMap(this);
return _facets;
}
@Override
public UIComponent getFacet(String facetName)
{
if (facetName == null)
throw new NullPointerException();
if (_facets == null)
return null;
else
return getFacets().get(facetName);
}
/**
* Returns an Iterator over the names of all facets.
* Unlike getFacets().keySet().iterator(), this does
* not require instantiating a Map if there are
* no facets. (Note that this is not part of the
* UIComponent API.)
*/
public Iterator<String> getFacetNames()
{
if (_facets == null)
return _EMPTY_STRING_ITERATOR;
else
return _facets.keySet().iterator();
}
@Override
public Iterator<UIComponent> getFacetsAndChildren()
{
// =-=AEW Is this supposed to be an immutable Iterator?
if (_facets == null)
{
if (_children == null)
return _EMPTY_UICOMPONENT_ITERATOR;
return _children.iterator();
}
else
{
if (_children == null)
return _facets.values().iterator();
}
return new CompositeIterator<UIComponent>(_children.iterator(), _facets.values().iterator());
}
// ------------------------------------------- Event processing methods
@Override
public void broadcast(FacesEvent event)
throws AbortProcessingException
{
if (event == null)
throw new NullPointerException();
if (_LOG.isFine())
_LOG.fine("Broadcasting event " + event + " to " + this);
UIComponent component = event.getComponent();
if (component != null && satisfiesPartialTrigger(event))
{
RequestContext adfContext = RequestContext.getCurrentInstance();
if (adfContext != null)
adfContext.partialUpdateNotify(component);
}
Iterator<FacesListener> iter =
(Iterator<FacesListener>)getFacesBean().entries(_LISTENERS_KEY);
while (iter.hasNext())
{
FacesListener listener = iter.next();
if (event.isAppropriateListener(listener))
{
event.processListener(listener);
}
}
if (event instanceof AttributeChangeEvent)
{
broadcastToMethodExpression(event, getAttributeChangeListener());
}
}
/**
* Check if a faces event broadcast to this component should trigger the partial updates of the
* target listeners of this component. By default, all events trigger a partial update of the listeners.
*
* @param event The event to check
* @return true if the partial triggers should be updated by this event being broadcast
*/
protected boolean satisfiesPartialTrigger(
FacesEvent event)
{
return true;
}
// ------------------------------------------- Lifecycle Processing Methods
@Override
public void decode(FacesContext context)
{
if (context == null)
throw new NullPointerException();
// Find all the partialTriggers and save on the context
Map<String, Object> attrs = getAttributes();
Object triggers = attrs.get("partialTriggers");
if (triggers instanceof String[])
{
RequestContext adfContext = RequestContext.getCurrentInstance();
if (adfContext != null)
adfContext.addPartialTriggerListeners(this, (String[]) triggers);
}
__rendererDecode(context);
}
@Override
public void encodeBegin(FacesContext context) throws IOException
{
if (context == null)
throw new NullPointerException();
// Call UIComponent.pushComponentToEL(javax.faces.context.FacesContext, javax.faces.component.UIComponent)
pushComponentToEL(context, this);
if (!isRendered())
return;
context.getApplication().publishEvent(context, PreRenderComponentEvent.class, UIComponent.class, this);
_cacheRenderer(context);
Renderer renderer = getRenderer(context);
// if there is a Renderer for this component
if (renderer != null)
{
renderer.encodeBegin(context, this);
}
}
@Override
public void encodeChildren(FacesContext context) throws IOException
{
if (context == null)
throw new NullPointerException();
if (!isRendered())
return;
Renderer renderer = getRenderer(context);
// if there is a Renderer for this component
if (renderer != null)
{
renderer.encodeChildren(context, this);
}
}
@Override
public void encodeEnd(FacesContext context) throws IOException
{
if (context == null)
throw new NullPointerException();
try
{
if (isRendered())
{
Renderer renderer = getRenderer(context);
// if there is a Renderer for this component
if (renderer != null)
{
renderer.encodeEnd(context, this);
}
}
}
finally
{
popComponentFromEL(context);
}
}
@Override
public void queueEvent(FacesEvent event)
{
if (event == null)
throw new NullPointerException();
UIComponent parent = getParent();
if (parent == null)
throw new IllegalStateException();
parent.queueEvent(event);
}
// ----------------------------------------------- Lifecycle Phase Handlers
@Override
public void processDecodes(FacesContext context)
{
if (context == null)
throw new NullPointerException();
if (!isRendered())
return;
pushComponentToEL(context, this);
try
{
// Process all facets and children of this component
decodeChildren(context);
// Process this component itself
decode(context);
}
finally
{
// Call UIComponent.popComponentFromEL(javax.faces.context.FacesContext) from inside of a finally
// block, just before returning.
popComponentFromEL(context);
}
}
@Override
public void processValidators(FacesContext context)
{
if (context == null)
throw new NullPointerException();
if (!isRendered())
return;
pushComponentToEL(context, this);
try
{
// Process all facets and children of this component
validateChildren(context);
}
finally
{
popComponentFromEL(context);
}
}
@Override
public void processUpdates(FacesContext context)
{
if (context == null)
throw new NullPointerException();
if (!isRendered())
return;
pushComponentToEL(context, this);
try
{
// Process all facets and children of this component
updateChildren(context);
}
finally
{
popComponentFromEL(context);
}
}
@Override
public Object processSaveState(FacesContext context)
{
if (context == null)
throw new NullPointerException();
if (_LOG.isFiner())
_LOG.finer("processSaveState() on " + this);
pushComponentToEL(context, this);
Object state = null;
try
{
if (((_children == null) || _children.isEmpty()) &&
((_facets == null) || _facets.isEmpty()))
{
state = saveState(context);
}
else
{
TreeState treeState = new TreeState();
treeState.saveState(context, this);
if (treeState.isEmpty())
state = null;
state = treeState;
}
}
catch (RuntimeException e)
{
_LOG.warning(_LOG.getMessage("COMPONENT_CHILDREN_SAVED_STATE_FAILED", this));
throw e;
}
finally
{
popComponentFromEL(context);
}
return state;
}
// TODO will have deep problems if UIComponent.saveState() ever
// returns a String.
// TODO crashes and burns if there are fewer children or missing
// facets from when state was saved.
@Override
public void processRestoreState(FacesContext context, Object state)
{
if (context == null)
throw new NullPointerException();
if (_LOG.isFiner())
_LOG.finer("processRestoreState() on " + this);
pushComponentToEL(context, this);
try
{
// If we saved a "TreeState", use it to restore everything
if (state instanceof TreeState)
{
((TreeState) state).restoreState(context, this);
}
// Otherwise, we had no children or facets, and just use
// the "state" object
else
{
restoreState(context, state);
}
}
finally
{
popComponentFromEL(context);
}
}
@Override
public void markInitialState()
{
// -= Simon Lessard =-
// FIXME: Set to true, but never read
//_initialStateMarked = true;
getFacesBean().markInitialState();
}
@Override
public void clearInitialState()
{
getFacesBean().clearInitialState();
}
@Override
public boolean initialStateMarked()
{
return getFacesBean().initialStateMarked();
}
public Object saveState(FacesContext facesContext)
{
Object state = getFacesBean().saveState(facesContext);
// if component state serialization checking is on, attempt to Serialize the
// component state immediately in order to determine which component's state
// failed state saving.
if (StateUtils.checkComponentStateSerialization(facesContext))
{
try
{
new ObjectOutputStream(new ByteArrayOutputStream()).writeObject(state);
}
catch (IOException e)
{
throw new RuntimeException(_LOG.getMessage("COMPONENT_SAVED_STATE_FAILED", this), e);
}
}
return state;
}
public void restoreState(
FacesContext facesContext,
Object stateObj)
{
getFacesBean().restoreState(facesContext, stateObj);
}
@Override
public String toString()
{
String className = getClass().getName();
int periodIndex = className.lastIndexOf('.');
if (periodIndex >= 0)
className = className.substring(periodIndex + 1);
return className + "[" + getFacesBean().toString() + ", id=" + getId() + "]";
}
/**
* <p>Return the {@link FacesContext} instance for the current request.</p>
*/
@Override
protected FacesContext getFacesContext()
{
// If we ever have a way for a component to get notified
// when it's finished being used for a given request,
// we could cache this as an instance variable.
return FacesContext.getCurrentInstance();
}
/**
* Delegates to LifecycleRenderer, if present,
* otherwise calls decodeChildrenImpl.
*
* @param context the current FacesContext
*/
final protected void decodeChildren(FacesContext context)
{
LifecycleRenderer renderer = getLifecycleRenderer(context);
// if there is a HierarchyRenderer for this component
if (renderer != null)
{
if (renderer.decodeChildren(context, this))
return;
}
decodeChildrenImpl(context);
}
/**
* Calls processDecodes on all facets and children of this
* component.
* @param context the current FacesContext
*/
protected void decodeChildrenImpl(FacesContext context)
{
Iterator<UIComponent> kids = getRenderedFacetsAndChildren(context);
while (kids.hasNext())
{
UIComponent kid = kids.next();
kid.processDecodes(context);
}
}
/**
* Delegates to LifecycleRenderer, if present,
* otherwise calls validateChildrenImpl.
*
* @param context the current FacesContext
*/
final protected void validateChildren(FacesContext context)
{
LifecycleRenderer renderer = getLifecycleRenderer(context);
// if there is a ExtendedRenderer for this component
if (renderer != null)
{
if (renderer.validateChildren(context, this))
return;
}
validateChildrenImpl(context);
}
/**
* Calls processValidators on all facets and children of this
* component.
* @param context the current FacesContext
*/
protected void validateChildrenImpl(FacesContext context)
{
// Process all the facets and children of this component
Iterator<UIComponent> kids = getRenderedFacetsAndChildren(context);
while (kids.hasNext())
{
UIComponent kid = kids.next();
kid.processValidators(context);
}
}
/**
* Delegates to LifecycleRenderer, if present,
* otherwise calls upateChildrenImpl.
*
* @param context the current FacesContext
*/
final protected void updateChildren(FacesContext context)
{
LifecycleRenderer renderer = getLifecycleRenderer(context);
// if there is a ExtendedRenderer for this component
if (renderer != null)
{
if (renderer.updateChildren(context, this))
return;
}
updateChildrenImpl(context);
}
protected void updateChildrenImpl(FacesContext context)
{
// Process all the facets and children of this component
Iterator<UIComponent> kids = getRenderedFacetsAndChildren(context);
while (kids.hasNext())
{
UIComponent kid = kids.next();
kid.processUpdates(context);
}
}
@Override
protected void addFacesListener(FacesListener listener)
{
if (listener == null)
throw new NullPointerException();
getFacesBean().addEntry(_LISTENERS_KEY, listener);
}
@Override
protected void removeFacesListener(FacesListener listener)
{
if (listener == null)
throw new NullPointerException();
getFacesBean().removeEntry(_LISTENERS_KEY, listener);
}
@Override
protected FacesListener[] getFacesListeners(Class clazz)
{
if (clazz == null)
throw new NullPointerException();
if (!FacesListener.class.isAssignableFrom(clazz))
throw new IllegalArgumentException();
return (FacesListener[])
getFacesBean().getEntries(_LISTENERS_KEY, clazz);
}
/**
* Adds a change for a Component, or the Component's subtree, returning the change actually added,
* or <code>null</code>, if no change was added. The proposed change may be rejected by the
* component itself, one of its ancestors, or the ChangeManager implementation.
* @param change The change to add for this component
* @return The ComponentChange actually added, or
* <code>null</code> if no change was added.
* @see #addComponentChange(UIComponent, ComponentChange)
*/
public final ComponentChange addComponentChange(ComponentChange change)
{
return addComponentChange(this, change);
}
private UIXComponentBase _getNextUIXComponentBaseAnxcestor()
{
UIComponent parent = getParent();
while (parent != null)
{
if (parent instanceof UIXComponentBase)
{
return (UIXComponentBase)parent;
}
parent = parent.getParent();
}
return null;
}
/**
* Called when adding a change to a Component, or the Component's subtree.
* The default implementation delegates the call to the parent, if possible, otherwise
* it adds the change to the ChangeManager directly.
* Subclasses can override this method to among other things, filter or transform the changes.
* @param component The component that the change is for
* @param change The change to add for this component
* @return The ComponentChange actually added, or
* <code>null</code> if no change was added.
* @see #addComponentChange(ComponentChange)
* @see #addAttributeChange
*/
protected ComponentChange addComponentChange(UIComponent component, ComponentChange change)
{
// check moved from addAttributeChange(), as this is more central
if ((component == this) && (change instanceof AttributeComponentChange))
{
AttributeComponentChange aa = (AttributeComponentChange)change;
Object attributeValue = aa.getAttributeValue();
if (attributeValue instanceof RowKeySet)
{
change = new RowKeySetAttributeChange(getClientId(getFacesContext()),
aa.getAttributeName(),
attributeValue);
}
}
// add the change unless changes for this subtree have suppressed
if (!Boolean.TRUE.equals(getAttributes().get(_NO_SUBTREE_CHANGE_ATTR)))
{
UIXComponentBase nextUIXParent = _getNextUIXComponentBaseAnxcestor();
if (nextUIXParent != null)
{
return nextUIXParent.addComponentChange(component, change);
}
else
{
RequestContext trinContext = RequestContext.getCurrentInstance();
trinContext.getChangeManager().addComponentChange(getFacesContext(), component, change);
return change;
}
}
else
{
return null;
}
}
/**
* Convenience function for
* <code>addComponentChange(new AttributeComponentChange(attributeName, attributeValue));</code>
* This function is not <code>final</code> for backwards compatibility reasons, however,
* existing subclassers whould override <code>addComponentChange</code> instead.
* @param attributeName
* @param attributeValue
* @see #addComponentChange(UIComponent, ComponentChange)
*/
protected void addAttributeChange(
String attributeName,
Object attributeValue)
{
addComponentChange(new AttributeComponentChange(attributeName, attributeValue));
}
void __rendererDecode(FacesContext context)
{
_cacheRenderer(context);
Renderer renderer = getRenderer(context);
// if there is a Renderer for this component
if (renderer != null)
{
renderer.decode(context, this);
}
}
/**
* Publish PostAddToViewEvent to the component and all facets and children.
*
* @param context the current FacesContext
* @param component the current UIComponent
*/
private void _publishPostAddToViewEvent(
FacesContext context,
UIComponent component)
{
component.setInView(true);
context.getApplication().publishEvent(context, PostAddToViewEvent.class, UIComponent.class, component);
if (component.getChildCount() > 0)
{
List<UIComponent> children = component.getChildren();
UIComponent child = null;
UIComponent currentChild = null;
int i = 0;
while (i < children.size())
{
child = children.get(i);
// Iterate over the same index if the component was removed
// This prevents skip components when processing
do
{
_publishPostAddToViewEvent(context, child);
currentChild = child;
}
while ((i < children.size()) &&
((child = children.get(i)) != currentChild) );
i++;
}
}
if (component.getFacetCount() > 0)
{
for (UIComponent child : component.getFacets().values())
{
_publishPostAddToViewEvent(context, child);
}
}
}
/**
* Publish PreRemoveFromViewEvent to the component and all facets and children.
*
* @param context the current FacesContext
* @param component the current UIComponent
*/
private void _publishPreRemoveFromViewEvent(
FacesContext context,
UIComponent component)
{
component.setInView(false);
context.getApplication().publishEvent(context, PreRemoveFromViewEvent.class, UIComponent.class, component);
if (component.getChildCount() > 0)
{
for (UIComponent child : component.getChildren())
{
_publishPreRemoveFromViewEvent(context, child);
}
}
if (component.getFacetCount() > 0)
{
for (UIComponent child : component.getFacets().values())
{
_publishPreRemoveFromViewEvent(context, child);
}
}
}
private void _cacheRenderer(FacesContext context)
{
Renderer renderer = _getRendererImpl(context);
_cachedRenderer = renderer;
// cache the lifecycle renderer
if (renderer instanceof LifecycleRenderer)
{
_cachedLifecycleRenderer = (LifecycleRenderer)renderer;
}
else
{
_cachedLifecycleRenderer = null;
}
}
private Renderer _getRendererImpl(FacesContext context)
{
String rendererType = getRendererType();
if (rendererType != null)
{
RenderKit renderKit = context.getRenderKit();
Renderer renderer = renderKit.getRenderer(getFamily(), rendererType);
if (renderer == null)
{
_LOG.warning("CANNOT_FIND_RENDERER", new Object[]{this, rendererType});
}
return renderer;
}
return null;
}
private LifecycleRenderer _getLifecycleRendererImpl(FacesContext context)
{
Renderer renderer = _getRendererImpl(context);
if (renderer instanceof LifecycleRenderer)
{
return (LifecycleRenderer)renderer;
}
return null;
}
@Override
protected Renderer getRenderer(FacesContext context)
{
Renderer renderer = _cachedRenderer;
if (renderer != _UNDEFINED_RENDERER)
return renderer;
return _getRendererImpl(context);
}
protected LifecycleRenderer getLifecycleRenderer(FacesContext context)
{
LifecycleRenderer renderer = _cachedLifecycleRenderer;
if (renderer != _UNDEFINED_LIFECYCLE_RENDERER)
return renderer;
return _getLifecycleRendererImpl(context);
}
protected void setProperty(PropertyKey key, Object value)
{
getFacesBean().setProperty(key, value);
}
protected Object getProperty(PropertyKey key)
{
return getFacesBean().getProperty(key);
}
protected void setBooleanProperty(PropertyKey key, boolean value)
{
getFacesBean().setProperty(key, value ? Boolean.TRUE : Boolean.FALSE);
}
protected boolean getBooleanProperty(PropertyKey key, boolean defaultValue)
{
Object o = getFacesBean().getProperty(key);
if (defaultValue)
return !Boolean.FALSE.equals(o);
else
return Boolean.TRUE.equals(o);
}
protected void setIntProperty(PropertyKey key, int value)
{
getFacesBean().setProperty(key, Integer.valueOf(value));
}
protected int getIntProperty(PropertyKey key, int defaultValue)
{
Number n = (Number) getFacesBean().getProperty(key);
if (n == null)
return defaultValue;
return n.intValue();
}
/**
* Return the number of facets. This is more efficient than
* calling getFacets().size();
*/
@Override
public int getFacetCount()
{
if (_facets == null)
return 0;
return _facets.size();
}
/**
* Broadcast an event to a MethodBinding.
* This can be used to support MethodBindings such as the "actionListener"
* binding on ActionSource components:
* <tr:commandButton actionListener="#{mybean.myActionListener}">
* @deprecated
*/
protected final void broadcastToMethodBinding(
FacesEvent event,
MethodBinding method) throws AbortProcessingException
{
if (method != null)
{
try
{
FacesContext context = getFacesContext();
method.invoke(context, new Object[] { event });
}
catch (EvaluationException ee)
{
// Checking for AbortProcessingExceptions, and unwrapping
// it if the underlying exception is AbortProcessingExceptions.
Throwable currentThrowable = ee.getCause();
while (currentThrowable != null)
{
if (currentThrowable instanceof AbortProcessingException)
{
throw ((AbortProcessingException)currentThrowable);
}
currentThrowable = currentThrowable.getCause();
}
throw ee;
}
}
}
/**
* Given a MethodBinding, create a MethodExpression that
* adapts it.
*/
static public MethodExpression adaptMethodBinding(MethodBinding binding)
{
return new MethodBindingMethodExpression(binding);
}
/**
* Broadcast an event to a MethodExpression.
* This can be used to support MethodBindings such as the "actionListener"
* binding on ActionSource components:
* <tr:commandButton actionListener="#{mybean.myActionListener}">
*/
protected final void broadcastToMethodExpression(
FacesEvent event,
MethodExpression method) throws AbortProcessingException
{
if (method != null)
{
try
{
FacesContext context = getFacesContext();
method.invoke(context.getELContext(), new Object[] { event });
}
catch (ELException ee)
{
Throwable t = ee.getCause();
// Unwrap AbortProcessingExceptions
if (t instanceof AbortProcessingException)
throw ((AbortProcessingException) t);
throw ee;
}
}
}
/**
* Convenience method to call <code>invokeOnComponent</code> on all of the
* children of a component, surrounding the invocation with calls to
* <code>setup/tearDownChildrenVisitingContext</code>.
* This is useful when a component sometimes optimizes
* away calling <code>invokeOnComponent</code> on its children.
* @see UIXComponent#setupChildrenVisitingContext
* @see UIXComponent#tearDownChildrenVisitingContext
*/
protected final boolean invokeOnChildrenComponents(
FacesContext context,
String clientId,
ContextCallback callback)
throws FacesException
{
setupChildrenVisitingContext(context);
boolean found = false;
try
{
Iterator<UIComponent> children = getFacetsAndChildren();
while (children.hasNext() && !found)
{
found = children.next().invokeOnComponent(context, clientId, callback);
}
}
finally
{
tearDownChildrenVisitingContext(context);
}
return found;
}
/**
* <p>
* Optimized implementation of <code>invokeOnComponent</code> for NamingContainers.
* If the clientId isn't within the NamingContainer, invocation of the
* NamingContainer's children is skipped.
* </p>
* <p>Subclasses implementing NamingContainer should override
* <code>invokeOnComponent</code> and delegate to this method.</p>
*/
protected final boolean invokeOnNamingContainerComponent(
FacesContext context,
String clientId,
ContextCallback callback)
throws FacesException
{
assert this instanceof NamingContainer : "Only use invokeOnNamingContainerComponent on NamingContainers";
boolean invokedComponent;
setupVisitingContext(context);
try
{
String thisClientId = getClientId(context);
if (clientId.equals(thisClientId))
{
pushComponentToEL(context, null);
try
{
// this is the component we want, so invoke the callback
callback.invokeContextCallback(context, this);
}
finally
{
popComponentFromEL(context);
}
invokedComponent = true;
}
else
{
// if this is a NamingContainer, only traverse into it if the clientId we are looking for
// is inside of it
if ((!clientId.startsWith(thisClientId) ||
(clientId.charAt(thisClientId.length()) != NamingContainer.SEPARATOR_CHAR)))
{
invokedComponent = false;
}
else
{
// iterate through children.
// We inline this code instead of calling super in order
// to avoid making an extra call to getClientId().
invokedComponent = invokeOnChildrenComponents(context, clientId, callback);
}
}
}
finally
{
// teardown the context now that we have visited the children
tearDownVisitingContext(context);
}
return invokedComponent;
}
/**
* Override to calls the hooks for setting up and tearing down the
* context before the children are visited.
* @see #setupVisitingContext
* @see #tearDownVisitingContext
*/
@Override
public boolean invokeOnComponent(
FacesContext context,
String clientId,
ContextCallback callback)
throws FacesException
{
boolean invokedComponent;
// set up the context for visiting the children
setupVisitingContext(context);
try
{
String thisClientId = getClientId(context);
if (clientId.equals(thisClientId))
{
pushComponentToEL(context, null);
try
{
// this is the component we want, so invoke the callback
callback.invokeContextCallback(context, this);
}
finally
{
popComponentFromEL(context);
}
// we found the component
invokedComponent = true;
}
else
{
// set up the children visiting context to iterate through children. We inline this
// code instead of calling super in order
// to avoid making an extra call to getClientId().
invokedComponent = invokeOnChildrenComponents(context, clientId, callback);
}
}
finally
{
// teardown the context now that we have visited the component
tearDownVisitingContext(context);
}
return invokedComponent;
}
@Override
public void subscribeToEvent(Class<? extends SystemEvent> eventClass, ComponentSystemEventListener componentListener)
{
if (eventClass == null)
{
throw new NullPointerException("eventClass required");
}
if (componentListener == null)
{
throw new NullPointerException("componentListener required");
}
FacesBean bean = getFacesBean();
AttachedObjects<Class<? extends SystemEvent>, SystemEventListener> eventStorage =
(AttachedObjects<Class<? extends SystemEvent>, SystemEventListener>)bean.getProperty(_SYSTEM_EVENT_LISTENERS_KEY);
if (eventStorage == null)
{
eventStorage = new AttachedObjects<Class<? extends SystemEvent>, SystemEventListener>();
bean.setProperty(_SYSTEM_EVENT_LISTENERS_KEY, eventStorage);
}
eventStorage.addAttachedObject(eventClass, new ComponentSystemEventListenerWrapper(componentListener, this));
}
@Override
public void unsubscribeFromEvent(Class<? extends SystemEvent> eventClass,
ComponentSystemEventListener componentListener)
{
if (eventClass == null)
{
throw new NullPointerException("eventClass required");
}
if (componentListener == null)
{
throw new NullPointerException("componentListener required");
}
FacesBean bean = getFacesBean();
AttachedObjects<Class<? extends SystemEvent>, SystemEventListener> eventStorage =
(AttachedObjects<Class<? extends SystemEvent>, SystemEventListener>)bean.getProperty(_SYSTEM_EVENT_LISTENERS_KEY);
if (eventStorage == null)
{
return;
}
// ComponentSystemEventListenerWrapper implements equals() to compare listener and component
eventStorage.removeAttachedObject(eventClass, new ComponentSystemEventListenerWrapper(componentListener, this));
}
@Override
public List<SystemEventListener> getListenersForEventClass(Class<? extends SystemEvent> eventClass)
{
FacesBean bean = getFacesBean();
AttachedObjects<Class<? extends SystemEvent>, SystemEventListener> eventStorage =
(AttachedObjects<Class<? extends SystemEvent>, SystemEventListener>)bean.getProperty(_SYSTEM_EVENT_LISTENERS_KEY);
if (eventStorage == null)
{
return Collections.emptyList();
}
return eventStorage.getAttachedObjectList(eventClass);
}
// ------------------------- Client behavior holder methods -------------------------
/**
* Utility method to assist sub-classes in the implementation of the
* {@link javax.faces.component.behavior.ClientBehaviorHolder} interface.
* <p>This method must only
* be called by classes that implement the interface, doing otherwise will result in an exception.
* </p>
* @param eventName The event name
* @param behavior The behavior to add
* @see javax.faces.component.behavior.ClientBehaviorHolder#addClientBehavior(String, ClientBehavior)
*/
protected void addClientBehavior(
String eventName,
ClientBehavior behavior)
{
// This will throw a class cast exception when illegally called by a class that does not
// implement ClientBehaviorHolder
Collection<String> events = ((ClientBehaviorHolder)this).getEventNames();
// This will throw a null pointer exception if the component author did not correctly implement
// the ClientBehaviorHolder contract which requires a non-empty collection to be returned from
// getEventNames
if (!events.contains(eventName))
{
return;
}
FacesBean bean = getFacesBean();
AttachedObjects<String, ClientBehavior> behaviors = (
AttachedObjects<String, ClientBehavior>)bean.getProperty(_CLIENT_BEHAVIORS_KEY);
if (behaviors == null)
{
behaviors = new AttachedObjects<String, ClientBehavior>();
bean.setProperty(_CLIENT_BEHAVIORS_KEY, behaviors);
}
behaviors.addAttachedObject(eventName, behavior);
}
// Note, we do not need to provide a default implementation for the event names, as client
// behavior holder components must provide a non-empty list of event names. UIComponentBase
// decided to return a non-valid null in their code, but that is only confusing to the user, it
// is better to not implement the method and force the users to write the method upon interface
// implementation.
//protected Collection<String> getEventNames() {}
/**
* Utility method to assist sub-classes in the implementation of the
* {@link javax.faces.component.behavior.ClientBehaviorHolder} interface.
* <p>This method must only
* be called by classes that implement the interface, doing otherwise will result in an exception.
* </p>
* @see javax.faces.component.behavior.ClientBehaviorHolder#getClientBehaviors()
* @return Read-only map of the client behaviors for this component
*/
protected Map<String, List<ClientBehavior>> getClientBehaviors()
{
AttachedObjects<String, ClientBehavior> behaviors = (
AttachedObjects<String, ClientBehavior>)getFacesBean().getProperty(_CLIENT_BEHAVIORS_KEY);
if (behaviors == null)
{
return Collections.emptyMap();
}
return behaviors.getAttachedObjectMap();
}
/**
* Utility method to assist sub-classes in the implementation of the
* {@link javax.faces.component.behavior.ClientBehaviorHolder} interface.
* <p>This method must only
* be called by classes that implement the interface, doing otherwise will result in an exception.
* </p>
* @return null
* @see javax.faces.component.behavior.ClientBehaviorHolder#getDefaultEventName()
*/
protected String getDefaultEventName()
{
_ensureClientBehaviorHolder();
return null;
}
private void _ensureClientBehaviorHolder()
{
if (!(this instanceof ClientBehaviorHolder))
{
throw new IllegalStateException("Component must implement ClientBehaviorHolder in order " +
"to make use of this method.");
}
}
// ------------------------- End of the client behavior holder methods -------------------------
/**
* <p>
* This gets a single threadlocal shared stringbuilder instance, each time you call
* __getSharedStringBuilder it sets the length of the stringBuilder instance to 0.
* </p><p>
* This allows you to use the same StringBuilder instance over and over.
* You must call toString on the instance before calling __getSharedStringBuilder again.
* </p>
* Example that works
* <pre><code>
* StringBuilder sb1 = __getSharedStringBuilder();
* sb1.append(a).append(b);
* String c = sb1.toString();
*
* StringBuilder sb2 = __getSharedStringBuilder();
* sb2.append(b).append(a);
* String d = sb2.toString();
* </code></pre>
* <br><br>
* Example that doesn't work, you must call toString on sb1 before
* calling __getSharedStringBuilder again.
* <pre><code>
* StringBuilder sb1 = __getSharedStringBuilder();
* StringBuilder sb2 = __getSharedStringBuilder();
*
* sb1.append(a).append(b);
* String c = sb1.toString();
*
* sb2.append(b).append(a);
* String d = sb2.toString();
* </code></pre>
*
*/
static StringBuilder __getSharedStringBuilder()
{
StringBuilder sb = _STRING_BUILDER.get();
if (sb == null)
{
sb = new StringBuilder();
_STRING_BUILDER.set(sb);
}
// clear out the stringBuilder by setting the length to 0
sb.setLength(0);
return sb;
}
/**
* render a component. this is called by renderers whose
* getRendersChildren() return true.
* @deprecated {@link UIComponent#encodeAll(FacesContext)} should be used instead of this method
*/
@Deprecated
void __encodeRecursive(FacesContext context, UIComponent component)
throws IOException
{
component.encodeAll(context);
}
static private UIComponent _findInsideOf(
UIComponent from,
String id)
{
Iterator<UIComponent> kids = from.getFacetsAndChildren();
while (kids.hasNext())
{
UIComponent kid = kids.next();
if (id.equals(kid.getId()))
return kid;
if (!(kid instanceof NamingContainer))
{
UIComponent returned = _findInsideOf(kid, id);
if (returned != null)
return returned;
}
}
return null;
}
/**
* <p>Verify that the specified component id is safe to add to the tree.
* </p>
*
* @param id The proposed component id to check for validity
*
* @exception IllegalArgumentException if <code>id</code>
* is <code>null</code> or contains invalid characters
*/
private void _validateId(String id)
{
if (id == null)
return;
int n = id.length();
if (0 == n ||
NamingContainer.SEPARATOR_CHAR == id.charAt(0))
_throwBadId(id);
for (int i = 0; i < n; i++)
{
char c = id.charAt(i);
if (i == 0)
{
if (!Character.isLetter(c) && (c != '_'))
_throwBadId(id);
}
else
{
if (!(Character.isLetter(c) ||
Character.isDigit(c) ||
(c == '-') || (c == '_')))
{
_throwBadId(id);
}
}
}
}
private void _throwBadId(String id)
{
throw new IllegalArgumentException(_LOG.getMessage(
"ILLEGAL_ID", id));
}
private void _init(
String rendererType)
{
FacesBean oldBean = _facesBean;
FacesBean newBean = createFacesBean(rendererType);;
if (oldBean != null)
newBean.addAll(oldBean);
_attributes = new ValueMap(newBean);
_facesBean = newBean;
// determine whether it is ok to store the attributes locally. We cache the result since
// this can be a little involved
boolean usesFacesBeanImpl = false;
if (newBean instanceof UIXFacesBeanImpl)
usesFacesBeanImpl = true;
else
{
// handle the wrapped case
FacesBean currImpl = newBean;
while (currImpl instanceof FacesBeanWrapper)
{
currImpl = ((FacesBeanWrapper)currImpl).getWrappedBean();
if (currImpl instanceof UIXFacesBeanImpl)
{
usesFacesBeanImpl = true;
break;
}
}
}
_usesFacesBeanImpl = usesFacesBeanImpl;
}
private FacesBean _facesBean;
private List<UIComponent> _children;
private Map<String, Object> _attributes;
private Map<String, UIComponent> _facets;
private UIComponent _parent;
private String _id;
private String _clientId;
private boolean _usesFacesBeanImpl;
// Cached instance of the Renderer for this component.
// The instance will be re-retrieved in encodeBegin()
private transient Renderer _cachedRenderer = _UNDEFINED_RENDERER;
private transient LifecycleRenderer _cachedLifecycleRenderer =
_UNDEFINED_LIFECYCLE_RENDERER;
// -= Simon Lessard =-
// FIXME: _initialStateMarked is never read
// So commented out, is that ok? If so, this attribute should be deleted
//private transient boolean _initialStateMarked;
private static final Iterator<String> _EMPTY_STRING_ITERATOR = CollectionUtils.emptyIterator();
private static final Iterator<UIComponent> _EMPTY_UICOMPONENT_ITERATOR =
CollectionUtils.emptyIterator();
static private final ThreadLocal<StringBuilder> _STRING_BUILDER =
ThreadLocalUtils.newRequestThreadLocal();
static private FacesBean.Type _createType()
{
try
{
ClassLoader cl = _getClassLoader();
URL url = cl.getResource("META-INF/faces-bean-type.properties");
if (url != null)
{
Properties properties = new Properties();
InputStream is = url.openStream();
try
{
properties.load(is);
String className = (String)
properties.get(UIXComponentBase.class.getName());
return (FacesBean.Type) cl.loadClass(className).newInstance();
}
finally
{
is.close();
}
}
}
catch (Exception e)
{
_LOG.severe("CANNOT_LOAD_TYPE_PROPERTIES", e);
}
// For testing purposes, return a valid Type
return new FacesBean.Type();
}
static private ClassLoader _getClassLoader()
{
ClassLoader loader = Thread.currentThread().getContextClassLoader();
if (loader == null)
loader = FacesBeanFactory.class.getClassLoader();
return loader;
}
static private class RendererImpl extends Renderer
{
}
static private class ExtendedRendererImpl extends ExtendedRenderer
{
}
private static boolean _isClientIdCachingEnabled()
{
return (_CLIENT_ID_CACHING != ClientIdCaching.OFF);
}
private static boolean _isClientIdDebuggingEnabled()
{
return (_CLIENT_ID_CACHING == ClientIdCaching.DEBUG);
}
// Warn if caching is disabled + production environment since this is
// undesirable from a performance perspective.
private static void _warnClientIdCachingConfig(FacesContext context)
{
if (_CLIENT_ID_CACHING != ClientIdCaching.ON &&
context.isProjectStage(ProjectStage.Production) &&
!_warnedClientIdCachingConfig(context))
{
_LOG.warning(
"The org.apache.myfaces.trinidad.CLIENT_ID_CACHING system property is set to: " +
_CLIENT_ID_CACHING +
". For best performance, client id caching should be ON in production environments.");
_clientIdCachingConfigWarned(context);
}
}
// Tests whether we have already warned about the caching config.
// We only want to warn once per run.
private static boolean _warnedClientIdCachingConfig(FacesContext context)
{
ExternalContext external = context.getExternalContext();
Map<String, Object> appMap = external.getApplicationMap();
return Boolean.TRUE.equals(appMap.get(_WARNED_CLIENT_ID_CACHING_KEY));
}
// Marks the fact that we have now warned about the caching config.
private static void _clientIdCachingConfigWarned(FacesContext context)
{
ExternalContext external = context.getExternalContext();
Map<String, Object> appMap = external.getApplicationMap();
appMap.put(_WARNED_CLIENT_ID_CACHING_KEY, Boolean.TRUE);
}
// Utility for deriving initial CLIENT_ID_CACHING value.
private static ClientIdCaching _initClientIdCaching()
{
String cachingProperty = _getClientIdCachingSystemProperty();
ClientIdCaching caching = _toClientIdCachingEnum(cachingProperty);
_LOG.config("Client id caching configuration: " + caching);
return caching;
}
private static String _getClientIdCachingSystemProperty()
{
try
{
return System.getProperty(_SYSTEM_PROP_CLIENT_ID_CACHING);
}
catch (Throwable t)
{
_LOG.warning(t);
}
return null;
}
private static ClientIdCaching _toClientIdCachingEnum(String cachingProperty)
{
try
{
return Enum.valueOf(ClientIdCaching.class,
(cachingProperty == null) ?
"ON" :
cachingProperty.toUpperCase());
}
catch (IllegalArgumentException e)
{
_LOG.warning("Invalid value specified for " +
_SYSTEM_PROP_CLIENT_ID_CACHING +
" system property: " +
cachingProperty +
". Valid values are: on | off | debug.");
}
return ClientIdCaching.ON;
}
// Little enum for tracking the client id caching behavior.
private enum ClientIdCaching
{
ON,
OFF,
DEBUG
}
private static class ComponentSystemEventListenerWrapper implements SystemEventListener, StateHolder
{
ComponentSystemEventListenerWrapper(ComponentSystemEventListener listener, UIComponent component)
{
_delegate = listener;
_componentClass = component.getClass();
}
// Default constructor for state restoration
public ComponentSystemEventListenerWrapper()
{
}
@Override
public boolean equals(Object o)
{
if (o == this)
{
return true;
}
else if (o instanceof ComponentSystemEventListenerWrapper)
{
ComponentSystemEventListenerWrapper other = (ComponentSystemEventListenerWrapper) o;
return _componentClass.equals(other._componentClass) && _delegate.equals(other._delegate);
}
return false;
}
@Override
public int hashCode()
{
return _componentClass.hashCode() + _delegate.hashCode();
}
// SystemEventListener implementation
@Override
public void processEvent(SystemEvent event) throws AbortProcessingException
{
assert (event instanceof ComponentSystemEvent);
_delegate.processEvent((ComponentSystemEvent)event);
}
@Override
public boolean isListenerForSource(Object source)
{
if (_delegate instanceof SystemEventListener)
{
return ((SystemEventListener)_delegate).isListenerForSource(source);
}
// From the spec: and its implementation of SystemEventListener.isListenerForSource(java.lang.Object) must return true
// if the instance class of this UIComponent is assignable from the argument to isListenerForSource.
return _componentClass.isAssignableFrom(source.getClass());
}
// StateHolder Implementation
@Override
public Object saveState(FacesContext context)
{
if (_delegate instanceof UIComponent)
{
return null;
}
Object[] state = new Object[2];
state[0] = StateUtils.saveStateHolder(context, _delegate);
state[1] = _componentClass;
return state;
}
@Override
public void restoreState(FacesContext context, Object state)
{
if (state == null)
{
return;
}
Object[] stateArr = (Object[]) state;
Object saved = stateArr[0];
_delegate = (ComponentSystemEventListener) ((saved == null) ? UIComponent .getCurrentComponent(context)
: StateUtils.restoreStateHolder(context, saved));
_componentClass = (Class<?>)stateArr[1];
}
@Override
public boolean isTransient()
{
if (_delegate instanceof StateHolder)
{
return ((StateHolder)_delegate).isTransient();
}
return false;
}
@Override
public void setTransient(boolean isTransient)
{
if (_delegate instanceof StateHolder)
{
((StateHolder)_delegate).setTransient(isTransient);
}
}
private ComponentSystemEventListener _delegate;
private Class<?> _componentClass;
}
private static final String _NO_SUBTREE_CHANGE_ATTR = "_trinNoSubtreeChange";
private static final ClientIdCaching _CLIENT_ID_CACHING = _initClientIdCaching();
// System property controlling whether client ID caching is enabled
private static final String _SYSTEM_PROP_CLIENT_ID_CACHING =
"org.apache.myfaces.trinidad.CLIENT_ID_CACHING";
// Application map key indicating that we've already warned once
// that the client id caching configuration is not optimized for
// production mode.
private static final String _WARNED_CLIENT_ID_CACHING_KEY =
"org.apache.myfaces.trinidad.WARNED_CLIENT_ID_CACHING";
static private final LifecycleRenderer _UNDEFINED_LIFECYCLE_RENDERER =
new ExtendedRendererImpl();
static private final Renderer _UNDEFINED_RENDERER = new RendererImpl();
}