void deleteNodeParent(DefaultMutableTreeNode parent) throws Exception { while (parent.getChildCount() != 0) { DefaultMutableTreeNode node = (DefaultMutableTreeNode) parent.getFirstChild(); deleteNodeParent(node); } deleteNode(parent); }
public DefaultMutableTreeNode findNode(DefaultMutableTreeNode parent, String match) { if (parent == null) return null; // Commented by Balan on 15/03/03 // String treename = (String)parent.getUserObject (); // Comment Ends // Added by Balan on 15/03/03 String treename = "" + ((Hashtable) parent.getUserObject()).get("TREE-NAME"); // Add Ends if (treename != null) { if (treename.equals(match)) return parent; } if (frame.model.isLeaf(parent)) return null; Enumeration en = parent.children(); if ((en == null) || (!en.hasMoreElements())) return null; for (; en.hasMoreElements(); ) { DefaultMutableTreeNode child = (DefaultMutableTreeNode) en.nextElement(); DefaultMutableTreeNode returnNode = findNode(child, match); if (returnNode != null) return returnNode; } return null; }
@Override public void actionPerformed(ActionEvent evt) { JCheckBoxMenuItem menuItem = (JCheckBoxMenuItem) evt.getSource(); boolean curState = menuItem.isSelected(); TreePath path = resultTree.getSelectionPath(); DefaultMutableTreeNode operNode = (DefaultMutableTreeNode) path.getLastPathComponent(); HyperSearchOperationNode operNodeObj = (HyperSearchOperationNode) operNode.getUserObject(); if (curState) operNodeObj.cacheResultNodes(operNode); operNode.removeAllChildren(); if (curState) { Exception excp = null; try { operNodeObj.insertTreeNodes(resultTree, operNode); } catch (Exception ex) { operNodeObj.restoreFlatNodes(resultTree, operNode); menuItem.setSelected(false); excp = ex; } finally { ((DefaultTreeModel) resultTree.getModel()).nodeStructureChanged(operNode); expandAllNodes(operNode); resultTree.scrollPathToVisible(new TreePath(operNode.getPath())); } if (excp != null) throw new RuntimeException(excp); } else operNodeObj.restoreFlatNodes(resultTree, operNode); operNodeObj.setTreeViewDisplayed(menuItem.isSelected()); }
@Override public String convertValueToText( Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) { String s = super.convertValueToText(value, selected, expanded, leaf, row, hasFocus); String newProp = jEdit.getProperty(HIGHLIGHT_PROP); if (newProp == null || newProp.isEmpty()) return s; DefaultMutableTreeNode node = (DefaultMutableTreeNode) value; while (node != null && !(node.getUserObject() instanceof HyperSearchOperationNode)) { node = (DefaultMutableTreeNode) node.getParent(); } if (node == null) return s; if (!newProp.equals(prop)) { prop = newProp; Font f = (resultTree != null) ? resultTree.getFont() : UIManager.getFont("Tree.font"); styleTag = HtmlUtilities.style2html(prop, f); } SearchMatcher matcher = ((HyperSearchOperationNode) node.getUserObject()).getSearchMatcher(); int i = s.indexOf(": "); if (i > 0) i += 2; else i = 0; Match m; List<Integer> matches = new ArrayList<Integer>(); while ((m = matcher.nextMatch(s.substring(i), true, true, true, false)) != null) { matches.add(i + m.start); matches.add(i + m.end); i += m.end; } return HtmlUtilities.highlightString(s, styleTag, matches); }
void onEdit() { DefaultTreeModel model = (DefaultTreeModel) m_tree.getModel(); TreePath path = m_tree.getSelectionPath(); DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent(); DefaultMutableTreeNode parent = (DefaultMutableTreeNode) node.getParent(); Organization org = (Organization) node.getUserObject(); OrganizationEditorDlg dlg = null; if (parent == model.getRoot()) dlg = new OrganizationEditorDlg( pohaci.gumunda.cgui.GumundaMainFrame.getMainFrame(), m_conn, m_sessionid, null, org); else dlg = new OrganizationEditorDlg( pohaci.gumunda.cgui.GumundaMainFrame.getMainFrame(), m_conn, m_sessionid, (DefaultMutableTreeNode) node.getParent(), org); dlg.setVisible(true); if (dlg.getResponse() == JOptionPane.OK_OPTION) { node.setUserObject(dlg.getOrganization()); model.nodeChanged(node); } }
public boolean restoreSelection(TreeSelection treeSelection) { if (treeSelection.isEmpty()) return false; DefaultMutableTreeNode root = (DefaultMutableTreeNode) myTreeModel.getRoot(); for (int i = 0; i < root.getChildCount(); i++) { TreeNode node = root.getChildAt(i); if (node instanceof MessageNode) { MessageNode messageNode = (MessageNode) node; String[] text = messageNode.getText(); if (text.length == 0) continue; if (Comparing.equal(treeSelection.mySelectedTarget, text[0])) { TreePath pathToSelect = new TreePath(messageNode.getPath()); for (Enumeration enumeration = messageNode.children(); enumeration.hasMoreElements(); ) { Object o = enumeration.nextElement(); if (o instanceof MessageNode) { messageNode = (MessageNode) o; if (Comparing.equal(treeSelection.mySelectedTask, text[0])) { pathToSelect = new TreePath(messageNode.getPath()); break; } } } TreeUtil.selectPath(myTree, pathToSelect); myTree.expandPath(pathToSelect); return true; } } } return false; }
private static void replaceChildren( final DefaultMutableTreeNode node, final Collection<? extends ElementNode> arrayList) { node.removeAllChildren(); for (ElementNode child : arrayList) { node.add(child); } }
public MsnTreeTest() { String[] tab = {"hello", "test", "blabla"}; container = getContentPane(); container.setLayout(null); eleve = new DefaultMutableTreeNode("MSN"); worker = new DefaultMutableTreeNode("Worker"); prof = new DefaultMutableTreeNode("Profs"); for (int i = 0; i < tab.length; i++) { worker.add(new DefaultMutableTreeNode(tab[i])); prof.add(new DefaultMutableTreeNode(tab[i])); } // worker.add(new DefaultMutableTreeNode("hello world2")); eleve.add(worker); eleve.add(prof); tree = new JTree(eleve); scroll = new JScrollPane(tree); scroll.setBounds(10, 10, 100, 100); container.add(scroll); setSize(300, 300); setLocation(200, 200); setDefaultCloseOperation(EXIT_ON_CLOSE); setVisible(true); // worker.add(n); }
private static boolean isToolbarAction(DefaultMutableTreeNode node) { return node.getParent() != null && ((DefaultMutableTreeNode) node.getParent()).getUserObject() instanceof Group && ((Group) ((DefaultMutableTreeNode) node.getParent()).getUserObject()) .getName() .equals(ActionsTreeUtil.MAIN_TOOLBAR); }
// =============================================================== // =============================================================== public Component getTreeCellRendererComponent( JTree tree, Object obj, boolean sel, boolean expanded, boolean leaf, int row, boolean hasFocus) { super.getTreeCellRendererComponent(tree, obj, sel, expanded, leaf, row, hasFocus); setBackgroundNonSelectionColor(background); setForeground(Color.black); setBackgroundSelectionColor(Color.lightGray); if (row == 0) { // ROOT setFont(fonts[TITLE]); setIcon(tango_icon); } else { DefaultMutableTreeNode node = (DefaultMutableTreeNode) obj; if (node.getUserObject() instanceof PollThread) { setFont(fonts[THREAD]); setIcon(class_icon); } else { setFont(fonts[DEVICE]); setIcon(cmd_icon); } } return this; }
/** * Recursively rebuild the tree nodes. * * @param root The full abstract path to the root saved layout directory. * @param local The current directory relative to root (null if none). * @param tnode The current parent tree node. */ private void rebuildTreeModel(Path root, Path local, DefaultMutableTreeNode tnode) { TreeSet<Path> subdirs = new TreeSet<Path>(); TreeSet<String> layouts = new TreeSet<String>(); { Path current = new Path(root, local); File files[] = current.toFile().listFiles(); if (files != null) { int wk; for (wk = 0; wk < files.length; wk++) { String name = files[wk].getName(); if (files[wk].isDirectory()) subdirs.add(new Path(local, name)); else if (files[wk].isFile()) layouts.add(name); } } } for (Path subdir : subdirs) { TreeData data = new TreeData(subdir); DefaultMutableTreeNode child = new DefaultMutableTreeNode(data, true); tnode.add(child); rebuildTreeModel(root, subdir, child); } for (String lname : layouts) { TreeData data = new TreeData(new Path(local, lname), lname); DefaultMutableTreeNode child = new DefaultMutableTreeNode(data, false); tnode.add(child); } }
@Nullable private static String getActionId(DefaultMutableTreeNode node) { return (String) (node.getUserObject() instanceof String ? node.getUserObject() : node.getUserObject() instanceof Pair ? ((Pair) node.getUserObject()).first : null); }
private void collapseTargets() { DefaultMutableTreeNode root = (DefaultMutableTreeNode) myTreeModel.getRoot(); for (int i = 0; i < root.getChildCount(); i++) { DefaultMutableTreeNode node = (DefaultMutableTreeNode) root.getChildAt(i); myTree.collapsePath(new TreePath(node.getPath())); } }
private void goToSelectedNode(int mode) { TreePath path = resultTree.getSelectionPath(); if (path == null) return; DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent(); Object value = node.getUserObject(); // do nothing if clicked "foo (showing n occurrences in m files)" if (node.getParent() != resultTreeRoot && value instanceof HyperSearchNode) { HyperSearchNode n = (HyperSearchNode) value; Buffer buffer = n.getBuffer(view); if (buffer == null) return; EditPane pane; switch (mode) { case M_OPEN: pane = view.goToBuffer(buffer); break; case M_OPEN_NEW_VIEW: pane = jEdit.newView(view, buffer, false).getEditPane(); break; case M_OPEN_NEW_PLAIN_VIEW: pane = jEdit.newView(view, buffer, true).getEditPane(); break; case M_OPEN_NEW_SPLIT: pane = view.splitHorizontally(); break; default: throw new IllegalArgumentException("Bad mode: " + mode); } n.goTo(pane); } } // }}}
private void doSave() { ObjectOutputStream objectStream = getObjectOutputStream(); if (objectStream != null) { try { System.out.println("Saving " + selectedChildrenPaths.size() + " Selected Generations..."); for (int i = 0; i < selectedChildrenPaths.size(); i++) { // Get the userObject at the supplied path Object selectedPath = ((TreePath) selectedChildrenPaths.elementAt(i)).getLastPathComponent(); DefaultMutableTreeNode selectedNode = (DefaultMutableTreeNode) selectedPath; objectStream.writeObject(selectedNode.getUserObject()); } objectStream.close(); System.out.println("Save completed successfully."); } catch (IOException e) { System.err.println(e); } } else { System.out.println("Save Selected Files has been aborted!"); } }
/** * Called when the selection changed in the tree. Loads the selected certificate. * * @param e the event */ private void valueChangedPerformed(TreeSelectionEvent e) { Object o = e.getNewLeadSelectionPath().getLastPathComponent(); if (o instanceof DefaultMutableTreeNode) { DefaultMutableTreeNode node = (DefaultMutableTreeNode) o; infoTextPane.setText(toString(node.getUserObject())); } }
private int compare(DefaultMutableTreeNode node1, DefaultMutableTreeNode node2) { SearchTOCItem item1, item2; double confidence1, confidence2; int hits1, hits2; item1 = (SearchTOCItem) node1.getUserObject(); confidence1 = item1.getConfidence(); hits1 = item1.hitCount(); item2 = (SearchTOCItem) node2.getUserObject(); confidence2 = item2.getConfidence(); hits2 = item2.hitCount(); // confidence is a penality. The lower the better if (confidence1 > confidence2) { // node1 is less than node2 return -1; } else if (confidence1 < confidence2) { // node1 is greater than node2 return 1; } else { // confidences are the same check the hits if (hits1 < hits2) { // node1 is less than node2 return -1; } else if (hits1 > hits2) { // node2 is greater than node2 return 1; } } // nodes1 and nodes2 are equivalent return 0; }
// 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(); }
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}); }
private ArrayList<TreeNode> childrenToArray(DefaultMutableTreeNode node) { ArrayList<TreeNode> arrayList = new ArrayList<TreeNode>(); for (int i = 0; i < node.getChildCount(); i++) { arrayList.add(node.getChildAt(i)); } return arrayList; }
/** * Adds nodes to the specified parent node recurrsively. * * @param parent_node the parent node. * @param list the list of child node names. */ protected void addNode(DefaultMutableTreeNode parent_node, Vector list) { SortableArray array = null; if (mode == DATE_ORIENTED && parent_node.getLevel() <= 2) { array = new Array(list.size()); for (int i = 0; i < list.size(); i++) ((Array) array).set(i, Integer.parseInt((String) list.elementAt(i))); } else { array = new StringArray(list.size()); for (int i = 0; i < list.size(); i++) ((StringArray) array).set(i, (String) list.elementAt(i)); } ArrayIndex index = array.sortAscendant(); for (int i = 0; i < array.getArraySize(); i++) { String name = (String) list.elementAt(index.get(i)); // Converts 1...12 to January...December. if (mode == DATE_ORIENTED && parent_node.getLevel() == 1) { int month = Integer.parseInt(name); name = JulianDay.getFullSpellMonthString(month); } DefaultMutableTreeNode node = new DefaultMutableTreeNode(name); parent_node.add(node); } }
// =============================================================== // =============================================================== private int getNextThreadNum() { int num = 0; for (int i = 0; i < root.getChildCount(); i++) { DefaultMutableTreeNode th_node = (DefaultMutableTreeNode) root.getChildAt(i); num = ((PollThread) th_node.getUserObject()).num; } return ++num; }
@Nullable public static TreeNode findNodeWithObject( final Object object, final TreeModel model, final Object parent) { for (int i = 0; i < model.getChildCount(parent); i++) { final DefaultMutableTreeNode childNode = (DefaultMutableTreeNode) model.getChild(parent, i); if (childNode.getUserObject().equals(object)) return childNode; } return null; }
// =============================================================== // =============================================================== private void createThreadsNodes() { for (int i = 0; i < threadsInfo.size(); i++) { PollThread thread = threadsInfo.threadAt(i); // Build node for class with all commansdds as leaf DefaultMutableTreeNode node = new DefaultMutableTreeNode(thread); root.add(node); for (Object obj : thread) node.add(new DefaultMutableTreeNode(obj)); } }
/** A value has changed. This is used as a TreeSelectionListener. */ public void valueChanged(TreeSelectionEvent e) { JHelpNavigator navigator = getHelpNavigator(); HelpModel helpmodel = navigator.getModel(); debug("ValueChanged: " + e); debug(" model: " + helpmodel); // send selected items into navigator TreeItem[] items = null; TreePath[] paths = tree.getSelectionPaths(); if (paths != null) { items = new TreeItem[paths.length]; for (int i = 0; i < paths.length; i++) { if (paths[i] != null) { DefaultMutableTreeNode node = (DefaultMutableTreeNode) paths[i].getLastPathComponent(); items[i] = (TreeItem) node.getUserObject(); } } } navigator.setSelectedItems(items); // change current id only if one items is selected if (items != null && items.length == 1) { SearchTOCItem item = (SearchTOCItem) items[0]; if (item != null) { if (item.getID() != null) { try { // navigator.setCurrentID(item.getID()); helpmodel.setCurrentID(item.getID(), item.getName(), navigator); } catch (InvalidHelpSetContextException ex) { System.err.println("BadID: " + item.getID()); return; } } else if (item.getURL() != null) { // navigator.setCurrentURL(item.getURL()); helpmodel.setCurrentURL(item.getURL(), item.getName(), navigator); } else { // no ID, no URL return; } if (helpmodel instanceof TextHelpModel) { DefaultHighlight h[] = new DefaultHighlight[item.hitCount()]; int i = 0; Enumeration enum1 = item.getSearchHits(); while (enum1.hasMoreElements()) { SearchHit info = (SearchHit) enum1.nextElement(); h[i] = new DefaultHighlight(info.getBegin(), info.getEnd()); i++; } // using setHighlights() instead of removeAll + add // avoids one highlighting event ((TextHelpModel) helpmodel).setHighlights(h); } } } }
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); } }
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); } }
private MutableTreeNode populatePlot(Plot p) throws SQLException { DefaultMutableTreeNode tree = new DefaultMutableTreeNode(p); // tree.add(populateAttributes(p)); Statement stmt = db.statement(); for (Tree t : p.loadTrees(stmt)) { tree.add(populateTree(t)); } stmt.close(); return tree; }
private MutableTreeNode populateNest(Nest n) throws SQLException { DefaultMutableTreeNode tree = new DefaultMutableTreeNode(n); // tree.add(populateAttributes(n)); Statement stmt = db.statement(); for (Visit v : n.loadVisits(stmt)) { tree.add(populateVisit(v)); } stmt.close(); return tree; }
private MutableTreeNode populateCavity(Cavity c) throws SQLException { DefaultMutableTreeNode tree = new DefaultMutableTreeNode(c); // tree.add(populateAttributes(c)); Statement stmt = db.statement(); for (Nest n : c.loadNests(stmt)) { tree.add(populateNest(n)); } stmt.close(); return tree; }