private static boolean isMoveSupported(JTree tree, int dir) {
   final TreePath[] selectionPaths = tree.getSelectionPaths();
   if (selectionPaths != null) {
     DefaultMutableTreeNode parent = null;
     for (TreePath treePath : selectionPaths)
       if (treePath.getLastPathComponent() != null) {
         final DefaultMutableTreeNode node =
             (DefaultMutableTreeNode) treePath.getLastPathComponent();
         if (parent == null) {
           parent = (DefaultMutableTreeNode) node.getParent();
         }
         if (parent != node.getParent()) {
           return false;
         }
         if (dir > 0) {
           if (parent.getIndex(node) == parent.getChildCount() - 1) {
             return false;
           }
         } else {
           if (parent.getIndex(node) == 0) {
             return false;
           }
         }
       }
     return true;
   }
   return false;
 }
示例#2
0
  // {{{ removeSelectedNode() method
  private void removeSelectedNode() {
    TreePath path = resultTree.getSelectionPath();
    if (path == null) return;

    MutableTreeNode value = (MutableTreeNode) path.getLastPathComponent();

    if (path.getPathCount() > 1) {
      // Adjust selection so that repeating some removals
      // behave naturally.
      TreePath parentPath = path.getParentPath();
      MutableTreeNode parent = (MutableTreeNode) parentPath.getLastPathComponent();
      int removingIndex = parent.getIndex(value);
      int nextIndex = removingIndex + 1;
      if (nextIndex < parent.getChildCount()) {
        TreeNode next = parent.getChildAt(nextIndex);
        resultTree.setSelectionPath(parentPath.pathByAddingChild(next));
      } else {
        resultTree.setSelectionPath(parentPath);
      }

      resultTreeModel.removeNodeFromParent(value);
    }

    HyperSearchOperationNode.removeNodeFromCache(value);
    if (resultTreeRoot.getChildCount() == 0) {
      hideDockable();
    }
  } // }}}
示例#3
0
    // {{{ getTreeCellRendererComponent() method
    @Override
    protected void configureTreeCellRendererComponent(
        JTree tree,
        Object value,
        boolean sel,
        boolean expanded,
        boolean leaf,
        int row,
        boolean hasFocus) {
      setIcon(null);
      DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;

      if (node.getUserObject() instanceof HyperSearchOperationNode) {
        setFont(boldFont);

        CountNodes countNodes = new CountNodes();
        traverseNodes(node, countNodes);

        setText(
            jEdit.getProperty(
                "hypersearch-results.result-caption",
                new Object[] {
                  node.toString(),
                  Integer.valueOf(countNodes.resultCount),
                  Integer.valueOf(countNodes.bufferCount)
                }));
      } else if (node.getUserObject() instanceof HyperSearchFolderNode) {
        setFont(plainFont);
        setText(node.toString() + " (" + node.getChildCount() + " files/folders)");
      } else if (node.getUserObject() instanceof HyperSearchFileNode) {
        // file name
        setFont(boldFont);
        HyperSearchFileNode hyperSearchFileNode = (HyperSearchFileNode) node.getUserObject();
        setText(
            jEdit.getProperty(
                "hypersearch-results.file-caption",
                new Object[] {
                  hyperSearchFileNode,
                  Integer.valueOf(hyperSearchFileNode.getCount()),
                  Integer.valueOf(node.getChildCount())
                }));
      } else {
        setFont(plainFont);
      }
    } // }}}
示例#4
0
文件: TreeUtil.java 项目: jexp/idea2
 public static void sort(final DefaultMutableTreeNode node, final Comparator comparator) {
   final List<TreeNode> children = childrenToArray(node);
   Collections.sort(children, comparator);
   node.removeAllChildren();
   addChildrenTo(node, children);
   for (int i = 0; i < node.getChildCount(); i++) {
     sort((DefaultMutableTreeNode) node.getChildAt(i), comparator);
   }
 }
