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;
}
private static void replaceChildren(
final DefaultMutableTreeNode node, final Collection<? extends ElementNode> arrayList) {
node.removeAllChildren();
for (ElementNode child : arrayList) {
node.add(child);
}
}
private ArrayList<TreeNode> childrenToArray(DefaultMutableTreeNode node) {
ArrayList<TreeNode> arrayList = new ArrayList<TreeNode>();
for (int i = 0; i < node.getChildCount(); i++) {
arrayList.add(node.getChildAt(i));
}
return arrayList;
}
private void collapseTargets() {
DefaultMutableTreeNode root = (DefaultMutableTreeNode) myTreeModel.getRoot();
for (int i = 0; i < root.getChildCount(); i++) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) root.getChildAt(i);
myTree.collapsePath(new TreePath(node.getPath()));
}
}
public void addSelectionPathTo(final Object element) {
DefaultMutableTreeNode node = myAbstractTreeBuilder.getNodeForElement(element);
if (node != null) {
final JTree tree = getTree();
final TreePath path = new TreePath(node.getPath());
if (node == tree.getModel().getRoot() && !tree.isExpanded(path)) tree.expandPath(path);
tree.addSelectionPath(path);
}
}
private static DefaultMutableTreeNode findInChildren(
DefaultMutableTreeNode currentTreeNode, AbstractTreeNode topPathElement) {
for (int i = 0; i < currentTreeNode.getChildCount(); i++) {
TreeNode child = currentTreeNode.getChildAt(i);
if (((DefaultMutableTreeNode) child).getUserObject().equals(topPathElement)) {
return (DefaultMutableTreeNode) child;
}
}
return null;
}
protected void restoreTree() {
Pair<ElementNode, List<ElementNode>> selection = storeSelection();
DefaultMutableTreeNode root = getRootNode();
if (!myShowClasses || myContainerNodes.isEmpty()) {
List<ParentNode> otherObjects = new ArrayList<ParentNode>();
Enumeration<ParentNode> children = getRootNodeChildren();
ParentNode newRoot =
new ParentNode(
null, new MemberChooserObjectBase(getAllContainersNodeName()), new Ref<Integer>(0));
while (children.hasMoreElements()) {
final ParentNode nextElement = children.nextElement();
if (nextElement instanceof ContainerNode) {
final ContainerNode containerNode = (ContainerNode) nextElement;
Enumeration<MemberNode> memberNodes = containerNode.children();
List<MemberNode> memberNodesList = new ArrayList<MemberNode>();
while (memberNodes.hasMoreElements()) {
memberNodesList.add(memberNodes.nextElement());
}
for (MemberNode memberNode : memberNodesList) {
newRoot.add(memberNode);
}
} else {
otherObjects.add(nextElement);
}
}
replaceChildren(root, otherObjects);
sortNode(newRoot, myComparator);
if (newRoot.children().hasMoreElements()) root.add(newRoot);
} else {
Enumeration<ParentNode> children = getRootNodeChildren();
while (children.hasMoreElements()) {
ParentNode allClassesNode = children.nextElement();
Enumeration<MemberNode> memberNodes = allClassesNode.children();
ArrayList<MemberNode> arrayList = new ArrayList<MemberNode>();
while (memberNodes.hasMoreElements()) {
arrayList.add(memberNodes.nextElement());
}
Collections.sort(arrayList, myComparator);
for (MemberNode memberNode : arrayList) {
myNodeToParentMap.get(memberNode).add(memberNode);
}
}
replaceChildren(root, myContainerNodes);
}
myTreeModel.nodeStructureChanged(root);
defaultExpandTree();
restoreSelection(selection);
}
public void addMessages(AntMessage[] messages) {
DefaultMutableTreeNode parentNode =
(DefaultMutableTreeNode) myParentPath.getLastPathComponent();
int[] indices = new int[messages.length];
for (int i = 0; i < messages.length; i++) {
AntMessage message = messages[i];
MessageNode messageNode = createMessageNode(message);
indices[i] = parentNode.getChildCount();
parentNode.insert(messageNode, indices[i]);
myMessageItems.add(messageNode);
}
myTreeModel.nodesWereInserted(parentNode, indices);
handleExpansion();
}
private void _storePaths(DefaultMutableTreeNode root) {
ArrayList<TreeNode> childNodes = childrenToArray(root);
for (final Object childNode1 : childNodes) {
DefaultMutableTreeNode childNode = (DefaultMutableTreeNode) childNode1;
TreePath path = new TreePath(childNode.getPath());
if (myTree.isPathSelected(path)) {
addPathToList(childNode, mySelectionPaths);
}
if ((myTree.isExpanded(path) || childNode.getChildCount() == 0) && !childNode.isLeaf()) {
addPathToList(childNode, myPathsToExpand);
_storePaths(childNode);
}
}
}
public void restore() {
final UsageNode node = myUsageNodes.get(myUsage);
if (node == NULL_NODE || node == null) {
return;
}
final DefaultMutableTreeNode parentGroupingNode = (DefaultMutableTreeNode) node.getParent();
if (parentGroupingNode != null) {
final TreePath treePath = new TreePath(parentGroupingNode.getPath());
myTree.expandPath(treePath);
if (mySelected) {
myTree.addSelectionPath(treePath.pathByAddingChild(node));
}
}
}
public void storePaths() {
myPathsToExpand = new ArrayList<String>();
mySelectionPaths = new ArrayList<String>();
DefaultMutableTreeNode root = (DefaultMutableTreeNode) myTree.getModel().getRoot();
TreePath path = new TreePath(root.getPath());
if (myTree.isPathSelected(path)) {
addPathToList(root, mySelectionPaths);
}
if (myTree.isExpanded(path) || root.getChildCount() == 0) {
addPathToList(root, myPathsToExpand);
_storePaths(root);
}
}
private void restoreUsageExpandState(final Collection<UsageState> states) {
// always expand the last level group
final DefaultMutableTreeNode root = (DefaultMutableTreeNode) myTree.getModel().getRoot();
for (int i = root.getChildCount() - 1; i >= 0; i--) {
final DefaultMutableTreeNode child = (DefaultMutableTreeNode) root.getChildAt(i);
if (child instanceof GroupNode) {
final TreePath treePath = new TreePath(child.getPath());
myTree.expandPath(treePath);
}
}
myTree.getSelectionModel().clearSelection();
for (final UsageState usageState : states) {
usageState.restore();
}
}
private void checkNodeValidity(@NotNull DefaultMutableTreeNode node) {
Enumeration enumeration = node.children();
while (enumeration.hasMoreElements()) {
checkNodeValidity((DefaultMutableTreeNode) enumeration.nextElement());
}
if (node instanceof Node && node != getModelRoot()) ((Node) node).update(this);
}
public void restorePaths() {
final ArrayList<DefaultMutableTreeNode> nodesToExpand = getNodesByPaths(myPathsToExpand);
for (DefaultMutableTreeNode node : nodesToExpand) {
myTree.expandPath(new TreePath(node.getPath()));
}
if (myTree.getSelectionModel().getSelectionCount() == 0) {
final ArrayList<DefaultMutableTreeNode> nodesToSelect = getNodesByPaths(mySelectionPaths);
if (!nodesToSelect.isEmpty()) {
for (DefaultMutableTreeNode node : nodesToSelect) {
TreeUtil.selectInTree(node, false, myTree);
}
} else {
myTree.setSelectionRow(0);
}
}
}
@Nullable
private static Navigatable getNavigatableForNode(@NotNull DefaultMutableTreeNode node) {
Object userObject = node.getUserObject();
if (userObject instanceof Navigatable) {
final Navigatable navigatable = (Navigatable) userObject;
return navigatable.canNavigate() ? navigatable : null;
}
return null;
}
public ElementNodeImpl(
@Nullable DefaultMutableTreeNode parent, MemberChooserObject delegate, Ref<Integer> order) {
myOrder = order.get();
order.set(myOrder + 1);
myDelegate = delegate;
if (parent != null) {
parent.add(this);
}
}
private void captureUsagesExpandState(TreePath pathFrom, final Collection<UsageState> states) {
if (!myTree.isExpanded(pathFrom)) {
return;
}
final DefaultMutableTreeNode node = (DefaultMutableTreeNode) pathFrom.getLastPathComponent();
final int childCount = node.getChildCount();
for (int idx = 0; idx < childCount; idx++) {
final TreeNode child = node.getChildAt(idx);
if (child instanceof UsageNode) {
final Usage usage = ((UsageNode) child).getUsage();
states.add(
new UsageState(
usage,
myTree.getSelectionModel().isPathSelected(pathFrom.pathByAddingChild(child))));
} else {
captureUsagesExpandState(pathFrom.pathByAddingChild(child), states);
}
}
}
public Object getData(String dataId) {
if (LangDataKeys.PSI_ELEMENT.is(dataId)) {
TreePath path = getSelectedUniquePath();
if (path == null) return null;
DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();
Object userObject = node.getUserObject();
if (!(userObject instanceof AbstractTreeNode)) return null;
AbstractTreeNode descriptor = (AbstractTreeNode) userObject;
Object element = descriptor.getValue();
if (element instanceof StructureViewTreeElement) {
element = ((StructureViewTreeElement) element).getValue();
}
if (!(element instanceof PsiElement)) return null;
if (!((PsiElement) element).isValid()) return null;
return element;
}
if (LangDataKeys.PSI_ELEMENT_ARRAY.is(dataId)) {
return convertToPsiElementsArray(getSelectedElements());
}
if (PlatformDataKeys.FILE_EDITOR.is(dataId)) {
return myFileEditor;
}
if (PlatformDataKeys.CUT_PROVIDER.is(dataId)) {
return myCopyPasteDelegator.getCutProvider();
}
if (PlatformDataKeys.COPY_PROVIDER.is(dataId)) {
return myCopyPasteDelegator.getCopyProvider();
}
if (PlatformDataKeys.PASTE_PROVIDER.is(dataId)) {
return myCopyPasteDelegator.getPasteProvider();
}
if (PlatformDataKeys.NAVIGATABLE.is(dataId)) {
Object[] selectedElements = getSelectedTreeElements();
if (selectedElements == null || selectedElements.length == 0) return null;
if (selectedElements[0] instanceof Navigatable) {
return selectedElements[0];
}
}
if (PlatformDataKeys.HELP_ID.is(dataId)) {
return getHelpID();
}
return super.getData(dataId);
}
@Override
public void keyPressed(KeyEvent e) {
TreePath path = myTree.getLeadSelectionPath();
if (path == null) return;
final Object lastComponent = path.getLastPathComponent();
if (e.getKeyCode() == KeyEvent.VK_ENTER) {
if (lastComponent instanceof ParentNode) return;
doOKAction();
e.consume();
} else if (e.getKeyCode() == KeyEvent.VK_INSERT) {
if (lastComponent instanceof ElementNode) {
final DefaultMutableTreeNode node = (DefaultMutableTreeNode) lastComponent;
if (!mySelectedNodes.contains(node)) {
if (node.getNextNode() != null) {
myTree.setSelectionPath(new TreePath(node.getNextNode().getPath()));
}
} else {
if (node.getNextNode() != null) {
myTree.removeSelectionPath(new TreePath(node.getPath()));
myTree.setSelectionPath(new TreePath(node.getNextNode().getPath()));
myTree.repaint();
}
}
e.consume();
}
}
}
private void restoreSelection(Pair<ElementNode, List<ElementNode>> pair) {
List<ElementNode> selectedNodes = pair.second;
DefaultMutableTreeNode root = getRootNode();
ArrayList<TreePath> toSelect = new ArrayList<TreePath>();
for (ElementNode node : selectedNodes) {
DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode) node;
if (root.isNodeDescendant(treeNode)) {
toSelect.add(new TreePath(treeNode.getPath()));
}
}
if (!toSelect.isEmpty()) {
myTree.setSelectionPaths(toSelect.toArray(new TreePath[toSelect.size()]));
}
ElementNode leadNode = pair.first;
if (leadNode != null) {
myTree.setLeadSelectionPath(new TreePath(((DefaultMutableTreeNode) leadNode).getPath()));
}
}
private static void collectUsages(
@NotNull DefaultMutableTreeNode node, @NotNull Set<Usage> usages) {
if (node instanceof UsageNode) {
UsageNode usageNode = (UsageNode) node;
final Usage usage = usageNode.getUsage();
usages.add(usage);
}
Enumeration enumeration = node.children();
while (enumeration.hasMoreElements()) {
DefaultMutableTreeNode child = (DefaultMutableTreeNode) enumeration.nextElement();
collectUsages(child, usages);
}
}
@Nullable
private String getPath(DefaultMutableTreeNode node) {
final Object userObject = node.getUserObject();
if (userObject instanceof String) {
String actionId = (String) userObject;
final TreeNode parent = node.getParent();
if (parent instanceof DefaultMutableTreeNode) {
final Object object = ((DefaultMutableTreeNode) parent).getUserObject();
if (object instanceof Group) {
return ((Group) object).getActionQualifiedPath(actionId);
}
}
return myMainGroup.getActionQualifiedPath(actionId);
}
if (userObject instanceof Group) {
return ((Group) userObject).getQualifiedPath();
}
if (userObject instanceof QuickList) {
return ((QuickList) userObject).getDisplayName();
}
return null;
}
private void reset(
final Keymap keymap,
final QuickList[] allQuickLists,
String filter,
@Nullable KeyboardShortcut shortcut) {
myKeymap = keymap;
final PathsKeeper pathsKeeper = new PathsKeeper();
pathsKeeper.storePaths();
myRoot.removeAllChildren();
ActionManager actionManager = ActionManager.getInstance();
Project project =
CommonDataKeys.PROJECT.getData(DataManager.getInstance().getDataContext(myComponent));
Group mainGroup =
ActionsTreeUtil.createMainGroup(
project,
myKeymap,
allQuickLists,
filter,
true,
ActionsTreeUtil.isActionFiltered(actionManager, myKeymap, shortcut, filter, true));
if ((filter != null && filter.length() > 0 || shortcut != null)
&& mainGroup.initIds().isEmpty()) {
mainGroup =
ActionsTreeUtil.createMainGroup(
project,
myKeymap,
allQuickLists,
filter,
false,
ActionsTreeUtil.isActionFiltered(actionManager, myKeymap, shortcut, filter, false));
}
myRoot = ActionsTreeUtil.createNode(mainGroup);
myMainGroup = mainGroup;
MyModel model = (MyModel) myTree.getModel();
model.setRoot(myRoot);
model.nodeStructureChanged(myRoot);
pathsKeeper.restorePaths();
}
public void finishBuild(String messageText) {
collapseTargets();
DefaultMutableTreeNode root = (DefaultMutableTreeNode) myTreeModel.getRoot();
myStatusNode = new DefaultMutableTreeNode(messageText);
myTreeModel.insertNodeInto(myStatusNode, root, root.getChildCount());
}
public void scrollToStatus() {
if (myStatusNode != null) {
TreeUtil.selectPath(myTree, new TreePath(myStatusNode.getPath()));
}
}