예제 #1
0
파일: Four_1.java 프로젝트: tryceo/CCI
  public static int getHeight(TreeNode node) {
    if (node.isLeaf()) {
      return 1;
    }

    int heightl = 0;
    int heightr = 0;
    if (node.getChildCount() > 0) {
      heightl = getHeight(node.getChildAt(0));
      if (heightl == -1) {
        return -1;
      }
    }

    if (node.getChildCount() > 1) {
      heightr = getHeight(node.getChildAt(1));
      if (heightr == -1) {
        return -1;
      }
    }

    if (Math.abs(heightl - heightr) > 1) {
      return -1;
    } else {
      return Math.max(heightl + 1, heightr + 1);
    }
  }
예제 #2
0
 @Override
 public void mouseClicked(MouseEvent e) {
   int clickedIndex = table.getSelectedRow(); // 获取鼠标点击的行数
   if (clickedIndex >= 0) {
     EditSelectAll.setEnabled(true);
     SelectAll.setEnabled(true);
     isTable = true;
     currentfile = tablemodel.getFile(clickedIndex);
     addressText.setText(currentfile.getAbsolutePath()); // 地址栏显示路径
     if (!currentnode.getFile().getName().equals(fsv.getHomeDirectory())) {
       FileDelete.setEnabled(true);
       Delete.setEnabled(true);
     }
   }
   if (e.getClickCount() >= 2) {
     EditSelectAll.setEnabled(true);
     SelectAll.setEnabled(true);
     if (currentfile.isDirectory()) // 当单击的是目录
     {
       try {
         upbtn.setEnabled(true);
         if (!tree.isExpanded(currentPath)) tree.expandPath(currentPath); // 将树中对应的节点打开
         if (currentnode.getChildCount() > 0) {
           for (int i = 0; i < currentnode.getChildCount(); i++) {
             FileTreeNode temp =
                 (FileTreeNode) currentnode.getChildAt(i); // 返回currentNode的子节点数组中指定索引处的子节点。
             if (temp.GetFile()
                 .getPath()
                 .equalsIgnoreCase(currentfile.getPath())) // 判断子节点路径是否等于列表中选的的路径
             {
               TreeNode[] nodes = treemodel.getPathToRoot(temp); // 获取从根节点到 temp的路径
               currentPath = new TreePath(nodes);
               tree.setSelectionPath(currentPath); // 选择子节点的父节点
               break;
             }
           }
         }
       } catch (Exception ee) {
         ee.printStackTrace();
       }
     }
     if (currentfile.isFile()) {
       Runtime ce = Runtime.getRuntime();
       String Temp = new String(currentfile.getAbsolutePath());
       String cmdarray = "cmd /c start " + Temp;
       try {
         ce.exec(cmdarray);
       } catch (IOException e1) {
         e1.printStackTrace();
       }
     }
   } else if (e.getButton() == e.BUTTON3) {
     popup.show(e.getComponent(), e.getX(), e.getY());
   }
 }
  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;
  }
예제 #4
0
파일: TreeUtil.java 프로젝트: jexp/idea2
 public static ArrayList<TreeNode> childrenToArray(final TreeNode node) {
   final ArrayList<TreeNode> result = new ArrayList<TreeNode>();
   for (int i = 0; i < node.getChildCount(); i++) {
     result.add(node.getChildAt(i));
   }
   return result;
 }
예제 #5
0
 /**
  * Recursive traverse of tree to determine selections A leaf is selected if rsm is selected.
  * Nonleaf nodes are selected if all children are selected.
  *
  * @param tn node in the tree for which to determine selection
  * @param nodeidx the ordinal postion in the segments array
  * @param gsm the graph segments selection model
  * @param rsm the table row selection model
  * @return true if given node tn is selected, else false
  */
 private boolean selTraverse(
     TreeNode tn, int[] nodeidx, ListSelectionModel gsm, ListSelectionModel rsm) {
   boolean selected = true;
   if (!tn.isLeaf()) {
     // A nonleaf node is selected if all its children are selected.
     for (int i = 0; i < tn.getChildCount(); i++) {
       TreeNode cn = tn.getChildAt(i);
       selected &= selTraverse(cn, nodeidx, gsm, rsm);
     }
   } else {
     if (tn instanceof RowCluster) {
       // get the row index of the leaf node
       int ri = ((RowCluster) tn).getIndex();
       // A leaf is selected if its row is selected in the row selection rsm.
       selected = rsm.isSelectedIndex(ri);
     }
   }
   // Get the offset into the segments array
   int idx = nodeidx[0] * segOffset;
   if (selected) {
     gsm.addSelectionInterval(idx, idx + (segOffset - 1));
   } else {
     gsm.removeSelectionInterval(idx, idx + (segOffset - 1));
   }
   // Increment the nodeidx in the tree
   nodeidx[0]++;
   return selected;
 }
예제 #6
0
파일: TreeUtil.java 프로젝트: jexp/idea2
 public static boolean traverseDepth(final TreeNode node, final Traverse traverse) {
   if (!traverse.accept(node)) return false;
   final int childCount = node.getChildCount();
   for (int i = 0; i < childCount; i++)
     if (!traverseDepth(node.getChildAt(i), traverse)) return false;
   return true;
 }
