public AssetTree() { this.nodeRoot = new DefaultMutableTreeNode(new IconTreeListItem(Resources.get("assettree_assets"), ASSET_ICON)); this.nodeSpritesheets = new DefaultMutableTreeNode(new IconTreeListItem(Resources.get("assettree_spritesheets"), SPRITESHEET_ICON)); this.nodeSpriteProps = new DefaultMutableTreeNode(new IconTreeListItem(Resources.get("assettree_spritesheets_props"), PROP_ICON)); this.nodeSpriteMisc = new DefaultMutableTreeNode(new IconTreeListItem(Resources.get("assettree_spritesheets_misc"), MISC_ICON)); this.nodeSpritesheets.add(this.nodeSpriteProps); this.nodeSpritesheets.add(this.nodeSpriteMisc); this.nodeRoot.add(nodeSpritesheets); this.entitiesTreeModel = new DefaultTreeModel(this.nodeRoot); this.setModel(this.entitiesTreeModel); this.setCellRenderer(new IconTreeListRenderer()); this.setMaximumSize(new Dimension(0, 250)); for (int i = 0; i < this.getRowCount(); i++) { this.expandRow(i); } this.addTreeSelectionListener(e -> { loadAssetsOfCurrentSelection(e.getPath()); }); }
/** * Returns textual representation of the tree model. * * @return textual representation of the tree model. */ String getCodeValue() { Object value = getValue(); if (value instanceof DefaultTreeModel) { DefaultTreeModel model = (DefaultTreeModel)value; Object root = model.getRoot(); if (root instanceof DefaultMutableTreeNode) { DefaultMutableTreeNode rootNode = (DefaultMutableTreeNode)root; Object userObject = rootNode.getUserObject(); if (userObject instanceof CodeUserObject) { CodeUserObject code = (CodeUserObject)userObject; return code.code; } } } return null; }
void setRefactoringEnabled(boolean enabled, boolean isRefreshing) { checkEventThread(); if (tree != null) { if (!enabled) { CheckNode c = (CheckNode) tree.getModel().getRoot(); if (!isRefreshing) { c.setNeedsRefresh(); } else { c.setDisabled(); } tree.setModel(new DefaultTreeModel(c, false)); } // tree.validate(); tree.setEnabled(enabled); if (refactorButton != null) { refactorButton.setEnabled(enabled); } } if (refactorButton != null) { refactorButton.requestFocusInWindow(); } else if (tree != null) { tree.requestFocusInWindow(); } }
public void caretUpdate (CaretEvent e) { if (rootNode == null) return; ASTPath path = rootNode.findPath (e.getDot ()); if (path == null) return; TreeNode tNode = (TreeNode) tree.getModel ().getRoot (); List<TreeNode> treePath = new ArrayList<TreeNode> (); Iterator it = path.listIterator (); if (!it.hasNext ()) return; it.next (); treePath.add (tNode); while (tNode instanceof TNode && it.hasNext ()) { tNode = ((TNode) tNode).getTreeNode (it.next ()); if (tNode == null) throw new NullPointerException (); treePath.add (tNode); } TreePath treePath2 = new TreePath (treePath.toArray ()); DefaultTreeModel model = new DefaultTreeModel ((TreeNode) tree.getModel ().getRoot ()); tree.setModel (model); tree.setSelectionPath (treePath2); tree.scrollPathToVisible (treePath2); }
private void refresh () { SwingUtilities.invokeLater(new Runnable() { public void run() { AbstractDocument doc = getCurrentDocument (); TokenSequence ts = null; if (doc != null) try { doc.readLock (); TokenHierarchy tokenHierarchy = TokenHierarchy.get (doc); if (tokenHierarchy == null) return; ts = tokenHierarchy.tokenSequence (); } finally { doc.readUnlock (); } if (ts == null) tree.setModel (new DefaultTreeModel (new DefaultMutableTreeNode ())); else tree.setModel (new DefaultTreeModel (new TSNode (null, ts, null, 0, 0))); JEditorPane editor = getCurrentEditor (); if (editor != null) { int position = getCurrentEditor ().getCaret ().getDot (); selectPath (position); } } }); }
/** * Updates the JTree with class files loaded from the current jar. */ public void refresh() { JarData jar = Recaf.INSTANCE.jarData; if (jar == null) { return; } // TODO: Expand new tree model to match the original // Root node String jarName = (jar.jar != null) ? jar.jar.getName() : "?"; ASMTreeNode root = new ASMTreeNode(jarName, null); DefaultTreeModel model = new DefaultTreeModel(root); tree.setModel(model); // Iterate classes List<String> names = Streams.sortedNameList(jar.classes.keySet()); for (String className : names) { if (!jar.classes.containsKey(className)) { continue; } ClassNode node = jar.classes.get(className); // Create directory path based on current node name. ArrayList<String> dirPath = new ArrayList<String>(Arrays.asList(node.name.split("/"))); // Create directory of nodes Swing.generateTreePath(root, dirPath, node, model); } model.setRoot(root); }
void clear() { this.txtClassName.setText(""); this.txtSuperClassName.setText(""); this.txtMagicNumber.setText(""); this.txtMajorVersion.setText(""); this.txtMinorVersion.setText(""); this.chkFinal.setSelected(false); this.chkPublic.setSelected(false); this.chkSuper.setSelected(false); this.chkInterface.setSelected(false); this.chkAbstract.setSelected(false); this.interfacesRootNode.removeAllChildren(); this.treeInterfaces.setModel(new DefaultTreeModel(this.interfacesRootNode)); this.txtNewInterfaceName.setText(""); this.txtConstPoolIndex.setText(""); }
void connect( JTree errorTree, DefaultTreeModel errModel, JComboBox severityComboBox, JCheckBox tasklistCheckBox, JPanel customizerPanel, JEditorPane descriptionTextArea) { this.errorTree = errorTree; this.errModel = errModel; this.severityComboBox = severityComboBox; this.tasklistCheckBox = tasklistCheckBox; this.customizerPanel = customizerPanel; this.descriptionTextArea = descriptionTextArea; valueChanged( null ); errorTree.addKeyListener(this); errorTree.addMouseListener(this); errorTree.getSelectionModel().addTreeSelectionListener(this); severityComboBox.addActionListener(this); tasklistCheckBox.addChangeListener(this); }
public void SelecioneByDiagramaSelecionado() { DefaultTreeModel df = (DefaultTreeModel) tree.getModel(); if (df.getRoot() instanceof TreeItem) { TreeItem root = (TreeItem) df.getRoot(); TreePath pt = new TreePath(root); if (diagrama.getSelecionado() == null || !(diagrama.getSelecionado() instanceof Forma)) { return; } for (int i = 0; i < root.getChildCount(); i++) { TreeItem item = (TreeItem) root.getChildAt(i); if (item.getId() == diagrama.getSelecionado().getID()) { tree.setSelectionPath(pt.pathByAddingChild(item)); break; } } } btnOK.setText("OK"); btnFechar.setVisible(false); }
private void saveObjectToGroup(ObjectGroup<MobileORObject> group, MobileTreeNode mobileNode) { MobileORObject dupObj = null; MobileORObject dummyObject = getDummyObject(mobileNode); for (MobileORObject object : group.getObjects()) { if (object.isEqualOf(dummyObject)) { dupObj = object; } } if (dupObj == null) { String objName = dummyObject.getName(); int i = 1; while (group.getObjectByName(objName) != null) { objName = dummyObject.getName() + i++; } MobileORObject newObj = group.addObject(objName); dummyObject.clone(newObj); LOG.log(Level.INFO, "Object Added : {0}", objName); ((DefaultTreeModel) objectTree.getTree().getModel()).nodesWereInserted(group, new int[]{group.getChildCount() - 1}); if (group.getChildCount() == 2) { ((DefaultTreeModel) objectTree.getTree().getModel()).reload(group.getParent()); } } else { LOG.log(Level.WARNING, "Object Similar To\nObject : {0}", dupObj.getName()); } }
public void setModels(final DefaultListModel mpModel, final DefaultListModel cpModel) { this.model = new JoinModel(mpModel, cpModel); this.list.setModel(this.model); DefaultTreeModel mpTreeModel = toTreeModel(mpModel, MODULEPATH); DefaultTreeModel cpTreeModel = toTreeModel(cpModel, CLASSPATH); mpModel.addListDataListener(new ListModelListener(mpModel, mpTreeModel, mpTree)); cpModel.addListDataListener(new ListModelListener(cpModel, cpTreeModel, cpTree)); mpTree.setModel(mpTreeModel); cpTree.setModel(cpTreeModel); SelectionModel mpTreeSelectionModel = new SelectionModel(); SelectionModel cpTreeSelectionModel = new SelectionModel(); mpTreeSelectionModel.addTreeSelectionListener(new SelectionListener(mpTreeModel, this.list, null, cpTreeSelectionModel)); cpTreeSelectionModel.addTreeSelectionListener(new SelectionListener(cpTreeModel, this.list, mpModel, mpTreeSelectionModel)); mpTree.setSelectionModel(mpTreeSelectionModel); cpTree.setSelectionModel(cpTreeSelectionModel); }
void setRootNode(final TreeNode root) { if(root != null) { EventQueue.invokeLater(new Runnable() { @Override public void run() { tree.setModel(new DefaultTreeModel(root)); for (int i = 0; i < tree.getRowCount(); i++) { tree.expandRow(i); } listScrollPane.setVisible(true); titleLabel.setVisible(true); initPanel.setVisible(false); } }); } else { messageLabel.setText(NbBundle.getMessage(RevertDeletedAction.class, "MSG_NO_FILES")); // NOI18N } }
public void setSelected(Object node, Boolean selected) { Object userObject = ((DefaultMutableTreeNode) node).getUserObject(); if (((DefaultMutableTreeNode) node).isRoot()) { getOptionsExportModel().setState(OptionsExportModel.State.valueOf(selected)); } else if (userObject instanceof OptionsExportModel.Category) { ((OptionsExportModel.Category) userObject).setState(OptionsExportModel.State.valueOf(selected)); } else if (userObject instanceof OptionsExportModel.Item) { ((OptionsExportModel.Item) userObject).setEnabled(selected); // update parent category Object parent = ((TreeNode) node).getParent(); updateCategoryNode((DefaultMutableTreeNode) parent); } // fire an event to refresh parent or child nodes ((DefaultTreeModel) treeModel).nodeChanged((TreeNode) node); dialogDescriptor.setValid(isPanelValid()); scrollPaneOptions.repaint(); }
private void scrollNodeToVisible( final Node n ) { EventQueue.invokeLater(new Runnable() { @Override public void run() { TreeNode tn = Visualizer.findVisualizer(n); if (tn == null) { return; } TreeModel model = tree.getModel(); if (!(model instanceof DefaultTreeModel)) { return; } TreePath path = new TreePath(((DefaultTreeModel) model).getPathToRoot(tn)); if( null == path ) return; Rectangle r = tree.getPathBounds(path); if (r != null) { tree.scrollRectToVisible(r); } } }); }
public MapPlacesViewer(MapPlaces places, MapPlace root, boolean topFrame, int xPos, int yPos) { this.places = places; this.topFrame = topFrame; this.rootPlace = root; this.rootNode = createTreeNodes(root); treeModel= new DefaultTreeModel(rootNode); bookmarkTree = new JTree(treeModel); this.initialXPos = xPos; this.initialYPos = yPos; initBookmarkFrame(); MapPlacesViewer.mapViewers.add(this); }
@Override public void apply() throws ConfigurationException { Set<SelectedExchangeCurrencyPair> selectedExchangeCurrencyPairs = Sets.newHashSet(); DefaultTreeModel model = (DefaultTreeModel) tree.getModel(); DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot(); Enumeration rootEnum = root.children(); while (rootEnum.hasMoreElements()) { DefaultMutableTreeNode rootEnumObject = (DefaultMutableTreeNode) rootEnum.nextElement(); String exchangeName = rootEnumObject.getUserObject().toString(); Enumeration childEnum = rootEnumObject.children(); Set<CurrencyPair> currencyPairs = Sets.newHashSet(); while (childEnum.hasMoreElements()) { CheckedTreeNode childEnumObject = (CheckedTreeNode) childEnum.nextElement(); if (childEnumObject.isChecked()) { currencyPairs.add(new CurrencyPair(childEnumObject.getUserObject().toString())); } } SelectedExchangeCurrencyPair selectedExchangeCurrencyPair = new SelectedExchangeCurrencyPair(exchangeName, currencyPairs); selectedExchangeCurrencyPairs.add(selectedExchangeCurrencyPair); } IdeaCurrencyConfig.getInstance().setSelectedExchangeCurrencyPairs(selectedExchangeCurrencyPairs); IdeaCurrencyConfig.getInstance().setReloadInterval(reloadIntervalSlider.getValue()); IdeaCurrencyConfig.getInstance().setActive(activeCheckBox.isSelected()); isModified = false; triggerConfigChange(); }
/** * Sort nodes descending. * * @param node the node * @param treeModel the tree model */ private void sortNodesDescending(DefaultMutableTreeNode node, DefaultTreeModel treeModel) { boolean unsorted = true; while (unsorted) { unsorted = false; for (int i = 0; i < node.getChildCount() - 1; i++) { ThreadInfoStorageAgent tiaFirst = (ThreadInfoStorageAgent) ((DefaultMutableTreeNode) node.getChildAt(i)).getUserObject(); ThreadInfoStorageAgent tiaSecond = (ThreadInfoStorageAgent) ((DefaultMutableTreeNode) node.getChildAt(i+1)).getUserObject(); if (tiaFirst.getXYSeriesMap().get("TOTAL_CPU_SYSTEM_TIME").getMaxY() < tiaSecond.getXYSeriesMap().get("TOTAL_CPU_SYSTEM_TIME").getMaxY()) { treeModel.insertNodeInto((MutableTreeNode) node.getChildAt(i+1), node, i); unsorted = true; } } } }
@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); }
private synchronized Component createLeftPanel() { SampleResult rootSampleResult = new SampleResult(); rootSampleResult.setSampleLabel("Root"); rootSampleResult.setSuccessful(true); root = new SearchableTreeNode(rootSampleResult, null); treeModel = new DefaultTreeModel(root); jTree = new JTree(treeModel); jTree.setCellRenderer(new ResultsNodeRenderer()); jTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION); jTree.addTreeSelectionListener(this); jTree.setRootVisible(false); jTree.setShowsRootHandles(true); JScrollPane treePane = new JScrollPane(jTree); treePane.setPreferredSize(new Dimension(200, 300)); VerticalPanel leftPane = new VerticalPanel(); leftPane.add(treePane, BorderLayout.CENTER); leftPane.add(createComboRender(), BorderLayout.NORTH); autoScrollCB = new JCheckBox(JMeterUtils.getResString("view_results_autoscroll")); // $NON-NLS-1$ autoScrollCB.setSelected(false); autoScrollCB.addItemListener(this); leftPane.add(autoScrollCB, BorderLayout.SOUTH); return leftPane; }
public static JTree updateJTree(JTree tree, TreeArrayList<?> data, ExpandedPaths ep) { ArrayList<String> expanded_paths = null; TreePath[] paths = null; if(ep != null) { expanded_paths = ep.getExpandedPaths(tree); paths = tree.getSelectionPaths(); } DefaultMutableTreeNode top = getDefaultMutableTreeNodeOfHashMap(data); DefaultTreeModel model = new DefaultTreeModel(top); DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot(); model.reload(root); tree.setModel(model); if(ep != null) { ep.expandPaths(tree, expanded_paths); tree.setSelectionPaths(paths); } return tree; }
/** * Update the label of the supplied MBean tree node. */ // Call on EDT private void updateNotificationsNodeLabel( DefaultMutableTreeNode node, String label) { synchronized (mbeansTab.getTree()) { invalidate(); XNodeInfo oldUserObject = (XNodeInfo) node.getUserObject(); XNodeInfo newUserObject = new XNodeInfo( oldUserObject.getType(), oldUserObject.getData(), label, oldUserObject.getToolTipText()); node.setUserObject(newUserObject); DefaultTreeModel model = (DefaultTreeModel) mbeansTab.getTree().getModel(); model.nodeChanged(node); validate(); repaint(); } }
public void initData(String rootPath){ File f=new File(rootPath); PathNode root=new PathNode(f.getName(), rootPath,f.isDirectory()); File[] files=f.listFiles(); for(int i=0;i<files.length;i++){ if(files[i].isDirectory() || files[i].getName().endsWith(".ql")){ PathNode node=new PathNode(files[i].getName(), files[i].getAbsolutePath(),files[i].isDirectory()); root.add(node); } } model=new DefaultTreeModel(root); this.setModel(model); FileTreeRenderer renderer=new FileTreeRenderer(); this.setCellRenderer(renderer); this.repaint(); }
/** * Constructs a tree, with cell renderer and editor set by * {@link #createRenderer()} and {@link #createEditor()}. */ public CheckboxTree() { setCellRenderer(createRenderer()); setCellEditor(createEditor()); setEditable(true); setRootVisible(false); setShowsRootHandles(true); // make sure the checkbox never selects the label // note that the BasicTreeUI may not be what is used in the current LAF, // but I don't know any other way to modify the selection behaviour BasicTreeUI ui = new BasicTreeUI() { @Override protected void selectPathForEvent(TreePath path, MouseEvent event) { if (!isOverCheckBox(path, event.getPoint().x)) { super.selectPathForEvent(path, event); } } }; setUI(ui); // initialise the tree model this.topNode = new DefaultMutableTreeNode(); this.treeModel = new DefaultTreeModel(this.topNode); setModel(this.treeModel); // set selection mode getSelectionModel().setSelectionMode(TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION); }
private void setModelForComboBoxServices(DefaultTreeModel model) { comboBoxServices = new JTreeComboBox(model); panelTreeCmbx.removeAll(); panelTreeCmbx.setLayout(new GridLayout(1, 1)); panelTreeCmbx.add(comboBoxServices); comboBoxServices.addItemListener((ItemEvent e) -> { if (((QService) e.getItem()).isLeaf()) { lastSelected = (QService) e.getItem(); preRegChange(false); } else { comboBoxServices.setSelectedItem(lastSelected); } }); comboBoxServices.setSelectedItem(model.getRoot()); }
protected static TreeModel getTreeModel() { root = new DefaultMutableTreeNode("Root"); a = new DefaultMutableTreeNode("A"); root.add(a); a1 = new DefaultMutableTreeNode("a1"); a.add(a1); b = new DefaultMutableTreeNode("B"); root.add(b); b1 = new DefaultMutableTreeNode("b1"); b.add(b1); b2 = new DefaultMutableTreeNode("b2"); b.add(b2); c = new DefaultMutableTreeNode("C"); root.add(c); c1 = new DefaultMutableTreeNode("c1"); c.add(c1); return new DefaultTreeModel(root); }
public void rebuildTree() { buildTree(); if (treeView != null) ((DefaultTreeModel) treeView.getModel()).reload(root); }
public static void reloadPackageList() { try { AVFileVars.importVariants(false); AVFileVars.AVPackages.sort(); tree.setModel(new DefaultTreeModel(AVFileVars.AVPackages)); } catch (IOException ex) { SPGlobal.logException(ex); } }
/** * Test of getTableCellRendererComponent method, of class * DefaultOutlineCellRenderer. */ public void testGetTableCellRendererComponent() { System.out.println("getTableCellRendererComponent"); UIManager.put("Table.alternateRowColor", Color.red); final DefaultMutableTreeNode node1 = new DefaultMutableTreeNode(); final DefaultMutableTreeNode node2 = new DefaultMutableTreeNode(); final Object[][] values = new Object[][]{{node1, "01"}, {node2, "11"}}; final String[] names = new String[]{"col1", "col2"}; TreeModel treeModel = new DefaultTreeModel(new DefaultMutableTreeNode()); DefaultTableModel tableModel = new DefaultTableModel(values, names); OutlineModel model = new DefaultOutlineModel(treeModel, tableModel, false, "Col1") { }; final Outline outline = new Outline(model); ColorRenderDataProvider rdp = new ColorRenderDataProvider(); outline.setRenderDataProvider(rdp); DefaultOutlineCellRenderer instance = new DefaultOutlineCellRenderer(); Component result = instance.getTableCellRendererComponent(outline, node1, false, false, 0, 0); assertEquals("First line backgroundColor defaults to", outline.getBackground(), result.getBackground()); assertEquals("Foreground defaults to", outline.getForeground(), result.getForeground()); result = instance.getTableCellRendererComponent(outline, node2, false, false, 1, 0); assertEquals("Second line backgroundColor defaults to", Color.red, result.getBackground()); assertEquals("Foreground defaults to", outline.getForeground(), result.getForeground()); rdp.backgroundColor = Color.BLUE; // Custom background color rdp.foregroundColor = Color.GREEN; // Custom foreground color result = instance.getTableCellRendererComponent(outline, node1, false, false, 0, 0); assertEquals("First line backgroundColor is set as", Color.BLUE, result.getBackground()); assertEquals("Foreground is set as", Color.GREEN, result.getForeground()); result = instance.getTableCellRendererComponent(outline, node2, false, false, 1, 0); assertEquals("Second line backgroundColor is set as", Color.BLUE, result.getBackground()); assertEquals("Foreground is set as", Color.GREEN, result.getForeground()); }
@Messages("NAME_Library=Library Name") CreateLibraryPanel(DependencyNode root) { initComponents(); DefaultComboBoxModel mdl = new DefaultComboBoxModel(); SwingValidationGroup.setComponentName(txtName, NAME_Library()); for (LibraryManager manager : LibraryManager.getOpenManagers()) { mdl.addElement(manager); } comManager.setModel(mdl); comManager.addActionListener(new ActionListener() { public @Override void actionPerformed(ActionEvent e) { if (vg != null) { vg.performValidation(); } } }); comManager.setRenderer(new DefaultListCellRenderer() { @Override public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) { LibraryManager man = (LibraryManager) value; return super.getListCellRendererComponent(list, man.getDisplayName(), index, isSelected, cellHasFocus); } }); trDeps.setCellRenderer(new CheckRenderer(false)); CheckNodeListener l = new CheckNodeListener(false); trDeps.addMouseListener(l); trDeps.addKeyListener(l); trDeps.setToggleClickCount(0); trDeps.setRootVisible(false); trDeps.setModel(new DefaultTreeModel(new DefaultMutableTreeNode())); rootnode = root; trDeps.setModel(new DefaultTreeModel(createDependenciesList())); setLibraryName(); }
private void trTransValueChanged(javax.swing.event.TreeSelectionEvent evt) {//GEN-FIRST:event_trTransValueChanged TreeNode tn = (TreeNode) evt.getPath().getLastPathComponent(); if (tn instanceof CheckNode) { setReferenceTree((CheckNode)tn); } else { trRef.setModel(new DefaultTreeModel(new DefaultMutableTreeNode())); } }
private void refreshInterfaceList() { this.interfacesRootNode.removeAllChildren(); int i = this.currClassFile.interfaces.getInterfacesCount(); for (int j = 0; j < i; j++) { String str = this.currClassFile.interfaces.getInterfaceName(j); DefaultMutableTreeNode localDefaultMutableTreeNode = new DefaultMutableTreeNode(str); localDefaultMutableTreeNode.setUserObject(str); this.interfacesRootNode.add(localDefaultMutableTreeNode); } this.treeInterfaces.setModel(new DefaultTreeModel(this.interfacesRootNode)); }
private void initHints() { DefaultMutableTreeNode rootNode = new DefaultMutableTreeNode(); hintsTreeModel = new DefaultTreeModel( rootNode ); FileObject folder = FileUtil.getConfigFile( RULES_FOLDER + mimeType + HINTS ); // NOI18N List<Pair<Rule,FileObject>> rules = readRules(folder); categorizeAstRules( rules, hints, folder, rootNode ); }
public ComponentSelector(Model logModel) { DefaultTreeModel model = new DefaultTreeModel(null); model.setAsksAllowsChildren(false); setModel(model); setRootVisible(false); setLogModel(logModel); setCellRenderer(new MyCellRenderer()); }
private void expandNode(final JFileChooser fileChooser, final TreePath path) { RequestProcessor.getDefault().post(new Runnable() { DirectoryNode node; @Override public void run() { if (!EventQueue.isDispatchThread()) { // first pass, out of EQ thread, loads data markStartTime(); setCursor(fileChooser, Cursor.WAIT_CURSOR); node = (DirectoryNode) path.getLastPathComponent(); node.loadChildren(fileChooser, true); // send to second pass EventQueue.invokeLater(this); } else { // second pass, in EQ thread ((DefaultTreeModel) tree.getModel()).nodeStructureChanged(node); /* * This happens when the add new directory action is called * and the node is not loaded. Furthermore, it ensures that * adding a new directory execute after the UI has finished * displaying the children of the expanded node. */ if(addNewDirectory) { addNewDirectory(path); addNewDirectory = false; } setCursor(fileChooser, Cursor.DEFAULT_CURSOR); checkUpdate(); } } }); }
@Override public void valueForPathChanged(TreePath path, Object newValue) { boolean refreshTree = false; if (path == null) { // no idea return; } DirectoryNode node = (DirectoryNode)path.getLastPathComponent(); File f = node.getFile(); File newFile = getFileChooser().getFileSystemView().createFileObject(f.getParentFile(), (String)newValue); if(f.renameTo(newFile)) { // fix bug #97521, #96960 if(tree.isExpanded(path)) { tree.collapsePath(path); refreshTree = true; } node.setFile(newFile); node.removeAllChildren(); ((DefaultTreeModel) tree.getModel()).nodeStructureChanged(node); if(refreshTree) { tree.expandPath(path); } } }
private void setModel(DefaultTreeModel errorTreeModel) { if (optionsFilter!=null) { optionsFilter.installFilteringModel(errorTree, errorTreeModel, new AcceptorImpl()); } else { errorTree.setModel(errorTreeModel); } }
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); }