public boolean isPathSelected(TreePath path, boolean dig) { if (!dig) { return super.isPathSelected(path); } while (path != null && !super.isPathSelected(path)) { path = path.getParentPath(); } return path != null; }
DefaultTreeModel model = (DefaultTreeModel)tree.getModel(); DefaultMutableTreeNode root = (DefaultMutableTreeNode)model.getRoot(); root.add(new DefaultMutableTreeNode("another_child")); model.reload(root);
private void addNode(DefaultMutableTreeNode level, PathElement element) { DefaultMutableTreeNode node = new DefaultMutableTreeNode(); node.setUserObject(element); level.add(node); }
DefaultTreeModel model = (DefaultTreeModel) tree.getModel(); DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot(); model.insertNodeInto(new DefaultMutableTreeNode("another_child"), root, root.getChildCount());
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; }
/** * <p>Returns the CategoryPath to the specified CategoryNode</p> * * @param node The target CategoryNode * @return CategoryPath */ public TreePath getTreePathToRoot(CategoryNode node) { if (node == null) { return null; } return (new TreePath(getPathToRoot(node))); }
@Override public void treeWillExpand(TreeExpansionEvent event) { TreePath path = event.getPath(); Object node = path.getLastPathComponent(); if (node instanceof JLoadableNode) { ((JLoadableNode) node).loadNode(); } }
private TreeCellRenderer createNoImageTreeCellRenderer() { DefaultTreeCellRenderer treeCellRenderer = new DefaultTreeCellRenderer(); treeCellRenderer.setLeafIcon(null); treeCellRenderer.setOpenIcon(null); treeCellRenderer.setClosedIcon(null); return treeCellRenderer; }
protected void insertChild(MutableTreeNode childNode) { int index = treeNode.getChildCount() <= 0 ? 0 : treeNode.getChildCount(); treeModel.insertNodeInto(childNode, treeNode, index); }
@Override public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean isLeaf, int row, boolean focused) { Component c = super.getTreeCellRendererComponent(tree, value, selected, expanded, isLeaf, row, focused); if (value instanceof JNode) { setIcon(((JNode) value).getIcon()); } return c; } });
private DefaultMutableTreeNode getLastChildNode(DefaultMutableTreeNode node) { if (node.getChildCount() != 0) { return (DefaultMutableTreeNode) node.getLastChild(); } return node; }
protected void removeChildren() { treeNode.removeAllChildren(); treeModel.nodeStructureChanged(treeNode); }
/** * Provide the standard Groovy <code>size()</code> method for <code>TreeNode</code>. * * @param self a TreeNode * @return the child count of the treeNode * @since 1.6.4 */ public static int size(TreeNode self) { return self.getChildCount(); }
@Override public void removeSelectionPaths(TreePath[] paths) { for (int i = 0; i < paths.length; i++) { TreePath path = paths[i]; if (path.getPathCount() == 1) { super.removeSelectionPaths(new TreePath[]{path}); } else { toggleRemoveSelection(path); } } }
/** * Support the subscript operator for TreeNode. * * @param self a TreeNode * @param index the index of the child node to get * @return the child node at the given index * @since 1.6.4 */ public static TreeNode getAt(TreeNode self, int index) { return self.getChildAt(index); }
private void reloadTree() { treeModel.reload(); tree.expandRow(1); }
private void initTree() { treeRoot = new JRoot(wrapper); treeRoot.setFlatPackages(isFlattenPackage); treeModel.setRoot(treeRoot); reloadTree(); }
protected TreePath getTreePath(CategoryNode node) { return new TreePath(node.getPath()); }
public void treeNodeChanged(FileTreeNode n) { TreePath t = new TreePath(makeTreePathArray(n)); //System.out.println("Tree path is: " + t); this.fireTreeStructureChanged(t); }