示例#5
0
  /**
   * Adds the nodes necessary to display the property values for the given configuration element
   * described by the given property definition.
   */
  private void addProperty(ConfigElement elt, PropertyDefinition propDef) {
    DefaultMutableTreeNode parent = getNodeFor(elt);

    // This property has only one value, add it in
    if ((propDef.getPropertyValueDefinitionCount() == 1)
        && (!propDef.isVariable())
        && (propDef.getType() != ConfigElement.class)) {
      int idx = parent.getChildCount();
      //         System.out.println("Adding property node for single-valued property: "+
      //                            propDesc.getToken()+"["+idx+"]");
      Object value = elt.getProperty(propDef.getToken(), 0);
      DefaultMutableTreeNode value_node = new DefaultMutableTreeNode(value);
      insertNodeInto(value_node, parent, idx);
    }
    // This property has (or can have) more than one value, add a node that is
    // the parent for all its values.
    else {
      int idx = parent.getChildCount();
      //         System.out.println("Adding property node for multi-valued property: "+
      //                            propDesc.getToken()+"["+idx+"]");
      DefaultMutableTreeNode prop_def_node = new DefaultMutableTreeNode(propDef);
      insertNodeInto(prop_def_node, parent, idx);
      parent = prop_def_node;

      int num_props = elt.getPropertyValueCount(propDef.getToken());
      for (int i = 0; i < num_props; ++i) {
        Object value = elt.getProperty(propDef.getToken(), i);
        if (propDef.getType() != ConfigElement.class) {
          //               System.out.println("Adding property value:
          // "+propDesc.getToken()+"["+i+"]");
          DefaultMutableTreeNode child = new DefaultMutableTreeNode(value);
          int prop_idx = parent.getChildCount();
          insertNodeInto(child, parent, prop_idx);
        } else {
          addEmbeddedElement(parent, (ConfigElement) value, i);
        }
      }
    }
  }
 private static MyTreeNode ensureGroup(
     @NotNull DefaultMutableTreeNode root, @NotNull List<String> path, int index) {
   String groupName = path.get(index++);
   for (int i = 0; i < root.getChildCount(); i++) {
     TreeNode child = root.getChildAt(i);
     if (child instanceof MyTreeNode && groupName.equals(child.toString())) {
       return index < path.size() - 1
           ? ensureGroup((MyTreeNode) child, path, index)
           : (MyTreeNode) child;
     }
   }
   MyTreeNode groupNode = new MyTreeNode(groupName);
   root.add(groupNode);
   return index < path.size() - 1 ? ensureGroup(groupNode, path, index) : groupNode;
 }
 private void restoreUsageExpandState(final Collection<UsageState> states) {
   // always expand the last level group
   final DefaultMutableTreeNode root = (DefaultMutableTreeNode) myTree.getModel().getRoot();
   for (int i = root.getChildCount() - 1; i >= 0; i--) {
     final DefaultMutableTreeNode child = (DefaultMutableTreeNode) root.getChildAt(i);
     if (child instanceof GroupNode) {
       final TreePath treePath = new TreePath(child.getPath());
       myTree.expandPath(treePath);
     }
   }
   myTree.getSelectionModel().clearSelection();
   for (final UsageState usageState : states) {
     usageState.restore();
   }
 }
示例#8
0
文件: TreeUtil.java 项目: jexp/idea2
 @Nullable
 public static DefaultMutableTreeNode findNodeWithObject(
     final DefaultMutableTreeNode aRoot, final Object aObject) {
   if (Comparing.equal(aRoot.getUserObject(), aObject)) {
     return aRoot;
   } else {
     for (int i = 0; i < aRoot.getChildCount(); i++) {
       final DefaultMutableTreeNode candidate =
           findNodeWithObject((DefaultMutableTreeNode) aRoot.getChildAt(i), aObject);
       if (null != candidate) {
         return candidate;
       }
     }
     return null;
   }
 }
 private void captureUsagesExpandState(TreePath pathFrom, final Collection<UsageState> states) {
   if (!myTree.isExpanded(pathFrom)) {
     return;
   }
   final DefaultMutableTreeNode node = (DefaultMutableTreeNode) pathFrom.getLastPathComponent();
   final int childCount = node.getChildCount();
   for (int idx = 0; idx < childCount; idx++) {
     final TreeNode child = node.getChildAt(idx);
     if (child instanceof UsageNode) {
       final Usage usage = ((UsageNode) child).getUsage();
       states.add(
           new UsageState(
               usage,
               myTree.getSelectionModel().isPathSelected(pathFrom.pathByAddingChild(child))));
     } else {
       captureUsagesExpandState(pathFrom.pathByAddingChild(child), states);
     }
   }
 }
示例#10
0
  /**
   * @param searchNode the result node
   * @param selectNode the node that must be selected, or null
   * @since jEdit 4.3pre12
   */
  public void searchDone(
      final DefaultMutableTreeNode searchNode, final DefaultMutableTreeNode selectNode) {
    stop.setEnabled(false);
    final int nodeCount = searchNode.getChildCount();
    if (nodeCount < 1) {
      searchFailed();
      return;
    }

    caption.setText(
        jEdit.getProperty("hypersearch-results.done", new String[] {trimSearchString()}));

    EventQueue.invokeLater(
        new Runnable() {
          @Override
          public void run() {
            if (!multiStatus) {
              for (int i = 0; i < resultTreeRoot.getChildCount(); i++) {
                resultTreeRoot.remove(0);
              }
            }

            resultTreeRoot.add(searchNode);
            resultTreeModel.reload(resultTreeRoot);

            for (int i = 0; i < nodeCount; i++) {
              TreePath lastNode =
                  new TreePath(((DefaultMutableTreeNode) searchNode.getChildAt(i)).getPath());

              resultTree.expandPath(lastNode);
            }
            TreePath treePath;
            if (selectNode == null) {
              treePath = new TreePath(new Object[] {resultTreeRoot, searchNode});
            } else {
              treePath = new TreePath(selectNode.getPath());
            }
            resultTree.setSelectionPath(treePath);
            resultTree.scrollPathToVisible(treePath);
          }
        });
  } // }}}
