private TreePath find2(JTree tree, TreePath parent, Village pNode, int depth) {
    TreeNode node = (TreeNode) parent.getLastPathComponent();
    DefaultMutableTreeNode o = (DefaultMutableTreeNode) node;

    // If equal, go down the branch
    if (o.getUserObject().equals(pNode)) {
      // If at end, return match
      return parent;
    } else {
      // Traverse children
      if (node.getChildCount() >= 0) {
        for (Enumeration e = node.children(); e.hasMoreElements(); ) {
          TreeNode n = (TreeNode) e.nextElement();
          TreePath path = parent.pathByAddingChild(n);
          TreePath result = find2(tree, path, pNode, depth + 1);
          // Found a match
          if (result != null) {
            return result;
          }
        }
      }
    }
    // No match at this branch
    return null;
  }
Exemple #2
0
  private TreePath find2(TreePath parent, Object[] nodes, int depth, boolean byName) {
    TreeNode node = (TreeNode) parent.getLastPathComponent();
    if (depth > nodes.length - 1) {
      return parent;
    }

    if (node.getChildCount() >= 0) {
      for (Enumeration<TreeNode> e = node.children(); e.hasMoreElements(); ) {
        TreeNode n = e.nextElement();
        TreePath path = parent.pathByAddingChild(n);
        boolean find;

        if (byName) {
          find = n.toString().toUpperCase().contains(nodes[depth].toString().toUpperCase());
        } else {
          find = n.equals(nodes[depth]);
        }

        if (find) {
          TreePath result = find2(path, nodes, depth + 1, byName);
          if (result != null) {
            return result;
          }
        } else {
          TreePath result = find2(path, nodes, depth, byName);
          if (result != null) {
            return result;
          }
        }
      }
    }

    return null;
  }
Exemple #3
0
 private static void expand(JTree tree, TreePath path, int levels) {
   if (levels == 0) return;
   tree.expandPath(path);
   TreeNode node = (TreeNode) path.getLastPathComponent();
   Enumeration children = node.children();
   while (children.hasMoreElements()) {
     expand(tree, path.pathByAddingChild(children.nextElement()), levels - 1);
   }
 }
  /**
   * Traverses the children, finds those affected by the given node, and notifies them that they are
   * modified.
   *
   * @param start the node to start from
   * @param node the given node
   */
  private void traverseModified(TreeNode start, Object node) {
    Enumeration children = start.children();
    while (children.hasMoreElements()) {
      TreeNode child = (TreeNode) children.nextElement();
      traverseModified(child, node);
    }

    if (start instanceof ExplorerTreeNode) {
      ((ExplorerTreeNode) start).nodeModified(node);
    }
  }
Exemple #5
0
 private void expandTree(JTree tree, TreePath parent) {
   TreeNode node = (TreeNode) parent.getLastPathComponent();
   if (node.getChildCount() >= 0) {
     for (Enumeration<?> e = node.children(); e.hasMoreElements(); ) {
       TreeNode n = (TreeNode) e.nextElement();
       TreePath path = parent.pathByAddingChild(n);
       expandTree(tree, path);
     }
   }
   tree.expandPath(parent);
 }
Exemple #6
0
 /**
  * * 完全展开或关闭一个树,用于递规执行
  *
  * @param tree JTree
  * @param parent 父节点
  * @param expand 为true则表示展开树,否则为关闭整棵树
  */
 private void expandAll(JTree tree, TreePath parent, boolean expand) {
   TreeNode node = (TreeNode) parent.getLastPathComponent();
   if (node.getChildCount() >= 0) {
     for (Enumeration e = node.children(); e.hasMoreElements(); ) {
       TreeNode n = (TreeNode) e.nextElement();
       TreePath path = parent.pathByAddingChild(n);
       expandAll(tree, path, expand);
     }
   }
   if (expand) {
     tree.expandPath(parent);
   } else {
     tree.collapsePath(parent);
   }
 }
 /**
  * Returns a copy of the tree starting at the given node.
  *
  * @param tree The tree to copy (may be {@code null}).
  * @return A mutable copy of the given tree, or {@code null} if the tree was null.
  * @todo Use {@code getUserObject} when we can.
  * @since 2.5
  */
 public static MutableTreeNode copy(final TreeNode node) {
   if (node == null) {
     return null;
   }
   final DefaultMutableTreeNode target =
       new DefaultMutableTreeNode(node.toString(), node.getAllowsChildren());
   final Enumeration children = node.children();
   if (children != null) {
     while (children.hasMoreElements()) {
       final TreeNode child = (TreeNode) children.nextElement();
       target.add(copy(child));
     }
   }
   return target;
 }
  /**
   * Traverses all the children of the last component of the given tree path and calls this method
   * recursively on them and also expands or collapse the tree path.
   *
   * @param tree The working JTree
   * @param expand true means expand the tree path, false collapse it.
   * @param parent
   */
  private static void expandAll(JTree tree, boolean expand, TreePath parent) {
    // Traverse children
    TreeNode node = (TreeNode) parent.getLastPathComponent();
    if (node.getChildCount() >= 0) {
      for (Enumeration<?> e = node.children(); e.hasMoreElements(); ) {
        TreeNode n = (TreeNode) e.nextElement();
        TreePath path = parent.pathByAddingChild(n);
        expandAll(tree, expand, path);
      }
    }

    // Expansion or collapse must be done bottom-up
    if (expand) {
      tree.expandPath(parent);
    } else {
      tree.collapsePath(parent);
    }
  }
Exemple #9
0
  public void getPaths(JTree tree, TreePath parent, boolean expanded, List list) {
    // Return if node is not expanded
    if (expanded && !tree.isVisible(parent)) {
      return;
    }

    // Add node to list
    list.add(parent);

    // Create paths for all children
    TreeNode node = (TreeNode) parent.getLastPathComponent();
    if (node.getChildCount() >= 0) {
      for (Enumeration e = node.children(); e.hasMoreElements(); ) {
        TreeNode n = (TreeNode) e.nextElement();
        TreePath path = parent.pathByAddingChild(n);
        getPaths(tree, path, expanded, list);
      }
    }
  }