/*
* 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.custom.aliasbean;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.el.ValueExpression;
import javax.faces.FacesException;
import javax.faces.component.ContextCallback;
import javax.faces.component.UIComponent;
import javax.faces.component.UIComponentBase;
import javax.faces.context.FacesContext;
import javax.faces.event.AbortProcessingException;
import javax.faces.event.FacesEvent;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFComponent;
import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFJspProperties;
import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFJspProperty;
import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFProperty;
import org.apache.myfaces.shared_tomahawk.component.BindingAware;
import org.apache.myfaces.shared_tomahawk.util.RestoreStateUtils;
/**
* The aliasBean tag allows you to create a temporary name for a real bean.
* The temporary name exists (is visible) only to the children of the aliasBean.
* <p>
* One use of this feature is to pass "parameters" from an including page to an
* included one. The included page can use any name it desires for beans it needs to
* reference, and the including page can then use aliasBean to make those names
* refer to the beans it wishes to "pass" as parameters.
* </p>
* <p>
* Suppose you have a block of components you use often but with different beans. You
* can create a separate JSP page (or equivalent) containing these beans, where the
* value-bindings refer to some fictive bean name. Document these names as the required
* "parameters" for this JSP page. Wherever you wish to use this block you then declare
* an alias component mapping each of these "parameters" to whatever beans (or literal
* values) you really want to apply the block to, then use jsp:include (or equivalent)
* to include the reusable block of components.
* </p>
* <p>
* Note, however, that AliasBean does not work for component bindings; JSF1.1
* just has no mechanism available to set up the alias during the "restore view"
* phase while the bindings of its children are being re-established, and then
* remove the alias after the child bindings are done.
* </p>
* <p>
* As a special case, if this component's direct parent is an AliasBeansScope
* then the alias (temporary name) is active until the end of the parent
* component, rather than the end of this component.
* </p>
*
* @author Sylvain Vieujot (latest modification by $Author: lu4242 $)
* @version $Revision: 1082663 $ $Date: 2011-03-17 14:47:10 -0500 (Thu, 17 Mar 2011) $
*/
@JSFComponent(
name="t:aliasBean",
tagClass = "org.apache.myfaces.custom.aliasbean.AliasBeanTag",
tagHandler = "org.apache.myfaces.custom.aliasbean.AliasBeanTagHandler")
@JSFJspProperties(properties={
@JSFJspProperty(
name = "rendered",
returnType = "boolean",
tagExcluded = true),
@JSFJspProperty(
name = "binding",
returnType = "java.lang.String",
tagExcluded = true)
})
public class AliasBean extends UIComponentBase implements BindingAware
{
private static final Log log = LogFactory.getLog(AliasBean.class);
public static final String COMPONENT_TYPE = "org.apache.myfaces.AliasBean";
public static final String COMPONENT_FAMILY = "javax.faces.Data";
private Alias alias;
// Indicates whether withinScope has been initialised or not.
private boolean scopeSearched = false;
// True if this is a direct child of an AliasBeansScope component.
private boolean withinScope;
private transient FacesContext _context = null;
public AliasBean()
{
alias = new Alias(this);
}
public String getFamily()
{
return COMPONENT_FAMILY;
}
public String getRendererType() {
return null;
}
/**
* Define the "fictive" name which will be visible to the children
* of this component as an alias to the "real" object specified
* by the value attribute of this component.
*
* @param aliasBeanExpression
*/
@JSFProperty
public void setAlias(String aliasBeanExpression)
{
alias.setAliasBeanExpression(aliasBeanExpression);
}
/**
* The existing value that the alias can be set to. This can be
* a literal string (like "toto") or a reference to an existing
* bean (like "#{myBean.member1}").
*
*/
@JSFProperty
public String getValue()
{
String valueExpression = alias.getValueExpression();
if (valueExpression != null)
return valueExpression;
// Normally, this component will have no value, because the setValue method always
// passes that data on to the alias instead. However it is possible for someone
// to use f:attribute (or other mechanism?) to set the value instead. So when the
// alias has no value, look for it there.
ValueExpression vb = getValueExpression("value");
return vb != null ? (String) vb.getValue(getFacesContext().getELContext()) : null;
}
public void setValue(String valueExpression)
{
alias.setValueExpression(valueExpression);
}
public Object saveState(FacesContext context)
{
log.debug("saveState");
_context = context;
return new Object[]{super.saveState(context), alias.saveState()};
}
public void restoreState(FacesContext context, Object state)
{
log.debug("restoreState");
_context = context;
Object values[] = (Object[]) state;
super.restoreState(context, values[0]);
alias.restoreState(values[1]);
}
public Object processSaveState(FacesContext context)
{
if (context == null)
throw new NullPointerException("context");
if (isTransient())
return null;
makeAlias(context);
Map facetMap = null;
for (Iterator it = getFacets().entrySet().iterator(); it.hasNext();)
{
Map.Entry entry = (Map.Entry) it.next();
if (facetMap == null)
facetMap = new HashMap();
UIComponent component = (UIComponent) entry.getValue();
if (!component.isTransient())
{
facetMap.put(entry.getKey(), component.processSaveState(context));
}
}
List childrenList = null;
if (getChildCount() > 0)
{
for (Iterator it = getChildren().iterator(); it.hasNext();)
{
UIComponent child = (UIComponent) it.next();
if (!child.isTransient())
{
if (childrenList == null)
childrenList = new ArrayList(getChildCount());
childrenList.add(child.processSaveState(context));
}
}
}
removeAlias(context);
return new Object[]{saveState(context), facetMap, childrenList};
}
public void processRestoreState(FacesContext context, Object state)
{
if (context == null)
throw new NullPointerException("context");
Object myState = ((Object[]) state)[0];
restoreState(context, myState);
makeAlias(context);
Map facetMap = (Map) ((Object[]) state)[1];
List childrenList = (List) ((Object[]) state)[2];
for (Iterator it = getFacets().entrySet().iterator(); it.hasNext();)
{
Map.Entry entry = (Map.Entry) it.next();
Object facetState = facetMap.get(entry.getKey());
if (facetState != null)
{
((UIComponent) entry.getValue()).processRestoreState(context, facetState);
}
else
{
context.getExternalContext().log("No state found to restore facet " + entry.getKey());
}
}
if (getChildCount() > 0)
{
int idx = 0;
for (Iterator it = getChildren().iterator(); it.hasNext();)
{
UIComponent child = (UIComponent) it.next();
Object childState = childrenList.get(idx++);
if (childState != null)
{
child.processRestoreState(context, childState);
}
else
{
context.getExternalContext().log("No state found to restore child of component " + getId());
}
}
}
removeAlias(context);
}
public void processValidators(FacesContext context)
{
if (withinScope)
return;
log.debug("processValidators");
makeAlias(context);
super.processValidators(context);
removeAlias(context);
}
public void processDecodes(FacesContext context)
{
log.debug("processDecodes");
if (withinScope)
{
if (! alias.isActive())
makeAlias(context);
super.processDecodes(context);
return;
}
makeAlias(context);
super.processDecodes(context);
removeAlias(context);
}
public void processUpdates(FacesContext context)
{
if (withinScope)
return;
log.debug("processUpdates");
makeAlias(context);
super.processUpdates(context);
removeAlias(context);
}
public void encodeBegin(FacesContext context) throws IOException {
makeAlias(context);
}
public void encodeEnd(FacesContext context) throws IOException {
removeAlias();
}
public void queueEvent(FacesEvent event)
{
super.queueEvent(new FacesEventWrapper(event, this));
}
public void broadcast(FacesEvent event) throws AbortProcessingException
{
makeAlias();
if (event instanceof FacesEventWrapper)
{
FacesEvent originalEvent = ((FacesEventWrapper) event).getWrappedFacesEvent();
originalEvent.getComponent().broadcast(originalEvent);
}
else
{
super.broadcast(event);
}
removeAlias();
}
void makeAlias(FacesContext context)
{
_context = context;
makeAlias();
}
private void makeAlias()
{
if (! scopeSearched)
{
withinScope = getParent() instanceof AliasBeansScope;
if (withinScope)
{
AliasBeansScope aliasScope = (AliasBeansScope) getParent();
aliasScope.addAlias(alias);
}
scopeSearched = true;
}
alias.make(_context);
}
void removeAlias(FacesContext context)
{
_context = context;
removeAlias();
}
private void removeAlias()
{
if (! withinScope)
alias.remove(_context);
}
public void handleBindings()
{
makeAlias(getFacesContext());
RestoreStateUtils.recursivelyHandleComponentReferencesAndSetValid(getFacesContext(),this,true);
removeAlias(getFacesContext());
}
@Override
public boolean invokeOnComponent(FacesContext context, String clientId,
ContextCallback callback) throws FacesException
{
makeAlias(getFacesContext());
try
{
return super.invokeOnComponent(context, clientId, callback);
}
finally
{
removeAlias(getFacesContext());
}
}
}