uitree.java

jsf example about book manager

    /**
     * If "rendered" is true, resets the cached model and saved
     * per-node state, calls processNodes() with a PhaseId for
     * this phase, resets the node ID, and calls the decode() method.
     */
    public void processDecodes(FacesContext context) {
        if (!isRendered()) {
            return;
        }

        model = null; // Re-evaluate even with server-side state saving
        saved = new HashMap(); // We don't need saved state here

	processNodes(context, PhaseId.APPLY_REQUEST_VALUES, null, 0);
	setNodeId(null);
	decode(context);
    }

    /**
     * If "rendered" is true, calls processNodes() with a PhaseId for
     * this phase, resets the node ID, and calls the decode() method.
     */
    public void processValidators(FacesContext context) {
        if (!isRendered()) {
            return;
        }

	processNodes(context, PhaseId.PROCESS_VALIDATIONS, null, 0);
	setNodeId(null);
    }

    /**
     * If "rendered" is true, calls processNodes() with a PhaseId for
     * this phase, resets the node ID, and calls the decode() method.
     */
    public void processUpdates(FacesContext context) {
        if (!isRendered()) {
            return;
        }

	processNodes(context, PhaseId.UPDATE_MODEL_VALUES, null, 0);
	setNodeId(null);
    }

    /**
     * Returns the component state to be saved as part of the view
     * state.
     */
    public Object saveState(FacesContext context) {
        Object values[] = new Object[4];
        values[0] = super.saveState(context);
        values[1] = value;
        values[2] = var;
        values[3] = varNodeToggler;
        return (values);
    }

    /**
     * Restores the component to the provided state, previously 
     * returned by the saveState() method.
     */
    public void restoreState(FacesContext context, Object state) {
        Object values[] = (Object[]) state;
        super.restoreState(context, values[0]);
        value = values[1];
        var = (String) values[2];
        varNodeToggler = (String) values[3];
    }

    /**
     * Returns the cached model, if any, or the components value,
     * as-is if it's a TreeModel or wrapped in a new TreeModel if
     * it's a TreeNode, saving a reference in the "model" variable.
     */
    private TreeModel getDataModel() {

        if (model != null) {
            return model;
        }

        Object value = getValue();
        if (value != null) {
	    if (value instanceof TreeModel) {
		model = (TreeModel) value;
	    } else if (value instanceof TreeNode) {
		model = new TreeModel((TreeNode) value);
	    }
	}
	return model;
    }

    /**
     * Recursively process all nodes at the root of the tree and
     * all nodes under an open node for the provided phase, i.e.,
     * by calling processDecodes(), processValidators() or
     * processUpdates() on the facet representing the node type.
     */
    private void processNodes(FacesContext context, PhaseId phaseId, 
			 String parentId, int childLevel) {

	// Iterate over all expanded nodes in the model and process the
	// appropriate facet for each node.
	UIComponent facet = null;
	setNodeId(parentId != null ? 
		  parentId + NamingContainer.SEPARATOR_CHAR + childLevel :
		  "0");
	TreeNode node = getNode();
	if (node.isLeafNode()) {
	    facet = getLeafNode();
	} 
	else if (node.isExpanded()) {
	    facet = getOpenNode();
	}
	else {
	    facet = getClosedNode();
	}
	if (phaseId == PhaseId.APPLY_REQUEST_VALUES) {
	    facet.processDecodes(context);
	} else if (phaseId == PhaseId.PROCESS_VALIDATIONS) {
	    facet.processValidators(context);
	} else {
	    facet.processUpdates(context);
	}
	
	if (node.isExpanded()) {
	    int kidId = 0;
	    String currId = getNodeId();
	    Iterator i = node.getChildren().iterator();
	    while (i.hasNext()) {
		TreeNode kid = (TreeNode) i.next();
		processNodes(context, phaseId, currId, kidId++);
	    }
	}
    }

    /**
     * Returns "true" if there's at least one error message queued
     * for a client ID matching one of the nodes.
     */
    private boolean keepSaved(FacesContext context) {

        Iterator clientIds = saved.keySet().iterator();
        while (clientIds.hasNext()) {
            String clientId = (String) clientIds.next();
            Iterator messages = context.getMessages(clientId);
            while (messages.hasNext()) {
                FacesMessage message = (FacesMessage) messages.next();
                if (message.getSeverity().compareTo(FacesMessage.SEVERITY_ERROR)
                    >= 0) {
                    return true;
                }
            }
        }
        return false;
    }


    /**
     * Restores state information for all facets by calling the
     * restoreDescendantState(UIComponent, FacesContext) method
     * on each facet.
     */
    private void restoreDescendantState() {
        FacesContext context = getFacesContext();
        Iterator i = getFacets().values().iterator();
        while (i.hasNext()) {
            UIComponent facet = (UIComponent) i.next();
	    restoreDescendantState(facet, context);
        }
    }

    /**
     * Restore state information for the specified component and its
     * children from the previously saved state, if any.
     */
    private void restoreDescendantState(UIComponent component,
                                        FacesContext context) {

        // Reset the client identifier for this component
        String id = component.getId();
        component.setId(id); // Forces client id to be reset

        if (component instanceof EditableValueHolder) {
            EditableValueHolder input = (EditableValueHolder) component;
            String clientId = component.getClientId(context);
            SavedState state = (SavedState) saved.get(clientId);
            if (state == null) {
                state = new SavedState();
            }
            input.setValue(state.getValue());
            input.setValid(state.isValid());
            input.setSubmittedValue(state.getSubmittedValue());
            // This *must* be set after the call to setValue(), since
            // calling setValue() always resets "localValueSet" to true.
            input.setLocalValueSet(state.isLocalValueSet());
        }

        Iterator kids = component.getChildren().iterator();
        while (kids.hasNext()) {
            restoreDescendantState((UIComponent) kids.next(), context);
        }
    }

    /**
     * Saves state information for all facets by calling the
     * saveDescendantState(UIComponent, FacesContext) method
     * on each facet.
     */
    private void saveDescendantState() {
        FacesContext context = getFacesContext();
        Iterator i = getFacets().values().iterator();
        while (i.hasNext()) {
            UIComponent facet = (UIComponent) i.next();
	    saveDescendantState(facet, context);
        }
    }

    /**
     * Saves state information for the specified component, if it
     * implements the EditableValueHolder interface, and its
     * children.
     */
    private void saveDescendantState(UIComponent component,
                                     FacesContext context) {

        if (component instanceof EditableValueHolder) {
            EditableValueHolder input = (EditableValueHolder) component;
            String clientId = component.getClientId(context);
            SavedState state = (SavedState) saved.get(clientId);
            if (state == null) {
                state = new SavedState();
                saved.put(clientId, state);
            }
            state.setValue(input.getLocalValue());
            state.setValid(input.isValid());
            state.setSubmittedValue(input.getSubmittedValue());
            state.setLocalValueSet(input.isLocalValueSet());
        }

        Iterator kids = component.getChildren().iterator();
        while (kids.hasNext()) {
            saveDescendantState((UIComponent) kids.next(), context);
        }
    }

    /**
     * Private class to represent saved state information.
     */
    private static class SavedState implements Serializable {

	private Object submittedValue;
	private boolean valid = true;
	private Object value;
	private boolean localValueSet;

	Object getSubmittedValue() {
	    return submittedValue;
	}

	void setSubmittedValue(Object submittedValue) {
	    this.submittedValue = submittedValue;
	}

	boolean isValid() {
	    return valid;
	}

	void setValid(boolean valid) {
	    this.valid = valid;
	}

	Object getValue() {
	    return value;
	}

	public void setValue(Object value) {
	    this.value = value;
	}

	boolean isLocalValueSet() {
	    return localValueSet;
	}

	public void setLocalValueSet(boolean localValueSet) {
	    this.localValueSet = localValueSet;
	}
    }

    /**
     * Private class to wrap an event with a node ID.
     */
    private static class ChildEvent extends FacesEvent {
	private FacesEvent event;
	private String nodeId;

	public ChildEvent(UIComponent component, FacesEvent event, 
	    String nodeId) {
	    super(component);
	    this.event = event;
	    this.nodeId = nodeId;
	}

	public FacesEvent getFacesEvent() {
	    return event;
	}

	public String getNodeId() {
	    return nodeId;
	}

	public PhaseId getPhaseId() {
	    return event.getPhaseId();
	}

	public void setPhaseId(PhaseId phaseId) {
	    event.setPhaseId(phaseId);
	}

	public boolean isAppropriateListener(FacesListener listener) {
	    return false;
	}

	public void processListener(FacesListener listener) {
	    throw new IllegalStateException();
	}
    }

    /**
     * A class with an action method that toggles the "expanded"
     * property value of the current node. It's intended to be
     * bound to command components used as the "closedNode" and
     * "openNode" facets.
     */
    public static class NodeToggler {
        private UITree tree;

        public NodeToggler(UITree tree) {
            this.tree = tree;
	}

	public String toggleExpanded() {
	    TreeNode node = tree.getDataModel().getNode();
	    node.setExpanded(!node.isExpanded());
	    return "toggledExpanded";
	}
    }
}