示例#11
0
  /** Sets the value for the given node at the given column to the given value. */
  public void setValueAt(Object value, Object node, int col) {
    DefaultMutableTreeNode tree_node = (DefaultMutableTreeNode) node;
    Object node_value = tree_node.getUserObject();

    switch (col) {
        // Name (not supported)
      case 0:
        break;
        // Value
      case 1:
        DefaultMutableTreeNode parent_node = (DefaultMutableTreeNode) tree_node.getParent();

        // First child of root is always the element name
        if (parent_node == getRoot() && parent_node.getIndex((TreeNode) node) == 0) {
          ConfigElement elt = (ConfigElement) parent_node.getUserObject();
          elt.setName((String) value);
          tree_node.setUserObject(value);
        } else if (node_value instanceof PropertyDefinition) {
          // Hey, we're editing a property definition. If it's type is not a
          // configuration element, we're probably editing a summary list of
          // the valuesof the children.
          if (((PropertyDefinition) node_value).getType() != ConfigElement.class) {
            ConfigElement elt = (ConfigElement) parent_node.getUserObject();
            PropertyDefinition prop_def = (PropertyDefinition) node_value;
            StringTokenizer tokenizer = new StringTokenizer((String) value, ", ");
            int idx = 0;
            while (tokenizer.hasMoreTokens()) {
              String token = tokenizer.nextToken();

              // Make sure we don't overrun the property values
              if ((idx >= prop_def.getPropertyValueDefinitionCount()) && (!prop_def.isVariable())) {
                break;
              }

              // Convert the value to the appropriate type
              Object new_value = null;
              Class type = prop_def.getType();
              if (type == Boolean.class) {
                new_value = new Boolean(token);
              } else if (type == Integer.class) {
                new_value = new Integer(token);
              } else if (type == Float.class) {
                new_value = new Float(token);
              } else if (type == String.class) {
                new_value = new String(token);
              } else if (type == ConfigElementPointer.class) {
                new_value = new ConfigElementPointer(token);
              }

              setProperty(new_value, elt, prop_def.getToken(), idx);

              // Get the node for the current property value and update it
              if (idx < tree_node.getChildCount()) {
                DefaultMutableTreeNode child_node =
                    (DefaultMutableTreeNode) tree_node.getChildAt(idx);
                child_node.setUserObject(new_value);
              } else {
                // Insert the new property
                DefaultMutableTreeNode new_node = new DefaultMutableTreeNode(new_value);
                tree_node.add(new_node);
                fireTreeNodesInserted(
                    this,
                    new Object[] {getPathToRoot(tree_node)},
                    new int[] {tree_node.getIndex(new_node)},
                    new Object[] {new_node});
              }
              ++idx;
            }
          }
        } else {
          // Parent is a ConfigElement ... must be a single-valued property
          if (parent_node.getUserObject() instanceof ConfigElement) {
            ConfigElement elt = (ConfigElement) parent_node.getUserObject();
            int desc_idx = parent_node.getIndex(tree_node);

            // If the parent is the root, take into account the extra name
            // and type nodes
            if (parent_node == getRoot()) {
              desc_idx -= 2;
            }
            PropertyDefinition prop_def =
                (PropertyDefinition) elt.getDefinition().getPropertyDefinitions().get(desc_idx);
            setProperty(value, elt, prop_def.getToken(), 0);
            tree_node.setUserObject(value);
          } else {
            // Parent must be a PropertyDefinition
            PropertyDefinition prop_def = (PropertyDefinition) parent_node.getUserObject();
            int value_idx = parent_node.getIndex(tree_node);
            DefaultMutableTreeNode elt_node = (DefaultMutableTreeNode) parent_node.getParent();
            ConfigElement elt = (ConfigElement) elt_node.getUserObject();
            setProperty(value, elt, prop_def.getToken(), value_idx);
            tree_node.setUserObject(value);
          }
        }
        fireTreeNodesChanged(
            this,
            new Object[] {getPathToRoot(parent_node)},
            new int[] {parent_node.getIndex(tree_node)},
            new Object[] {tree_node});
        break;
      default:
        throw new IllegalArgumentException("Invalid column: " + col);
    }
  }