@Nullable public FilteringTreeStructure.FilteringNode selectPsiElement(PsiElement element) { Set<PsiElement> parents = getAllParents(element); FilteringTreeStructure.FilteringNode node = (FilteringTreeStructure.FilteringNode) myAbstractTreeBuilder.getRootElement(); while (node != null) { boolean changed = false; for (FilteringTreeStructure.FilteringNode n : node.children()) { final PsiElement psiElement = getPsi(n); if (psiElement != null && parents.contains(psiElement)) { node = n; changed = true; break; } } if (!changed) { myAbstractTreeBuilder.select(node); if (myAbstractTreeBuilder.getSelectedElements().isEmpty()) { TreeUtil.selectFirstNode(myTree); } myInitialNodeIsLeaf = node.getChildren().length == 0; return node; } } TreeUtil.selectFirstNode(myTree); return null; }
private void sortChildren(InspectionTreeNode node) { final List<TreeNode> children = TreeUtil.childrenToArray(node); Collections.sort(children, InspectionResultsViewComparator.getInstance()); node.removeAllChildren(); TreeUtil.addChildrenTo(node, children); ((DefaultTreeModel) getModel()).reload(node); }
public ActionCallback selectNodeInTree( final DefaultMutableTreeNode nodeToSelect, boolean center, final boolean requestFocus) { if (requestFocus) { myTree.requestFocus(); } if (nodeToSelect != null) { return TreeUtil.selectInTree(nodeToSelect, requestFocus, myTree, center); } else { return TreeUtil.selectFirstNode(myTree); } }
protected void setUp() throws Exception { super.setUp(); myTreeModel.insertNodeInto(myChildA, myRoot, 0); myTreeModel.insertNodeInto(myChildB, myRoot, 1); myTreeModel.insertNodeInto(myChild2, myChildA, 0); myTreeModel.insertNodeInto(new DefaultMutableTreeNode(), myChild2, 0); myTreeModel.insertNodeInto(new DefaultMutableTreeNode(), myChildB, 0); myChildAPath = TreeUtil.getPathFromRoot(myChildA); myChild2Path = TreeUtil.getPathFromRoot(myChild2); myChildBPath = TreeUtil.getPathFromRoot(myChildB); }
@Override protected Object[] getAllElements() { if (myCanExpand) { final Object root = myComponent.getModel().getRoot(); if (root instanceof DefaultMutableTreeNode || root instanceof PathAwareTreeNode) { final List<TreePath> paths = new ArrayList<TreePath>(); TreeUtil.traverseDepth( (TreeNode) root, new TreeUtil.Traverse() { @Override public boolean accept(Object node) { if (node instanceof DefaultMutableTreeNode) { paths.add(new TreePath(((DefaultMutableTreeNode) node).getPath())); } else if (node instanceof PathAwareTreeNode) { paths.add(((PathAwareTreeNode) node).getPath()); } return true; } }); return paths.toArray(new TreePath[paths.size()]); } } TreePath[] paths = new TreePath[myComponent.getRowCount()]; for (int i = 0; i < paths.length; i++) { paths[i] = myComponent.getPathForRow(i); } return paths; }
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; }
@Override protected boolean findAdditionalMembers(final Set<UsageInfo> toMakeStatic) { if (!toMakeStatic.isEmpty()) { myAdditionalMethods = new ArrayList<PsiMethod>(); if (ApplicationManager.getApplication().isUnitTestMode()) { for (UsageInfo usageInfo : toMakeStatic) { myAdditionalMethods.add((PsiMethod) usageInfo.getElement()); } } else { final JavaCallerChooser chooser = new MakeStaticJavaCallerChooser( myMember, myProject, methods -> myAdditionalMethods.addAll(methods)) { @Override protected ArrayList<UsageInfo> getTopLevelItems() { return new ArrayList<UsageInfo>(toMakeStatic); } }; TreeUtil.expand(chooser.getTree(), 2); if (!chooser.showAndGet()) { return false; } } } return true; }
public InspectionTree(final Project project) { super(new InspectionRootNode(project)); setCellRenderer(new CellRenderer()); // project)); setShowsRootHandles(true); UIUtil.setLineStyleAngled(this); addTreeWillExpandListener(new ExpandListener()); myExpandedUserObjects = new HashSet<Object>(); myExpandedUserObjects.add(project); TreeUtil.installActions(this); new TreeSpeedSearch( this, new Convertor<TreePath, String>() { @Override public String convert(TreePath o) { return InspectionsConfigTreeComparator.getDisplayTextToSort( o.getLastPathComponent().toString()); } }); addTreeSelectionListener( new TreeSelectionListener() { @Override public void valueChanged(TreeSelectionEvent e) { TreePath newSelection = e.getNewLeadSelectionPath(); if (newSelection != null) { mySelectionPath = new SelectionPath(newSelection); } } }); }
@Override public boolean update(DnDEvent aEvent) { aEvent.setDropPossible(false); aEvent.hideHighlighter(); final Object object = aEvent.getAttachedObject(); if (object instanceof PackagingElementDraggingObject) { final DefaultMutableTreeNode parent = findParentCompositeElementNode(aEvent.getRelativePoint().getPoint(myTree)); if (parent != null) { final PackagingElementDraggingObject draggingObject = (PackagingElementDraggingObject) object; final PackagingElementNode node = getNode(parent); if (node != null && draggingObject.canDropInto(node)) { final PackagingElement element = node.getFirstElement(); if (element instanceof CompositePackagingElement) { draggingObject.setTargetNode(node); draggingObject.setTargetElement((CompositePackagingElement<?>) element); final Rectangle bounds = myTree.getPathBounds(TreeUtil.getPathFromRoot(parent)); aEvent.setHighlighting( new RelativeRectangle(myTree, bounds), DnDEvent.DropTargetHighlightingType.RECTANGLE); aEvent.setDropPossible(true); } } } } return false; }
public void selectFirstCertificate() { if (!isEmpty()) { Tree tree = (Tree) getTree(); TreePath path = TreeUtil.getFirstLeafNodePath(tree); tree.addSelectionPath(path); } }
@Override public void removeWatches(final List<? extends XDebuggerTreeNode> nodes) { List<? extends WatchNode> children = myRootNode.getAllChildren(); int minIndex = Integer.MAX_VALUE; List<XDebuggerTreeNode> toRemove = new ArrayList<XDebuggerTreeNode>(); if (children != null) { for (XDebuggerTreeNode node : nodes) { @SuppressWarnings("SuspiciousMethodCalls") int index = children.indexOf(node); if (index != -1) { toRemove.add(node); minIndex = Math.min(minIndex, index); } } } myRootNode.removeChildren(toRemove); List<? extends WatchNode> newChildren = myRootNode.getAllChildren(); if (newChildren != null && !newChildren.isEmpty()) { WatchNode node = minIndex < newChildren.size() ? newChildren.get(minIndex) : newChildren.get(newChildren.size() - 1); TreeUtil.selectNode(myTreePanel.getTree(), node); } updateSessionData(); }
public void apply() throws ConfigurationException { processRemovedItems(); final ConfigurationException[] ex = new ConfigurationException[1]; TreeUtil.traverse( myRoot, new TreeUtil.Traverse() { public boolean accept(Object node) { if (node instanceof MyNode) { try { final NamedConfigurable configurable = ((MyNode) node).getConfigurable(); if (isInitialized(configurable) && configurable.isModified()) { configurable.apply(); } } catch (ConfigurationException e) { ex[0] = e; return false; } } return true; } }); if (ex[0] != null) { throw ex[0]; } myHasDeletedItems = false; }
private void createTreeModel() { final PsiManager psiManager = PsiManager.getInstance(myProject); final FileIndex fileIndex = myModule != null ? ModuleRootManager.getInstance(myModule).getFileIndex() : ProjectRootManager.getInstance(myProject).getFileIndex(); fileIndex.iterateContent( new ContentIterator() { public boolean processFile(VirtualFile fileOrDir) { if (fileOrDir.isDirectory() && fileIndex.isInSourceContent(fileOrDir)) { final PsiDirectory psiDirectory = psiManager.findDirectory(fileOrDir); LOG.assertTrue(psiDirectory != null); PsiPackage aPackage = JavaDirectoryService.getInstance().getPackage(psiDirectory); if (aPackage != null) { addPackage(aPackage); } } return true; } }); TreeUtil.sort( myModel, new Comparator() { public int compare(Object o1, Object o2) { DefaultMutableTreeNode n1 = (DefaultMutableTreeNode) o1; DefaultMutableTreeNode n2 = (DefaultMutableTreeNode) o2; PsiNamedElement element1 = (PsiNamedElement) n1.getUserObject(); PsiNamedElement element2 = (PsiNamedElement) n2.getUserObject(); return element1.getName().compareToIgnoreCase(element2.getName()); } }); }
protected Tree createTree() { final Tree tree = new Tree(new DefaultTreeModel(new DefaultMutableTreeNode())); tree.setCellRenderer(getTreeCellRenderer()); UIUtil.setLineStyleAngled(tree); tree.setRootVisible(false); tree.setShowsRootHandles(true); tree.addKeyListener(new TreeKeyListener()); tree.addTreeSelectionListener(new MyTreeSelectionListener()); if (!myAllowMultiSelection) { tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION); } new DoubleClickListener() { @Override protected boolean onDoubleClick(MouseEvent e) { if (tree.getPathForLocation(e.getX(), e.getY()) != null) { doOKAction(); return true; } return false; } }.installOn(tree); TreeUtil.installActions(tree); return tree; }
public void selectBreakpoint(Breakpoint breakpoint) { final CheckedTreeNode node = myDescriptorToNodeMap.get(new BreakpointDescriptor(breakpoint)); if (node == null) { return; } TreeUtil.selectNode(this, node); }
protected void checkTree(String filter) { myPopupFixture.getPopup().setSearchFilterForTests(filter); myPopupFixture.getBuilder().refilter(null, false, true); myPopupFixture.getBuilder().queueUpdate(); TreeUtil.selectPath( myPopupFixture.getTree(), (TreePath) myPopupFixture.getSpeedSearch().findElement(filter)); checkTree(); }
protected void removeFacetNodes(@NotNull List<Facet> facets) { for (Facet facet : facets) { MyNode node = findNodeByObject(myRoot, facet); if (node != null) { removePaths(TreeUtil.getPathFromRoot(node)); } } }
void scrollToLastMessage() { if (myTree == null) return; int count = myTree.getRowCount(); if (count > 0) { int row = count - 1; TreeUtil.selectPath(myTree, myTree.getPathForRow(row)); } }
protected void removePaths(final TreePath... paths) { MyNode parentNode = null; int idx = -1; for (TreePath path : paths) { final MyNode node = (MyNode) path.getLastPathComponent(); final NamedConfigurable namedConfigurable = node.getConfigurable(); final Object editableObject = namedConfigurable.getEditableObject(); parentNode = (MyNode) node.getParent(); idx = parentNode.getIndex(node); ((DefaultTreeModel) myTree.getModel()).removeNodeFromParent(node); myHasDeletedItems |= wasObjectStored(editableObject); fireItemsChangeListener(editableObject); onItemDeleted(editableObject); namedConfigurable.disposeUIResources(); } if (paths.length > 0) { if (parentNode != null && idx != -1) { DefaultMutableTreeNode toSelect = null; if (idx < parentNode.getChildCount()) { toSelect = (DefaultMutableTreeNode) parentNode.getChildAt(idx); } else { if (idx > 0 && parentNode.getChildCount() > 0) { if (idx - 1 < parentNode.getChildCount()) { toSelect = (DefaultMutableTreeNode) parentNode.getChildAt(idx - 1); } else { toSelect = (DefaultMutableTreeNode) parentNode.getFirstChild(); } } else { if (parentNode.isRoot() && myTree.isRootVisible()) { toSelect = parentNode; } else if (parentNode.getChildCount() > 0) { toSelect = (DefaultMutableTreeNode) parentNode.getFirstChild(); } } } if (toSelect != null) { TreeUtil.selectInTree(toSelect, true, myTree); } } else { TreeUtil.selectFirstNode(myTree); } } }
public void actionPerformed(final AnActionEvent e) { final Set<PsiFile> selectedScope = getSelectedScope(myLeftTree); exclude(selectedScope); myExcluded.addAll(selectedScope); final TreePath[] paths = myLeftTree.getSelectionPaths(); for (TreePath path : paths) { TreeUtil.removeLastPathComponent(myLeftTree, path); } }
public void apply() throws ConfigurationException { final List<TreePath> treePaths = TreeUtil.collectExpandedPaths(myActionsTree); if (mySelectedSchema != null) { CustomizationUtil.optimizeSchema(myActionsTree, mySelectedSchema); } restorePathsAfterTreeOptimization(treePaths); CustomActionsSchema.getInstance().copyFrom(mySelectedSchema); setCustomizationSchemaForCurrentProjects(); }
public void centerSelectedRow() { TreePath path = getTree().getSelectionPath(); if (path == null) { return; } myAutoScrollToSourceHandler.setShouldAutoScroll(false); TreeUtil.showRowCentered(getTree(), getTree().getRowForPath(path), false); myAutoScrollToSourceHandler.setShouldAutoScroll(true); }
@Override public void actionPerformed(AnActionEvent e) { final Component c = e.getData(PlatformDataKeys.CONTEXT_COMPONENT); if (c != null) { final JTree tree = UIUtil.getParentOfType(JTree.class, c); if (tree != null) { TreeUtil.expandAll(tree); } } }
public void setSelected(AnActionEvent event, boolean flag) { DependencyUISettings.getInstance().UI_SHOW_FILES = flag; mySettings.UI_SHOW_FILES = flag; if (!flag && myLeftTree.getSelectionPath() != null && myLeftTree.getSelectionPath().getLastPathComponent() instanceof FileNode) { TreeUtil.selectPath(myLeftTree, myLeftTree.getSelectionPath().getParentPath()); } rebuild(); }
public void selectPackage(final String qualifiedName) { /*ApplicationManager.getApplication().invokeLater(new Runnable() { public void run() {*/ DefaultMutableTreeNode node = findNodeForPackage(qualifiedName); if (node != null) { TreePath path = new TreePath(node.getPath()); TreeUtil.selectPath(myTree, path); } /* } }, ModalityState.stateForComponent(getRootPane()));*/ }
private static List<List<PathElement>> createPaths(final JTree tree) { final ArrayList<List<PathElement>> result = new ArrayList<List<PathElement>>(); final List<TreePath> expandedPaths = TreeUtil.collectExpandedPaths(tree); for (final TreePath expandedPath : expandedPaths) { final List<PathElement> path = createPath(expandedPath); if (path != null) { result.add(path); } } return result; }
public void restoreState() { myStructureViewState = myFileEditor.getUserData(STRUCTURE_VIEW_STATE_KEY); if (myStructureViewState == null) { TreeUtil.expand(getTree(), 2); } else { expandStoredElements(); selectStoredElements(); myFileEditor.putUserData(STRUCTURE_VIEW_STATE_KEY, null); myStructureViewState = null; } }
protected void initTree() { ((DefaultTreeModel) myTree.getModel()).setRoot(myRoot); myTree.setRootVisible(false); myTree.setShowsRootHandles(true); UIUtil.setLineStyleAngled(myTree); TreeUtil.installActions(myTree); myTree.setCellRenderer( new ColoredTreeCellRenderer() { public void customizeCellRenderer( JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) { if (value instanceof MyNode) { final MyNode node = ((MyNode) value); setIcon(node.getIcon(expanded)); final Font font = UIUtil.getTreeFont(); if (node.isDisplayInBold()) { setFont(font.deriveFont(Font.BOLD)); } else { setFont(font.deriveFont(Font.PLAIN)); } append( node.getDisplayName(), node.isDisplayInBold() ? SimpleTextAttributes.REGULAR_BOLD_ATTRIBUTES : SimpleTextAttributes.REGULAR_ATTRIBUTES); } } }); initToolbar(); ArrayList<AnAction> actions = createActions(true); if (actions != null) { final DefaultActionGroup group = new DefaultActionGroup(); for (AnAction action : actions) { group.add(action); } actions = getAdditionalActions(); if (actions != null) { group.addSeparator(); for (AnAction action : actions) { group.add(action); } } PopupHandler.installPopupHandler( myTree, group, ActionPlaces.UNKNOWN, ActionManager.getInstance()); // popup should follow the selection } }
private void installTree() { getTree().getSelectionModel().setSelectionMode(TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION); myAutoScrollToSourceHandler.install(getTree()); myAutoScrollFromSourceHandler.install(); TreeUtil.installActions(getTree()); new TreeSpeedSearch(getTree()); addTreeKeyListener(); addTreeMouseListeners(); restoreState(); }
public void restore(BreakpointTree tree) { final List<TreePath> pathsToExpand = getPaths(tree, myExpandedUserObjects); if (!pathsToExpand.isEmpty()) { TreeUtil.restoreExpandedPaths(tree, pathsToExpand); } final List<TreePath> pathsToSelect = getPaths(tree, mySelectedUserObjects); if (!pathsToSelect.isEmpty()) { tree.getSelectionModel().clearSelection(); tree.setSelectionPaths(pathsToSelect.toArray(new TreePath[pathsToSelect.size()])); } }