From 67b2b4a4f30983a113bd05f60bdaa3e630db0455 Mon Sep 17 00:00:00 2001 From: Kirill Kalishev Date: Thu, 8 Oct 2009 19:11:15 +0400 Subject: [PATCH] TreeUi: misc tests and fixes --- .../ide/util/treeView/AbstractTreeUi.java | 23 ++++- .../ide/util/treeView/UpdaterTreeState.java | 7 -- .../filtered/FilteringTreeBuilder.java | 85 ++++--------------- 3 files changed, 37 insertions(+), 78 deletions(-) diff --git a/platform/platform-api/src/com/intellij/ide/util/treeView/AbstractTreeUi.java b/platform/platform-api/src/com/intellij/ide/util/treeView/AbstractTreeUi.java index 3d9876bfc65d..52c2ebf23308 100644 --- a/platform/platform-api/src/com/intellij/ide/util/treeView/AbstractTreeUi.java +++ b/platform/platform-api/src/com/intellij/ide/util/treeView/AbstractTreeUi.java @@ -643,8 +643,6 @@ public class AbstractTreeUi { } final void updateSubtreeNow(TreeUpdatePass pass, boolean canSmartExpand) { - System.out.println("AbstractTreeUi.updateSubtreeNow pass=" + pass); - maybeSetBusyAndScheduleWaiterForReady(true); initRootNodeNowIfNeeded(pass); @@ -1813,6 +1811,8 @@ public class AbstractTreeUi { } private boolean isValidForSelectionAdjusting(TreeNode node) { + if (!myTree.isRootVisible() && getRootNode() == node) return false; + if (isLoadingNode(node)) return true; final Object elementInTree = getElementFor(node); @@ -2376,7 +2376,14 @@ public class AbstractTreeUi { if (!addToSelection) { myTree.clearSelection(); } - addNext(elementsToSelect, 0, onDone, originalRows, deferred, scrollToVisible, canSmartExpand); + addNext(elementsToSelect, 0, new Runnable() { + public void run() { + if (getTree().isSelectionEmpty()) { + restoreSelection(currentElements); + } + runDone(onDone); + } + }, originalRows, deferred, scrollToVisible, canSmartExpand); } else { addToDeferred(elementsToSelect, onDone); @@ -2385,6 +2392,16 @@ public class AbstractTreeUi { }); } + private void restoreSelection(Set selection) { + for (Object each : selection) { + DefaultMutableTreeNode node = getNodeForElement(each, false); + if (node != null && isValidForSelectionAdjusting(node)) { + addSelectionPath(getPathFor(node), false, null); + } + } + } + + private void addToDeferred(final Object[] elementsToSelect, final Runnable onDone) { myDeferredSelections.clear(); myDeferredSelections.add(new Runnable() { diff --git a/platform/platform-api/src/com/intellij/ide/util/treeView/UpdaterTreeState.java b/platform/platform-api/src/com/intellij/ide/util/treeView/UpdaterTreeState.java index 79305738c32d..4441ed412ff0 100644 --- a/platform/platform-api/src/com/intellij/ide/util/treeView/UpdaterTreeState.java +++ b/platform/platform-api/src/com/intellij/ide/util/treeView/UpdaterTreeState.java @@ -130,8 +130,6 @@ public class UpdaterTreeState { myProcessingNow = true; - System.out.println("UpdaterTreeState.restore actionNode=" + actionNode); - final Object[] toSelect = getToSelect(); final Object[] toExpand = getToExpand(); @@ -144,10 +142,8 @@ public class UpdaterTreeState { final Set originallySelected = myUi.getSelectedElements(); - System.out.println("UpdaterTreeState.restore toSelect=" + Arrays.asList(toSelect) + " now selected=" + originallySelected); myUi._select(toSelect, new Runnable() { public void run() { - System.out.println("UpdaterTreeState.run finished selecting=" + Arrays.asList(toSelect) + " now selected=" + myUi.getSelectedElements() + " adjuested=" + adjusted); processUnsuccessfulSelections(toSelect, new Function() { public Object fun(final Object o) { if (myUi.getTree().isRootVisible() || !myUi.getTreeStructure().getRootElement().equals(o)) { @@ -186,11 +182,9 @@ public class UpdaterTreeState { if (readyElement.equals(myUi.getTreeStructure().getParentElement(eachToSelect))) { List children = myUi.getLoadedChildrenFor(readyElement); if (!children.contains(eachToSelect)) { - System.out.println(" removed from toSelect node=" + eachToSelect); toSelect.remove(); if (!myToSelect.containsKey(readyElement) && !myUi.getSelectedElements().contains(eachToSelect)) { addAdjustedSelection(eachToSelect, Condition.FALSE); - System.out.println(" addToAdjusted node=" + eachToSelect); } } } @@ -328,7 +322,6 @@ public class UpdaterTreeState { } public void addAdjustedSelection(final Object element, Condition isExpired) { - System.out.println("UpdaterTreeState.addAdjustedSelection " + element); myAdjustedSelection.put(element, isExpired); } diff --git a/platform/platform-api/src/com/intellij/ui/treeStructure/filtered/FilteringTreeBuilder.java b/platform/platform-api/src/com/intellij/ui/treeStructure/filtered/FilteringTreeBuilder.java index 87404a69257e..ca9f2331a1b0 100644 --- a/platform/platform-api/src/com/intellij/ui/treeStructure/filtered/FilteringTreeBuilder.java +++ b/platform/platform-api/src/com/intellij/ui/treeStructure/filtered/FilteringTreeBuilder.java @@ -6,16 +6,17 @@ import com.intellij.ide.util.treeView.NodeDescriptor; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.ActionCallback; import com.intellij.openapi.util.Disposer; -import com.intellij.openapi.util.Ref; import com.intellij.ui.speedSearch.ElementFilter; -import com.intellij.ui.treeStructure.*; +import com.intellij.ui.treeStructure.PatchedDefaultMutableTreeNode; +import com.intellij.ui.treeStructure.SimpleTree; +import com.intellij.ui.treeStructure.Tree; import com.intellij.util.ui.update.MergingUpdateQueue; import com.intellij.util.ui.update.Update; import org.jetbrains.annotations.Nullable; +import javax.swing.*; import javax.swing.tree.DefaultMutableTreeNode; import javax.swing.tree.DefaultTreeModel; -import javax.swing.*; import java.util.Comparator; public class FilteringTreeBuilder extends AbstractTreeBuilder { @@ -105,18 +106,22 @@ public class FilteringTreeBuilder extends AbstractTreeBuilder { private ActionCallback refilterNow(final Object preferredSelection, final boolean adjustSelection) { final ActionCallback result = new ActionCallback(); - ((FilteringTreeStructure)getTreeStructure()).refilter(); + getFilteredStructure().refilter(); updateFromRoot(); getReady(this).doWhenDone(new Runnable() { public void run() { - System.out.println("ready=" + getUi().isReady() + " preferred=" + preferredSelection); + Object toSelect = preferredSelection != null ? preferredSelection : myLastSuccessfulSelect; - if (adjustSelection && preferredSelection != null) { - FilteringTreeStructure.Node node = ((FilteringTreeStructure)getTreeStructure()).getVisibleNodeFor(preferredSelection); - if (node != null) { - select(node, new Runnable() { + if (adjustSelection && toSelect != null) { + final FilteringTreeStructure.Node nodeToSelect = getFilteredStructure().getVisibleNodeFor(toSelect); + + if (nodeToSelect != null) { + select(nodeToSelect, new Runnable() { public void run() { + if (getSelectedElements().contains(nodeToSelect)) { + myLastSuccessfulSelect = getOriginalNode(nodeToSelect); + } result.setDone(); } }); @@ -130,64 +135,8 @@ public class FilteringTreeBuilder extends AbstractTreeBuilder { return result; } - private void select(boolean adjustSelection, final Ref toSelect) { - if (adjustSelection) { - System.out.println("FilteringTreeBuilder.select toSelect=" + toSelect.get()); - - boolean wasSelected = false; - if (toSelect.get() != null && isSelectable(toSelect.get()) && isSimpleTree()) { - wasSelected = ((SimpleTree)myTree).select(this, new SimpleNodeVisitor() { - public boolean accept(SimpleNode simpleNode) { - if (simpleNode instanceof FilteringTreeStructure.Node) { - FilteringTreeStructure.Node node = (FilteringTreeStructure.Node)simpleNode; - return node.getDelegate().equals(toSelect.get()); - } - else { - return false; - } - } - }, true); - } - - if (!wasSelected && isSimpleTree()) { - ((SimpleTree)myTree).select(this, new SimpleNodeVisitor() { - public boolean accept(SimpleNode simpleNode) { - if (simpleNode instanceof FilteringTreeStructure.Node) { - - final boolean isRoot = getTreeStructure().getRootElement() == simpleNode; - if (isRoot && !myTree.isRootVisible()) return false; - - FilteringTreeStructure.Node node = (FilteringTreeStructure.Node)simpleNode; - if (isSelectable(node.getDelegate())) { - return true; - } - } - else { - return false; - } - return false; - } - }, true); - } - - if (!wasSelected && myLastSuccessfulSelect != null && isSimpleTree()) { - wasSelected = ((SimpleTree)myTree).select(this, new SimpleNodeVisitor() { - public boolean accept(SimpleNode simpleNode) { - if (simpleNode instanceof FilteringTreeStructure.Node) { - Object object = ((FilteringTreeStructure.Node)simpleNode).getDelegate(); - return myLastSuccessfulSelect.equals(object); - } - return false; - } - }, true); - if (wasSelected) { - myLastSuccessfulSelect = getSelected(); - } - } - else if (wasSelected) { - myLastSuccessfulSelect = getSelected(); - } - } + private FilteringTreeStructure getFilteredStructure() { + return ((FilteringTreeStructure)getTreeStructure()); } //todo kirillk @@ -207,7 +156,7 @@ public class FilteringTreeBuilder extends AbstractTreeBuilder { } public FilteringTreeStructure.Node getVisibleNodeFor(Object nodeObject) { - return ((FilteringTreeStructure)getTreeStructure()).getVisibleNodeFor(nodeObject); + return getFilteredStructure().getVisibleNodeFor(nodeObject); } public Object getOriginalNode(Object node) {