Example #1
0
 @Override
 public void treeNodesRemoved(TreeModelEvent e) {
   final TreeNode root = (TreeNode) application.getSubjectHierarchy().getRoot();
   if (root.getChildCount() == 0) {
     isExpanded = false;
   }
 }
  private void removeNodeFromParent(DefaultMutableTreeNode node) {
    TreeNode parent = node.getParent();
    int idx = parent.getIndex(node);
    node.removeFromParent();

    (getModel()).nodesWereRemoved(parent, new int[] {idx}, new TreeNode[] {node});
  }
Example #3
0
  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);
    }
  }
  public void expandRootChildren() {
    TreeNode root = (TreeNode) myTreeModel.getRoot();

    if (root.getChildCount() == 1) {
      myTree.expandPath(new TreePath(new Object[] {root, root.getChildAt(0)}));
    }
  }
  public void updateClientState(Node nodeUpdate) {
    for (int i = 0; i < rootNode.getChildCount(); i++) {
      TreeNode treeNode = rootNode.getChildAt(i);
      //            System.out.println(treeNode.toString());
      if (treeNode.toString().equals(nodeUpdate.getName())) {
        DefaultMutableTreeNode node = (DefaultMutableTreeNode) treeNode;
        if (nodeUpdate.isOnline() && nodeUpdate.isValid()) {
          // 删除”状态:在线,可信“ 那一行
          node.remove(2);

          node.add(new DefaultMutableTreeNode("状态:在线,可信"));
          Log.i(this.getClass().getName(), nodeUpdate.getName() + " 已登录,状态可信.");

        } else if (nodeUpdate.isOnline() && !nodeUpdate.isValid()) {
          node.remove(2);
          node.add(new DefaultMutableTreeNode("状态:在线,不可信"));
          Log.v(
              this.getClass().getName(),
              nodeUpdate.getName() + "状态不可信,IP地址为:" + nodeUpdate.getIP());
        } else {
          node.remove(2);
          node.add(new DefaultMutableTreeNode("状态:离线"));
          Log.i(
              this.getClass().getName(), nodeUpdate.getName() + "不在线,IP地址为:" + nodeUpdate.getIP());
        }
        this.jTree.updateUI();
        return;
      }
    }
  }
  public void load(JarIndex index, boolean recurse) {
    // get all the child nodes
    for (EntryReference<BehaviorEntry, BehaviorEntry> reference :
        index.getBehaviorReferences(m_entry)) {
      add(
          new BehaviorReferenceTreeNode(
              m_deobfuscatingTranslator, reference, index.getAccess(m_entry)));
    }

    if (recurse && children != null) {
      for (Object child : children) {
        if (child instanceof BehaviorReferenceTreeNode) {
          BehaviorReferenceTreeNode node = (BehaviorReferenceTreeNode) child;

          // don't recurse into ancestor
          Set<Entry> ancestors = Sets.newHashSet();
          TreeNode n = (TreeNode) node;
          while (n.getParent() != null) {
            n = n.getParent();
            if (n instanceof BehaviorReferenceTreeNode) {
              ancestors.add(((BehaviorReferenceTreeNode) n).getEntry());
            }
          }
          if (ancestors.contains(node.getEntry())) {
            continue;
          }

          node.load(index, true);
        }
      }
    }
  }
Example #7
0
  /**
   * add tree node function
   *
   * @version 1.0
   * @author dinglinhui
   */
  private boolean addTreeNode(String name) {

    for (int i = 0; i < root.getChildCount(); i++) {
      TreeNode node = root.getChildAt(i);
      if (name.equals(node.toString())) {
        return false;
      }
    }

    IconNode nodesChnl = new IconNode(name);
    IconNode[] nodesType = new IconNode[3];
    nodesChnl.setIcon(getImageIcon(RESOURCE_IMAGES_PATH + "ligthbulb_on.png", 16, 16));

    nodesType[0] = new IconNode("遥测");
    nodesType[0].setIcon(getImageIcon(RESOURCE_IMAGES_PATH + "Orange Ball.png", 16, 16));
    nodesChnl.add(nodesType[0]);

    nodesType[1] = new IconNode("遥信");
    nodesType[1].setIcon(getImageIcon(RESOURCE_IMAGES_PATH + "Green Ball.png", 16, 16));
    nodesChnl.add(nodesType[1]);

    nodesType[2] = new IconNode("遥控");
    nodesType[2].setIcon(getImageIcon(RESOURCE_IMAGES_PATH + "Yellow Ball.png", 16, 16));
    nodesChnl.add(nodesType[2]);

    root.add(nodesChnl);

    return true;
  }
