Author: nbelaevski Date: 2010-12-01 11:27:24 -0500 (Wed, 01 Dec 2010) New Revision: 20261 Added: trunk/ui/common/ui/src/main/java/org/richfaces/component/UIDataAdaptor.java.orig trunk/ui/iteration/ui/src/main/java/org/richfaces/component/AbstractTree.java.orig trunk/ui/iteration/ui/src/main/java/org/richfaces/model/SwingTreeNodeDataModelImpl.java.orig trunk/ui/iteration/ui/src/main/java/org/richfaces/model/TreeSequenceKeyModel.java.orig trunk/ui/iteration/ui/src/main/java/org/richfaces/renderkit/TreeEncoderBase.java.orig Log: RF-9680 Added: trunk/ui/common/ui/src/main/java/org/richfaces/component/UIDataAdaptor.java.orig =================================================================== --- trunk/ui/common/ui/src/main/java/org/richfaces/component/UIDataAdaptor.java.orig (rev 0) +++ trunk/ui/common/ui/src/main/java/org/richfaces/component/UIDataAdaptor.java.orig 2010-12-01 16:27:24 UTC (rev 20261) @@ -0,0 +1,1523 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright ${year}, Red Hat, Inc. and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * This is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ + +package org.richfaces.component; + +import java.io.IOException; +import java.io.Serializable; +import java.text.MessageFormat; +import java.util.Collection; +import java.util.Collections; +import java.util.Iterator; +import java.util.Map; + +import javax.el.ValueExpression; +import javax.faces.FacesException; +import javax.faces.application.Application; +import javax.faces.application.FacesMessage; +import javax.faces.component.ContextCallback; +import javax.faces.component.EditableValueHolder; +import javax.faces.component.NamingContainer; +import javax.faces.component.PartialStateHolder; +import javax.faces.component.StateHelper; +import javax.faces.component.StateHolder; +import javax.faces.component.UIComponent; +import javax.faces.component.UIComponentBase; +import javax.faces.component.UIForm; +import javax.faces.component.UINamingContainer; +import javax.faces.component.UIViewRoot; +import javax.faces.component.UniqueIdVendor; +import javax.faces.component.visit.VisitCallback; +import javax.faces.component.visit.VisitContext; +import javax.faces.component.visit.VisitResult; +import javax.faces.context.FacesContext; +import javax.faces.convert.Converter; +import javax.faces.convert.ConverterException; +import javax.faces.event.AbortProcessingException; +import javax.faces.event.ComponentSystemEvent; +import javax.faces.event.ComponentSystemEventListener; +import javax.faces.event.FacesEvent; +import javax.faces.event.ListenerFor; +import javax.faces.event.PhaseId; +import javax.faces.event.PostValidateEvent; +import javax.faces.event.PreRenderComponentEvent; +import javax.faces.event.PreValidateEvent; +import javax.faces.render.Renderer; + +import org.ajax4jsf.component.IterationStateHolder; +import org.ajax4jsf.model.DataComponentState; +import org.ajax4jsf.model.DataVisitResult; +import org.ajax4jsf.model.DataVisitor; +import org.ajax4jsf.model.ExtendedDataModel; +import org.ajax4jsf.model.Range; +import org.ajax4jsf.model.SerializableDataModel; +import org.richfaces.context.ExtendedVisitContext; +import org.richfaces.log.Logger; +import org.richfaces.log.RichfacesLogger; + +/** + * Base class for iterable components, like dataTable, Tomahawk dataList, Facelets repeat, tree etc., with support for + * partial rendering on AJAX responces for one or more selected iterations. + * + * @author shura + */ +@ListenerFor(systemEventClass = PreRenderComponentEvent.class) +public abstract class UIDataAdaptor extends UIComponentBase implements NamingContainer, + UniqueIdVendor, IterationStateHolder, ComponentSystemEventListener { + + /** + * <p>The standard component family for this component.</p> + */ + public static final String COMPONENT_FAMILY = "org.richfaces.Data"; + + /** + * <p>The standard component type for this component.</p> + */ + public static final String COMPONENT_TYPE = "org.richfaces.Data"; + + private static final class IterationState implements Serializable { + + private static final long serialVersionUID = -3502645160277416066L; + + private DataComponentState componentState; + + private Object savedComponentState; + + private boolean componentStateIsStateHolder; + + private ExtendedDataModel<?> dataModel; + + public IterationState() { + super(); + } + + public IterationState(DataComponentState componentState, ExtendedDataModel<?> dataModel) { + super(); + this.componentState = componentState; + this.dataModel = dataModel; + } + + public ExtendedDataModel<?> getDataModel() { + return dataModel; + } + + public DataComponentState getComponentState() { + return componentState; + } + + /** + * @param uiDataAdaptor + */ + public void restoreComponentState(UIDataAdaptor uiDataAdaptor) { + if (savedComponentState != null && componentStateIsStateHolder) { + componentState = uiDataAdaptor.createComponentState(); + ((StateHolder) componentState).restoreState(FacesContext.getCurrentInstance(), savedComponentState); + savedComponentState = null; + } + } + + final Object saveState() { + boolean localComponentStateIsHolder = false; + Object localSavedComponentState = null; + + if (componentState != null) { + if (componentState instanceof StateHolder) { + localComponentStateIsHolder = true; + + StateHolder stateHolder = (StateHolder) componentState; + if (!stateHolder.isTransient()) { + localSavedComponentState = stateHolder.saveState(FacesContext.getCurrentInstance()); + } + } else { + if (componentState instanceof Serializable) { + localSavedComponentState = componentState; + } + } + } + + Object savedSerializableModel = null; + + if (componentState != null && dataModel != null) { + // TODO handle model serialization - "execute" model + savedSerializableModel = dataModel.getSerializableModel(componentState.getRange()); + } + + if (localSavedComponentState != null || savedSerializableModel != null) { + return new Object[] { + localComponentStateIsHolder, + localSavedComponentState, + savedSerializableModel + }; + } else { + return null; + } + } + + final void restoreState(Object stateObject) { + if (stateObject != null) { + Object[] state = (Object[]) stateObject; + componentStateIsStateHolder = Boolean.TRUE.equals(state[0]); + Object localSavedComponentState = state[1]; + + if (componentStateIsStateHolder) { + savedComponentState = localSavedComponentState; + } else { + componentState = (DataComponentState) localSavedComponentState; + } + + dataModel = (ExtendedDataModel<?>) state[2]; + } + } + + private void writeObject(java.io.ObjectOutputStream out) + throws IOException { + + out.writeObject(saveState()); + } + + private void readObject(java.io.ObjectInputStream in) + throws IOException, ClassNotFoundException { + + restoreState(in.readObject()); + } + } + + private static final VisitCallback STUB_CALLBACK = new VisitCallback() { + + public VisitResult visit(VisitContext context, UIComponent target) { + return VisitResult.ACCEPT; + } + }; + + private static final Logger LOG = RichfacesLogger.COMPONENTS.getLogger(); + + /** + * Visitor for process decode on children components. + */ + protected ComponentVisitor decodeVisitor = new ComponentVisitor() { + @Override + public void processComponent(FacesContext context, UIComponent c, Object argument) { + c.processDecodes(context); + } + }; + + /** + * Visitor for process validation phase + */ + protected ComponentVisitor validateVisitor = new ComponentVisitor() { + @Override + public void processComponent(FacesContext context, UIComponent c, Object argument) { + c.processValidators(context); + } + }; + + /** + * Visitor for process update model phase. + */ + protected ComponentVisitor updateVisitor = new ComponentVisitor() { + @Override + public void processComponent(FacesContext context, UIComponent c, Object argument) { + c.processUpdates(context); + } + }; + + //TODO nick - PSH support? + private DataComponentState componentState = null; + private ExtendedDataModel<?> extendedDataModel = null; + + private Object rowKey = null; + + private boolean rowDataIsSet = false; + + private Object rowData; + + private String clientId; + + private Object originalVarValue; + + private Converter rowKeyConverter; + + /** + * @author Nick Belaevski + * + */ + private final class DataVisitorForVisitTree implements DataVisitor { + /** + * + */ + private final VisitCallback callback; + /** + * + */ + private final VisitContext visitContext; + /** + * + */ + private boolean visitResult; + + /** + * @param callback + * @param visitContext + */ + private DataVisitorForVisitTree(VisitCallback callback, VisitContext visitContext) { + this.callback = callback; + this.visitContext = visitContext; + } + + public DataVisitResult process(FacesContext context, Object rowKey, Object argument) { + setRowKey(context, rowKey); + + if (isRowAvailable()) { + VisitResult result = VisitResult.ACCEPT; + + if (visitContext instanceof ExtendedVisitContext) { + result = visitContext.invokeVisitCallback(UIDataAdaptor.this, callback); + if (VisitResult.COMPLETE.equals(result)) { + visitResult = true; + + return DataVisitResult.STOP; + } + + if (result == VisitResult.ACCEPT) { + result = visitDataChildrenMetaComponents((ExtendedVisitContext) visitContext, callback); + if (VisitResult.COMPLETE.equals(result)) { + visitResult = true; + + return DataVisitResult.STOP; + } + } + } + + if (VisitResult.ACCEPT.equals(result)) { + Iterator<UIComponent> dataChildrenItr = dataChildren(); + + while (dataChildrenItr.hasNext()) { + UIComponent dataChild = dataChildrenItr.next(); + + if (dataChild.visitTree(visitContext, callback)) { + visitResult = true; + + return DataVisitResult.STOP; + } + } + } + } + + return DataVisitResult.CONTINUE; + } + + public boolean getVisitResult() { + return visitResult; + } + } + + private enum PropertyKeys { + lastId, var, rowKeyVar, stateVar, childState, rowKeyConverter, rowKeyConverterSet, keepSaved + } + + public UIDataAdaptor() { + super(); + } + + protected Map<String, Object> getVariablesMap(FacesContext facesContext) { + return facesContext.getExternalContext().getRequestMap(); + } + + /* + * (non-Javadoc) + * @see javax.faces.component.UIComponent#getFamily() + */ + @Override + public String getFamily() { + return COMPONENT_FAMILY; + } + + /* + * (non-Javadoc) + * @see javax.faces.component.UniqueIdVendor#createUniqueId(javax.faces.context.FacesContext, java.lang.String) + */ + public String createUniqueId(FacesContext context, String seed) { + Integer i = (Integer) getStateHelper().get(PropertyKeys.lastId); + int lastId = (i != null) ? i : 0; + + getStateHelper().put(PropertyKeys.lastId, ++lastId); + + return UIViewRoot.UNIQUE_ID_PREFIX + ((seed == null) ? lastId : seed); + } + + /** + * @return the rowKey + */ + public Object getRowKey() { + return rowKey; + } + + private void setRowKeyAndData(FacesContext facesContext, Object rowKey, boolean localRowDataAvailable, Object localRowData) { + this.saveChildState(facesContext); + + this.rowKey = rowKey; + + if (localRowDataAvailable) { + this.rowData = localRowData; + this.rowDataIsSet = (rowKey != null); + } else { + this.rowData = null; + this.rowDataIsSet = false; + + getExtendedDataModel().setRowKey(rowKey); + } + + this.clientId = null; + + boolean rowSelected = (rowKey != null) && isRowAvailable(); + + setupVariable(facesContext, rowSelected); + + this.restoreChildState(facesContext); + } + + protected void setRowKeyAndData(FacesContext facesContext, Object rowKey, Object localRowData) { + setRowKeyAndData(facesContext, rowKey, true, localRowData); + } + + /** + * Setup current row by key. Perform same functionality as + * {@link javax.faces.component.UIData#setRowIndex(int)}, but for key object - it may be not only + * row number in sequence data, but, for example - path to current node in + * tree. + * + * @param faces - + * current FacesContext + * @param key new key value. + */ + public void setRowKey(FacesContext facesContext, Object rowKey) { +<<<<<<< HEAD + this.saveChildState(facesContext); + + this.rowKey = rowKey; + + getExtendedDataModel().setRowKey(rowKey); + + this.clientId = null; + + boolean rowSelected = (rowKey != null) && isRowAvailable(); + + setupVariable(facesContext, rowSelected); + + this.restoreChildState(facesContext); +======= + setRowKeyAndData(facesContext, rowKey, false, null); +>>>>>>> RF-9680: + } + + /** + * Save values of {@link EditableValueHolder} fields before change current + * row. + * + * @param faces + */ + protected void saveChildState(FacesContext facesContext) { + Iterator<UIComponent> itr = dataChildren(); + + while (itr.hasNext()) { + this.saveChildState(facesContext, (UIComponent) itr.next()); + } + } + + /** + * @param facesContext + * @param next + * @param childState + */ + protected void saveChildState(FacesContext facesContext, UIComponent component) { + + // TODO - is it right? + if (component.isTransient()) { + return; + } + + SavedState state = null; + + if (component instanceof IterationStateHolder) { + IterationStateHolder ish = (IterationStateHolder) component; + + state = new SavedState(ish); + } else if (component instanceof EditableValueHolder) { + EditableValueHolder evh = (EditableValueHolder) component; + + state = new SavedState(evh); + } else if (component instanceof UIForm) { + UIForm form = (UIForm) component; + + state = new SavedState(form); + } + + if (state != null) { + + // TODO - use local map - children save their state themselves using visitors + getStateHelper().put(PropertyKeys.childState, component.getClientId(facesContext), state); + } + + if (component.getChildCount() > 0) { + for (UIComponent child : component.getChildren()) { + saveChildState(facesContext, child); + } + } + + if (component.getFacetCount() > 0) { + for (UIComponent facet : component.getFacets().values()) { + saveChildState(facesContext, facet); + } + } + } + + protected Iterator<UIComponent> dataChildren() { + if (getChildCount() > 0) { + return getChildren().iterator(); + } else { + return Collections.<UIComponent>emptyList().iterator(); + } + } + + protected Iterator<UIComponent> fixedChildren() { + if (getFacetCount() > 0) { + return getFacets().values().iterator(); + } else { + return Collections.<UIComponent>emptyList().iterator(); + } + } + + /** + * @param facesContext + */ + protected void restoreChildState(FacesContext facesContext) { + Iterator<UIComponent> itr = dataChildren(); + + while (itr.hasNext()) { + this.restoreChildState(facesContext, (UIComponent) itr.next()); + } + } + + /** + * Restore values of {@link EditableValueHolder} fields after change current + * row. + * + * @param facesContext + * @param next + * @param childState + */ + protected void restoreChildState(FacesContext facesContext, UIComponent component) { + String id = component.getId(); + + component.setId(id); // Forces client id to be reset + + SavedState savedState = null; + @SuppressWarnings("unchecked") + Map<String, SavedState> savedStatesMap = (Map<String, SavedState>) getStateHelper() + .get(PropertyKeys.childState); + + if (savedStatesMap != null) { + savedState = savedStatesMap.get(component.getClientId(facesContext)); + } + + if (savedState == null) { + savedState = SavedState.EMPTY; + } + + if (component instanceof IterationStateHolder) { + IterationStateHolder ish = (IterationStateHolder) component; + + savedState.apply(ish); + } else if (component instanceof EditableValueHolder) { + EditableValueHolder evh = (EditableValueHolder) component; + + savedState.apply(evh); + } else if (component instanceof UIForm) { + UIForm form = (UIForm) component; + + savedState.apply(form); + } + + if (component.getChildCount() > 0) { + for (UIComponent child : component.getChildren()) { + restoreChildState(facesContext, child); + } + } + + if (component.getFacetCount() > 0) { + for (UIComponent facet : component.getFacets().values()) { + restoreChildState(facesContext, facet); + } + } + } + + public void setRowKey(Object rowKey) { + setRowKey(getFacesContext(), rowKey); + } + + protected FacesEvent wrapEvent(FacesEvent event) { + return new RowKeyContextEventWrapper(this, event, getRowKey()); + } + + @Override + public void queueEvent(FacesEvent event) { + super.queueEvent(wrapEvent(event)); + } + + /* + * (non-Javadoc) + * @see javax.faces.component.UIComponentBase#broadcast(javax.faces.event.FacesEvent) + */ + @Override + public void broadcast(FacesEvent event) throws AbortProcessingException { + if (event instanceof RowKeyContextEventWrapper) { + RowKeyContextEventWrapper eventWrapper = (RowKeyContextEventWrapper) event; + + eventWrapper.broadcast(getFacesContext()); + } else { + super.broadcast(event); + } + } + + /** + * @return the extendedDataModel + */ + protected ExtendedDataModel<?> getExtendedDataModel() { + if (extendedDataModel == null) { + extendedDataModel = createExtendedDataModel(); + } + + return extendedDataModel; + } + + /** + * @return + */ + protected abstract ExtendedDataModel<?> createExtendedDataModel(); + + /** + * @param extendedDataModel the extendedDataModel to set + */ + protected void setExtendedDataModel(ExtendedDataModel<?> extendedDataModel) { + this.extendedDataModel = extendedDataModel; + } + + public String getVar() { + return (String) getStateHelper().get(PropertyKeys.var); + } + + public void setVar(String var) { + getStateHelper().put(PropertyKeys.var, var); + } + + public String getRowKeyVar() { + return (String) getStateHelper().get(PropertyKeys.rowKeyVar); + } + + public void setRowKeyVar(String rowKeyVar) { + getStateHelper().put(PropertyKeys.rowKeyVar, rowKeyVar); + } + + public String getStateVar() { + return (String) getStateHelper().get(PropertyKeys.stateVar); + } + + public void setStateVar(String stateVar) { + getStateHelper().put(PropertyKeys.stateVar, stateVar); + } + + //XXX - review and probably remove - useful method, should be left + public int getRowCount() { + return getExtendedDataModel().getRowCount(); + } + + public Object getRowData() { + if (rowDataIsSet) { + return rowData; + } + + return getExtendedDataModel().getRowData(); + } + + public boolean isRowAvailable() { + return rowDataIsSet || getExtendedDataModel().isRowAvailable(); + } + + /** + * Boolean attribute that defines whether this iteration component will reset saved children's state + * before rendering. By default state is reset if there are no faces messages with severity error or higher. + * @return + */ + public boolean isKeepSaved() { + Object value = getStateHelper().eval(PropertyKeys.keepSaved); + + if (value == null) { + return keepSaved(getFacesContext()); + } else { + return Boolean.valueOf(value.toString()); + } + } + + public void setKeepSaved(boolean keepSaved) { + getStateHelper().put(PropertyKeys.keepSaved, keepSaved); + } + + /** + * Setup EL variable for different iteration. Value of row data and + * component state will be put into request scope attributes with names + * given by "var" and "varState" bean properties. + * <p/> + * Changed: does not check for row availability now + * + * @param faces current faces context + * @param localModel + * @param rowSelected + */ + protected void setupVariable(FacesContext faces, boolean rowSelected) { + Map<String, Object> attrs = getVariablesMap(faces); + + if (rowSelected) { + + // Current row data. + setupVariable(getVar(), attrs, getRowData()); + + // Component state variable. + setupVariable(getStateVar(), attrs, getComponentState()); + + // Row key Data variable. + setupVariable(getRowKeyVar(), attrs, getRowKey()); + } else { + removeVariable(getVar(), attrs); + removeVariable(getStateVar(), attrs); + removeVariable(getRowKeyVar(), attrs); + } + } + + /** + * @return + */ + public DataComponentState getComponentState() { + if (componentState != null) { + return componentState; + } + + ValueExpression componentStateExpression = getValueExpression("componentState"); + + if (componentStateExpression != null) { + componentState = (DataComponentState) componentStateExpression.getValue(getFacesContext().getELContext()); + } + + if (componentState == null) { + componentState = createComponentState(); + + if ((componentStateExpression != null) + && !componentStateExpression.isReadOnly(getFacesContext().getELContext())) { + componentStateExpression.setValue(getFacesContext().getELContext(), componentState); + } + } + + return componentState; + } + + protected abstract DataComponentState createComponentState(); + + /** + * @param var + * @param attrs + * @param rowData + */ + private void setupVariable(String var, Map<String, Object> attrs, Object rowData) { + if (var != null) { + attrs.put(var, rowData); + } + } + + /** + * @param var + * @param attrs + * @param rowData + */ + private void removeVariable(String var, Map<String, Object> attrs) { + if (var != null) { + attrs.remove(var); + } + } + + public Converter getRowKeyConverter() { + if (this.rowKeyConverter != null) { + return this.rowKeyConverter; + } + + return (Converter) getStateHelper().eval(PropertyKeys.rowKeyConverter); + } + + public void setRowKeyConverter(Converter converter) { + StateHelper stateHelper = getStateHelper(); + if (initialStateMarked()) { + stateHelper.put(PropertyKeys.rowKeyConverterSet, Boolean.TRUE); + } + + this.rowKeyConverter = converter; + } + + private boolean isSetRowKeyConverter() { + Boolean value = (Boolean) getStateHelper().get(PropertyKeys.rowKeyConverterSet); + return Boolean.TRUE.equals(value); + } + + @Override + public String getClientId(FacesContext facesContext) { + if (facesContext == null) { + throw new NullPointerException("context"); + } + + if (null == clientId) { + StringBuilder id = new StringBuilder(super.getClientId(facesContext)); + Object rowKey = getRowKey(); + + if (rowKey != null) { + + // Use converter to get String representation ot the row key. + Converter rowKeyConverter = getRowKeyConverter(); + + if (null == rowKeyConverter) { + + // Create default converter for a row key. + rowKeyConverter = facesContext.getApplication().createConverter(rowKey.getClass()); + + // Store converter for a invokeOnComponents call. + if (null != rowKeyConverter) { + // TODO - review + setRowKeyConverter(rowKeyConverter); + } + } + + String rowKeyString; + + if (null != rowKeyConverter) { + + // Temporary set clientId, to avoid infinite calls from converter. + clientId = id.toString(); + rowKeyString = rowKeyConverter.getAsString(facesContext, this, rowKey); + } else { + rowKeyString = rowKey.toString(); + } + + id.append(UINamingContainer.getSeparatorChar(facesContext)).append(rowKeyString); + } + + Renderer renderer = getRenderer(facesContext); + + if (null != renderer) { + clientId = renderer.convertClientId(facesContext, id.toString()); + } else { + clientId = id.toString(); + } + } + + return clientId; + } + + public String getBaseClientId(FacesContext context) { + return super.getClientId(context); + } + + /** + * Save current state of data variable. + * + * @param faces current faces context + */ + + // TODO move into walk() method body + public void captureOrigValue(FacesContext faces) { + String var = getVar(); + + if (var != null) { + Map<String, Object> attrs = getVariablesMap(faces); + + this.originalVarValue = attrs.get(var); + } + + // TODO add support for another variables + } + + /** + * Restore value of data variable after processing phase. + * + * @param faces current faces context + */ + public void restoreOrigValue(FacesContext faces) { + String var = getVar(); + + if (var != null) { + Map<String, Object> attrs = getVariablesMap(faces); + + if (this.originalVarValue != null) { + attrs.put(var, this.originalVarValue); + } else { + attrs.remove(var); + } + } + } + + /* + * (non-Javadoc) + * @see javax.faces.component.UIComponent#setValueExpression(java.lang.String, javax.el.ValueExpression) + */ + @Override + public void setValueExpression(String name, ValueExpression binding) { + if ("var".equals(name) || "rowKeyVar".equals(name) || "stateVar".equals(name)) { + throw new IllegalArgumentException(MessageFormat.format("{0} cannot be EL-expression", name)); + } + + super.setValueExpression(name, binding); + } + + /** + * Check for validation errors on children components. If true, saved values + * must be keep on render phase + * + * @param context + * @return + */ + protected boolean keepSaved(FacesContext context) { + + // For an any validation errors, children components state should be preserved + FacesMessage.Severity sev = context.getMaximumSeverity(); + + return (sev != null) && (FacesMessage.SEVERITY_ERROR.compareTo(sev) >= 0); + } + + /** + * Perform iteration on all children components and all data rows with given + * visitor. + * + * @param faces + * @param visitor + */ + protected void iterate(FacesContext faces, ComponentVisitor visitor) { + + // stop if not rendered + if (!this.isRendered()) { + return; + } + + // reset rowIndex + this.captureOrigValue(faces); + this.setRowKey(faces, null); + + try { + Iterator<UIComponent> fixedChildren = fixedChildren(); + + while (fixedChildren.hasNext()) { + UIComponent component = fixedChildren.next(); + + visitor.processComponent(faces, component, null); + } + + walk(faces, visitor, null); + } catch (Exception e) { + throw new FacesException(e); + } finally { + this.setRowKey(faces, null); + this.restoreOrigValue(faces); + } + } + + /** + * Walk ( visit ) this component on all data-aware children for each row. + * + * @param faces + * @param visitor + */ + public void walk(FacesContext faces, DataVisitor visitor, Object argument) { + Object key = getRowKey(); + captureOrigValue(faces); + + Range range = null; + DataComponentState componentState = getComponentState(); + + if (componentState != null) { + range = componentState.getRange(); + } + + getExtendedDataModel().walk(faces, visitor, range, argument); + + setRowKey(faces, key); + restoreOrigValue(faces); + } + + public void processDecodes(FacesContext faces) { + if (!this.isRendered()) { + return; + } + + pushComponentToEL(faces, this); + preDecode(faces); + this.iterate(faces, decodeVisitor); + this.decode(faces); + popComponentFromEL(faces); + } + + public void processValidators(FacesContext faces) { + if (!this.isRendered()) { + return; + } + + pushComponentToEL(faces, this); + Application app = faces.getApplication(); + app.publishEvent(faces, PreValidateEvent.class, this); + preValidate(faces); + this.iterate(faces, validateVisitor); + app.publishEvent(faces, PostValidateEvent.class, this); + popComponentFromEL(faces); + } + + public void processUpdates(FacesContext faces) { + if (!this.isRendered()) { + return; + } + + pushComponentToEL(faces, this); + preUpdate(faces); + this.iterate(faces, updateVisitor); + + ExtendedDataModel<?> dataModel = getExtendedDataModel(); + + // If no validation errors, update values for serializable model, + // restored from view. + if ((dataModel instanceof SerializableDataModel) && (!isKeepSaved())) { + SerializableDataModel serializableModel = (SerializableDataModel) dataModel; + + serializableModel.update(); + } + + doUpdate(); + + popComponentFromEL(faces); + } + + protected void doUpdate() { + + } + + @Override + public void setId(String id) { + super.setId(id); + this.clientId = null; + } + + /* + * (non-Javadoc) + * @see org.ajax4jsf.component.IterationStateHolder#getIterationState() + */ + public Object getIterationState() { + assert rowKey == null; + + return new IterationState(this.componentState, this.extendedDataModel); + } + + /* + * (non-Javadoc) + * + * @see org.ajax4jsf.component.IterationStateHolder#setIterationState(java.lang.Object) + */ + public void setIterationState(Object stateObject) { + assert rowKey == null; + + // TODO - ? + // restoreChildState(getFacesContext()); + if (stateObject != null) { + IterationState iterationState = (IterationState) stateObject; + iterationState.restoreComponentState(this); + + this.componentState = iterationState.getComponentState(); + this.extendedDataModel = iterationState.getDataModel(); + } else { + this.componentState = null; + this.extendedDataModel = null; + } + } + + protected void resetDataModel() { + this.extendedDataModel = null; + } + + protected void resetChildState() { + getStateHelper().remove(PropertyKeys.childState); + } + + protected void preDecode(FacesContext context) { + resetDataModel(); + + Object savedChildState = getStateHelper().get(PropertyKeys.childState); + // TODO - verify the check for null: savedChildState == null + if (savedChildState == null || !isKeepSaved()) { + resetChildState(); + } + } + + // TODO - do we need this method? + protected void preValidate(FacesContext context) { + } + + // TODO - do we need this method? + protected void preUpdate(FacesContext context) { + } + + protected void preEncodeBegin(FacesContext context) { + resetDataModel(); + + if (!isKeepSaved()) { + //TODO - this also resets state for the nested iteration components - is it correct? + resetChildState(); + } + } + + @Override + public void markInitialState() { + super.markInitialState(); + + if (rowKeyConverter instanceof PartialStateHolder) { + ((PartialStateHolder) rowKeyConverter).markInitialState(); + } + } + + @Override + public void clearInitialState() { + super.clearInitialState(); + + if (rowKeyConverter instanceof PartialStateHolder) { + ((PartialStateHolder) rowKeyConverter).clearInitialState(); + } + } + + /* + * (non-Javadoc) + * @see javax.faces.component.UIComponentBase#saveState(javax.faces.context.FacesContext) + */ + @Override + public Object saveState(FacesContext context) { + Object parentState = super.saveState(context); + Object savedComponentState = new IterationState(componentState, extendedDataModel).saveState(); + + Object converterState = null; + boolean nullDelta = true; + + boolean converterHasPartialState = false; + + if (initialStateMarked()) { + if (!isSetRowKeyConverter() && rowKeyConverter != null && rowKeyConverter instanceof PartialStateHolder) { + // Delta + StateHolder holder = (StateHolder) rowKeyConverter; + if (!holder.isTransient()) { + Object attachedState = holder.saveState(context); + if (attachedState != null) { + nullDelta = false; + converterState = attachedState; + } + converterHasPartialState = true; + } else { + converterState = null; + } + } else if (isSetRowKeyConverter() || rowKeyConverter != null) { + // Full + converterState = saveAttachedState(context, rowKeyConverter); + nullDelta = false; + } + + if (parentState == null && savedComponentState == null && nullDelta) { + // No values + return null; + } + } else { + converterState = saveAttachedState(context, rowKeyConverter); + } + + return new Object[] { + parentState, + savedComponentState, + converterHasPartialState, + converterState + }; + } + + /* + * (non-Javadoc) + * + * @see javax.faces.component.UIComponentBase#restoreState(javax.faces.context.FacesContext, java.lang.Object) + */ + @Override + public void restoreState(FacesContext context, Object stateObject) { + if (stateObject == null) { + return ; + } + + Object[] state = (Object[]) stateObject; + + super.restoreState(context, state[0]); + + if (state[1] != null) { + IterationState iterationState = new IterationState(); + iterationState.restoreState(state[1]); + iterationState.restoreComponentState(this); + + // TODO update state model binding + componentState = iterationState.getComponentState(); + extendedDataModel = iterationState.getDataModel(); + } + + boolean converterHasPartialState = Boolean.TRUE.equals(state[2]); + Object savedConverterState = state[3]; + if (converterHasPartialState) { + ((StateHolder) rowKeyConverter).restoreState(context, savedConverterState); + } else { + rowKeyConverter = (Converter) UIComponentBase.restoreAttachedState(context, savedConverterState); + } + } + + private boolean matchesBaseId(String clientId, String baseId, char separatorChar) { + if (clientId.equals(baseId)) { + return true; + } + + // if clientId.startsWith(baseId + separatorChar) + if (clientId.startsWith(baseId) && (clientId.length() > baseId.length()) + && (clientId.charAt(baseId.length()) == separatorChar)) { + return true; + } + + return false; + } + + @Override + public boolean invokeOnComponent(FacesContext context, String clientId, ContextCallback callback) + throws FacesException { + + if ((null == context) || (null == clientId) || (null == callback)) { + throw new NullPointerException(); + } + + String baseId = super.getClientId(context); + + if (!matchesBaseId(clientId, baseId, UINamingContainer.getSeparatorChar(context))) { + return false; + } + + boolean found = false; + Object oldRowKey = getRowKey(); + + // TODO - this does not seem right + captureOrigValue(context); + + try { + + // TODO - ? + // if (null != oldRowKey) { + setRowKey(context, null); + + // } + if (clientId.equals(baseId)) { + callback.invokeContextCallback(context, this); + found = true; + } else { + Iterator<UIComponent> fixedChildrenItr = fixedChildren(); + + while (fixedChildrenItr.hasNext() && !found) { + UIComponent fixedChild = fixedChildrenItr.next(); + + found = fixedChild.invokeOnComponent(context, clientId, callback); + } + } + + if (!found) { + Object newRowKey = null; + + // Call for a child component - try to detect row key + // baseId.length() + 1 expression skips SEPARATOR_CHAR + //TODO - convertKeyString + String rowKeyString = extractKeySegment(context, clientId.substring(baseId.length() + 1)); + + if (rowKeyString != null) { + Converter keyConverter = getRowKeyConverter(); + + if (null != keyConverter) { + try { + //TODO: review + newRowKey = keyConverter.getAsObject(context, this, rowKeyString); + } catch (ConverterException e) { + + // TODO: LOG error + } + } + } + + setRowKey(context, newRowKey); + + if (isRowAvailable()) { + Iterator<UIComponent> dataChildrenItr = dataChildren(); + + while (dataChildrenItr.hasNext() && !found) { + UIComponent dataChild = dataChildrenItr.next(); + + found = dataChild.invokeOnComponent(context, clientId, callback); + } + } + } + } catch (Exception e) { + throw new FacesException(e); + } finally { + + // if (null != oldRowKey) { + try { + setRowKey(context, oldRowKey); + restoreOrigValue(context); + } catch (Exception e) { + LOG.error(e.getMessage(), e); + } + + // } + } + + return found; + } + + // Tests whether we need to visit our children as part of + // a tree visit + private boolean doVisitChildren(VisitContext context, boolean visitRows) { + + // Just need to check whether there are any ids under this + // subtree. Make sure row index is cleared out since + // getSubtreeIdsToVisit() needs our row-less client id. + + // TODO check this + if (visitRows) { + setRowKey(context.getFacesContext(), null); + } + + // TODO optimize for returned IDs + Collection<String> idsToVisit = context.getSubtreeIdsToVisit(this); + + assert idsToVisit != null; + + if (idsToVisit == VisitContext.ALL_IDS) { + // TODO + } + + // All ids or non-empty collection means we need to visit our children. + return !idsToVisit.isEmpty(); + } + + private boolean visitComponents(Iterator<UIComponent> components, VisitContext context, VisitCallback callback) { + + while (components.hasNext()) { + UIComponent nextChild = components.next(); + + if (nextChild.visitTree(context, callback)) { + return true; + } + } + + return false; + } + + protected boolean visitFixedChildren(VisitContext visitContext, VisitCallback callback) { + + return visitComponents(fixedChildren(), visitContext, callback); + } + + protected VisitResult visitDataChildrenMetaComponents(ExtendedVisitContext extendedVisitContext, VisitCallback callback) { + return VisitResult.ACCEPT; + } + + protected boolean visitDataChildren(VisitContext visitContext, VisitCallback callback, boolean visitRows) { + + if (visitRows) { + FacesContext facesContext = visitContext.getFacesContext(); + + DataVisitorForVisitTree dataVisitor = new DataVisitorForVisitTree(callback, visitContext); + this.walk(facesContext, dataVisitor, null); + + return dataVisitor.getVisitResult(); + } else { + return visitComponents(dataChildren(), visitContext, callback); + } + } + + @Override + public boolean visitTree(VisitContext visitContext, VisitCallback callback) { + + // First check to see whether we are visitable. If not + // short-circuit out of this subtree, though allow the + // visit to proceed through to other subtrees. + if (!isVisitable(visitContext)) { + return false; + } + + // Clear out the row index is one is set so that + // we start from a clean slate. + FacesContext facesContext = visitContext.getFacesContext(); + + // NOTE: that the visitRows local will be obsolete once the + // appropriate visit hints have been added to the API + boolean visitRows = requiresRowIteration(facesContext); + + Object oldRowKey = null; + if (visitRows) { + captureOrigValue(facesContext); + oldRowKey = getRowKey(); + setRowKey(facesContext, null); + } + + // Push ourselves to EL + pushComponentToEL(facesContext, null); + + try { + + // Visit ourselves. Note that we delegate to the + // VisitContext to actually perform the visit. + VisitResult result = visitContext.invokeVisitCallback(this, callback); + + // If the visit is complete, short-circuit out and end the visit + if (result == VisitResult.COMPLETE) { + return true; + } + + // Visit children, short-circuiting as necessary + if ((result == VisitResult.ACCEPT) && doVisitChildren(visitContext, visitRows)) { + if (visitRows) { + setRowKey(facesContext, null); + } + + if (visitFixedChildren(visitContext, callback)) { + return true; + } + + if (visitContext instanceof ExtendedVisitContext) { + ExtendedVisitContext extendedVisitContext = (ExtendedVisitContext) visitContext; + + Collection<String> directSubtreeIdsToVisit = extendedVisitContext.getDirectSubtreeIdsToVisit(this); + if (directSubtreeIdsToVisit != VisitContext.ALL_IDS) { + if (directSubtreeIdsToVisit.isEmpty()) { + return false; + } else { + VisitContext directChildrenVisitContext = + extendedVisitContext.createNamingContainerVisitContext(this, directSubtreeIdsToVisit); + + if (visitRows) { + setRowKey(facesContext, null); + } + if (visitFixedChildren(directChildrenVisitContext, STUB_CALLBACK)) { + return false; + } + } + } + } + + if (visitDataChildren(visitContext, callback, visitRows)) { + return true; + } + } + } finally { + + // Clean up - pop EL and restore old row index + popComponentFromEL(facesContext); + + if (visitRows) { + try { + setRowKey(facesContext, oldRowKey); + restoreOrigValue(facesContext); + } catch (Exception e) { + + // TODO: handle exception + LOG.error(e.getMessage(), e); + } + } + } + + // Return false to allow the visit to continue + return false; + } + + /** + * @param facesContext + * @return + */ + private boolean requiresRowIteration(FacesContext context) { + return (!PhaseId.RESTORE_VIEW.equals(context.getCurrentPhaseId())); + } + + /** + * @param context + * @param substring + * @return + */ + // TODO review! + protected String extractKeySegment(FacesContext context, String substring) { + char separatorChar = UINamingContainer.getSeparatorChar(context); + int separatorIndex = substring.indexOf(separatorChar); + + if (separatorIndex < 0) { + return null; + } else { + return substring.substring(0, separatorIndex); + } + } + + /** + * Base class for visit data model at phases decode, validation and update model + * + * @author shura + */ + protected abstract class ComponentVisitor implements DataVisitor { + public DataVisitResult process(FacesContext context, Object rowKey, Object argument) { + setRowKey(context, rowKey); + + if (isRowAvailable()) { + Iterator<UIComponent> childIterator = dataChildren(); + + while (childIterator.hasNext()) { + UIComponent component = childIterator.next(); + + processComponent(context, component, argument); + } + } + + return DataVisitResult.CONTINUE; + } + + public abstract void processComponent(FacesContext context, UIComponent c, Object argument); + } + + @Override + public void processEvent(ComponentSystemEvent event) throws AbortProcessingException { + super.processEvent(event); + + if (event instanceof PreRenderComponentEvent) { + preEncodeBegin(getFacesContext()); + } + } + + protected DataComponentState getLocalComponentState() { + return componentState; + } +} Added: trunk/ui/iteration/ui/src/main/java/org/richfaces/component/AbstractTree.java.orig =================================================================== --- trunk/ui/iteration/ui/src/main/java/org/richfaces/component/AbstractTree.java.orig (rev 0) +++ trunk/ui/iteration/ui/src/main/java/org/richfaces/component/AbstractTree.java.orig 2010-12-01 16:27:24 UTC (rev 20261) @@ -0,0 +1,575 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2010, Red Hat, Inc. and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * This is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.richfaces.component; + +import java.io.IOException; +import java.util.Collection; +import java.util.HashSet; +import java.util.Iterator; + +import javax.el.ELContext; +import javax.el.ELException; +import javax.el.MethodExpression; +import javax.el.ValueExpression; +import javax.faces.application.Application; +import javax.faces.application.FacesMessage; +import javax.faces.component.UIComponent; +import javax.faces.component.UpdateModelException; +import javax.faces.component.html.HtmlOutputText; +import javax.faces.component.visit.VisitCallback; +import javax.faces.component.visit.VisitContext; +import javax.faces.component.visit.VisitResult; +import javax.faces.context.FacesContext; +import javax.faces.convert.Converter; +import javax.faces.event.AbortProcessingException; +import javax.faces.event.ExceptionQueuedEvent; +import javax.faces.event.ExceptionQueuedEventContext; +import javax.faces.event.FacesEvent; +import javax.faces.event.PhaseId; + +import org.ajax4jsf.model.DataComponentState; +import org.ajax4jsf.model.DataVisitor; +import org.ajax4jsf.model.ExtendedDataModel; +import org.richfaces.application.MessageFactory; +import org.richfaces.application.ServiceTracker; +import org.richfaces.appplication.FacesMessages; +import org.richfaces.cdk.annotations.Attribute; +import org.richfaces.cdk.annotations.EventName; +import org.richfaces.cdk.annotations.JsfComponent; +import org.richfaces.cdk.annotations.JsfRenderer; +import org.richfaces.cdk.annotations.Signature; +import org.richfaces.cdk.annotations.Tag; +import org.richfaces.component.util.MessageUtil; +import org.richfaces.context.ExtendedVisitContext; +import org.richfaces.context.ExtendedVisitContextMode; +import org.richfaces.convert.SequenceRowKeyConverter; +import org.richfaces.event.TreeSelectionChangeEvent; +import org.richfaces.event.TreeSelectionChangeListener; +import org.richfaces.event.TreeSelectionChangeSource; +import org.richfaces.event.TreeToggleEvent; +import org.richfaces.event.TreeToggleListener; +import org.richfaces.event.TreeToggleSource; +import org.richfaces.model.DeclarativeTreeDataModelImpl; +<<<<<<< HEAD +import org.richfaces.model.DeclarativeTreeModel; +======= +>>>>>>> RF-9680 +import org.richfaces.model.SwingTreeNodeDataModelImpl; +import org.richfaces.model.TreeDataModel; +import org.richfaces.model.TreeDataModelTuple; +import org.richfaces.model.TreeDataVisitor; +import org.richfaces.renderkit.MetaComponentRenderer; + +import com.google.common.base.Predicate; +import com.google.common.base.Strings; +import com.google.common.collect.Iterables; +import com.google.common.collect.Iterators; + +/** + * @author Nick Belaevski + * + */ +@JsfComponent( + type = AbstractTree.COMPONENT_TYPE, + family = AbstractTree.COMPONENT_FAMILY, + tag = @Tag(name = "tree", handler = "org.richfaces.view.facelets.TreeHandler"), + renderer = @JsfRenderer(type = "org.richfaces.TreeRenderer"), + attributes = {"events-props.xml", "core-props.xml", "i18n-props.xml"} +) +//TODO add rowData caching for wrapper events +public abstract class AbstractTree extends UIDataAdaptor implements MetaComponentResolver, MetaComponentEncoder, TreeSelectionChangeSource, TreeToggleSource { + + public static final String COMPONENT_TYPE = "org.richfaces.Tree"; + + public static final String COMPONENT_FAMILY = "org.richfaces.Tree"; + + public static final String SELECTION_META_COMPONENT_ID = "selection"; + + private static final String DEFAULT_TREE_NODE_CREATED = AbstractTree.class.getName() + ":DEFAULT_TREE_NODE_CREATED"; + + private static final class MatchingTreeNodePredicate implements Predicate<UIComponent> { + + private String type; + + public MatchingTreeNodePredicate(String type) { + super(); + this.type = type; + } + + public boolean apply(UIComponent input) { + if (!(input instanceof AbstractTreeNode)) { + return false; + } + + String nodeType = ((AbstractTreeNode) input).getType(); + if (type == null && nodeType == null) { + return true; + } + + return type != null && type.equals(nodeType); + } + }; + + private static final Converter ROW_KEY_CONVERTER = new SequenceRowKeyConverter(); + + private enum PropertyKeys { + selection + } + + @SuppressWarnings("unused") + @Attribute(generate = false, signature = @Signature(returnType = Void.class, parameters = TreeSelectionChangeEvent.class)) + private MethodExpression selectionChangeListener; + + @SuppressWarnings("unused") + @Attribute(generate = false, signature = @Signature(returnType = Void.class, parameters = TreeToggleListener.class)) + private MethodExpression toggleListener; + + private transient TreeRange treeRange; + + public AbstractTree() { + setKeepSaved(true); + setRendererType("org.richfaces.TreeRenderer"); + } + + protected TreeRange getTreeRange() { + if (treeRange == null) { + treeRange = new TreeRange(this); + } + + return treeRange; + } + + public abstract Object getValue(); + + public abstract boolean isImmediate(); + + public abstract String getIconLeaf(); + + public abstract String getIconExpanded(); + + public abstract String getIconCollapsed(); + + public abstract String getNodeClass(); + + public abstract String getHandleClass(); + + public abstract String getIconClass(); + + public abstract String getLabelClass(); + + @Attribute(events = @EventName("nodetoggle")) + public abstract String getOnnodetoggle(); + + @Attribute(events = @EventName("beforenodetoggle")) + public abstract String getOnbeforenodetoggle(); + + @Attribute(events = @EventName("selectionchange")) + public abstract String getOnselectionchange(); + + @Attribute(events = @EventName("beforeselectionchange")) + public abstract String getOnbeforeselectionchange(); + + @Attribute(defaultValue = "SwitchType.DEFAULT") + public abstract SwitchType getToggleType(); + + @Attribute(defaultValue = "SwitchType.client") + public abstract SwitchType getSelectionType(); + + public abstract String getNodeType(); + + public abstract String getToggleNodeEvent(); + + @Override + public String getFamily() { + return COMPONENT_FAMILY; + } + + public Collection<Object> getSelection() { + @SuppressWarnings("unchecked") + Collection<Object> selection = (Collection<Object>) getStateHelper().eval(PropertyKeys.selection); + if (selection == null) { + selection = new HashSet<Object>(); + + ValueExpression ve = getValueExpression(PropertyKeys.selection.toString()); + if (ve != null) { + ve.setValue(getFacesContext().getELContext(), selection); + } else { + getStateHelper().put(PropertyKeys.selection, selection); + } + } + + return selection; + } + + public void setSelection(Collection<Object> selection) { + getStateHelper().put(PropertyKeys.selection, selection); + } + + @Override + protected DataComponentState createComponentState() { + // TODO Auto-generated method stub + return null; + } + + @Override + public Converter getRowKeyConverter() { + Converter converter = super.getRowKeyConverter(); + if (converter == null) { + converter = ROW_KEY_CONVERTER; + } + return converter; + } + + protected Iterator<UIComponent> findMatchingTreeNodeComponent(String nodeType, UIComponent parentComponent) { + Iterator<UIComponent> children = parentComponent.getChildren().iterator(); + if (parentComponent != this) { + children = Iterators.concat(children, this.getChildren().iterator()); + } + + return Iterators.filter(children, new MatchingTreeNodePredicate(nodeType)); + } + + protected UIComponent getCurrentComponent() { + ExtendedDataModel<?> dataModel = getExtendedDataModel(); + if (dataModel instanceof DeclarativeTreeModel) { + return ((DeclarativeTreeModel) dataModel).getCurrentComponent(); + } + + return this; + } + + public AbstractTreeNode findTreeNodeComponent() { + FacesContext facesContext = getFacesContext(); + + String nodeType = getNodeType(); + + Iterator<UIComponent> nodesItr = findMatchingTreeNodeComponent(nodeType, getCurrentComponent()); + + if (nodesItr.hasNext()) { + Iterator<UIComponent> renderedNodesItr = Iterators.filter(nodesItr, ComponentPredicates.isRendered()); + if (renderedNodesItr.hasNext()) { + return (AbstractTreeNode) renderedNodesItr.next(); + } + + return null; + } + + if (Strings.isNullOrEmpty(nodeType)) { + if (getAttributes().put(DEFAULT_TREE_NODE_CREATED, Boolean.TRUE) != null) { + return null; + } + + Application application = facesContext.getApplication(); + AbstractTreeNode treeNode = (AbstractTreeNode) application.createComponent(AbstractTreeNode.COMPONENT_TYPE); + treeNode.setId("__defaultTreeNode"); + + getChildren().add(treeNode); + + UIComponent text = application.createComponent(HtmlOutputText.COMPONENT_TYPE); + text.setValueExpression("value", application.getExpressionFactory().createValueExpression(facesContext.getELContext(), + "#{" + getVar() + "}", String.class)); + treeNode.getChildren().add(text); + + return treeNode; + } + + return null; + } + + @Override + public void broadcast(FacesEvent event) throws AbortProcessingException { + super.broadcast(event); + + if (event instanceof TreeSelectionChangeEvent) { + TreeSelectionChangeEvent selectionEvent = (TreeSelectionChangeEvent) event; + + final Collection<Object> newSelection = selectionEvent.getNewSelection(); + + Collection<Object> selectionCollection = getSelection(); + + Iterables.removeIf(selectionCollection, new Predicate<Object>() { + public boolean apply(Object input) { + return !newSelection.contains(input); + }; + }); + + if (!newSelection.isEmpty()) { + Iterables.addAll(selectionCollection, newSelection); + } + } else if (event instanceof TreeToggleEvent) { + TreeToggleEvent toggleEvent = (TreeToggleEvent) event; + AbstractTreeNode treeNodeComponent = findTreeNodeComponent(); + + boolean newExpandedValue = toggleEvent.isExpanded(); + + FacesContext context = getFacesContext(); + ValueExpression expression = getValueExpression(AbstractTreeNode.PropertyKeys.expanded.toString()); + if (expression != null) { + ELContext elContext = context.getELContext(); + Exception caught = null; + FacesMessage message = null; + try { + expression.setValue(elContext, newExpandedValue); + } catch (ELException e) { + caught = e; + String messageStr = e.getMessage(); + Throwable result = e.getCause(); + while (null != result && + result.getClass().isAssignableFrom(ELException.class)) { + messageStr = result.getMessage(); + result = result.getCause(); + } + if (null == messageStr) { + MessageFactory messageFactory = ServiceTracker.getService(MessageFactory.class); + message = + messageFactory.createMessage(context, FacesMessages.UIINPUT_UPDATE, + MessageUtil.getLabel(context, this)); + } else { + message = new FacesMessage(FacesMessage.SEVERITY_ERROR, + messageStr, + messageStr); + } + } catch (Exception e) { + caught = e; + MessageFactory messageFactory = ServiceTracker.getService(MessageFactory.class); + message = + messageFactory.createMessage(context, FacesMessages.UIINPUT_UPDATE, + MessageUtil.getLabel(context, this)); + } + if (caught != null) { + assert(message != null); + UpdateModelException toQueue = new UpdateModelException(message, caught); + ExceptionQueuedEventContext eventContext = + new ExceptionQueuedEventContext(context, + toQueue, + this, + PhaseId.UPDATE_MODEL_VALUES); + context.getApplication().publishEvent(context, + ExceptionQueuedEvent.class, + eventContext); + } + } else { + treeNodeComponent.setExpanded(newExpandedValue); + } + } + } + + @Override + protected boolean visitFixedChildren(VisitContext visitContext, VisitCallback callback) { + if (visitContext instanceof ExtendedVisitContext) { + ExtendedVisitContext extendedVisitContext = (ExtendedVisitContext) visitContext; + + if (ExtendedVisitContextMode.RENDER == extendedVisitContext.getVisitMode()) { + VisitResult result = extendedVisitContext.invokeMetaComponentVisitCallback(this, callback, SELECTION_META_COMPONENT_ID); + if (result != VisitResult.ACCEPT) { + return result == VisitResult.COMPLETE; + } + } + } + + return super.visitFixedChildren(visitContext, callback); + } + + void decodeMetaComponent(FacesContext context, String metaComponentId) { + ((MetaComponentRenderer) getRenderer(context)).decodeMetaComponent(context, this, metaComponentId); + } + + public void encodeMetaComponent(FacesContext context, String metaComponentId) throws IOException { + ((MetaComponentRenderer) getRenderer(context)).encodeMetaComponent(context, this, metaComponentId); + } + + public String resolveClientId(FacesContext facesContext, UIComponent contextComponent, String metaComponentId) { + if (SELECTION_META_COMPONENT_ID.equals(metaComponentId)) { + return getClientId(facesContext) + MetaComponentResolver.META_COMPONENT_SEPARATOR_CHAR + metaComponentId; + } + + return null; + } + + public String substituteUnresolvedClientId(FacesContext facesContext, UIComponent contextComponent, + String metaComponentId) { + + return null; + } + + @Override + protected Iterator<UIComponent> dataChildren() { + AbstractTreeNode treeNodeComponent = findTreeNodeComponent(); + if (treeNodeComponent != null) { + return Iterators.<UIComponent>singletonIterator(treeNodeComponent); + } else { + return Iterators.<UIComponent>emptyIterator(); + } + } + + public void addTreeSelectionChangeListener(TreeSelectionChangeListener listener) { + addFacesListener(listener); + } + + @Attribute(hidden = true) + public TreeSelectionChangeListener[] getTreeSelectionChangeListeners() { + return (TreeSelectionChangeListener[]) getFacesListeners(TreeSelectionChangeListener.class); + } + + public void removeTreeSelectionChangeListener(TreeSelectionChangeListener listener) { + removeFacesListener(listener); + } + + public void addTreeToggleListener(TreeToggleListener listener) { + addFacesListener(listener); + } + + @Attribute(hidden = true) + public TreeToggleListener[] getTreeToggleListeners() { + return (TreeToggleListener[]) getFacesListeners(TreeToggleListener.class); + } + + public void removeTreeToggleListener(TreeToggleListener listener) { + removeFacesListener(listener); + } + + @Attribute(hidden = true) + public boolean isExpanded() { + if (getRowKey() == null) { + return true; + } + + AbstractTreeNode treeNode = findTreeNodeComponent(); + if (treeNode == null) { + return false; + } + + return treeNode.isExpanded(); + } + + //TODO review + protected TreeDataModel<?> getTreeDataModel() { + return (TreeDataModel<?>) getExtendedDataModel(); + } + + @Attribute(hidden = true) + public boolean isLeaf() { + if (getRowKey() == null) { + return false; + } + + return getTreeDataModel().isLeaf(); + } + + @Override + public void walk(final FacesContext faces, final DataVisitor visitor, final Object argument) { + walkModel(faces, new TreeDataVisitor() { + + public void enterNode() { + visitor.process(faces, getRowKey(), argument); + } + + public void exitNode() { + } + + public void beforeChildrenVisit() { + } + + public void afterChildrenVisit() { + } + + }); + } + + @Override + protected ExtendedDataModel<?> createExtendedDataModel() { + ExtendedDataModel<?> dataModel; + + Object value = getValue(); + if (value == null) { + dataModel = new DeclarativeTreeDataModelImpl(this, getVar(), getVariablesMap(getFacesContext())); + } else { + dataModel = new SwingTreeNodeDataModelImpl(); + dataModel.setWrappedData(getValue()); + } + + return dataModel; + } + + public void walkModel(FacesContext context, TreeDataVisitor dataVisitor) { + TreeDataModel<?> model = getTreeDataModel(); + + if (!getTreeRange().shouldProcessNode()) { + return; + } + + boolean isRootNode = (getRowKey() == null); + + if (!isRootNode) { + dataVisitor.enterNode(); + } + + walkModelChildren(context, dataVisitor, model); + + if (!isRootNode) { + dataVisitor.exitNode(); + } + } + + private void walkModelChildren(FacesContext context, TreeDataVisitor dataVisitor, TreeDataModel<?> model) { + if (!getTreeRange().shouldIterateChildren()) { + return; + } + + dataVisitor.beforeChildrenVisit(); + + Iterator<TreeDataModelTuple> childrenTuples = model.children(); + while (childrenTuples.hasNext()) { + TreeDataModelTuple tuple = childrenTuples.next(); + + restoreFromSnapshot(context, tuple); + + if (!getTreeRange().shouldProcessNode()) { + continue; + } + + dataVisitor.enterNode(); + + walkModelChildren(context, dataVisitor, model); + + dataVisitor.exitNode(); + } + + dataVisitor.afterChildrenVisit(); + } + + @Override + protected void resetDataModel() { + super.resetDataModel(); + treeRange = null; + } + + public TreeDataModelTuple createSnapshot() { + return getTreeDataModel().createSnapshot(); + } + + public void restoreFromSnapshot(FacesContext context, TreeDataModelTuple tuple) { + getTreeDataModel().restoreFromSnapshot(tuple); + setRowKey(context, tuple.getRowKey()); + } + +} Added: trunk/ui/iteration/ui/src/main/java/org/richfaces/model/SwingTreeNodeDataModelImpl.java.orig =================================================================== --- trunk/ui/iteration/ui/src/main/java/org/richfaces/model/SwingTreeNodeDataModelImpl.java.orig (rev 0) +++ trunk/ui/iteration/ui/src/main/java/org/richfaces/model/SwingTreeNodeDataModelImpl.java.orig 2010-12-01 16:27:24 UTC (rev 20261) @@ -0,0 +1,196 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2010, Red Hat, Inc. and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * This is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.richfaces.model; + +import java.util.Collection; +import java.util.Enumeration; +import java.util.Iterator; +import java.util.NoSuchElementException; + +import javax.swing.tree.TreeNode; + +import com.google.common.base.Predicates; +import com.google.common.collect.Iterables; +import com.google.common.collect.Iterators; + +/** + * @author Nick Belaevski + * + */ +public class SwingTreeNodeDataModelImpl extends TreeSequenceKeyModel<Integer, TreeNode> { + + private final class SwingTreeNodeRowKeyIterator implements Iterator<TreeDataModelTuple> { + + private SequenceRowKey<Integer> baseKey; + + private Iterator<TreeNode> children; + + private int counter = 0; + + private SwingTreeNodeRowKeyIterator(SequenceRowKey<Integer> baseKey, Iterator<TreeNode> children) { + this.baseKey = baseKey; + this.children = children; + } + + private int getNextCounterValue() { + return counter++; + } + + public boolean hasNext() { + return children.hasNext(); + } + + public TreeDataModelTuple next() { + TreeNode node = children.next(); + + SequenceRowKey<Integer> key; + + if (baseKey != null) { + key = baseKey.append(getNextCounterValue()); + } else { + key = new SequenceRowKey<Integer>(getNextCounterValue()); + } + + return new TreeDataModelTuple(key, node); + } + + public void remove() { + throw new UnsupportedOperationException(); + } + + } + + private final class FakeRootNode implements TreeNode { + + private Collection<TreeNode> wrappedData; + + public FakeRootNode(Collection<TreeNode> wrappedData) { + super(); + this.wrappedData = wrappedData; + } + + public boolean isLeaf() { + return !wrappedData.isEmpty(); + } + + public TreeNode getParent() { + return null; + } + + public int getIndex(TreeNode node) { + if (wrappedData == null) { + return -1; + } + + return Iterables.indexOf(wrappedData, Predicates.equalTo(node)); + } + + public int getChildCount() { + if (wrappedData == null) { + return 0; + } + + return wrappedData.size(); + } + + public TreeNode getChildAt(int childIndex) { + if (wrappedData == null) { + throw new NoSuchElementException(String.valueOf(childIndex)); + } + + return Iterables.get(wrappedData, childIndex); + } + + public boolean getAllowsChildren() { + return true; + } + + public Enumeration<?> children() { + if (wrappedData == null) { + return Iterators.asEnumeration(Iterators.emptyIterator()); + } + + return Iterators.asEnumeration(wrappedData.iterator()); + } + + public Collection<TreeNode> getWrappedData() { + return wrappedData; + } + } + + private boolean asksAllowsChildren = false; + + private Iterator<TreeNode> safeGetChildren(TreeNode treeNode) { + if (treeNode == null) { + return Iterators.emptyIterator(); + } + + return Iterators.forEnumeration((Enumeration<TreeNode>) treeNode.children()); + } + + + public Object getParentRowKey(Object rowKey) { + throw new UnsupportedOperationException(); + } + + public void setWrappedData(Object data) { + setRootNode(new FakeRootNode((Collection<TreeNode>) data)); + } + + public Collection<TreeNode> getWrappedData() { + FakeRootNode rootNode = (FakeRootNode) getRootNode(); + if (rootNode == null) { + return null; + } + return rootNode.getWrappedData(); + } + + protected TreeNode findChild(TreeNode parent, Integer simpleKey) { + return parent.getChildAt(simpleKey.intValue()); + } + + public Iterator<TreeDataModelTuple> children() { + return new SwingTreeNodeRowKeyIterator(getRowKey(), safeGetChildren(getData())); + } + + + public boolean isLeaf() { + if (!asksAllowsChildren) { + return getData().isLeaf(); + } else { + return !getData().getAllowsChildren(); + } + } + + @Override + protected void walkNext(Integer segment) { + TreeNode child = findChild(getData(), segment); + //TODO what if node is missing? + //TODO - optimize - remove partial keys creation + setRowKeyAndData(safeGetRowKey().append(segment), child); + } +<<<<<<< HEAD + +======= + +>>>>>>> RF-9680 +} \ No newline at end of file Added: trunk/ui/iteration/ui/src/main/java/org/richfaces/model/TreeSequenceKeyModel.java.orig =================================================================== --- trunk/ui/iteration/ui/src/main/java/org/richfaces/model/TreeSequenceKeyModel.java.orig (rev 0) +++ trunk/ui/iteration/ui/src/main/java/org/richfaces/model/TreeSequenceKeyModel.java.orig 2010-12-01 16:27:24 UTC (rev 20261) @@ -0,0 +1,180 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2010, Red Hat, Inc. and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * This is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.richfaces.model; + +import javax.faces.context.FacesContext; + +import org.ajax4jsf.model.DataVisitor; +import org.ajax4jsf.model.ExtendedDataModel; +import org.ajax4jsf.model.Range; + + +/** + * @author Nick Belaevski + * + */ +public abstract class TreeSequenceKeyModel<K, V> extends ExtendedDataModel<V> implements TreeDataModel<V> { + + private final SequenceRowKey<K> emptyKey = new SequenceRowKey<K>(); + +<<<<<<< HEAD + private V rootNode; + +======= +>>>>>>> RF-9680: + private V data; + + private SequenceRowKey<K> rowKey; + + public SequenceRowKey<K> getRowKey() { + return rowKey; + } + + protected SequenceRowKey<K> safeGetRowKey() { + SequenceRowKey<K> key = getRowKey(); + + if (key == null) { + key = emptyKey; + } + + return key; + } + + public void setRowKey(Object rowKey) { + if (this.rowKey == null || !this.rowKey.equals(rowKey)) { +<<<<<<< HEAD + walkKey((SequenceRowKey<K>) rowKey); + } + } + + protected void resetRowKeyAndData() { + setRowKeyAndData(null, rootNode); + } + +======= + this.rowKey = (SequenceRowKey<K>) rowKey; + this.data = findData(this.rowKey); + } + } + +>>>>>>> RF-9680: + protected void setRowKeyAndData(SequenceRowKey<K> key, V data) { + this.rowKey = key; + this.data = data; + } + + public boolean isDataAvailable() { +<<<<<<< HEAD + return getRowKey() == null || data != null; +======= + return data != null; +>>>>>>> RF-9680: + } + + public V getData() { + if (!isDataAvailable()) { + throw new IllegalArgumentException(); + } + + return data; + } +<<<<<<< HEAD + + protected void walkKey(SequenceRowKey<K> key) { + resetRowKeyAndData(); +======= + + protected V findData(SequenceRowKey<K> key) { + if (key == null) { + return rootNode; + } + + V result = rootNode; + + for (K simpleKey : key.getSimpleKeys()) { + result = findChild(result, simpleKey); +>>>>>>> RF-9680: + + if (key != null) { + for (K simpleKey: key.getSimpleKeys()) { + walkNext(simpleKey); + } + } + } + + protected abstract void walkNext(K segment); + + protected V getRootNode() { + return rootNode; + } + + protected void setRootNode(V rootNode) { + this.rootNode = rootNode; + } + + //TODO ExtendedDataModel legacy + @Override + public void walk(FacesContext context, DataVisitor visitor, Range range, Object argument) { + throw new UnsupportedOperationException(); + } + + + @Override + public boolean isRowAvailable() { + return isDataAvailable(); + } + + + @Override + public int getRowCount() { + throw new UnsupportedOperationException(); + } + + + @Override + public V getRowData() { + return getData(); + } + + + @Override + public int getRowIndex() { + throw new UnsupportedOperationException(); + } + + + @Override + public void setRowIndex(int rowIndex) { + throw new UnsupportedOperationException(); +<<<<<<< HEAD + } + + public TreeDataModelTuple createSnapshot() { + return new TreeDataModelTuple(getRowKey(), getData()); + } + + public void restoreFromSnapshot(TreeDataModelTuple tuple) { + setRowKeyAndData((SequenceRowKey<K>) tuple.getRowKey(), (V) tuple.getData()); +======= +>>>>>>> RF-9680: + } +} Added: trunk/ui/iteration/ui/src/main/java/org/richfaces/renderkit/TreeEncoderBase.java.orig =================================================================== --- trunk/ui/iteration/ui/src/main/java/org/richfaces/renderkit/TreeEncoderBase.java.orig (rev 0) +++ trunk/ui/iteration/ui/src/main/java/org/richfaces/renderkit/TreeEncoderBase.java.orig 2010-12-01 16:27:24 UTC (rev 20261) @@ -0,0 +1,227 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2010, Red Hat, Inc. and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * This is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.richfaces.renderkit; + +import java.io.IOException; + +import javax.faces.context.FacesContext; +import javax.faces.context.ResponseWriter; + +import org.ajax4jsf.context.AjaxContext; +import org.ajax4jsf.javascript.JSFunction; +import org.richfaces.component.AbstractTree; +import org.richfaces.component.AbstractTreeNode; +import org.richfaces.component.util.HtmlUtil; +import org.richfaces.model.TreeDataModelTuple; +import org.richfaces.model.TreeDataVisitor; + +abstract class TreeEncoderBase implements TreeDataVisitor { + + private static final class QueuedData { + + private enum State { + initial, visited, encoded + } + + private State state = State.initial; + + private TreeDataModelTuple tuple; + + public QueuedData(TreeDataModelTuple tuple) { + super(); + this.tuple = tuple; + } + + public boolean isEncoded() { + return state == State.encoded; + } + + public void makeEncoded() { + this.state = State.encoded; + } + + public void makeVisited() { + this.state = State.visited; + } + + public boolean isVisited() { + return state == State.visited; + } + + public TreeDataModelTuple getTuple() { + return tuple; + } + + } + + static final String TREE_NODE_STATE_ATTRIBUTE = "__treeNodeState"; + + protected final FacesContext context; + + protected final ResponseWriter responseWriter; + + protected final AbstractTree tree; + +<<<<<<< HEAD + private LinkedList<QueuedData> queuedDataList = new LinkedList<QueuedData>(); + +======= +>>>>>>> RF-9680: + public TreeEncoderBase(FacesContext context, AbstractTree tree) { + super(); + this.context = context; + this.responseWriter = context.getResponseWriter(); + this.tree = tree; + } + + protected void encodeTree() throws IOException { + tree.walkModel(context, this); + } + +<<<<<<< HEAD + protected void flushParentNode() throws IOException { + if (queuedDataList.isEmpty()) { + return; + } + + QueuedData data = queuedDataList.getLast(); + if (!data.isEncoded()) { + data.makeEncoded(); + tree.restoreFromSnapshot(context, data.getTuple()); + + TreeNodeState nodeState = getNodeState(tree.isLeaf(), false); + + writeTreeNodeStartElement(nodeState); + tree.findTreeNodeComponent().encodeAll(context); + } + } + + private TreeNodeState getNodeState(boolean leaf, boolean visited) { + TreeNodeState nodeState; + if (leaf) { + nodeState = TreeNodeState.leaf; + } else if (visited) { + nodeState = TreeNodeState.expandedNoChildren; + } else if (tree.isExpanded()) { + nodeState = TreeNodeState.expanded; + } else { + nodeState = TreeNodeState.collapsed; + } + return nodeState; + } + + public void beforeChildrenVisit() { + if (!queuedDataList.isEmpty()) { + queuedDataList.getLast().makeVisited(); + } + } + + public void afterChildrenVisit() { + } + + public void enterNode() { + TreeDataModelTuple tuple = tree.createSnapshot(); + QueuedData queuedData = new QueuedData(tuple); + + try { + flushParentNode(); + } catch (IOException e) { + throw new FacesException(e.getMessage(), e); + } + + tree.restoreFromSnapshot(context, tuple); + queuedDataList.add(queuedData); + } + + public void exitNode() { + QueuedData data = queuedDataList.removeLast(); + + tree.restoreFromSnapshot(context, data.getTuple()); + try { + if (!data.isEncoded()) { + writeTreeNodeStartElement(getNodeState(tree.isLeaf(), data.isVisited())); + tree.findTreeNodeComponent().encodeAll(context); + } + +======= + public void enterNode() { + TreeNodeState state; + if (tree.isLeaf()) { + state = TreeNodeState.leaf; + } else { + if (tree.isExpanded()) { + state = TreeNodeState.expanded; + } else { + state = TreeNodeState.collapsed; + } + } + + try { + writeTreeNodeStartElement(state); + tree.findTreeNodeComponent().encodeAll(context); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + public void exitNode() { + try { +>>>>>>> RF-9680: + writeTreeNodeEndElement(); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + protected void writeTreeNodeStartElement(TreeNodeState nodeState) throws IOException { + AbstractTreeNode treeNodeComponent = tree.findTreeNodeComponent(); + + context.getAttributes().put(TREE_NODE_STATE_ATTRIBUTE, nodeState); + + responseWriter.startElement(HtmlConstants.DIV_ELEM, tree); + responseWriter.writeAttribute(HtmlConstants.CLASS_ATTRIBUTE, + HtmlUtil.concatClasses("rf-tr-nd", nodeState.getNodeClass()), + null); + responseWriter.writeAttribute(HtmlConstants.ID_ATTRIBUTE, treeNodeComponent.getClientId(context), null); + + emitClientToggleEvent(treeNodeComponent, nodeState); + } + + protected void writeTreeNodeEndElement() throws IOException { + responseWriter.endElement(HtmlConstants.DIV_ELEM); + } + + public abstract void encode() throws IOException; + + private void emitClientToggleEvent(AbstractTreeNode treeNode, TreeNodeState nodeState) { + if (treeNode.getClientId(context).equals(context.getAttributes().get(TreeNodeRendererBase.AJAX_TOGGLED_NODE_ATTRIBUTE))) { + TreeNodeState initialState = (TreeNodeState) context.getAttributes().get(TreeNodeRendererBase.AJAX_TOGGLED_NODE_STATE_ATTRIBUTE); + + if (initialState.isDifferentThan(nodeState)) { + AjaxContext ajaxContext = AjaxContext.getCurrentInstance(context); + ajaxContext.appendOncomplete(new JSFunction("RichFaces.ui.TreeNode.emitToggleEvent", treeNode.getClientId(context))); + } + } + } +} \ No newline at end of file