@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();
}