Example #8
0
  public String toXPath() {
    /* HOW TO CLIMB UP !!!!!*/
    TreeNode parent = getParent();

    if (parent == null) return (String.valueOf(myNode.getName()));
    else return (parent.toString() + "/" + myNode.getName());
  }
Example #9
0
 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;
 }
  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;
  }
Example #11
0
 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;
 }
Example #12
0
  private static List<PathElement> createPath(final TreePath treePath) {
    final ArrayList<PathElement> result = new ArrayList<PathElement>();
    for (int i = 0; i < treePath.getPathCount(); i++) {
      final Object pathComponent = treePath.getPathComponent(i);
      if (pathComponent instanceof DefaultMutableTreeNode) {
        final DefaultMutableTreeNode node = (DefaultMutableTreeNode) pathComponent;
        final TreeNode parent = node.getParent();

        final Object userObject = node.getUserObject();
        if (userObject instanceof NodeDescriptor) {
          final NodeDescriptor nodeDescriptor = (NodeDescriptor) userObject;
          // nodeDescriptor.update();
          final int childIndex = parent != null ? parent.getIndex(node) : 0;
          result.add(
              new PathElement(
                  getDescriptorKey(nodeDescriptor),
                  getDescriptorType(nodeDescriptor),
                  childIndex,
                  nodeDescriptor));
        } else {
          result.add(new PathElement("", "", 0, userObject));
        }
      } else {
        return null;
      }
    }
    return result;
  }
Example #13
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;
 }
Example #14
0
  /** *************************************************** */
  private void setCopyList(TreeNode copiedNode) {
    if (index++ == 0) {
      copyFile = new Vector<TreeNode>();
      copyFile.add(copiedNode);

      copiedList.add(copyFile);
      pos = copiedNode.getPath().toString().lastIndexOf(File.separator);
    }

    File[] copieFiles = copiedNode.getFile().listFiles();

    if (copieFiles != null) {
      for (File file : copieFiles) {
        if (file.isDirectory()) {
          copyFile = new Vector<TreeNode>();

          TreeNode node_ = new TreeNode(file);
          copyFile.add(node_);
          copiedList.add(copyFile);

          setCopyList(node_);
        } else {
          copyFile = new Vector<TreeNode>();

          TreeNode node_ = new TreeNode(file);
          copyFile.add(node_);
          copiedList.add(copyFile);
        }
      }
    }
  }
Example #15
0
 public static boolean isAncestor(final TreeNode ancestor, final TreeNode node) {
   TreeNode parent = node;
   while (parent != null) {
     if (parent == ancestor) return true;
     parent = parent.getParent();
   }
   return false;
 }
Example #16
0
 TreeNode buildBST(int[] a, int start, int end) {
   if (start > end) return null;
   int mid = (start + end) / 2;
   TreeNode n = new TreeNode(a[mid]);
   n.left = buildBST(a, start, mid - 1);
   n.right = buildBST(a, mid + 1, end);
   return n;
 }
Example #17
0
 public void invertTreeInternal(TreeNode root) {
   if (root == null) return;
   TreeNode temp = root.right;
   root.right = root.left;
   root.left = temp;
   invertTree(root.left);
   invertTree(root.right);
 }
Example #18
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);
   }
 }
  protected TreeNode findChild(TreeNode parent, Integer simpleKey) {
    int childIdx = simpleKey.intValue();

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

    return null;
  }
Example #20
0
 private void collectExisting(MPSTreeNode node, Collection<String> existing) {
   for (int idx = 0; idx < node.getChildCount(); idx++) {
     TreeNode child = node.getChildAt(idx);
     if (child instanceof MPSTreeNode) {
       existing.add(child.toString());
       collectExisting(((MPSTreeNode) child), existing);
     }
   }
 }
 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);
   }
 }
 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);
   }
 }
