public static TreeNode getRoot() { DefaultMutableTreeNode node = new DefaultMutableTreeNode("root"); DefaultMutableTreeNode first = new DefaultMutableTreeNode("first"); DefaultMutableTreeNode second = new DefaultMutableTreeNode("second"); DefaultMutableTreeNode third = new DefaultMutableTreeNode("third"); first.add(new DefaultMutableTreeNode("1.1")); first.add(new DefaultMutableTreeNode("1.2")); first.add(new DefaultMutableTreeNode("1.3")); second.add(new DefaultMutableTreeNode("2.1")); second.add(new DefaultMutableTreeNode("2.2")); second.add(new DefaultMutableTreeNode("2.3")); third.add(new DefaultMutableTreeNode("3.1")); third.add(new DefaultMutableTreeNode("3.2")); third.add(new DefaultMutableTreeNode("3.3")); node.add(first); node.add(second); node.add(third); return node; }
@Override public void run() { Thread.currentThread().setUncaughtExceptionHandler(this); DefaultMutableTreeNode root = new DefaultMutableTreeNode(); DefaultMutableTreeNode child = new DefaultMutableTreeNode("Child"); DefaultTreeModel model = new DefaultTreeModel(root); this.tree = new JTree(); this.tree.setModel(model); JFrame frame = new JFrame(getClass().getSimpleName()); frame.add(this.tree); model.addTreeModelListener(this); // frame is not visible yet model.insertNodeInto(child, root, root.getChildCount()); model.removeNodeFromParent(child); frame.setSize(640, 480); frame.setLocationRelativeTo(null); frame.setDefaultCloseOperation(DISPOSE_ON_CLOSE); frame.setVisible(true); }
/** * @param root */ public PlotConfigurationTreeModel(DefaultMutableTreeNode root, PlotConfiguration plotConfig, PlotConfigurationTree plotConfigTree) { super(root); this.plotConfig = plotConfig; this.plotConfigTree = plotConfigTree; if (root != null) { fillNewPlotConfigNode(plotConfig); } if (plotConfig != null) { plotConfig.addPlotConfigurationListener(this); } }
private DefaultMutableTreeNode createRamoptionNode(Ramoption ramoption) { DefaultMutableTreeNode dmtNode = new DefaultMutableTreeNode("ramoption"); String value = ramoption.getValue(); if (value != null && !value.isEmpty()) { dmtNode.add(new DefaultMutableTreeNode("value" + valueDivider + value)); } String aDefault = ramoption.getDefault(); if (aDefault != null && !aDefault.isEmpty()) { dmtNode.add(new DefaultMutableTreeNode("default" + valueDivider + aDefault)); } return dmtNode; }
@Override public Component getTreeCellRendererComponent(JTree tree, Object value, boolean sel, boolean expanded, boolean leaf, int row, boolean hasFocus) { super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row, hasFocus); DefaultMutableTreeNode node = (DefaultMutableTreeNode) value; if (node.getChildCount() > 0) { setIcon(this.pack); } else if (getFileName(node).endsWith(".class") || getFileName(node).endsWith(".java")) { setIcon(this.java_image); } else if (getFileName(node).endsWith(".yml") || getFileName(node).endsWith(".yaml")) { setIcon(this.yml_image); } else { setIcon(this.file_image); } return this; }
/** * {@inheritDoc} */ @Override public void addSubTrees(DefaultMutableTreeNode root) { DefaultMutableTreeNode parent = new DefaultMutableTreeNode(new ColopediaTreeItem(this, getId(), getName(), null)); List<NationType> nations = new ArrayList<>(); nations.addAll(getSpecification().getEuropeanNationTypes()); nations.addAll(getSpecification().getREFNationTypes()); nations.addAll(getSpecification().getIndianNationTypes()); ImageIcon icon = new ImageIcon(ImageLibrary.getMiscImage(ImageLibrary.BELLS, ImageLibrary.ICON_SIZE)); for (NationType type : nations) { parent.add(buildItem(type, icon)); } root.add(parent); }
private void retrieveDeletedFiles(final Node[] activatedNodes, final RevertPanel p) { VCSContext ctx = VCSContext.forNodes(activatedNodes); Set<VCSFileProxy> rootSet = ctx.getRootFiles(); if(rootSet == null || rootSet.size() < 1) { return; } DefaultMutableTreeNode rootNode = new DefaultMutableTreeNode(); for (VCSFileProxy root : rootSet) { PlainFileNode rfn = new PlainFileNode(root); populateNode(rfn, root, !VersioningSupport.isFlat(root)); if(rfn.getChildCount() > 0) { rootNode.add(rfn); } } if(rootNode.getChildCount() > 0) { p.setRootNode(rootNode); } else { p.setRootNode(null); } }
/** * Shows the a dialog allowing the user to edit the ray. */ private void editRayAction() { // getProperty the currently selected body TreePath path = this.tree.getSelectionPath(); // make sure something is selected if (path != null) { // getProperty the selected node DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent(); // make sure its a ray that is selected if (node.getUserObject() instanceof SandboxRay) { // getProperty the ray from the node SandboxRay ray = (SandboxRay) node.getUserObject(); // show the right dialog synchronized (Simulation.LOCK) { SandboxRay nRay = EditRayDialog.show(ControlUtilities.getParentWindow(this), ray); this.simulation.getRays().remove(ray); this.simulation.getRays().add(nRay); node.setUserObject(nRay); } } } }
/** * Returns the index of a child of a given node, provided its string value. * * @param node The node to search its children. * @param childValue The value of the child to compare with. * @return The index. */ private int childIndex(final DefaultMutableTreeNode node, final String childValue) { @SuppressWarnings("unchecked") Enumeration<DefaultMutableTreeNode> children = node.children(); DefaultMutableTreeNode child = null; int index = -1; while (children.hasMoreElements() && index < 0) { child = children.nextElement(); if (child.getUserObject() != null && childValue.equals(child.getUserObject())) { index = node.getIndex(child); } } return index; }
/** * This function analyses a tree selection event and calls the * right methods to take care of building the requested unit's * details. * * @param event The incoming TreeSelectionEvent. */ @Override public void valueChanged(TreeSelectionEvent event) { detailPanel.removeAll(); DefaultMutableTreeNode node = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent(); if (node != null) { if (node.isLeaf()) { OptionGroup group = (OptionGroup) node.getUserObject(); for (Option option : group.getOptions()) { addOptionUI(option, editable && group.isEditable()); } } else { tree.expandPath(event.getPath()); } } detailPanel.revalidate(); detailPanel.repaint(); }
/** * @param e */ protected void itemSelected(MouseEvent e) { if (e.getClickCount() == 2) { DefaultMutableTreeNode node = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent(); if (node != null) { if (node.isLeaf()) if (node.getParent() != null) { if (node.getParent().toString().equals("graphs")) { for (int i=0 ; i<observers.size() ; i++) (observers.get(i)).graphSelected(node.toString()); } else if (node.getParent().toString().equals("animations")) { for (int i=0 ; i<observers.size() ; i++) (observers.get(i)).animationSelected(node.toString()); } else if (node.getParent().toString().equals("algorithms")) { for (int i=0 ; i<observers.size() ; i++) (observers.get(i)).algorithmSelected(node.toString()); } } } } }
@Override public void actionPerformed(ActionEvent e) { Runnable runner = new Runnable() { @Override public void run() { TreePath[] paths = resourcesTree.getSelectionPaths(); for(TreePath path : paths) { final Object userObject = ((DefaultMutableTreeNode) path.getLastPathComponent()).getUserObject(); if(userObject instanceof NameBearerHandle) { SwingUtilities.invokeLater(new Runnable() { @Override public void run() { ((NameBearerHandle)userObject).getCloseAction() .actionPerformed(null); }}); } } } }; Thread thread = new Thread(runner, "CloseSelectedResourcesAction"); thread.setPriority(Thread.MIN_PRIORITY); thread.start(); }
/** * Provides the Vector of all currently available nodes of the same kind as the current node. * * @param currNode The current node of the object structure * @return the multiple nodes available */ private Vector<DefaultMutableTreeNode> getMultipleNodesAvailable(DefaultMutableTreeNode currNode) { // --- The result vector of all needed nodes ------------------------------------ Vector<DefaultMutableTreeNode> nodesFound = new Vector<DefaultMutableTreeNode>(); // --- Can we find the number of similar nodes to the current one? -------------- DynType currDT = (DynType) currNode.getUserObject(); // --- The current parentNode and the position of the current node -------------- DefaultMutableTreeNode parentNode = (DefaultMutableTreeNode) currNode.getParent(); // --- Search for all similar nodes --------------------------------------------- for (int i = 0; i < parentNode.getChildCount(); i++) { DefaultMutableTreeNode checkNode = (DefaultMutableTreeNode) parentNode.getChildAt(i); DynType checkDT = (DynType) checkNode.getUserObject(); if (checkDT.equals(currDT)) { nodesFound.add(checkNode); } } return nodesFound; }
/** Construct a FileTree */ public FileTree(File dir) { setLayout(new BorderLayout()); applyComponentOrientation(ComponentOrientation.RIGHT_TO_LEFT); setBorder(null); // Make a tree list with all the nodes, and make it a JTree JTree tree = new JTree(addNodes(null, dir)); tree.applyComponentOrientation(ComponentOrientation.RIGHT_TO_LEFT); // Add a listener tree.addTreeSelectionListener(new TreeSelectionListener() { public void valueChanged(TreeSelectionEvent e) { DefaultMutableTreeNode node = (DefaultMutableTreeNode) e .getPath().getLastPathComponent(); } }); add(BorderLayout.CENTER, tree); JScrollPane scrollBarExplorer = new JScrollPane(); scrollBarExplorer.getViewport().add(tree); scrollBarExplorer.setBorder(null); add(scrollBarExplorer, BorderLayout.CENTER); }
private TreeNode createReferenceModel(Set<DependencyNode> nds, CheckNode trans) { DefaultMutableTreeNode root = new DefaultMutableTreeNode(null, true); ChangeListener list = new Listener(); List<CheckNode> s = new ArrayList<CheckNode>(); Icon icn = ImageUtilities.image2Icon(ImageUtilities.loadImage(IconResources.DEPENDENCY_ICON, true)); //NOI18N change2Trans.put(list, trans); change2Refs.put(list, s); for (DependencyNode nd : nds) { String label = nd.getArtifact().getGroupId() + ":" + nd.getArtifact().getArtifactId(); CheckNode child = new CheckNode(nd, label, icn); child.setSelected(isSingle); child.addChangeListener(list); s.add(child); root.add(child); } return root; }
/** * Shows an add new joint dialog using the given joint panel. * <p> * If the user closes or cancels, nothing is modified. If the user clicks the add button * a new joint is created and added to the world. * * @param clazz the joint class */ private void addJointAction(Class<? extends Joint> clazz) { synchronized (Simulation.LOCK) { SandboxBody[] bodies = this.getBodies(); // check the joint class type if (bodies == null || bodies.length == 0 || (clazz != PinJoint.class && bodies.length == 1)) { JOptionPane.showMessageDialog(ControlUtilities.getParentWindow(this), Messages.getString("menu.resources.joint.add.warning"), Messages.getString("menu.resources.joint.add.warning.title"), JOptionPane.ERROR_MESSAGE); return; } Joint joint = AddJointDialog.show(ControlUtilities.getParentWindow(this), bodies, clazz); if (joint != null) { // add the joint to the world this.simulation.getWorld().addJoint(joint); // add the joint to the root node DefaultMutableTreeNode jointNode = new DefaultMutableTreeNode(joint); // insert into the tree this.model.insertNodeInto(jointNode, this.jointFolder, this.jointFolder.getChildCount()); // expand the path to the new node this.tree.expandPath(new TreePath(jointNode.getPath()).getParentPath()); } } }
/** * Recursively adds new nodes to the tree. */ protected void addNode(DefaultMutableTreeNode parent, Component component, Component selectedComponent) { DefaultMutableTreeNode componentNode = new DefaultMutableTreeNode(new ComponentWrapper(component)); parent.add(componentNode); if (component == selectedComponent) { TreePath selectedPath = new TreePath(componentNode.getPath()); componentTree.setSelectionPath(selectedPath); componentTree.scrollPathToVisible(selectedPath); } if (component instanceof Container) { Container container = (Container) component; Component[] childComponents = container.getComponents(); for (Component child : childComponents) { addNode(componentNode, child, selectedComponent); } } }
/** * Applies a force to the given body if the user accepts the input. */ private void applyForceAction() { // the current selection should have the body selected TreePath path = this.tree.getSelectionPath(); // make sure that something is selected if (path != null) { // getProperty the currently selected node DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent(); // make sure the selected node is a body if (node.getUserObject() instanceof SandboxBody) { // getProperty the body from the node SandboxBody body = (SandboxBody) node.getUserObject(); // show the force input dialog Vector2 f = ApplyForceDialog.show(ControlUtilities.getParentWindow(this)); // make sure the user accepted the input if (f != null) { synchronized (Simulation.LOCK) { body.applyForce(f); } } } } }
private void handleClick(MouseEvent e) { if (e.isPopupTrigger()) { Point p = e.getPoint(); TreePath path = errorTree.getPathForLocation(e.getPoint().x, e.getPoint().y); if (path != null) { DefaultMutableTreeNode o = (DefaultMutableTreeNode) path.getLastPathComponent(); if (o.getUserObject() instanceof HintMetadata) { HintMetadata hint = (HintMetadata) o.getUserObject(); if (hint.category.equals(Utilities.CUSTOM_CATEGORY)) { JPopupMenu popup = new JPopupMenu(); popup.add(new JMenuItem(new RenameHint(o, hint, path))); popup.add(new JMenuItem(new RemoveHint(o, hint))); popup.show(errorTree, e.getX(), e.getY()); } } } } }
/** * Called when the user clicks the Center On Origin menu item on a body. */ private void centerOnOriginAction() { // the current selection should have the body selected TreePath path = this.tree.getSelectionPath(); // make sure that something is selected if (path != null) { // getProperty the currently selected node DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent(); // make sure the selected node is a body if (node.getUserObject() instanceof SandboxBody) { // getProperty the body from the node SandboxBody body = (SandboxBody) node.getUserObject(); synchronized (Simulation.LOCK) { // re-center the body body.translateToOrigin(); } } } }
/** * Overridden DefaultTreeCellRenderer method to change the type of drawing. * @param tree the main tree object * @param value the value we want to display * @param isSel if this tree node is selected * @param isExp if this tree node is expanded * @param isLeaf if this is a leaf node * @param index the index of this node in the tree node array * @param cHasFocus if the focus is on this node */ @Override public Component getTreeCellRendererComponent(JTree tree, Object value, boolean isSel, boolean isExp, boolean isLeaf, int index, boolean cHasFocus) { super.getTreeCellRendererComponent(tree, value, isSel, isExp, isLeaf, index, cHasFocus); Object o = ((DefaultMutableTreeNode)value).getUserObject(); if (o instanceof Entrant) { Entrant e = (Entrant)o; String display = e.getNumber() + " - " + e.getName() + " - " + e.getCarModel() + " " + Database.d.getEffectiveIndexStr(e.getCar()); setText(display); } return this; }
/** * This method will create the configuration tab tree * * @param dataStore * - the RLCDataStore that was used to collect all the data for * the RLCs processed * @param configurationDataStore * - the ConfigurationDataStore that was used to collect all the * data for the RLCs processed * @return JScrollPane */ public JScrollPane createConfigurationResultsTree(final RLCDataStore dataStore, final ConfigurationDataStore configurationDataStore) { final DefaultMutableTreeNode top = new DefaultMutableTreeNode("root"); final ConfigurationAnalyser configurationAnalyser = new ConfigurationAnalyser(configurationDataStore); // Populate with config tab results final DefaultMutableTreeNode commPointAnalysis = new DefaultMutableTreeNode("Communication Points"); for (final String type : configurationAnalyser.getAllCommunicationPointTypes()) { final List<ModifiedPropertyCountData> properties = configurationAnalyser .getModifiedCommunicationPointPropertyCounts(type, -1); addResultTreeNode(commPointAnalysis, "" + type + " configuration", properties); } top.add(commPointAnalysis); return new JScrollPane(manipulateJTree(top)); }
/** * Builds the JTree which represents the navigation menu and then * returns it * * @param group The {@code OptionGroup} to build from. * @param parent The tree to build onto. */ private void buildTree(OptionGroup group, DefaultMutableTreeNode parent) { for (Option option : group.getOptions()) { if (option instanceof OptionGroup) { if (!((OptionGroup)option).isVisible()) continue; DefaultMutableTreeNode branch = new DefaultMutableTreeNode(option); parent.add(branch); buildTree((OptionGroup) option, branch); } } }
/** * This method is used to add nodes to a tree * * @param node * - the node to be added to * @param categoryName * - the group name of the list of the items * @param counts * - list of counts values */ private void addResultTreeNode(final DefaultMutableTreeNode node, final String categoryName, final List<ModifiedPropertyCountData> counts) { final DefaultMutableTreeNode category = new DefaultMutableTreeNode(categoryName); node.add(category); for (final ModifiedPropertyCountData count : counts) { final DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(ResultsFormatter.formatCount(count)); category.add(childNode); } }
public boolean isMBeanNode(DefaultMutableTreeNode node) { Object userObject = node.getUserObject(); if (userObject instanceof XNodeInfo) { XNodeInfo uo = (XNodeInfo) userObject; return uo.getType().equals(Type.MBEAN); } return false; }
public void valueForPathChanged(TreePath path, Object newValue) { DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent(); String name = ((String) newValue).trim(); if (node.toString().equals(name))//s-a introdus acelasi text return; boolean ok = true; if (name == null || name.isEmpty()) { ok = false; JOptionPane.showMessageDialog(grammarEditor.frame, "The node name cannot be empty", "Error", JOptionPane.ERROR_MESSAGE); } else if (grammarEditor.grammar.getGraphs().containsKey(name)) { ok = false; JOptionPane.showMessageDialog(grammarEditor.frame, "A graph with this name exists already", "Error", JOptionPane.ERROR_MESSAGE); } if (!ok) { grammarEditor.graphTree.startEditingAtPath(path); } else { RenameGraphCommand renameGraphCommand = new RenameGraphCommand(); renameGraphCommand.graph = ((MyTreeNodeObject) node.getUserObject()).graph; renameGraphCommand.grammarEditor = grammarEditor; renameGraphCommand.prevName = renameGraphCommand.graph.getId(); renameGraphCommand.nextName = name; grammarEditor.grammar.getGraphs().put(name, renameGraphCommand.graph); grammarEditor.grammar.getGraphs().remove(renameGraphCommand.graph.getId()); renameGraphCommand.graph.setId(name); grammarEditor.undoSupport.postEdit(renameGraphCommand); grammarEditor.refreshTree(); } nodeChanged(node); }
@Override public boolean canImport(TransferHandler.TransferSupport info) { final JTree.DropLocation dl = (JTree.DropLocation) info.getDropLocation(); final TreePath tp = dl.getPath(); final DefaultMutableTreeNode parent = (DefaultMutableTreeNode) tp .getLastPathComponent(); return parent.getParent().getParent() == null; }
protected Action buildCloneAction(final Configurable target) { final DefaultMutableTreeNode targetNode = getTreeNode(target); if (targetNode.getParent() != null) { return new AbstractAction("Clone") { private static final long serialVersionUID = 1L; public void actionPerformed(ActionEvent evt) { Configurable clone = null; try { clone = target.getClass().getConstructor().newInstance(); } catch (Throwable t) { ReflectionUtils.handleNewInstanceFailure(t, target.getClass()); } if (clone != null) { clone.build(target.getBuildElement(Builder.createNewDocument())); insert(getParent(targetNode), clone, targetNode.getParent().getIndex(targetNode) + 1); } } }; } else { return null; } }
private static DefaultTreeModel toTreeModel(final DefaultListModel lm, final String rootName) { DefaultMutableTreeNode root = new DefaultMutableTreeNode(rootName); for (int i = 0; i < lm.getSize(); i++) { Object obj = lm.getElementAt(i); if (obj instanceof ClassPathSupport.Item) { root.add(toTreeNode(obj)); } } return new DefaultTreeModel(root); }
@Override public Component getTreeCellEditorComponent(JTree tree, Object value, boolean isSelected, boolean expanded, boolean leaf, int row) { MyTreeNodeObject myTreeNodeObject = (MyTreeNodeObject) ((DefaultMutableTreeNode) value).getUserObject(); if (myTreeNodeObject.graph == null || myTreeNodeObject.graph.getId().equals("Main")) { Toolkit.getDefaultToolkit().beep(); return renderer.getTreeCellRendererComponent(tree, value, isSelected, expanded, leaf, row, true); // hasFocus == true } return super.getTreeCellEditorComponent(tree, value, isSelected, expanded, leaf, row); }
/** Required by TreeSelectionListener interface. */ @Override public void valueChanged(TreeSelectionEvent e) { DefaultMutableTreeNode node = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent(); if (node != null && node.isLeaf()) { int pos = workspace.getDividerLocation(); workspace.setTopComponent((JPanel) node.getUserObject()); workspace.setDividerLocation(pos); } }
protected Transferable createTransferable(JComponent c) { JTree tree = (JTree)c; TreePath[] paths = tree.getSelectionPaths(); if(paths != null) { // Make up a node array of copies for transfer and // another for/of the nodes that will be removed in // exportDone after a successful drop. List<DefaultMutableTreeNode> copies = new ArrayList<DefaultMutableTreeNode>(); List<DefaultMutableTreeNode> toRemove = new ArrayList<DefaultMutableTreeNode>(); DefaultMutableTreeNode node = (DefaultMutableTreeNode)paths[0].getLastPathComponent(); DefaultMutableTreeNode copy = copy(node); copies.add(copy); toRemove.add(node); for(int i = 1; i < paths.length; i++) { DefaultMutableTreeNode next = (DefaultMutableTreeNode)paths[i].getLastPathComponent(); // Do not allow higher level nodes to be added to list. if(next.getLevel() < node.getLevel()) { break; } else if(next.getLevel() > node.getLevel()) { // child node copy.add(copy(next)); // node already contains child } else { // sibling copies.add(copy(next)); toRemove.add(next); } } DefaultMutableTreeNode[] nodes = copies.toArray(new DefaultMutableTreeNode[copies.size()]); nodesToRemove = toRemove.toArray(new DefaultMutableTreeNode[toRemove.size()]); return new NodesTransferable(nodes); } return null; }
@Override public Component getTreeCellRendererComponent(JTree tree, Object value, boolean sel, boolean expanded, boolean leaf, int row, boolean hasFocus) { super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row, hasFocus); if(value == resourcesTreeRoot) { setIcon(MainFrame.getIcon("GATE")); setToolTipText("Resources tree root "); } else if(value == applicationsRoot) { setIcon(MainFrame.getIcon("applications")); setToolTipText("Run processes on data "); } else if(value == languageResourcesRoot) { setIcon(MainFrame.getIcon("lrs")); setToolTipText("Data used for annotating "); } else if(value == processingResourcesRoot) { setIcon(MainFrame.getIcon("prs")); setToolTipText("Processes that annotate data "); } else if(value == datastoresRoot) { setIcon(MainFrame.getIcon("datastores")); setToolTipText("Repositories for large data "); } else { // not one of the default root nodes value = ((DefaultMutableTreeNode)value).getUserObject(); if(value instanceof Handle) { setIcon(((Handle)value).getIcon()); setText(((Handle)value).getTitle()); setToolTipText(((Handle)value).getTooltipText()); } } return this; }
private void expandTree(JTree tree) { DefaultMutableTreeNode root = (DefaultMutableTreeNode) tree.getModel() .getRoot(); Enumeration e = root.breadthFirstEnumeration(); while (e.hasMoreElements()) { DefaultMutableTreeNode node = (DefaultMutableTreeNode) e.nextElement(); if (node.isLeaf()) { continue; } int row = tree.getRowForPath(new TreePath(node.getPath())); tree.expandRow(row); } }
private void jTree1ValueChanged(TreeSelectionEvent paramTreeSelectionEvent) { DefaultMutableTreeNode localDefaultMutableTreeNode = (DefaultMutableTreeNode) this.jTree1.getLastSelectedPathComponent(); if (localDefaultMutableTreeNode == null) { return; } ClassFileStatus localClassFileStatus = (ClassFileStatus) localDefaultMutableTreeNode; switchClass(localClassFileStatus); }
private String getMouseSelectedGame() { DefaultMutableTreeNode node = (DefaultMutableTreeNode) folderTree.getLastSelectedPathComponent(); if (node == null) { return null; } Object nodeInfo = node.getUserObject(); return nodeInfo.toString(); }
/** * Filter node by key. * * @param node the node * @param key the key */ private void filterNodeByKey(DefaultMutableTreeNode node, String key){ Vector<DefaultMutableTreeNode> toDeleteVect= new Vector<DefaultMutableTreeNode>(); @SuppressWarnings("unchecked") Enumeration<DefaultMutableTreeNode> e = node.breadthFirstEnumeration(); if(e != null){ while (e.hasMoreElements()){ DefaultMutableTreeNode actualElement = e.nextElement(); if (actualElement.isLeaf() == true && key.isEmpty() == false && actualElement.toString().toLowerCase().contains(key.toLowerCase()) == false) { //--- immediate removal invalidates the enumeration --- // actualElement.removeFromParent(); // --- remember for later removal --- toDeleteVect.add(actualElement); } if(actualElement.isLeaf() == true && actualElement.toString().toLowerCase().contains(key.toLowerCase()) == true){ //--- (re)expand collapsed parent if search string matches --- int level = actualElement.getLevel() -1; StringBuilder sb = new StringBuilder(); sb.append(level -1).append(","); String levelString = sb.toString(); if(expansionState.contains(levelString) == false){ levelString = sb.append(level).append(",").toString(); expansionState = expansionState.concat(levelString); } } } } //--- delete nodes --- for( int i=0; i < toDeleteVect.size(); i++){ toDeleteVect.get(i).removeFromParent(); } }
private void addScale() { DefaultMutableTreeNode node = new DefaultMutableTreeNode("Scaled by"); getContentPane().remove(currentComponent); JPanel scalePanel = new ScalePanel(node); currentComponent = scalePanel; getContentPane().add(scalePanel); scalePanels.add(scalePanel); ((DefaultTreeModel) tree.getModel()).insertNodeInto(node, data, data.getChildCount()); tree.setSelectionPath(new TreePath(node.getPath())); getContentPane().validate(); }
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; }
@Override public void insertNodeInto(DefaultMutableTreeNode parent, int index, DefaultMutableTreeNode child) { RmlTag parentRmlTag = (RmlTag) parent.getUserObject(); RmlTag childRmlTag = (RmlTag) child.getUserObject(); editor.replaceRmlTag(parentRmlTag, childRmlTag, index); lastParentRmlTag = parentRmlTag; lastIndex = index; }