예제 #7
0
 @Override
 public void treeNodesRemoved(TreeModelEvent e) {
   final TreeNode root = (TreeNode) application.getSubjectHierarchy().getRoot();
   if (root.getChildCount() == 0) {
     isExpanded = false;
   }
 }
  public void expandRootChildren() {
    TreeNode root = (TreeNode) myTreeModel.getRoot();

    if (root.getChildCount() == 1) {
      myTree.expandPath(new TreePath(new Object[] {root, root.getChildAt(0)}));
    }
  }
예제 #9
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;
  }
  protected TreeNode findChild(TreeNode parent, Integer simpleKey) {
    int childIdx = simpleKey.intValue();

    if (childIdx < parent.getChildCount()) {
      return parent.getChildAt(childIdx);
    }

    return null;
  }
 private static void resetNode(TreeNode node, CodeStyleSettings settings) {
   if (node instanceof MyTreeNode) {
     ((MyTreeNode) node).reset(settings);
   }
   for (int j = 0; j < node.getChildCount(); j++) {
     TreeNode child = node.getChildAt(j);
     resetNode(child, settings);
   }
 }
 private static void applyNode(TreeNode node, final CodeStyleSettings settings) {
   if (node instanceof MyTreeNode) {
     ((MyTreeNode) node).apply(settings);
   }
   for (int j = 0; j < node.getChildCount(); j++) {
     TreeNode child = node.getChildAt(j);
     applyNode(child, settings);
   }
 }
예제 #13
0
 /**
  * Return a count of this node and all its descendents.
  *
  * @param node A node in the Treemodel.
  * @return The number of nodes in this branch of the Treemodel.
  */
 private static int getNodeCount(TreeNode tn) {
   int nc = 1; // this node
   if (!tn.isLeaf()) {
     for (int i = 0; i < tn.getChildCount(); i++) {
       TreeNode cn = tn.getChildAt(i);
       nc += getNodeCount(cn);
     }
   }
   return nc;
 }
예제 #14
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);
 }
예제 #15
0
 int getTotalUnseen(TreeNode n) {
   int unseen = 0;
   for (int i = 0; i < n.getChildCount(); i++) {
     TreeNode child = n.getChildAt(i);
     if (child instanceof PlaylistTreeNode) unseen += ((PlaylistTreeNode) child).numUnseenTracks;
     else if (child instanceof LibraryTreeNode)
       unseen += ((LibraryTreeNode) child).numUnseenTracks;
     else unseen += getTotalUnseen(child);
   }
   return unseen;
 }
예제 #16
0
 /**
  * Return the number of leaf nodes that descend from the given node.
  *
  * @param node A node in the Treemodel.
  * @return The number of leaf nodes that descend from the given node.
  */
 private static int getLeafCount(TreeNode tn) {
   int lc = 0;
   if (!tn.isLeaf()) {
     for (int i = 0; i < tn.getChildCount(); i++) {
       TreeNode cn = tn.getChildAt(i);
       lc += getLeafCount(cn);
     }
   } else {
     lc = 1;
   }
   return lc;
 }
 private static boolean isModified(TreeNode node, final CodeStyleSettings settings) {
   if (node instanceof MyTreeNode) {
     if (((MyTreeNode) node).isModified(settings)) return true;
   }
   for (int j = 0; j < node.getChildCount(); j++) {
     TreeNode child = node.getChildAt(j);
     if (isModified(child, settings)) {
       return true;
     }
   }
   return false;
 }
예제 #18
0
 /**
  * Traververse the tree selecting rows coresponding to leaf nodes of the given node tn
  *
  * @param tn the node from which to start traversing
  * @param rsm the selection model in which to mark selected rows
  */
 private void selectTraverse(TreeNode tn, ListSelectionModel rsm) {
   if (!tn.isLeaf()) {
     for (int i = 0; i < tn.getChildCount(); i++) {
       TreeNode cn = tn.getChildAt(i);
       selectTraverse(cn, rsm);
     }
   } else {
     if (tn instanceof RowCluster) {
       int ri = ((RowCluster) tn).getIndex();
       rsm.addSelectionInterval(ri, ri);
     }
   }
 }
예제 #19
0
  /** Collapses the tree of algorithms */
  public void collapseAll() {

    final TreeNode root = (TreeNode) jTree.getModel().getRoot();
    final TreePath path = new TreePath(root);
    expandAll(jTree, path, false);
    jTree.expandPath(path);
    final int iChildCount = root.getChildCount();
    for (int i = 0; i < iChildCount; i++) {
      final TreeNode node = root.getChildAt(i);
      final TreePath subpath = path.pathByAddingChild(node);
      jTree.expandPath(subpath);
    }
  }
 @Nullable
 private DefaultMutableTreeNode findNodeOnToolbar(String actionId) {
   final TreeNode toolbar =
       ((DefaultMutableTreeNode) myActionsTree.getModel().getRoot()).getChildAt(1);
   for (int i = 0; i < toolbar.getChildCount(); i++) {
     final DefaultMutableTreeNode child = (DefaultMutableTreeNode) toolbar.getChildAt(i);
     final String childId = getActionId(child);
     if (childId != null && childId.equals(actionId)) {
       return child;
     }
   }
   return null;
 }
