@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 void selectFirstBreakpoint() { TreeUtil.traverseDepth( myRootNode, new TreeUtil.Traverse() { public boolean accept(Object node) { final CheckedTreeNode treeNode = (CheckedTreeNode) node; final TreeDescriptor descriptor = (TreeDescriptor) treeNode.getUserObject(); if (descriptor instanceof BreakpointDescriptor) { TreeUtil.selectNode(BreakpointTree.this, treeNode); return false; } return true; } }); }
protected static MyNode findNodeByCondition( final TreeNode root, final Condition<NamedConfigurable> condition) { final MyNode[] nodeToSelect = new MyNode[1]; TreeUtil.traverseDepth( root, new TreeUtil.Traverse() { public boolean accept(Object node) { if (condition.value(((MyNode) node).getConfigurable())) { nodeToSelect[0] = (MyNode) node; return false; } return true; } }); return nodeToSelect[0]; }
protected void clearChildren() { TreeUtil.traverseDepth( myRoot, new TreeUtil.Traverse() { public boolean accept(Object node) { if (node instanceof MyNode) { final MyNode treeNode = ((MyNode) node); treeNode.getConfigurable().disposeUIResources(); if (!(treeNode instanceof MyRootNode)) { treeNode.setUserObject(null); } } return true; } }); myRoot.removeAllChildren(); }
public boolean isModified() { if (myHasDeletedItems) return true; final boolean[] modified = new boolean[1]; TreeUtil.traverseDepth( myRoot, new TreeUtil.Traverse() { public boolean accept(Object node) { if (node instanceof MyNode) { final NamedConfigurable configurable = ((MyNode) node).getConfigurable(); if (isInitialized(configurable) && configurable.isModified()) { modified[0] = true; return false; } } return true; } }); return modified[0]; }
public List<PackagingElementNode<?>> findNodes( final Collection<? extends PackagingElement<?>> elements) { final List<PackagingElementNode<?>> nodes = new ArrayList<PackagingElementNode<?>>(); TreeUtil.traverseDepth( getRootNode(), new TreeUtil.Traverse() { public boolean accept(Object node) { final Object userObject = ((DefaultMutableTreeNode) node).getUserObject(); if (userObject instanceof PackagingElementNode) { final PackagingElementNode<?> packagingNode = (PackagingElementNode<?>) userObject; final List<? extends PackagingElement<?>> nodeElements = packagingNode.getPackagingElements(); if (ContainerUtil.intersects(nodeElements, elements)) { nodes.add(packagingNode); } } return true; } }); return nodes; }
public Breakpoint[] getSelectedBreakpoints() { final TreePath[] selectionPaths = getSelectionPaths(); if (selectionPaths == null || selectionPaths.length == 0) { return Breakpoint.EMPTY_ARRAY; } final List<Breakpoint> breakpoints = new ArrayList<Breakpoint>(selectionPaths.length); for (TreePath path : selectionPaths) { final CheckedTreeNode node = (CheckedTreeNode) path.getLastPathComponent(); TreeUtil.traverseDepth( node, new TreeUtil.Traverse() { public boolean accept(Object _node) { final CheckedTreeNode node = (CheckedTreeNode) _node; final TreeDescriptor descriptor = (TreeDescriptor) node.getUserObject(); if (descriptor instanceof BreakpointDescriptor) { breakpoints.add(((BreakpointDescriptor) descriptor).getBreakpoint()); } return true; } }); } return breakpoints.toArray(new Breakpoint[breakpoints.size()]); }
protected void doOKAction() { final ActionManager actionManager = ActionManager.getInstance(); TreeUtil.traverseDepth( (TreeNode) myTree.getModel().getRoot(), new TreeUtil.Traverse() { public boolean accept(Object node) { if (node instanceof DefaultMutableTreeNode) { final DefaultMutableTreeNode mutableNode = (DefaultMutableTreeNode) node; final Object userObject = mutableNode.getUserObject(); if (userObject instanceof Pair) { String actionId = (String) ((Pair) userObject).first; final AnAction action = actionManager.getAction(actionId); Icon icon = (Icon) ((Pair) userObject).second; action.getTemplatePresentation().setIcon(icon); action.setDefaultIcon(icon == null); editToolbarIcon(actionId, mutableNode); } } return true; } }); super.doOKAction(); setCustomizationSchemaForCurrentProjects(); }