tree.java

Tree taglib,生成树的标签库

    }

    public void select(String[] treeNodeIds) {
        multipleSelectVsSelectionModeValidation(treeNodeIds);
        for (int i = 0; i < treeNodeIds.length; i++) {
            select(treeNodeIds[i]);
        }
    }

    public void select(Collection nodeIds) {
        for (Iterator iterator = nodeIds.iterator(); iterator.hasNext();) {
            select((String) iterator.next());
        }
    }

    public void selectOnly(String[] treeNodeIds){
        multipleSelectVsSelectionModeValidation(treeNodeIds);
        Set selectOnlySet = new HashSet();
        for (int i = 0; i < treeNodeIds.length; i++) {
            selectOnlySet.add(treeNodeIds[i]);
        }
        Set selected = copy(this.selected);
        Set unselect = copy(this.selected);
        unselect.removeAll(selectOnlySet);
        for (Iterator iterator = unselect.iterator(); iterator.hasNext();) {
            String nodeId =  (String) iterator.next();
            unSelect(nodeId);
        }

        selectOnlySet.removeAll(selected);
        for (Iterator iterator = selectOnlySet.iterator(); iterator.hasNext();) {
            select((String) iterator.next());
        }
    }

    public void selectDescendants(String nodeId) {
        ITreeNode node = findNode(nodeId);
        selectDescendants(node);
    }

    public void selectDescendantsAndSelf(String nodeId) {
        select(nodeId);
        selectDescendants((nodeId));
    }

    public void selectParent(String nodeId) {
        ITreeNode node = findNode(nodeId);
        if(!isRoot(node)){
            select(node.getParent().getId());
        }
    }

    public void selectParentAndSelf(String nodeId) {
        select(nodeId);
        selectParent(nodeId);
    }

    public void selectAncestors(String nodeId) {
        ITreeNode node = findNode(nodeId);
        if(node == null) return;
        while(!isRoot(node)){
            select(node.getParent().getId());
            node = node.getParent();
        }
    }

    public void selectAncestorsAndSelf(String nodeId) {
        select(nodeId);
        selectAncestors(nodeId);
    }

    public void selectChildren(String nodeId) {
        ITreeNode node = findNode(nodeId);
        if(node != null && node.getChildren().size() > 0){
            Iterator iterator = node.getChildren().iterator();
            while(iterator.hasNext()){
                ITreeNode child = (ITreeNode) iterator.next();
                select(child.getId());
            }
        }
    }

    public void selectChildrenAndSelf(String nodeId){
        select(nodeId);
        selectChildren(nodeId);
    }


    private Set copy(Set selectedNodes) {
        Set copy = new HashSet();
        for (Iterator iterator = selectedNodes.iterator(); iterator.hasNext();) {
            copy.add(iterator.next());
        }
        return copy;
    }


    public void unSelect(String treeNodeId) {
        if(notifyOnChangeOnly && !isSelected(treeNodeId)) return;
        this.selected.remove(treeNodeId);
        notifyUnselectListeners(treeNodeId);
    }

    public void unSelectAll() {
        Iterator iterator =  this.selected.iterator();
        while(iterator.hasNext()){
            String nodeId = (String) iterator.next();
            iterator.remove();
            notifyUnselectListeners(nodeId);
        }
    }

    public void unSelect(String[] nodeIds) {
        for(int i=0; i<nodeIds.length; i++){
            unSelect(nodeIds[i]);
        }
    }

    public void unSelect(Collection nodeIds) {
        for (Iterator iterator = nodeIds.iterator(); iterator.hasNext();) {
            unSelect((String) iterator.next());
        }
    }

    public void unSelectDescendants(String nodeId) {
        ITreeNode node = findNode(nodeId);
        unSelectDescendants(node);
    }

    private void selectDescendants(ITreeNode node){
        if(node == null) return;
        for (Iterator iterator = node.getChildren().iterator(); iterator.hasNext();) {
            ITreeNode treeNode = (ITreeNode) iterator.next();
            select(treeNode.getId());
            if(treeNode.hasChildren()){
                selectDescendants(treeNode);
            }
        }
    }

    private void unSelectDescendants(ITreeNode node){
        if(node == null) return;
        for (Iterator iterator = node.getChildren().iterator(); iterator.hasNext();) {
            ITreeNode treeNode = (ITreeNode) iterator.next();
            unSelect(treeNode.getId());
            if(treeNode.hasChildren()){
                unSelectDescendants(treeNode);
            }
        }
    }

    public void unSelectDescendantsAndSelf(String nodeId) {
        unSelect(nodeId);
        unSelectDescendants(nodeId);
    }

    public void unSelectParent(String nodeId) {
        ITreeNode node = findNode(nodeId);
        if(node != null && !isRoot(node)){
            unSelect(node.getParent().getId());
        }
    }

    public void unSelectParentAndSelf(String nodeId) {
        unSelect(nodeId);
        unSelectParent(nodeId);
    }

    public void unSelectAncestors(String nodeId) {
        ITreeNode node = findNode(nodeId);
        if(node == null) return;
        while(!isRoot(node)){
            unSelect(node.getParent().getId());
            node = node.getParent();
        }
    }

    public void unSelectAncestorsAndSelf(String nodeId) {
        unSelect(nodeId);
        unSelectAncestors(nodeId);
    }

    public void unSelectChildren(String nodeId) {
        ITreeNode node = findNode(nodeId);
        if(node != null && node.getChildren().size() > 0){
            Iterator iterator = node.getChildren().iterator();
            while(iterator.hasNext()){
                ITreeNode child = (ITreeNode) iterator.next();
                unSelect(child.getId());
            }
        }
    }

    public void unSelectChildrenAndSelf(String nodeId){
        unSelect(nodeId);
        unSelectChildren(nodeId);
    }


    public Set getSelectedNodes() {
        return findNodes(this.selected);
    }

    public void setSingleSelectionMode(boolean mode) {
        this.singleSelectionMode = mode;
    }

    public boolean isSingleSelectionMode(){
        return this.singleSelectionMode;
    }

    public void addSelectListener(ISelectListener selectListener) {
        this.selectListeners.add(selectListener);
    }

    public void removeSelectListener(ISelectListener selectListener) {
        this.selectListeners.remove(selectListener);
    }

    public void addUnSelectListener(IUnSelectListener unSelectListener) {
        this.unselectListeners.add(unSelectListener);
    }

    public void removeUnSelectListener(IUnSelectListener unSelectListener) {
        this.unselectListeners.remove(unSelectListener);
    }

    public Iterator iterator(boolean includeRootNode) {
        return new TreeIterator(this, includeRootNode);
    }

    public ITreeNode[] getNodePath(String nodeId) {
        ITreeNode node = findNode(nodeId);
        if(node == null) return new ITreeNode[0];

        NodePath nodePath = new NodePath();
        getNodePath(node, nodePath);
        return nodePath.nodePath;
    }


    public ITreeFilter getFilter() {
        return this.filter;
    }

    public void setFilter(ITreeFilter filter) {
        this.filter = filter;
    }

    public void setNotifyOnChangeOnly(boolean notifyOnChangeOnly) {
        this.notifyOnChangeOnly = notifyOnChangeOnly;
    }

    public boolean isNotifyOnChangeOnly() {
        return this.notifyOnChangeOnly;
    }

    private void getNodePath(ITreeNode node, NodePath nodePath) {
        if(!isRoot(node)){
            nodePath.nodeCount++;
            getNodePath(node.getParent(), nodePath);
            nodePath.nodePath[nodePath.currentNode++] = node;
        } else {
            nodePath.nodePath = new ITreeNode[nodePath.nodeCount];
            nodePath.nodePath[0] = node;
            nodePath.currentNode++;
        }
    }


    private void multipleSelectVsSelectionModeValidation(String[] treeNodeIds) {
        if(isSingleSelectionMode() && treeNodeIds.length > 1){
            throw new IllegalStateException("You cannot select more than one node when the tree " +
                    "is in single-selection mode. ");
        }
    }

    private void notifyCollapseListeners(String treeNodeId) {
        if(this.collapseListeners.size() > 0){
            ITreeNode collapsedNode = findNode(treeNodeId);
            Iterator iterator = this.collapseListeners.iterator();
            while(iterator.hasNext()){
                ((ICollapseListener) iterator.next()).nodeCollapsed(collapsedNode, this);
            }
        }
    }

    private void notifySelectListeners(String treeNodeId) {
        if(this.selectListeners.size() > 0){
            ITreeNode selectedNode = findNode(treeNodeId);
            Iterator iterator = this.selectListeners.iterator();
            while(iterator.hasNext()){
                ((ISelectListener) iterator.next()).nodeSelected(selectedNode, this);
            }
        }
    }

    private void notifyUnselectListeners(String treeNodeId) {
        if(this.unselectListeners.size() > 0){
            ITreeNode unselectedNode = findNode(treeNodeId);
            Iterator iterator = this.unselectListeners.iterator();
            while(iterator.hasNext()){
                ((IUnSelectListener) iterator.next()).nodeUnselected(unselectedNode, this);
            }
        }
    }

    private void notifyExpandListeners(String treeNodeId) {
        if(this.expandListeners.size() > 0){
            ITreeNode expandedNode = findNode(treeNodeId);
            Iterator iterator = this.expandListeners.iterator();
            while(iterator.hasNext()){
                ((IExpandListener) iterator.next()).nodeExpanded(expandedNode, this);
            }
        }
    }

    private class NodePath{
        public int currentNode = 0;
        public int nodeCount   = 1;
        public ITreeNode[] nodePath = null;
    }

}