예제 #21
0
 boolean anyComments(TreeNode n) {
   for (int i = 0; i < n.getChildCount(); i++) {
     TreeNode child = n.getChildAt(i);
     if (child instanceof PlaylistTreeNode) {
       if (((PlaylistTreeNode) child).hasComments) return true;
     } else if (child instanceof LibraryTreeNode) {
       if (((LibraryTreeNode) child).hasComments) return true;
     } else {
       if (anyComments(child)) return true;
     }
   }
   return false;
 }
  /**
   * Expand the given tree to the given level, starting from the given node and path.
   *
   * @param tree The tree to be expanded
   * @param node The node to start from
   * @param path The path to start from
   * @param level The number of levels to expand to
   */
  private static void expandNode(
      final JTree tree, final TreeNode node, final TreePath path, final int level) {
    if (level <= 0) {
      return;
    }

    tree.expandPath(path);

    for (int i = 0; i < node.getChildCount(); ++i) {
      final TreeNode childNode = node.getChildAt(i);
      expandNode(tree, childNode, path.pathByAddingChild(childNode), level - 1);
    }
  }
예제 #23
0
  // returns the project based on the project header id
  public Element getProject(String id) {
    Element project = null;

    TreeNode root = (TreeNode) treeModel.getRoot();
    for (int i = 0; i < root.getChildCount(); i++) {
      ItTreeNode child = (ItTreeNode) root.getChildAt(i);
      Element projectHeader = child.getReference();
      if (id.equals(projectHeader.getAttributeValue("id"))) {
        project = child.getData();
        break;
      }
    }
    return project;
  }
예제 #24
0
파일: TreeView.java 프로젝트: jexp/idea2
  @Nullable
  private static TreePath getFirstErrorPath(TreePath treePath) {
    TreeNode treeNode = (TreeNode) treePath.getLastPathComponent();
    if (treeNode instanceof MessageNode) {
      AntBuildMessageView.MessageType type = ((MessageNode) treeNode).getType();
      if (type == AntBuildMessageView.MessageType.ERROR) {
        return treePath;
      }
    }

    if (treeNode.getChildCount() == 0) {
      return null;
    }
    for (int i = 0; i < treeNode.getChildCount(); i++) {
      TreeNode childNode = treeNode.getChildAt(i);
      TreePath childPath = treePath.pathByAddingChild(childNode);
      TreePath usagePath = getFirstErrorPath(childPath);
      if (usagePath != null) {
        return usagePath;
      }
    }
    return null;
  }
예제 #25
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);
   }
 }
예제 #26
0
  /**
   * Returns the position of the specified LayerNode or -1 if it is not contained in the ContentTree.<br>
   * In the following example this method will return 4 for the 'X'-LayerNode.
   *
   * <pre>
   *   -O
   *    |-O
   *    |-O
   *    |-O
   *   -O
   *    |-O
   *    |-X
   *    |-O
   *
   * &#064;param layerNode
   * @return
   *
   */
  public int positionOf(LayerNode layerNode) {
    int position = 0;
    for (int i = 0; i < root.getChildCount(); i++) {
      TreeNode storageNode = root.getChildAt(i);

      for (int j = 0; j < storageNode.getChildCount(); j++) {

        if (storageNode.getChildAt(j) != layerNode) {
          position++;
        } else {
          return position;
        }
      }
    }

    return -1;
  }
예제 #27
0
  /**
   * 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);
    }
  }
 private static void hideActions(
     @NotNull CustomActionsSchema schema,
     @NotNull DefaultMutableTreeNode root,
     @NotNull final TreeNode actionGroup,
     Set<String> items) {
   for (int i = 0; i < actionGroup.getChildCount(); i++) {
     final DefaultMutableTreeNode child = (DefaultMutableTreeNode) actionGroup.getChildAt(i);
     final int childCount = child.getChildCount();
     final String childId = getItemId(child);
     if (childId != null && items.contains(childId)) {
       final TreePath treePath = TreeUtil.getPath(root, child);
       final ActionUrl url = CustomizationUtil.getActionUrl(treePath, ActionUrl.DELETED);
       schema.addAction(url);
     } else if (childCount > 0) {
       hideActions(schema, child, child, items);
     }
   }
 }
예제 #29
0
  public void dragOver(DropTargetDragEvent dtde) {
    /*
     * The idea here is to change the selection path as the user drags an
     * item over - it works but it does not seem to expand...
     */

    final TreePath path = getPathForLocation(dtde.getLocation().x, dtde.getLocation().y);

    if (path != null) {
      final TreeNode leafNode = (TreeNode) path.getLastPathComponent();

      if (leafNode.getChildCount() > 0) {
        final TreePath newPath = path.pathByAddingChild(leafNode.getChildAt(0));
        expandPath(newPath);
        setSelectionPath(path);
        repaint();
      }
    }
  }
예제 #30
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);
      }
    }
  }