private TreePath collapseRoot() { TreePath rootPath = new TreePath(myRoot); myTree.collapsePath(rootPath); myTree.setSelectionPath(rootPath); checkCollapsed(rootPath); return rootPath; }
public GAGenerationTreePanel(GAObjectMonitor monitor, String parentNodeTitle) { super(); selectedChildrenPaths = new Vector(); generationNumber = 1; saveNumber = 0; generations = new DefaultMutableTreeNode(parentNodeTitle); gaMonitor = monitor; setLayout(new BorderLayout()); tree = new JTree(generations); tree.setShowsRootHandles(true); tree.setRootVisible(true); tree.putClientProperty("JTree.lineStyle", "Angled"); // Add Action Listeners MyTreeSelectionListener listener = new MyTreeSelectionListener(monitor.getSelectionInfoPanel()); MyTreeClickListener mlistener = new MyTreeClickListener(); tree.addTreeSelectionListener(listener); tree.addMouseListener(mlistener); // Add Scroll Plane scrollPane = new JScrollPane(tree); add(scrollPane, BorderLayout.CENTER); // Add Menu Bar Functionality createMenuBar(); add(menuBar, BorderLayout.NORTH); }
@Nullable private TreePath getSelectedUniquePath() { JTree tree = getTree(); if (tree == null) return null; TreePath[] paths = tree.getSelectionPaths(); return paths == null || paths.length != 1 ? null : paths[0]; }
public DynamicTree() { super(new GridLayout(1, 0)); rootNode = new JscTreeNode("Vitenfabrikken"); treeModel = new DefaultTreeModel(rootNode); tree = new JTree(treeModel); tree.setEditable(false); tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION); tree.setShowsRootHandles(true); tree.addTreeSelectionListener(this); JPanel content = new JPanel(new BorderLayout(0, 0)); JScrollPane scrollPane = new JScrollPane(tree); scrollPane.setSize(500, 300); scrollPane.setBorder(BorderFactory.createTitledBorder("Maskiner")); content.add(scrollPane); // add(scrollPane); currentSelectionField = new JTextField("Valgt: NONE"); // currentSelectionField.setSize(500, 15); currentSelectionField.setMaximumSize(new Dimension(500, 15)); content.add(currentSelectionField, BorderLayout.SOUTH); // add(currentSelectionField); // content.setPreferredSize(new Dimension(500, 315)); add(content); setSize(500, 315); }
public InputFrame(SipModel sipModel) { super(Which.INPUT, sipModel, "Input"); sipModel.addParseListener( new SipModel.ParseListener() { @Override public void updatedRecord(MetadataRecord metadataRecord) { exec(new RecordSetter(metadataRecord)); } }); recordTree = new JTree(EMPTY_MODEL) { @Override public String getToolTipText(MouseEvent evt) { TreePath treePath = recordTree.getPathForLocation(evt.getX(), evt.getY()); return treePath != null ? ((GroovyTreeNode) treePath.getLastPathComponent()).toolTip : ""; } }; recordTree.setToolTipText("Input Record"); recordTree.setCellRenderer(new Renderer()); recordTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION); recordTree.setTransferHandler(new TreeTransferHandler()); filterField.addActionListener(rewind); }
// {{{ 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(); } } // }}}
@Nullable public static Object getTagAtForRenderer( CheckboxTree.CheckboxTreeCellRenderer renderer, MouseEvent e) { JTree tree = (JTree) e.getSource(); Object tag = null; final TreePath path = tree.getPathForLocation(e.getX(), e.getY()); if (path != null) { final Rectangle rectangle = tree.getPathBounds(path); assert rectangle != null; int dx = e.getX() - rectangle.x; final TreeNode treeNode = (TreeNode) path.getLastPathComponent(); final int row = tree.getRowForLocation(e.getX(), e.getY()); tree.getCellRenderer() .getTreeCellRendererComponent(tree, treeNode, false, false, true, row, true); if (treeNode instanceof RepositoryNode) { RepositoryNode repositoryNode = (RepositoryNode) treeNode; int checkBoxWidth = repositoryNode.isCheckboxVisible() ? renderer.getCheckbox().getWidth() : 0; tag = renderer.getTextRenderer().getFragmentTagAt(dx - checkBoxWidth); } else { tag = renderer.getTextRenderer().getFragmentTagAt(dx); } } return tag; }
private static void drawSelection(JTree tree, Graphics g, final int width) { int y = 0; final int[] rows = tree.getSelectionRows(); final int height = tree.getRowHeight(); for (int row : rows) { final TreeCellRenderer renderer = tree.getCellRenderer(); final Object value = tree.getPathForRow(row).getLastPathComponent(); if (value == null) continue; final Component component = renderer.getTreeCellRendererComponent(tree, value, false, false, false, row, false); if (component.getFont() == null) { component.setFont(tree.getFont()); } g.translate(0, y); component.setBounds(0, 0, width, height); boolean wasOpaque = false; if (component instanceof JComponent) { final JComponent j = (JComponent) component; if (j.isOpaque()) wasOpaque = true; j.setOpaque(false); } component.paint(g); if (wasOpaque) { ((JComponent) component).setOpaque(true); } y += height; g.translate(0, -y); } }
public Component getTreeCellRendererComponent( JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) { Component renderer = delegate.getTreeCellRendererComponent(tree, value, selected, expanded, leaf, row, hasFocus); if (!showRootNodeCheckBox && tree.getModel().getRoot() == value) return renderer; TreePath path = tree.getPathForRow(row); if (path != null) { if (checkBoxCustomer != null && !checkBoxCustomer.showCheckBox(path)) return renderer; if (selectionModel.isPathSelected(path, selectionModel.isDigged())) checkBox.getTristateModel().setState(TristateState.SELECTED); else checkBox .getTristateModel() .setState( selectionModel.isDigged() && selectionModel.isPartiallySelected(path) ? TristateState.INDETERMINATE : TristateState.DESELECTED); } removeAll(); add(checkBox, BorderLayout.WEST); add(renderer, BorderLayout.CENTER); return this; }
private void selectCompanion(CompanionFacade compFacade) { TreeTableModel treeTableModel = companionsTable.getTreeTableModel(); treeTableModel.getRoot(); TreePath path = null; JTree tree = companionsTable.getTree(); String companionType = compFacade.getCompanionType(); for (int i = 0; i < tree.getRowCount(); i++) { TreePath pathForRow = tree.getPathForRow(i); Object lastPathComponent = pathForRow.getLastPathComponent(); if (lastPathComponent.toString().startsWith(companionType)) { tree.expandRow(i); } else if (lastPathComponent instanceof pcgen.gui2.tabs.CompanionInfoTab.CompanionsModel.CompanionNode) { CompanionFacade rowComp = (CompanionFacade) ((pcgen.gui2.tabs.CompanionInfoTab.CompanionsModel.CompanionNode) lastPathComponent) .getValueAt(0); if (rowComp != null && rowComp.getFileRef().getReference() == compFacade.getFileRef().getReference() && rowComp.getNameRef().getReference() == compFacade.getNameRef().getReference() && rowComp.getRaceRef().getReference() == compFacade.getRaceRef().getReference()) { path = pathForRow; } } } if (path != null) { companionsTable.getTree().setSelectionPath(path); companionsTable.getTree().scrollPathToVisible(path); } }
// reorder the nodes private void reorder(Vector nodes) { debug("reorder nodes"); // remove all the children of topNode (they'll be added back later) topNode.removeAllChildren(); // Create an array of the elements for sorting & copy the elements // into the array. DefaultMutableTreeNode[] array = new DefaultMutableTreeNode[nodes.size()]; nodes.copyInto(array); // Sort the array (Quick Sort) quickSort(array, 0, array.length - 1); // Reload the topNode. Everthing is in order now. for (int i = 0; i < array.length; i++) { topNode.add((DefaultMutableTreeNode) array[i]); } // Tell the tree to repaint itself ((DefaultTreeModel) tree.getModel()).reload(); tree.invalidate(); tree.repaint(); }
public static List<TreePath> collectExpandedPaths(final JTree tree, TreePath path) { final ArrayList<TreePath> result = new ArrayList<TreePath>(); if (!tree.isExpanded(path)) return result; final Object lastPathComponent = path.getLastPathComponent(); final TreeModel model = tree.getModel(); if (model.isLeaf(lastPathComponent)) { result.add(path); } else { boolean pathWasAdded = false; for (int i = model.getChildCount(lastPathComponent) - 1; i >= 0; i--) { final TreePath childPath = path.pathByAddingChild(model.getChild(lastPathComponent, i)); if (model.isLeaf(lastPathComponent)) { if (!pathWasAdded) { result.add(path); pathWasAdded = true; } } else if (tree.isExpanded(childPath)) { result.addAll(collectExpandedPaths(tree, childPath)); } else { if (!pathWasAdded) { result.add(path); pathWasAdded = true; } } } } return result; }
/** Construct a FileTree */ public FilePanel(JPanel panel, final IDEWindow ideWindow) { pane = panel; setLayout(new BorderLayout()); // Make a tree list with all the nodes, and make it a JTree JTree tree = new JTree(addNodes(null, new File(System.getProperty("user.dir")))); // Add a listener tree.addTreeSelectionListener( new TreeSelectionListener() { public void valueChanged(TreeSelectionEvent e) { DefaultMutableTreeNode node = (DefaultMutableTreeNode) e.getPath().getLastPathComponent(); File file = null; if (node.isLeaf()) { file = new File(node.getParent() + "/" + node); ToolbarFunctions.open(file, ideWindow); } } }); setSize(panel.getPreferredSize()); // Lastly, put the JTree into a JScrollPane. JScrollPane scrollpane = new JScrollPane(); scrollpane.getViewport().add(tree); add(BorderLayout.CENTER, scrollpane); }
public ReplicatedTreeView(ReplicatedTree tree, Object title) throws Exception { this.tree = tree; tree.addReplicatedTreeListener(this); addNotify(); setTitle("ReplicatedTreeDemo: mbr=" + title); tree_model = new DefaultTreeModel(root); jtree = new JTree(tree_model); jtree.setDoubleBuffered(true); jtree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION); JScrollPane scroll_pane = new JScrollPane(jtree); populateTree(); getContentPane().add(scroll_pane, BorderLayout.CENTER); addWindowListener(this); table_model.setColumnIdentifiers(new String[] {"Name", "Value"}); table_model.addTableModelListener(this); setTableColumnWidths(); tablePanel = new JPanel(); tablePanel.setLayout(new BorderLayout()); tablePanel.add(table.getTableHeader(), BorderLayout.NORTH); tablePanel.add(table, BorderLayout.CENTER); getContentPane().add(tablePanel, BorderLayout.SOUTH); jtree.addTreeSelectionListener(this); // REVISIT MouseListener ml = new MouseAdapter() { public void mouseClicked(MouseEvent e) { int selRow = jtree.getRowForLocation(e.getX(), e.getY()); TreePath selPath = jtree.getPathForLocation(e.getX(), e.getY()); if (selRow != -1) { selected_node = makeFQN(selPath.getPath()); jtree.setSelectionPath(selPath); if (e.getModifiers() == java.awt.event.InputEvent.BUTTON3_MASK) { operationsPopup.show(e.getComponent(), e.getX(), e.getY()); } } } }; jtree.addMouseListener(ml); createMenus(); setLocation(50, 50); setSize( getInsets().left + getInsets().right + 485, getInsets().top + getInsets().bottom + 367); init(); setVisible(true); }
protected Transferable createTransferable(JComponent c) { JTree tree = (JTree) c; TreePath[] paths = tree.getSelectionPaths(); if (paths == null || paths.length != 1) return null; TreePath path = tree.getSelectionPath(); GroovyTreeNode groovyTreeNode = (GroovyTreeNode) path.getLastPathComponent(); return new StringTransferable((String) (groovyTreeNode.node.getNodeValue())); }
/** * Constructor. * * @param tree a JTree */ public CheckTreeManager(JTree tree) { this.tree = tree; selectionModel = new CheckTreeSelectionModel(tree.getModel()); tree.setCellRenderer(new CheckTreeCellRenderer(tree.getCellRenderer(), selectionModel)); tree.addMouseListener(this); tree.addMouseMotionListener(this); selectionModel.addTreeSelectionListener(this); }
public static ActionCallback selectFirstNode(final JTree tree) { final TreeModel model = tree.getModel(); final Object root = model.getRoot(); TreePath selectionPath = new TreePath(root); if (!tree.isRootVisible() && model.getChildCount(root) > 0) selectionPath = selectionPath.pathByAddingChild(model.getChild(root, 0)); return selectPath(tree, selectionPath); }
/** * Handles mouse moved events. * * @param e the mouse event */ public void mouseMoved(MouseEvent e) { TreePath path = tree.getPathForLocation(e.getX(), e.getY()); if (path == null) return; if (e.getX() > tree.getPathBounds(path).x + hotspot - 3 || e.getX() < tree.getPathBounds(path).x + 2) tree.setCursor(Cursor.getDefaultCursor()); else { tree.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR)); } }
public void setSelected(AnActionEvent e, boolean state) { configuration.setShowMembers(state); if (state) { ((TreeItemModel) tree.getModel()).removeFilter(filter); } else { ((TreeItemModel) tree.getModel()).addFilter(filter); } tree.updateUI(); }
public void addSelectionPathTo(final Object element) { DefaultMutableTreeNode node = myAbstractTreeBuilder.getNodeForElement(element); if (node != null) { final JTree tree = getTree(); final TreePath path = new TreePath(node.getPath()); if (node == tree.getModel().getRoot() && !tree.isExpanded(path)) tree.expandPath(path); tree.addSelectionPath(path); } }
public void testCollapse() { myTree.expandPath(myChildAPath); myTree.expandPath(myChild2Path); checkExpanded(myChild2Path); myTree.setSelectionPath(myChild2Path); TreeExpandCollapse.collapse(myTree); checkCollapsed(myChild2Path); checkExpanded(myChildAPath); }
public void testTotalExpandWithSelection() { myTree.expandPath(new TreePath(myRoot)); myTree.collapsePath(myChildAPath); myTree.collapsePath(myChildBPath); myTree.setSelectionPath(myChildAPath); TreeExpandCollapse.expandAll(myTree); checkExpanded(myChildAPath); checkCollapsed(myChildBPath); }
Main() { FuncClass RootClass = new FuncClass(System.getProperty("user.dir") + "\\root", "Mathematica Input Assistant"); JTree tree = new JTree(RootClass.getTreeNode()); final DefaultTreeModel treeModel = (DefaultTreeModel) tree.getModel(); new MainFrame(tree, RootClass, "Mathematica Input Assistant"); }
@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); }
/** * Set the currently selected Variable. * * @param v select this Variable, must be already in the tree. */ public void setSelected(VariableIF v) { if (v == null) return; // construct chain of variables List<VariableIF> vchain = new ArrayList<>(); vchain.add(v); VariableIF vp = v; while (vp.isMemberOfStructure()) { vp = vp.getParentStructure(); vchain.add(0, vp); // reverse } // construct chain of groups List<Group> gchain = new ArrayList<>(); Group gp = vp.getParentGroup(); gchain.add(gp); while (gp.getParentGroup() != null) { gp = gp.getParentGroup(); gchain.add(0, gp); // reverse } List<Object> pathList = new ArrayList<>(); // start at root, work down through the nested groups, if any GroupNode gnode = (GroupNode) model.getRoot(); pathList.add(gnode); Group parentGroup = gchain.get(0); // always the root group for (int i = 1; i < gchain.size(); i++) { parentGroup = gchain.get(i); gnode = gnode.findNestedGroup(parentGroup); assert gnode != null; pathList.add(gnode); } vp = vchain.get(0); VariableNode vnode = gnode.findNestedVariable(vp); if (vnode == null) return; // not found pathList.add(vnode); // now work down through the structure members, if any for (int i = 1; i < vchain.size(); i++) { vp = vchain.get(i); vnode = vnode.findNestedVariable(vp); if (vnode == null) return; // not found pathList.add(vnode); } // convert to TreePath, and select it Object[] paths = pathList.toArray(); TreePath treePath = new TreePath(paths); tree.setSelectionPath(treePath); tree.scrollPathToVisible(treePath); }
public void testInfiniteExpand() { InfiniteTreeModel model = new InfiniteTreeModel(); myTree = new JTree(model); TreePath rootPath = new TreePath(model.getRoot()); myTree.setSelectionPath(rootPath); myTree.collapsePath(rootPath); TreeExpandCollapse.expandAll(myTree); checkExpanded(rootPath); TreeExpandCollapse.expandAll(myTree); }
@Override public Font getFont() { Font font = super.getFont(); // Cell renderers could have no parent and no explicit set font. // Take tree font in this case. if (font != null) return font; JTree tree = getTree(); return tree != null ? tree.getFont() : null; }
public static ActionCallback selectPath(final JTree tree, final TreePath path, boolean center) { tree.makeVisible(path); if (center) { return showRowCentred(tree, tree.getRowForPath(path)); } else { final int row = tree.getRowForPath(path); return showAndSelect( tree, row - ListScrollingUtil.ROW_PADDING, row + ListScrollingUtil.ROW_PADDING, row, -1); } }
public void actionPerformed(ActionEvent event) { JTree tree = getTree(); TreePath path = tree.getSelectionPath(); if (path == null) { sheet.getLogger().warning("Warning: User must select a node to attach a new config to"); // XXX add a message telling users to select a node } else { createAttrConfigForNode((Node) path.getLastPathComponent()); } }
private static void expandTree(final JTree tree) { int oldRowCount = 0; do { int rowCount = tree.getRowCount(); if (rowCount == oldRowCount) break; oldRowCount = rowCount; for (int i = 0; i < rowCount; i++) { tree.expandRow(i); } } while (true); }