Example #23
0
  @Override
  public void adoptElement(SceneElement elem) {
    if (!(elem instanceof NenyaImageSceneElement
        || elem instanceof NenyaTileSceneElement
        || elem instanceof NenyaComponentSceneElement)) {
      enableEditor(false);
      return;
    }

    DefaultComboBoxModel dcm = (DefaultComboBoxModel) itemList.getModel();

    // Important: Work on a copy, not on the original. Otherwise we mess up the undomanager
    sceneElement = elem.copy();

    if ((sceneElement instanceof NenyaImageSceneElement) && !locked) {
      dcm.removeAllElements();
      String[] tmp = ((NenyaImageSceneElement) sceneElement).getPath();
      dcm.addElement(tmp[tmp.length - 1]);
    }
    if ((sceneElement instanceof NenyaTileSceneElement) && !locked) {
      dcm.removeAllElements();
      dcm.addElement(((NenyaTileSceneElement) sceneElement).getTileName());
    }
    if ((sceneElement instanceof NenyaComponentSceneElement) && !locked) {
      dcm.removeAllElements();
      NenyaComponentItem[] ni = ((NenyaComponentSceneElement) sceneElement).getComponents();
      for (NenyaComponentItem element : ni) {
        dcm.addElement(element);
      }
    }

    try {
      ClassedItem[] cols = null;
      if (elem instanceof NenyaTileSceneElement)
        cols = ((NenyaTileSceneElement) elem).getColorList();
      if (elem instanceof NenyaImageSceneElement)
        cols = ((NenyaImageSceneElement) elem).getColorList();
      if (elem instanceof NenyaComponentSceneElement) {
        NenyaComponentItem nci = (NenyaComponentItem) dcm.getSelectedItem();
        cols = nci.getColorList();
      }
      Vector<TreePath> collect = new Vector<TreePath>();
      TreeNode root = (TreeNode) colors.getModel().getRoot();
      for (ClassedItem col : cols) {
        String[] tmp = {root.toString(), col.getClassName(), col.getItemName()};
        collect.add(TreeUtil.findPath(root, tmp));
      }
      TreePath[] path = collect.toArray(new TreePath[0]);
      colors.getSelectionModel().setSelectionPaths(path);
    } catch (Exception e) {
      // Either the tree is filtered away or the selected item is not colorized.
    }

    enableEditor(true);
    itemList.setEnabled(elem instanceof NenyaComponentSceneElement);
  }
Example #24
0
 public void refreshNode() {
   try {
     Vector files = treeview.GetAll(currentnode.GetFile());
     tablemodel.addAllFiles(files);
     appendNodes(currentnode, treeview.GetAllDirectories(currentnode.GetFile()));
     treemodel.nodeStructureChanged(currentnode);
   } catch (Exception e) {
     e.printStackTrace();
   }
 }
Example #25
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;
 }
Example #26
0
  private void initializeItems() {
    moveTo = new JMenu(model.getName("SPOT_POPUP_MOVE_ITEM"));

    add(moveTo);
    for (TreeNode n : groups) {
      JMenuItem item = new JMenuItem(n.toString());
      item.addActionListener(this);
      moveTo.add(item);
    }
  }
Example #27
0
 /**
  * 刷新节点中文名称
  *
  * @param node
  */
 private void refreshNodeChName(TreeNode node) {
   TreeNode parNode = node.getParent();
   int index = parNode.getIndex(node);
   Caliber cal = (Caliber) ((DefaultMutableTreeNode) node).getUserObject();
   if (index == 0) {
     cal.setFirstNode(true);
   } else {
     cal.setFirstNode(false);
   }
 }
 public void dragEnter(DropTargetDragEvent dtde) {
   TreeNode node = getNodeForEvent(dtde);
   if (node.isLeaf()) {
     dtde.rejectDrag();
   } else {
     // start by supporting move operations
     // dtde.acceptDrag(DnDConstants.ACTION_MOVE);
     dtde.acceptDrag(dtde.getDropAction());
   }
 }
Example #29
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());
   }
 }
Example #30
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;
 }