platform/platform-impl/src/com/intellij/openapi/options/newEditor/OptionsTree.java

   1 package com.intellij.openapi.options.newEditor;
   2
   3 import com.intellij.ide.util.treeView.NodeDescriptor;
   4 import com.intellij.openapi.Disposable;
   5 import com.intellij.openapi.options.Configurable;
   6 import com.intellij.openapi.options.ConfigurableGroup;
   7 import com.intellij.openapi.options.SearchableConfigurable;
   8 import com.intellij.openapi.project.Project;
   9 import com.intellij.openapi.util.ActionCallback;
  10 import com.intellij.openapi.util.Disposer;
  11 import com.intellij.openapi.util.SystemInfo;
  12 import com.intellij.ui.ErrorLabel;
  13 import com.intellij.ui.GroupedElementsRenderer;
  14 import com.intellij.ui.LoadingNode;
  15 import com.intellij.ui.TreeUIHelper;
  16 import com.intellij.ui.components.panels.NonOpaquePanel;
  17 import com.intellij.ui.treeStructure.*;
  18 import com.intellij.ui.treeStructure.filtered.FilteringTreeBuilder;
  19 import com.intellij.ui.treeStructure.filtered.FilteringTreeStructure;
  20 import com.intellij.util.ui.UIUtil;
  21 import com.intellij.util.ui.update.MergingUpdateQueue;
  22 import com.intellij.util.ui.update.Update;
  23 import org.jetbrains.annotations.Nullable;
  24
  25 import javax.swing.*;
  26 import javax.swing.border.EmptyBorder;
  27 import javax.swing.event.TreeExpansionEvent;
  28 import javax.swing.event.TreeExpansionListener;
  29 import javax.swing.event.TreeSelectionEvent;
  30 import javax.swing.event.TreeSelectionListener;
  31 import javax.swing.plaf.TreeUI;
  32 import javax.swing.plaf.basic.BasicTreeUI;
  33 import javax.swing.tree.DefaultMutableTreeNode;
  34 import javax.swing.tree.TreeCellRenderer;
  35 import javax.swing.tree.TreePath;
  36 import javax.swing.tree.TreeSelectionModel;
  37 import java.awt.*;
  38 import java.awt.event.*;
  39 import java.util.*;
  40 import java.util.List;
  41
  42 public class OptionsTree extends JPanel implements Disposable, OptionsEditorColleague {
  43   Project myProject;
  44   final SimpleTree myTree;
  45   List<ConfigurableGroup> myGroups;
  46   FilteringTreeBuilder myBuilder;
  47   Root myRoot;
  48   OptionsEditorContext myContext;
  49
  50   Map<Configurable, EditorNode> myConfigurable2Node = new HashMap<Configurable, EditorNode>();
  51
  52   MergingUpdateQueue mySelection;
  53   private final OptionsTree.Renderer myRendrer;
  54
  55   public OptionsTree(Project project, ConfigurableGroup[] groups, OptionsEditorContext context) {
  56     myProject = project;
  57     myGroups = Arrays.asList(groups);
  58     myContext = context;
  59
  60
  61     myRoot = new Root();
  62     final SimpleTreeStructure structure = new SimpleTreeStructure() {
  63       public Object getRootElement() {
  64         return myRoot;
  65       }
  66     };
  67
  68     myTree = new MyTree();
  69     myTree.setBorder(new EmptyBorder(0, 1, 0, 0));
  70
  71     myTree.setRowHeight(-1);
  72     myTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
  73     myRendrer = new Renderer();
  74     myTree.setCellRenderer(myRendrer);
  75     myTree.setRootVisible(false);
  76     myTree.setShowsRootHandles(false);
  77     myBuilder = new MyBuilder(structure);
  78     myBuilder.setFilteringMerge(300, null);
  79     Disposer.register(this, myBuilder);
  80
  81     myBuilder.updateFromRoot();
  82
  83     setLayout(new BorderLayout());
  84
  85     myTree.addComponentListener(new ComponentAdapter() {
  86       @Override
  87       public void componentResized(final ComponentEvent e) {
  88         revalidateTree();
  89       }
  90
  91       @Override
  92       public void componentMoved(final ComponentEvent e) {
  93         revalidateTree();
  94       }
  95
  96       @Override
  97       public void componentShown(final ComponentEvent e) {
  98         revalidateTree();
  99       }
 100     });
 101
 102     final JScrollPane scrolls = new JScrollPane(myTree);
 103     scrolls.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
 104
 105     add(scrolls, BorderLayout.CENTER);
 106
 107     mySelection = new MergingUpdateQueue("OptionsTree", 150, false, this, this, this).setRestartTimerOnAdd(true);
 108     myTree.getSelectionModel().addTreeSelectionListener(new TreeSelectionListener() {
 109       public void valueChanged(final TreeSelectionEvent e) {
 110         final TreePath path = e.getNewLeadSelectionPath();
 111         if (path == null) {
 112           queueSelection(null);
 113         }
 114         else {
 115           final Base base = extractNode(path.getLastPathComponent());
 116           queueSelection(base != null ? base.getConfigurable() : null);
 117         }
 118       }
 119     });
 120     myTree.addKeyListener(new KeyListener() {
 121       public void keyTyped(final KeyEvent e) {
 122         _onTreeKeyEvent(e);
 123       }
 124
 125       public void keyPressed(final KeyEvent e) {
 126         _onTreeKeyEvent(e);
 127       }
 128
 129       public void keyReleased(final KeyEvent e) {
 130         _onTreeKeyEvent(e);
 131       }
 132     });
 133   }
 134
 135   protected void _onTreeKeyEvent(KeyEvent e) {
 136     final KeyStroke stroke = KeyStroke.getKeyStrokeForEvent(e);
 137
 138     final Object action = myTree.getInputMap().get(stroke);
 139     if (action == null) {
 140       onTreeKeyEvent(e);
 141     }
 142   }
 143
 144   protected void onTreeKeyEvent(KeyEvent e) {
 145
 146   }
 147
 148
 149   ActionCallback select(@Nullable Configurable configurable) {
 150     return queueSelection(configurable);
 151   }
 152
 153   public void selectFirst() {
 154     for (ConfigurableGroup eachGroup : myGroups) {
 155       final Configurable[] kids = eachGroup.getConfigurables();
 156       if (kids.length > 0) {
 157         queueSelection(kids[0]);
 158         return;
 159       }
 160     }
 161   }
 162
 163   ActionCallback queueSelection(final Configurable configurable) {
 164     final ActionCallback callback = new ActionCallback();
 165     final Update update = new Update(this) {
 166       public void run() {
 167         if (configurable == null) {
 168           myTree.getSelectionModel().clearSelection();
 169           myContext.fireSelected(null, OptionsTree.this);
 170         }
 171         else {
 172           final EditorNode editorNode = myConfigurable2Node.get(configurable);
 173           FilteringTreeStructure.Node editorUiNode = myBuilder.getVisibleNodeFor(editorNode);
 174           if (!myBuilder.getSelectedElements().contains(editorUiNode)) {
 175             myBuilder.select(editorUiNode, new Runnable() {
 176               public void run() {
 177                 fireSelected(configurable, callback);
 178               }
 179             });
 180           } else {
 181             myBuilder.scrollSelectionToVisible(new Runnable() {
 182               public void run() {
 183                 fireSelected(configurable, callback);
 184               }
 185             }, false);
 186           }
 187         }
 188       }
 189
 190       @Override
 191       public void setRejected() {
 192         super.setRejected();
 193         callback.setRejected();
 194       }
 195     };
 196     mySelection.queue(update);
 197     return callback;
 198   }
 199
 200   private void fireSelected(Configurable configurable, final ActionCallback callback) {
 201     myContext.fireSelected(configurable, this).doWhenProcessed(new Runnable() {
 202       public void run() {
 203         callback.setDone();
 204       }
 205     });
 206   }
 207
 208   void revalidateTree() {
 209     myTree.invalidate();
 210     myTree.setRowHeight(myTree.getRowHeight() == -1 ? -2 : -1);
 211     myTree.revalidate();
 212     myTree.repaint();
 213   }
 214
 215   public JTree getTree() {
 216     return myTree;
 217   }
 218
 219   public List<Configurable> getPathToRoot(final Configurable configurable) {
 220     final ArrayList<Configurable> path = new ArrayList<Configurable>();
 221
 222     EditorNode eachNode = myConfigurable2Node.get(configurable);
 223     if (eachNode == null) return path;
 224
 225     while (eachNode != null) {
 226       path.add(eachNode.getConfigurable());
 227       final SimpleNode parent = eachNode.getParent();
 228       if (parent instanceof EditorNode) {
 229         eachNode = (EditorNode)parent;
 230       }
 231       else {
 232         break;
 233       }
 234     }
 235
 236     return path;
 237   }
 238
 239   @Nullable
 240   public Configurable getParentFor(final Configurable configurable) {
 241     final List<Configurable> path = getPathToRoot(configurable);
 242     if (path.size() > 1) {
 243       return path.get(1);
 244     }
 245     else {
 246       return null;
 247     }
 248   }
 249
 250   public SimpleNode findNodeFor(final Configurable toSelect) {
 251     return myConfigurable2Node.get(toSelect);
 252   }
 253
 254   class Renderer extends GroupedElementsRenderer.Tree implements TreeCellRenderer {
 255
 256
 257     private JLabel myHandle;
 258
 259     @Override
 260     protected void layout() {
 261       myRendererComponent.setOpaqueActive(false);
 262
 263       myRendererComponent.add(mySeparatorComponent, BorderLayout.NORTH);
 264
 265       final NonOpaquePanel content = new NonOpaquePanel(new BorderLayout());
 266       myHandle = new JLabel("", JLabel.CENTER);
 267       if (!SystemInfo.isMac) {
 268         myHandle.setBorder(new EmptyBorder(0, 2, 0, 2));
 269       }
 270       myHandle.setOpaque(false);
 271       content.add(myHandle, BorderLayout.WEST);
 272       content.add(myComponent, BorderLayout.CENTER);
 273       myRendererComponent.add(content, BorderLayout.CENTER);
 274     }
 275
 276     public Component getTreeCellRendererComponent(final JTree tree,
 277                                                   final Object value,
 278                                                   final boolean selected,
 279                                                   final boolean expanded,
 280                                                   final boolean leaf,
 281                                                   final int row,
 282                                                   final boolean hasFocus) {
 283
 284
 285       JComponent result;
 286       Color fg = UIUtil.getTreeTextForeground();
 287
 288       final Base base = extractNode(value);
 289       if (base instanceof EditorNode) {
 290         DefaultMutableTreeNode node = (DefaultMutableTreeNode)value;
 291
 292         final EditorNode editor = (EditorNode)base;
 293         ConfigurableGroup group = null;
 294         if (editor.getParent() == myRoot) {
 295           final DefaultMutableTreeNode prevValue = ((DefaultMutableTreeNode)value).getPreviousSibling();
 296           if (prevValue == null || prevValue instanceof LoadingNode) {
 297             group = editor.getGroup();
 298           }
 299           else {
 300             final Base prevBase = extractNode(prevValue);
 301             if (prevBase instanceof EditorNode) {
 302               final EditorNode prevEditor = (EditorNode)prevBase;
 303               if (prevEditor.getGroup() != editor.getGroup()) {
 304                 group = editor.getGroup();
 305               }
 306             }
 307           }
 308         }
 309
 310         int forcedWidth = 2000;
 311         TreePath path = tree.getPathForRow(row);
 312         if (path == null) {
 313           if (value instanceof DefaultMutableTreeNode) {
 314             path = new TreePath(((DefaultMutableTreeNode)value).getPath());
 315           }
 316         }
 317
 318         final boolean toStretch = tree.isVisible() && path != null;
 319
 320         if (toStretch) {
 321           final Rectangle visibleRect = tree.getVisibleRect();
 322
 323           int nestingLevel = tree.isRootVisible() ? path.getPathCount() - 1 : path.getPathCount() - 2;
 324
 325           final int left = UIManager.getInt("Tree.leftChildIndent");
 326           final int right = UIManager.getInt("Tree.rightChildIndent");
 327
 328           final Insets treeInsets = tree.getInsets();
 329
 330           int indent = (left + right) * nestingLevel + (treeInsets != null ? treeInsets.left + treeInsets.right : 0);
 331
 332           forcedWidth = visibleRect.width > 0 ? visibleRect.width - indent : forcedWidth;
 333         }
 334
 335         result = configureComponent(base.getText(), base.getText(), null, null, row == -1 ? true : selected, group != null,
 336                                     group != null ? group.getDisplayName() : null, forcedWidth - 4);
 337
 338
 339         if (base.isError()) {
 340           fg = Color.red;
 341         }
 342         else if (base.isModified()) {
 343           fg = Color.blue;
 344         }
 345
 346       }
 347       else {
 348         result = configureComponent(value.toString(), null, null, null, selected, false, null, -1);
 349       }
 350
 351       if (value instanceof DefaultMutableTreeNode) {
 352         DefaultMutableTreeNode node = (DefaultMutableTreeNode)value;
 353         TreePath nodePath = new TreePath(node.getPath());
 354         myHandle.setIcon(((SimpleTree)tree).getHandleIcon(node, nodePath));
 355       } else {
 356         myHandle.setIcon(null);
 357       }
 358
 359
 360       myTextLabel.setForeground(selected ? UIUtil.getTreeSelectionForeground() : fg);
 361
 362       myTextLabel.setOpaque(selected);
 363
 364       return result;
 365     }
 366
 367     protected JComponent createItemComponent() {
 368       myTextLabel = new ErrorLabel();
 369       return myTextLabel;
 370     }
 371
 372     public boolean isUnderHandle(final Point point) {
 373       final Point handlePoint = SwingUtilities.convertPoint(myRendererComponent, point, myHandle);
 374       final Rectangle bounds = myHandle.getBounds();
 375       return bounds.x < handlePoint.x && bounds.getMaxX() >= handlePoint.x;
 376     }
 377   }
 378
 379   @Nullable
 380   private Base extractNode(Object object) {
 381     if (object instanceof DefaultMutableTreeNode) {
 382       final DefaultMutableTreeNode uiNode = (DefaultMutableTreeNode)object;
 383       final Object o = uiNode.getUserObject();
 384       if (o instanceof FilteringTreeStructure.Node) {
 385         return (Base)((FilteringTreeStructure.Node)o).getDelegate();
 386       }
 387     }
 388
 389     return null;
 390   }
 391
 392   abstract class Base extends CachingSimpleNode {
 393
 394     protected Base(final SimpleNode aParent) {
 395       super(aParent);
 396     }
 397
 398     String getText() {
 399       return null;
 400     }
 401
 402     boolean isModified() {
 403       return false;
 404     }
 405
 406     boolean isError() {
 407       return false;
 408     }
 409
 410     Configurable getConfigurable() {
 411       return null;
 412     }
 413   }
 414
 415   class Root extends Base {
 416
 417     Root() {
 418       super(null);
 419     }
 420
 421     protected SimpleNode[] buildChildren() {
 422       ArrayList<SimpleNode> result = new ArrayList<SimpleNode>();
 423       for (int i = 0; i < myGroups.size(); i++) {
 424         ConfigurableGroup eachGroup = myGroups.get(i);
 425         result.addAll(buildGroup(eachGroup));
 426       }
 427
 428       return result.toArray(new SimpleNode[result.size()]);
 429     }
 430
 431     private List<EditorNode> buildGroup(final ConfigurableGroup eachGroup) {
 432       List<EditorNode> result = new ArrayList<EditorNode>();
 433       final Configurable[] kids = eachGroup.getConfigurables();
 434       if (kids.length > 0) {
 435         for (Configurable eachKid : kids) {
 436           if (isInvisibleNode(eachKid)) {
 437             result.addAll(OptionsTree.this.buildChildren(eachKid, this, eachGroup));
 438           }
 439           else {
 440             result.add(new EditorNode(this, eachKid, eachGroup));
 441           }
 442         }
 443
 444       }
 445       return sort(result);
 446     }
 447   }
 448
 449   private boolean isInvisibleNode(final Configurable child) {
 450     return child instanceof SearchableConfigurable.Parent && !((SearchableConfigurable.Parent)child).isVisible();
 451   }
 452
 453   private static List<EditorNode> sort(List<EditorNode> c) {
 454     List<EditorNode> cc = new ArrayList<EditorNode>(c);
 455     Collections.sort(cc, new Comparator<EditorNode>() {
 456       public int compare(final EditorNode o1, final EditorNode o2) {
 457         return getConfigurableDisplayName(o1.getConfigurable()).compareToIgnoreCase(getConfigurableDisplayName(o2.getConfigurable()));
 458       }
 459     });
 460     return cc;
 461   }
 462
 463   private static String getConfigurableDisplayName(final Configurable c) {
 464     final String name = c.getDisplayName();
 465     return name != null ? name : "{ Unnamed Page:" + c.getClass().getSimpleName() + " }";
 466   }
 467
 468   private List<EditorNode> buildChildren(final Configurable configurable, SimpleNode parent, final ConfigurableGroup group) {
 469     if (configurable instanceof Configurable.Composite) {
 470       final Configurable[] kids = ((Configurable.Composite)configurable).getConfigurables();
 471       final List<EditorNode> result = new ArrayList<EditorNode>(kids.length);
 472       for (Configurable child : kids) {
 473         if (isInvisibleNode(child)) {
 474           result.addAll(buildChildren(child, parent, group));
 475         }
 476         result.add(new EditorNode(parent, child, group));
 477         myContext.registerKid(configurable, child);
 478       }
 479       return result; // TODO: DECIDE IF INNERS SHOULD BE SORTED: sort(result);
 480     }
 481     else {
 482       return Collections.EMPTY_LIST;
 483     }
 484   }
 485
 486   class EditorNode extends Base {
 487
 488     Configurable myConfigurable;
 489     ConfigurableGroup myGroup;
 490
 491     EditorNode(SimpleNode parent, Configurable configurable, @Nullable ConfigurableGroup group) {
 492       super(parent);
 493       myConfigurable = configurable;
 494       myGroup = group;
 495       myConfigurable2Node.put(configurable, this);
 496       addPlainText(getConfigurableDisplayName(configurable));
 497     }
 498
 499     protected EditorNode[] buildChildren() {
 500       List<EditorNode> list = OptionsTree.this.buildChildren(myConfigurable, this, null);
 501       return list.toArray(new EditorNode[list.size()]);
 502     }
 503
 504     @Override
 505     public boolean isContentHighlighted() {
 506       return getParent() == myRoot;
 507     }
 508
 509     @Override
 510     Configurable getConfigurable() {
 511       return myConfigurable;
 512     }
 513
 514     @Override
 515     public int getWeight() {
 516       if (getParent() == myRoot) {
 517         return Integer.MAX_VALUE - myGroups.indexOf(myGroup);
 518       }
 519       else {
 520         return WeightBasedComparator.UNDEFINED_WEIGHT;
 521       }
 522     }
 523
 524     public ConfigurableGroup getGroup() {
 525       return myGroup;
 526     }
 527
 528     @Override
 529     String getText() {
 530       return getConfigurableDisplayName(myConfigurable).replace("\n", " ");
 531     }
 532
 533     @Override
 534     boolean isModified() {
 535       return myContext.getModified().contains(myConfigurable);
 536     }
 537
 538     @Override
 539     boolean isError() {
 540       return myContext.getErrors().containsKey(myConfigurable);
 541     }
 542   }
 543
 544   public void dispose() {
 545   }
 546
 547   public ActionCallback onSelected(final Configurable configurable, final Configurable oldConfigurable) {
 548     return queueSelection(configurable);
 549   }
 550
 551   public ActionCallback onModifiedAdded(final Configurable colleague) {
 552     myTree.repaint();
 553     return new ActionCallback.Done();
 554   }
 555
 556   public ActionCallback onModifiedRemoved(final Configurable configurable) {
 557     myTree.repaint();
 558     return new ActionCallback.Done();
 559   }
 560
 561   public ActionCallback onErrorsChanged() {
 562     return new ActionCallback.Done();
 563   }
 564
 565   public void processTextEvent(KeyEvent e) {
 566     myTree.processKeyEvent(e);
 567   }
 568
 569   private class MyTree extends SimpleTree {
 570
 571     private MyTree() {
 572       getInputMap().clear();
 573     }
 574
 575     @Override
 576     protected boolean highlightSingleNode() {
 577       return false;
 578     }
 579
 580     @Override
 581     public void setUI(final TreeUI ui) {
 582       TreeUI actualUI = ui;
 583       if (!(ui instanceof MyTreeUi)) {
 584         actualUI = new MyTreeUi();
 585       }
 586       super.setUI(actualUI);
 587     }
 588
 589     @Override
 590     protected void configureUiHelper(final TreeUIHelper helper) {
 591       helper.installToolTipHandler(this);
 592     }
 593
 594     @Override
 595     public boolean getScrollableTracksViewportWidth() {
 596       return true;
 597     }
 598
 599
 600     @Override
 601     public void processKeyEvent(final KeyEvent e) {
 602       TreePath path = myTree.getSelectionPath();
 603       if (path != null) {
 604         if (e.getKeyCode() == KeyEvent.VK_LEFT) {
 605           if (isExpanded(path)) {
 606             collapsePath(path);
 607             return;
 608           }
 609         } else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
 610           if (isCollapsed(path)) {
 611             expandPath(path);
 612             return;
 613           }
 614         }
 615       }
 616
 617       super.processKeyEvent(e);
 618     }
 619
 620     @Override
 621     protected void processMouseEvent(final MouseEvent e) {
 622       final MyTreeUi ui = (MyTreeUi)myTree.getUI();
 623       if (e.getID() == MouseEvent.MOUSE_RELEASED && UIUtil.isActionClick(e, MouseEvent.MOUSE_RELEASED) && !ui.isToggleEvent(e)) {
 624         final TreePath path = getPathForLocation(e.getX(), e.getY());
 625         if (path != null) {
 626           final Rectangle bounds = getPathBounds(path);
 627           if (bounds != null && path.getLastPathComponent() instanceof DefaultMutableTreeNode) {
 628             DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent();
 629             final boolean selected = isPathSelected(path);
 630             final boolean expanded = isExpanded(path);
 631             final Component comp =
 632               myRendrer.getTreeCellRendererComponent(this, node, selected, expanded, node.isLeaf(), getRowForPath(path), isFocusOwner());
 633
 634             comp.setBounds(bounds);
 635             comp.validate();
 636
 637             Point point = new Point(e.getX() - bounds.x, e.getY() - bounds.y);
 638             if (myRendrer.isUnderHandle(point)) {
 639               ui.toggleExpandState(path);
 640               e.consume();
 641               return;
 642             }
 643           }
 644         }
 645       }
 646
 647       super.processMouseEvent(e);
 648     }
 649
 650     private class MyTreeUi extends BasicTreeUI {
 651
 652       @Override
 653       public void toggleExpandState(final TreePath path) {
 654         super.toggleExpandState(path);
 655       }
 656
 657       @Override
 658       public boolean isToggleEvent(final MouseEvent event) {
 659         return super.isToggleEvent(event);
 660       }
 661
 662       @Override
 663       protected boolean shouldPaintExpandControl(final TreePath path,
 664                                                  final int row,
 665                                                  final boolean isExpanded,
 666                                                  final boolean hasBeenExpanded,
 667                                                  final boolean isLeaf) {
 668         return false;
 669       }
 670
 671       @Override
 672       protected void paintHorizontalPartOfLeg(final Graphics g,
 673                                               final Rectangle clipBounds,
 674                                               final Insets insets,
 675                                               final Rectangle bounds,
 676                                               final TreePath path,
 677                                               final int row,
 678                                               final boolean isExpanded,
 679                                               final boolean hasBeenExpanded,
 680                                               final boolean isLeaf) {
 681
 682       }
 683
 684       @Override
 685       protected void paintVerticalPartOfLeg(final Graphics g, final Rectangle clipBounds, final Insets insets, final TreePath path) {
 686       }
 687     }
 688   }
 689
 690   private class MyBuilder extends FilteringTreeBuilder {
 691
 692     List<Object> myToExpandOnResetFilter;
 693     boolean myRefilteringNow;
 694     boolean myWasHoldingFilter;
 695
 696     public MyBuilder(SimpleTreeStructure structure) {
 697       super(OptionsTree.this.myProject, OptionsTree.this.myTree, OptionsTree.this.myContext.getFilter(), structure, new WeightBasedComparator(false));
 698       myTree.addTreeExpansionListener(new TreeExpansionListener() {
 699         public void treeExpanded(TreeExpansionEvent event) {
 700           invalidateExpansions();
 701         }
 702
 703         public void treeCollapsed(TreeExpansionEvent event) {
 704           invalidateExpansions();
 705         }
 706       });
 707     }
 708
 709     private void invalidateExpansions() {
 710       if (!myRefilteringNow) {
 711         myToExpandOnResetFilter = null;
 712       }
 713     }
 714
 715     @Override
 716     protected boolean isSelectable(final Object nodeObject) {
 717       return nodeObject instanceof EditorNode;
 718     }
 719
 720     @Override
 721     public boolean isAutoExpandNode(final NodeDescriptor nodeDescriptor) {
 722       return myContext.isHoldingFilter();
 723     }
 724
 725     @Override
 726     protected ActionCallback refilterNow(Object preferredSelection, boolean adjustSelection) {
 727       final List<Object> toRestore = new ArrayList<Object>();
 728       if (myContext.isHoldingFilter() && !myWasHoldingFilter && myToExpandOnResetFilter == null) {
 729         myToExpandOnResetFilter = myBuilder.getUi().getExpandedElements();
 730       } else if (!myContext.isHoldingFilter() && myWasHoldingFilter && myToExpandOnResetFilter != null) {
 731         toRestore.addAll(myToExpandOnResetFilter);
 732         myToExpandOnResetFilter = null;
 733       }
 734
 735       myWasHoldingFilter = myContext.isHoldingFilter();
 736
 737       ActionCallback result = super.refilterNow(preferredSelection, adjustSelection);
 738       myRefilteringNow = true;
 739       return result.doWhenDone(new Runnable() {
 740         public void run() {
 741           myRefilteringNow = false;
 742           if (!myContext.isHoldingFilter()) {
 743             restoreExpandedState(toRestore);
 744           }
 745         }
 746       });
 747     }
 748
 749     private void restoreExpandedState(List<Object> toRestore) {
 750       TreePath[] selected = myTree.getSelectionPaths();
 751       if (selected == null) {
 752         selected = new TreePath[0];
 753       }
 754
 755       List<TreePath> toCollapse = new ArrayList<TreePath>();
 756
 757       for (int eachRow = 0; eachRow < myTree.getRowCount(); eachRow++) {
 758         if (!myTree.isExpanded(eachRow)) continue;
 759
 760         TreePath eachVisiblePath = myTree.getPathForRow(eachRow);
 761         if (eachVisiblePath == null) continue;
 762
 763         Object eachElement = myBuilder.getElementFor(eachVisiblePath.getLastPathComponent());
 764         if (toRestore.contains(eachElement)) continue;
 765
 766
 767         for (TreePath eachSelected : selected) {
 768           if (!eachVisiblePath.isDescendant(eachSelected)) {
 769             toCollapse.add(eachVisiblePath);
 770           }
 771         }
 772       }
 773
 774       for (TreePath each : toCollapse) {
 775         myTree.collapsePath(each);
 776       }
 777
 778     }
 779   }
 780 }