public UIComponent createComponent(FaceletContext ctx) {
FacesContext context = ctx.getFacesContext();
UIComponent cc;
// we have to handle the binding here, as Application doesn't
// expose a method to do so with Resource.
if (binding != null) {
ValueExpression ve = binding.getValueExpression(ctx, UIComponent.class);
cc = (UIComponent) ve.getValue(ctx);
if (cc != null && !UIComponent.isCompositeComponent(cc)) {
if (LOGGER.isLoggable(Level.SEVERE)) {
LOGGER.log(Level.SEVERE, "jsf.compcomp.binding.eval.non.compcomp", binding.toString());
}
cc = null;
}
if (cc == null) {
cc = context.getApplication().createComponent(context, ccResource);
ve.setValue(ctx, cc);
}
} else {
cc = context.getApplication().createComponent(context, ccResource);
}
setCompositeComponent(context, cc);
return cc;
}
public String getIsCompositeComponentValue() {
String result = null;
UIComponent currentComposite =
UIComponent.getCurrentCompositeComponent(FacesContext.getCurrentInstance());
result = "" + UIComponent.isCompositeComponent(currentComposite);
return result;
}
public boolean push(UIComponent compositeComponent) {
if (compositeComponent != null) {
assert (UIComponent.isCompositeComponent(compositeComponent));
Stack<UIComponent> s = getStack(true);
s.push(compositeComponent);
return true;
}
return false;
}
protected boolean pushComponentToEL(
FaceletContext ctx, UIComponent c, CompositeComponentStackManager ccStackManager) {
c.pushComponentToEL(ctx.getFacesContext(), c);
boolean compcompPushed = false;
if (UIComponent.isCompositeComponent(c)) {
compcompPushed = ccStackManager.push(c, TreeCreation);
}
return compcompPushed;
}
public void apply(FaceletContext ctx, UIComponent parent) throws IOException {
// only process if it's been created
if (parent == null || !ComponentHandler.isNew(parent)) {
return;
}
if (isEventSource(parent)) {
applyAttachedObject(ctx.getFacesContext(), parent);
} else if (UIComponent.isCompositeComponent(parent)) {
// Allow the composite component to know about the target component.
TagHandlerUtils.getOrCreateRetargetableHandlersList(parent).add(this);
} else {
throw new TagException(
this.tag, "Parent does not match event source requirements: " + parent);
}
}
protected void addComponentToView(
FaceletContext ctx, UIComponent parent, UIComponent c, boolean componentFound) {
FacesContext context = ctx.getFacesContext();
boolean suppressEvents = ComponentSupport.suppressViewModificationEvents(context);
boolean compcomp = UIComponent.isCompositeComponent(c);
if (suppressEvents && componentFound && !compcomp) {
context.setProcessingEvents(false);
}
ComponentSupport.addComponent(ctx, parent, c);
if (suppressEvents && componentFound && !compcomp) {
context.setProcessingEvents(true);
}
}
public void applyMetadata(FaceletContext ctx, Object instance) {
ValueExpression ve = attr.getValueExpression(ctx, type);
UIComponent cc = (UIComponent) instance;
assert (UIComponent.isCompositeComponent(cc));
Map<String, Object> attrs = cc.getAttributes();
BeanInfo componentMetadata = (BeanInfo) attrs.get(UIComponent.BEANINFO_KEY);
BeanDescriptor desc = componentMetadata.getBeanDescriptor();
Collection<String> attributesWithDeclaredDefaultValues =
(Collection<String>) desc.getValue(RIConstants.ATTRS_WITH_DECLARED_DEFAULT_VALUES);
if (null != attributesWithDeclaredDefaultValues
&& attributesWithDeclaredDefaultValues.contains(name)) {
// It is necessary to remove the value from the attribute
// map because the ELexpression transparancy doesn't know
// about the value's existence.
attrs.remove(name);
}
cc.setValueExpression(name, ve);
}
public void broadcast(FacesContext context) throws AbortProcessingException {
// Set up the correct context and fire our wrapped event
UIDataAdaptor dataAdaptor = getComponent();
initialRowKey = dataAdaptor.getRowKey();
UIComponent compositeParent = null;
UIComponent targetComponent = event.getComponent();
try {
if (!UIComponent.isCompositeComponent(targetComponent)) {
compositeParent = UIComponent.getCompositeComponentParent(targetComponent);
}
if (compositeParent != null) {
compositeParent.pushComponentToEL(context, null);
}
setupEventContext(context);
targetComponent.pushComponentToEL(context, null);
targetComponent.broadcast(event);
} finally {
try {
dataAdaptor.setRowKey(context, initialRowKey);
} catch (Exception e) {
LOGGER.error(e.getMessage(), e);
}
initialRowKey = null;
targetComponent.popComponentFromEL(context);
if (compositeParent != null) {
compositeParent.popComponentFromEL(context);
}
}
}
/**
* Method handles UIComponent tree creation in accordance with the JSF 1.2 spec.
*
* <ol>
* <li>First determines this UIComponent's id by calling {@link
* javax.faces.view.facelets.ComponentHandler#getTagId()}.
* <li>Search the parent for an existing UIComponent of the id we just grabbed
* <li>If found, {@link
* com.sun.faces.facelets.tag.jsf.ComponentSupport#markForDeletion(javax.faces.component.UIComponent)
* mark} its children for deletion.
* <li>If <i>not</i> found, call {@link #createComponent(FaceletContext) createComponent}.
* <ol>
* <li>Only here do we apply {@link
* com.sun.faces.facelets.tag.MetaTagHandlerImpl#setAttributes(FaceletContext,
* Object)}
* <li>Set the UIComponent's id
* <li>Set the RendererType of this instance
* </ol>
* <li>Now apply the nextHandler, passing the UIComponent we've created/found.
* <li>Now add the UIComponent to the passed parent
* <li>Lastly, if the UIComponent already existed (found), then {@link
* ComponentSupport#finalizeForDeletion(UIComponent) finalize} for deletion.
* </ol>
*
* @throws TagException if the UIComponent parent is null
*/
@Override
public void apply(FaceletContext ctx, UIComponent parent) throws IOException {
FacesContext context = ctx.getFacesContext();
// make sure our parent is not null
if (parent == null) {
throw new TagException(owner.getTag(), "Parent UIComponent was null");
}
// our id
String id = ctx.generateUniqueId(owner.getTagId());
// grab our component
UIComponent c = findChild(ctx, parent, id);
if (null == c
&& context.isPostback()
&& UIComponent.isCompositeComponent(parent)
&& parent.getAttributes().get(id) != null) {
c = findReparentedComponent(ctx, parent, id);
} else {
/**
* If we found a child that is dynamic, the actual parent might have changed, so we need to
* remove it from the actual parent. The reapplyDynamicActions will then replay the actions
* and will make sure it ends up in the correct order.
*/
if (c != null
&& c.getParent() != parent
&& c.getAttributes().containsKey(DYNAMIC_COMPONENT)) {
c.getParent().getChildren().remove(c);
}
}
boolean componentFound = false;
if (c != null) {
componentFound = true;
doExistingComponentActions(ctx, id, c);
} else {
c = this.createComponent(ctx);
doNewComponentActions(ctx, id, c);
assignUniqueId(ctx, parent, id, c);
// hook method
owner.onComponentCreated(ctx, c, parent);
}
CompositeComponentStackManager ccStackManager =
CompositeComponentStackManager.getManager(context);
boolean compcompPushed = pushComponentToEL(ctx, c, ccStackManager);
if (ProjectStage.Development == context.getApplication().getProjectStage()) {
ComponentSupport.setTagForComponent(context, c, this.owner.getTag());
}
// If this this a naming container, stop generating unique Ids
// for the repeated tags
boolean setUniqueIds = false;
boolean oldUnique = false;
if (c instanceof NamingContainer) {
oldUnique = ComponentSupport.setNeedUniqueIds(ctx, false);
setUniqueIds = true;
}
try {
// first allow c to get populated
owner.applyNextHandler(ctx, c);
} finally {
if (setUniqueIds) ComponentSupport.setNeedUniqueIds(ctx, oldUnique);
}
// finish cleaning up orphaned children
if (componentFound) {
doOrphanedChildCleanup(ctx, parent, c);
}
this.privateOnComponentPopulated(ctx, c);
owner.onComponentPopulated(ctx, c, parent);
// add to the tree afterwards
// this allows children to determine if it's
// been part of the tree or not yet
addComponentToView(ctx, parent, c, componentFound);
adjustIndexOfDynamicChildren(context, c);
popComponentFromEL(ctx, c, ccStackManager, compcompPushed);
}
