platform/platform-api/src/com/intellij/ide/util/treeView/AbstractTreeBuilder.java

   1 /*
   2  * Copyright 2000-2007 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.intellij.ide.util.treeView;
  18
  19 import com.intellij.ide.projectView.PresentationData;
  20 import com.intellij.openapi.Disposable;
  21 import com.intellij.openapi.application.Application;
  22 import com.intellij.openapi.application.ApplicationManager;
  23 import com.intellij.openapi.progress.ProgressIndicator;
  24 import com.intellij.openapi.util.ActionCallback;
  25 import com.intellij.util.containers.HashSet;
  26 import com.intellij.util.ui.UIUtil;
  27 import com.intellij.util.ui.update.MergingUpdateQueue;
  28 import org.jetbrains.annotations.NotNull;
  29 import org.jetbrains.annotations.Nullable;
  30
  31 import javax.swing.*;
  32 import javax.swing.tree.DefaultMutableTreeNode;
  33 import javax.swing.tree.DefaultTreeModel;
  34 import javax.swing.tree.TreeNode;
  35 import javax.swing.tree.TreePath;
  36 import java.lang.ref.WeakReference;
  37 import java.util.*;
  38
  39 public class AbstractTreeBuilder implements Disposable {
  40   private AbstractTreeUi myUi;
  41   private static final String TREE_BUILDER = "TreeBuilder";
  42
  43   public AbstractTreeBuilder(JTree tree,
  44                              DefaultTreeModel treeModel,
  45                              AbstractTreeStructure treeStructure,
  46                              @Nullable Comparator<NodeDescriptor> comparator) {
  47     init(tree, treeModel, treeStructure, comparator, true);
  48   }
  49   public AbstractTreeBuilder(JTree tree,
  50                              DefaultTreeModel treeModel,
  51                              AbstractTreeStructure treeStructure,
  52                              @Nullable Comparator<NodeDescriptor> comparator,
  53                              boolean updateIfInactive) {
  54     init(tree, treeModel, treeStructure, comparator, updateIfInactive);
  55   }
  56
  57   protected AbstractTreeBuilder() {
  58   }
  59
  60
  61   protected void init(final JTree tree, final DefaultTreeModel treeModel, final AbstractTreeStructure treeStructure, final @Nullable Comparator<NodeDescriptor> comparator) {
  62
  63     myUi = createUi();
  64     getUi().init(this, tree, treeModel, treeStructure, comparator);
  65   }
  66   protected void init(final JTree tree, final DefaultTreeModel treeModel, final AbstractTreeStructure treeStructure, final @Nullable Comparator<NodeDescriptor> comparator,
  67                       final boolean updateIfInactive) {
  68
  69     tree.putClientProperty(TREE_BUILDER, new WeakReference(this));
  70
  71     myUi = createUi();
  72     getUi().init(this, tree, treeModel, treeStructure, comparator, updateIfInactive);
  73   }
  74
  75   protected AbstractTreeUi createUi() {
  76     return new AbstractTreeUi();
  77   }
  78
  79   public final void select(final Object element) {
  80     select(element, null);
  81   }
  82
  83   public final void select(final Object element, @Nullable final Runnable onDone) {
  84     getUi().select(element, onDone);
  85   }
  86
  87   public final void select(final Object element, @Nullable final Runnable onDone, boolean addToSelection) {
  88     getUi().select(element, onDone, addToSelection);
  89   }
  90
  91   public final void expand(Object element, @Nullable Runnable onDone) {
  92     getUi().expand(element, onDone);
  93   }
  94
  95   public final void expand(Object[] element, @Nullable Runnable onDone) {
  96     getUi().expand(element, onDone);
  97   }
  98
  99   public final void collapseChildren(Object element, @Nullable Runnable onDone) {
 100     getUi().collapseChildren(element, onDone);
 101   }
 102
 103   public final void select(final Object[] elements, @Nullable final Runnable onDone) {
 104     getUi().select(elements, onDone);
 105   }
 106
 107   public final void select(final Object[] elements, @Nullable final Runnable onDone, boolean addToSelection) {
 108     getUi().select(elements, onDone, addToSelection);
 109   }
 110
 111   protected AbstractTreeNode createSearchingTreeNodeWrapper() {
 112     return new AbstractTreeNodeWrapper();
 113   }
 114
 115   public final AbstractTreeBuilder setClearOnHideDelay(final long clearOnHideDelay) {
 116     getUi().setClearOnHideDelay(clearOnHideDelay);
 117     return this;
 118   }
 119
 120   protected AbstractTreeUpdater createUpdater() {
 121     AbstractTreeUpdater updater = new AbstractTreeUpdater(this);
 122     updater.setModalityStateComponent(MergingUpdateQueue.ANY_COMPONENT);
 123     return updater;
 124   }
 125
 126   protected final AbstractTreeUpdater getUpdater() {
 127     return getUi().getUpdater();
 128   }
 129
 130   public final boolean addSubtreeToUpdateByElement(Object element) {
 131     return getUpdater().addSubtreeToUpdateByElement(element);
 132   }
 133
 134   public final void addSubtreeToUpdate(DefaultMutableTreeNode node) {
 135     getUi().addSubtreeToUpdate(node);
 136   }
 137
 138   public final void addSubtreeToUpdate(DefaultMutableTreeNode node, Runnable afterUpdate) {
 139     getUi().addSubtreeToUpdate(node, afterUpdate);
 140   }
 141
 142   public final DefaultMutableTreeNode getRootNode() {
 143     return getUi().getRootNode();
 144   }
 145
 146   public final void setNodeDescriptorComparator(Comparator<NodeDescriptor> nodeDescriptorComparator) {
 147     getUi().setNodeDescriptorComparator(nodeDescriptorComparator);
 148   }
 149
 150   /**
 151   * node descriptor getElement contract is as follows:
 152   * 1.TreeStructure always returns & recieves "treestructure" element returned by getTreeStructureElement
 153   * 2.Paths contain "model" element returned by getElement
 154   */
 155
 156   protected Object getTreeStructureElement(NodeDescriptor nodeDescriptor) {
 157     return nodeDescriptor.getElement();
 158   }
 159
 160
 161   protected void updateNode(final DefaultMutableTreeNode node) {
 162     getUi().doUpdateNode(node);
 163   }
 164
 165   protected boolean validateNode(final Object child) {
 166     return true;
 167   }
 168
 169   protected boolean isDisposeOnCollapsing(NodeDescriptor nodeDescriptor) {
 170     return true;
 171   }
 172
 173   public final JTree getTree() {
 174     return getUi().getTree();
 175   }
 176
 177   public final AbstractTreeStructure getTreeStructure() {
 178     return getUi().getTreeStructure();
 179   }
 180
 181   public final void setTreeStructure(final AbstractTreeStructure structure) {
 182     getUi().setTreeStructure(structure);
 183   }
 184
 185   public void updateFromRoot() {
 186     getUi().doUpdateFromRoot();
 187   }
 188
 189   protected ActionCallback updateFromRootCB() {
 190    return getUi().doUpdateFromRootCB();
 191   }
 192
 193   public void initRootNode() {
 194     getUi().initRootNode();
 195   }
 196
 197   /**
 198    * @deprecated
 199    * @param element
 200    */
 201   public void buildNodeForElement(Object element) {
 202     getUi().buildNodeForElement(element);
 203   }
 204
 205   /**
 206    * @deprecated
 207    * @param element
 208    * @return
 209    */
 210   @Nullable
 211   public DefaultMutableTreeNode getNodeForElement(Object element) {
 212     return getUi().getNodeForElement(element, false);
 213   }
 214
 215   public void cleanUp() {
 216     getUi().doCleanUp();
 217   }
 218
 219   @Nullable
 220   protected ProgressIndicator createProgressIndicator() {
 221     return null;
 222   }
 223
 224   protected void expandNodeChildren(final DefaultMutableTreeNode node) {
 225     getUi().doExpandNodeChildren(node);
 226   }
 227
 228   protected boolean isAutoExpandNode(final NodeDescriptor nodeDescriptor) {
 229     return getTreeStructure().getRootElement() == getTreeStructureElement(nodeDescriptor);
 230   }
 231
 232   protected boolean isAlwaysShowPlus(final NodeDescriptor descriptor) {
 233     return false;
 234   }
 235
 236
 237
 238   protected boolean isSmartExpand() {
 239     return true;
 240   }
 241
 242   public final boolean isDisposed() {
 243     return getUi() == null || getUi().isReleased();
 244   }
 245
 246   /**
 247    * @deprecated
 248    * @param node
 249    */
 250   public final void updateSubtree(final DefaultMutableTreeNode node) {
 251     getUi().updateSubtree(node, true);
 252   }
 253
 254   public final boolean wasRootNodeInitialized() {
 255     return getUi().wasRootNodeInitialized();
 256   }
 257
 258   public final boolean isNodeBeingBuilt(final TreePath path) {
 259     return getUi().isNodeBeingBuilt(path);
 260   }
 261
 262   /**
 263    * @deprecated
 264    * @param path
 265    */
 266   public final void buildNodeForPath(final Object[] path) {
 267     getUi().buildNodeForPath(path);
 268   }
 269
 270   /**
 271    * @deprecated
 272    */
 273   public final DefaultMutableTreeNode getNodeForPath(final Object[] path) {
 274     return getUi().getNodeForPath(path);
 275   }
 276
 277   protected Object findNodeByElement(final Object element) {
 278     return getUi().findNodeByElement(element);
 279   }
 280
 281   public static boolean isLoadingNode(final DefaultMutableTreeNode node) {
 282     return AbstractTreeUi.isLoadingNode(node);
 283   }
 284
 285   public boolean isChildrenResortingNeeded(NodeDescriptor descriptor) {
 286     return true;
 287   }
 288
 289   protected void runOnYeildingDone(Runnable onDone) {
 290     UIUtil.invokeLaterIfNeeded(onDone);
 291   }
 292
 293   protected void yield(Runnable runnable) {
 294     SwingUtilities.invokeLater(runnable);
 295   }
 296
 297   public boolean isToYieldUpdateFor(DefaultMutableTreeNode node) {
 298     return true;
 299   }
 300
 301   public boolean isToEnsureSelectionOnFocusGained() {
 302     return true;
 303   }
 304
 305   protected void runBackgroundLoading(final Runnable runnable) {
 306     final Application app = ApplicationManager.getApplication();
 307     if (app != null) {
 308       app.runReadAction(new Runnable() {
 309         public void run() {
 310           runnable.run();
 311         }
 312       });
 313     } else {
 314       runnable.run();
 315     }
 316   }
 317
 318   protected void updateAfterLoadedInBackground(Runnable runnable) {
 319     UIUtil.invokeLaterIfNeeded(runnable);
 320   }
 321
 322   public final ActionCallback getIntialized() {
 323     return myUi.getInitialized();
 324   }
 325
 326   public final ActionCallback getReady(Object requestor) {
 327     return myUi.getReady(requestor);
 328   }
 329
 330   protected void sortChildren(Comparator<TreeNode> nodeComparator, DefaultMutableTreeNode node, ArrayList<TreeNode> children) {
 331     Collections.sort(children, nodeComparator);
 332   }
 333
 334   public static class AbstractTreeNodeWrapper extends AbstractTreeNode<Object> {
 335     public AbstractTreeNodeWrapper() {
 336       super(null, null);
 337     }
 338
 339     @NotNull
 340     public Collection<AbstractTreeNode> getChildren() {
 341       return Collections.emptyList();
 342     }
 343
 344     public void update(PresentationData presentation) {
 345     }
 346   }
 347
 348   public final AbstractTreeUi getUi() {
 349     return myUi;
 350   }
 351
 352   public void dispose() {
 353     if (isDisposed()) return;
 354
 355     myUi.release();
 356     myUi = null;
 357   }
 358
 359   protected boolean updateNodeDescriptor(final NodeDescriptor descriptor) {
 360     return getUi().doUpdateNodeDescriptor(descriptor);
 361   }
 362
 363   public final DefaultTreeModel getTreeModel() {
 364     return (DefaultTreeModel)getTree().getModel();
 365   }
 366
 367   @NotNull
 368   public final Set<Object> getSelectedElements() {
 369     return getUi().getSelectedElements();
 370   }
 371
 372   @NotNull
 373   public final <T> Set<T> getSelectedElements(Class<T> elementClass) {
 374     Set<T> result = new HashSet<T>();
 375     for (Object o : getSelectedElements()) {
 376       Object each = transformElement(o);
 377       if (elementClass.isInstance(each)) {
 378         //noinspection unchecked
 379         result.add((T) each);
 380       }
 381     }
 382     return result;
 383   }
 384
 385   protected Object transformElement(Object object) {
 386     return object;
 387   }
 388
 389   public final void setCanYieldUpdate(boolean yield) {
 390     getUi().setCanYield(yield);
 391   }
 392
 393   @Nullable
 394   public static AbstractTreeBuilder getBuilderFor(JTree tree) {
 395     final WeakReference ref = (WeakReference)tree.getClientProperty(TREE_BUILDER);
 396     return ref != null ? (AbstractTreeBuilder)ref.get() : null;
 397   }
 398
 399   @Nullable
 400   public final <T> Object accept(Class nodeClass, TreeVisitor<T> visitor) {
 401     return accept(nodeClass, getTreeStructure().getRootElement(), visitor);
 402   }
 403
 404   @Nullable
 405   private <T> Object accept(Class nodeClass, Object element, TreeVisitor<T> visitor) {
 406     if (element == null) return null;
 407
 408     if (nodeClass.isAssignableFrom(element.getClass())) {
 409       if (visitor.visit((T)element)) return element;
 410     }
 411
 412     final Object[] children = getTreeStructure().getChildElements(element);
 413     for (Object each : children) {
 414       final Object childObject = accept(nodeClass, each, visitor);
 415       if (childObject != null) return childObject;
 416     }
 417
 418     return null;
 419   }
 420
 421   public <T> boolean select(Class nodeClass, TreeVisitor<T> visitor, @Nullable Runnable onDone, boolean addToSelection) {
 422     final Object element = accept(nodeClass, visitor);
 423     if (element != null) {
 424       getUi().select(element, onDone, addToSelection);
 425       return true;
 426     }
 427
 428     return false;
 429   }
 430
 431   public void scrollSelectionToVisible(@Nullable Runnable onDone, boolean shouldBeCentered) {
 432     myUi.scrollSelectionToVisible(onDone, shouldBeCentered);
 433   }
 434
 435 }