java类javax.swing.tree.DefaultMutableTreeNode的实例源码

/** Required by TreeSelectionListener interface. */
@Override
public void valueChanged(TreeSelectionEvent e) {
    DefaultMutableTreeNode node = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();

    if (node != null && node.isLeaf()) {
        int pos = workspace.getDividerLocation();
        workspace.setTopComponent((JPanel) node.getUserObject());
        workspace.setDividerLocation(pos);
    }
}

protected Transferable createTransferable(JComponent c) {
    JTree tree = (JTree)c;
    TreePath[] paths = tree.getSelectionPaths();
    if(paths != null) {
        // Make up a node array of copies for transfer and
        // another for/of the nodes that will be removed in
        // exportDone after a successful drop.
        List<DefaultMutableTreeNode> copies =
            new ArrayList<DefaultMutableTreeNode>();
        List<DefaultMutableTreeNode> toRemove =
            new ArrayList<DefaultMutableTreeNode>();
        DefaultMutableTreeNode node =
            (DefaultMutableTreeNode)paths[0].getLastPathComponent();
        DefaultMutableTreeNode copy = copy(node);
        copies.add(copy);
        toRemove.add(node);
        for(int i = 1; i < paths.length; i++) {
            DefaultMutableTreeNode next =
                (DefaultMutableTreeNode)paths[i].getLastPathComponent();
            // Do not allow higher level nodes to be added to list.
            if(next.getLevel() < node.getLevel()) {
                break;
            } else if(next.getLevel() > node.getLevel()) {  // child node
                copy.add(copy(next));
                // node already contains child
            } else {                                        // sibling
                copies.add(copy(next));
                toRemove.add(next);
            }
        }
        DefaultMutableTreeNode[] nodes =
            copies.toArray(new DefaultMutableTreeNode[copies.size()]);
        nodesToRemove =
            toRemove.toArray(new DefaultMutableTreeNode[toRemove.size()]);
        return new NodesTransferable(nodes);
    }
    return null;
}

@Override
public Component getTreeCellRendererComponent(JTree tree, Object value,
  boolean sel, boolean expanded, boolean leaf, int row, boolean hasFocus) {
  super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row,
    hasFocus);
  if(value == resourcesTreeRoot) {
    setIcon(MainFrame.getIcon("GATE"));
    setToolTipText("Resources tree root ");
  }
  else if(value == applicationsRoot) {
    setIcon(MainFrame.getIcon("applications"));
    setToolTipText("Run processes on data ");
  }
  else if(value == languageResourcesRoot) {
    setIcon(MainFrame.getIcon("lrs"));
    setToolTipText("Data used for annotating ");
  }
  else if(value == processingResourcesRoot) {
    setIcon(MainFrame.getIcon("prs"));
    setToolTipText("Processes that annotate data ");
  }
  else if(value == datastoresRoot) {
    setIcon(MainFrame.getIcon("datastores"));
    setToolTipText("Repositories for large data ");
  }
  else {
    // not one of the default root nodes
    value = ((DefaultMutableTreeNode)value).getUserObject();
    if(value instanceof Handle) {
      setIcon(((Handle)value).getIcon());
      setText(((Handle)value).getTitle());
      setToolTipText(((Handle)value).getTooltipText());
    }
  }
  return this;
}

private void expandTree(JTree tree) {
    DefaultMutableTreeNode root = (DefaultMutableTreeNode) tree.getModel()
            .getRoot();
    Enumeration e = root.breadthFirstEnumeration();
    while (e.hasMoreElements()) {
        DefaultMutableTreeNode node = (DefaultMutableTreeNode) e.nextElement();
        if (node.isLeaf()) {
            continue;
        }
        int row = tree.getRowForPath(new TreePath(node.getPath()));
        tree.expandRow(row);
    }
}

private void jTree1ValueChanged(TreeSelectionEvent paramTreeSelectionEvent) {
    DefaultMutableTreeNode localDefaultMutableTreeNode = (DefaultMutableTreeNode) this.jTree1.getLastSelectedPathComponent();
    if (localDefaultMutableTreeNode == null) {
        return;
    }
    ClassFileStatus localClassFileStatus = (ClassFileStatus) localDefaultMutableTreeNode;
    switchClass(localClassFileStatus);
}

private String getMouseSelectedGame() {
    DefaultMutableTreeNode node = (DefaultMutableTreeNode) folderTree.getLastSelectedPathComponent();
    if (node == null) {
        return null;
    }
    Object nodeInfo = node.getUserObject();
    return nodeInfo.toString();
}

/**
 * Filter node by key.
 *
 * @param node the node
 * @param key the key
 */
private void filterNodeByKey(DefaultMutableTreeNode node, String key){

        Vector<DefaultMutableTreeNode> toDeleteVect= new Vector<DefaultMutableTreeNode>();

        @SuppressWarnings("unchecked")
        Enumeration<DefaultMutableTreeNode> e = node.breadthFirstEnumeration();
        if(e != null){
            while (e.hasMoreElements()){
                DefaultMutableTreeNode actualElement = e.nextElement();
                if (actualElement.isLeaf() == true && key.isEmpty() == false && actualElement.toString().toLowerCase().contains(key.toLowerCase()) == false) {
                    //--- immediate removal invalidates the enumeration ---
    //              actualElement.removeFromParent();
                    // --- remember for later removal ---
                    toDeleteVect.add(actualElement); 
                }
                if(actualElement.isLeaf() == true && actualElement.toString().toLowerCase().contains(key.toLowerCase()) == true){
                    //--- (re)expand collapsed parent if search string matches ---
                    int level = actualElement.getLevel() -1;
                    StringBuilder sb = new StringBuilder();
                    sb.append(level -1).append(",");
                    String levelString = sb.toString();
                    if(expansionState.contains(levelString) == false){
                        levelString = sb.append(level).append(",").toString();
                        expansionState = expansionState.concat(levelString);
                    }
                }
            }
        }
        //--- delete nodes ---
        for( int i=0; i < toDeleteVect.size(); i++){
            toDeleteVect.get(i).removeFromParent();
        }
    }

private void addScale() {
    DefaultMutableTreeNode node = new DefaultMutableTreeNode("Scaled by");

    getContentPane().remove(currentComponent);

    JPanel scalePanel = new ScalePanel(node); 
    currentComponent = scalePanel;
    getContentPane().add(scalePanel);
    scalePanels.add(scalePanel);

    ((DefaultTreeModel) tree.getModel()).insertNodeInto(node, data, data.getChildCount());
    tree.setSelectionPath(new TreePath(node.getPath()));

    getContentPane().validate();
}

private String getRowPathStr(TreePath trp) {
    String pathStr = "";
    if (trp.getPathCount() > 1) {
        for (int i = 1; i < trp.getPathCount(); i++) {
            DefaultMutableTreeNode node = (DefaultMutableTreeNode) trp.getPathComponent(i);
            TreeNodeUserObject userObject = (TreeNodeUserObject) node.getUserObject();
            pathStr = pathStr + userObject.getOriginalName() + "/";
        }
    }
    return pathStr;
}

@Override
public void insertNodeInto(DefaultMutableTreeNode parent, int index, DefaultMutableTreeNode child) {
    RmlTag parentRmlTag = (RmlTag) parent.getUserObject();
    RmlTag childRmlTag = (RmlTag) child.getUserObject();
    editor.replaceRmlTag(parentRmlTag, childRmlTag, index);
    lastParentRmlTag = parentRmlTag;
    lastIndex = index;
}