platform/lang-impl/src/com/intellij/codeInsight/intention/impl/config/IntentionSettingsTree.java

   1 /*
   2  * Copyright 2000-2009 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 /**
  18  * @author cdr
  19  */
  20 package com.intellij.codeInsight.intention.impl.config;
  21
  22 import com.intellij.ide.CommonActionsManager;
  23 import com.intellij.ide.TreeExpander;
  24 import com.intellij.ide.ui.search.SearchUtil;
  25 import com.intellij.openapi.actionSystem.ActionManager;
  26 import com.intellij.openapi.actionSystem.ActionPlaces;
  27 import com.intellij.openapi.actionSystem.ActionToolbar;
  28 import com.intellij.openapi.actionSystem.DefaultActionGroup;
  29 import com.intellij.openapi.util.Ref;
  30 import com.intellij.packageDependencies.ui.TreeExpansionMonitor;
  31 import com.intellij.ui.*;
  32 import com.intellij.util.ArrayUtil;
  33 import com.intellij.util.ui.UIUtil;
  34 import com.intellij.util.ui.tree.TreeUtil;
  35
  36 import javax.swing.*;
  37 import javax.swing.event.TreeSelectionEvent;
  38 import javax.swing.event.TreeSelectionListener;
  39 import javax.swing.tree.DefaultMutableTreeNode;
  40 import javax.swing.tree.DefaultTreeModel;
  41 import javax.swing.tree.TreePath;
  42 import java.awt.*;
  43 import java.util.*;
  44 import java.util.List;
  45
  46 public abstract class IntentionSettingsTree {
  47   private JComponent myComponent;
  48   private CheckboxTree myTree;
  49   private FilterComponent myFilter;
  50   private JPanel myToolbarPanel;
  51
  52   private final Map<IntentionActionMetaData, Boolean> myIntentionToCheckStatus = new HashMap<IntentionActionMetaData, Boolean>();
  53
  54   protected IntentionSettingsTree() {
  55     initTree();
  56   }
  57
  58   public JTree getTree(){
  59     return myTree;
  60   }
  61
  62   public JComponent getComponent() {
  63     return myComponent;
  64   }
  65
  66   private void initTree() {
  67     myTree = new CheckboxTree(new CheckboxTree.CheckboxTreeCellRenderer(true) {
  68       public void customizeCellRenderer(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
  69         CheckedTreeNode node = (CheckedTreeNode)value;
  70         SimpleTextAttributes attributes = node.getUserObject() instanceof IntentionActionMetaData ? SimpleTextAttributes.REGULAR_ATTRIBUTES : SimpleTextAttributes.REGULAR_BOLD_ATTRIBUTES;
  71         final String text = getNodeText(node);
  72         if (text != null) {
  73           SearchUtil.appendFragments(myFilter != null ? myFilter.getFilter() : null,
  74                                      text,
  75                                      attributes.getStyle(),
  76                                      attributes.getFgColor(),
  77                                      selected ? UIUtil.getTreeSelectionBackground() : UIUtil.getTreeTextBackground(),
  78                                      getTextRenderer());
  79         }
  80       }
  81     }, new CheckedTreeNode(null));
  82
  83     myTree.getSelectionModel().addTreeSelectionListener(new TreeSelectionListener() {
  84       public void valueChanged(TreeSelectionEvent e) {
  85         TreePath path = e.getPath();
  86         Object userObject = ((DefaultMutableTreeNode)path.getLastPathComponent()).getUserObject();
  87         selectionChanged(userObject);
  88       }
  89     });
  90
  91     myFilter = new MyFilterComponent();
  92     myComponent = new JPanel(new BorderLayout());
  93     JScrollPane scrollPane = new JScrollPane(myTree);
  94     myToolbarPanel = new JPanel(new BorderLayout());
  95     myToolbarPanel.add(createTreeToolbarPanel().getComponent(), BorderLayout.WEST);
  96     myToolbarPanel.add(myFilter, BorderLayout.CENTER);
  97     myComponent.add(myToolbarPanel, BorderLayout.NORTH);
  98     myComponent.add(scrollPane, BorderLayout.CENTER);
  99
 100     SwingUtilities.invokeLater(new Runnable() {
 101       public void run() {
 102         myTree.setSelectionRow(0);
 103       }
 104     });
 105     myFilter.reset();
 106   }
 107
 108   private ActionToolbar createTreeToolbarPanel() {
 109     final CommonActionsManager actionManager = CommonActionsManager.getInstance();
 110
 111     TreeExpander treeExpander = new TreeExpander() {
 112       public void expandAll() {
 113         TreeUtil.expandAll(myTree);
 114       }
 115
 116       public boolean canExpand() {
 117         return true;
 118       }
 119
 120       public void collapseAll() {
 121         TreeUtil.collapseAll(myTree, 3);
 122       }
 123
 124       public boolean canCollapse() {
 125         return true;
 126       }
 127     };
 128
 129     DefaultActionGroup actions = new DefaultActionGroup();
 130     actions.add(actionManager.createExpandAllAction(treeExpander, myTree));
 131     actions.add(actionManager.createCollapseAllAction(treeExpander, myTree));
 132
 133     return ActionManager.getInstance().createActionToolbar(ActionPlaces.MAIN_TOOLBAR, actions, true);
 134   }
 135
 136   protected abstract void selectionChanged(Object selected);
 137   protected abstract List<IntentionActionMetaData> filterModel(String filter, final boolean force);
 138
 139   public void filter(List<IntentionActionMetaData> intentionsToShow) {
 140     refreshCheckStatus((CheckedTreeNode)myTree.getModel().getRoot());
 141     reset(intentionsToShow);
 142   }
 143
 144   public void reset(){
 145     resetCheckStatus();
 146     reset(IntentionManagerSettings.getInstance().getMetaData());
 147   }
 148
 149   private void resetCheckStatus() {
 150     myIntentionToCheckStatus.clear();
 151     IntentionManagerSettings manager = IntentionManagerSettings.getInstance();
 152     for (IntentionActionMetaData metaData : manager.getMetaData()) {
 153       myIntentionToCheckStatus.put(metaData, manager.isEnabled(metaData));
 154     }
 155   }
 156
 157   private void reset(List<IntentionActionMetaData> intentionsToShow) {
 158     CheckedTreeNode root = new CheckedTreeNode(null);
 159     final DefaultTreeModel treeModel = (DefaultTreeModel)myTree.getModel();
 160     intentionsToShow = sort(intentionsToShow);
 161
 162     for (final IntentionActionMetaData metaData : intentionsToShow) {
 163       String[] category = metaData.myCategory;
 164       CheckedTreeNode node = root;
 165       for (final String name : category) {
 166         CheckedTreeNode child = findChild(node, name);
 167         if (child == null) {
 168           CheckedTreeNode newChild = new CheckedTreeNode(name);
 169           treeModel.insertNodeInto(newChild, node, node.getChildCount());
 170           child = newChild;
 171         }
 172         node = child;
 173       }
 174       CheckedTreeNode newChild = new CheckedTreeNode(metaData);
 175       treeModel.insertNodeInto(newChild, node, node.getChildCount());
 176     }
 177     resetCheckMark(root);
 178     treeModel.setRoot(root);
 179     treeModel.nodeChanged(root);
 180   }
 181
 182   private static List<IntentionActionMetaData> sort(final List<IntentionActionMetaData> intentionsToShow) {
 183     List<IntentionActionMetaData> copy = new ArrayList<IntentionActionMetaData>(intentionsToShow);
 184     Collections.sort(copy, new Comparator<IntentionActionMetaData>() {
 185       public int compare(final IntentionActionMetaData data1, final IntentionActionMetaData data2) {
 186         String[] category1 = data1.myCategory;
 187         String[] category2 = data2.myCategory;
 188         int result = ArrayUtil.lexicographicCompare(category1, category2);
 189         if (result!= 0) {
 190           return result;
 191         }
 192         return data1.getFamily().compareTo(data2.getFamily());
 193       }
 194     });
 195     return copy;
 196   }
 197
 198   private CheckedTreeNode getRoot() {
 199     return (CheckedTreeNode)myTree.getModel().getRoot();
 200   }
 201
 202   private boolean resetCheckMark(final CheckedTreeNode root) {
 203     Object userObject = root.getUserObject();
 204     if (userObject instanceof IntentionActionMetaData) {
 205       IntentionActionMetaData metaData = (IntentionActionMetaData)userObject;
 206       Boolean b = myIntentionToCheckStatus.get(metaData);
 207       boolean enabled = b == null ? false : b.booleanValue();
 208       root.setChecked(enabled);
 209       return enabled;
 210     }
 211     else {
 212       root.setChecked(false);
 213       visitChildren(root, new CheckedNodeVisitor() {
 214         public void visit(CheckedTreeNode node) {
 215           if (resetCheckMark(node)) {
 216             root.setChecked(true);
 217           }
 218         }
 219       });
 220       return root.isChecked();
 221     }
 222   }
 223
 224   private static CheckedTreeNode findChild(CheckedTreeNode node, final String name) {
 225     final Ref<CheckedTreeNode> found = new Ref<CheckedTreeNode>();
 226     visitChildren(node, new CheckedNodeVisitor() {
 227       public void visit(CheckedTreeNode node) {
 228         String text = getNodeText(node);
 229         if (name.equals(text)) {
 230           found.set(node);
 231         }
 232       }
 233     });
 234     return found.get();
 235   }
 236
 237   private static String getNodeText(CheckedTreeNode node) {
 238     final Object userObject = node.getUserObject();
 239     String text;
 240     if (userObject instanceof String) {
 241       text = (String)userObject;
 242     }
 243     else if (userObject instanceof IntentionActionMetaData) {
 244       text = ((IntentionActionMetaData)userObject).getFamily();
 245     }
 246     else {
 247       text = "???";
 248     }
 249     return text;
 250   }
 251
 252   public void apply() {
 253     CheckedTreeNode root = getRoot();
 254     apply(root);
 255   }
 256
 257   private void refreshCheckStatus(final CheckedTreeNode root) {
 258     Object userObject = root.getUserObject();
 259     if (userObject instanceof IntentionActionMetaData) {
 260       IntentionActionMetaData actionMetaData = (IntentionActionMetaData)userObject;
 261       myIntentionToCheckStatus.put(actionMetaData, root.isChecked());
 262     }
 263     else {
 264       visitChildren(root, new CheckedNodeVisitor() {
 265         public void visit(CheckedTreeNode node) {
 266           refreshCheckStatus(node);
 267         }
 268       });
 269     }
 270
 271   }
 272
 273   private static void apply(CheckedTreeNode root) {
 274     Object userObject = root.getUserObject();
 275     if (userObject instanceof IntentionActionMetaData) {
 276       IntentionActionMetaData actionMetaData = (IntentionActionMetaData)userObject;
 277       IntentionManagerSettings.getInstance().setEnabled(actionMetaData, root.isChecked());
 278     }
 279     else {
 280       visitChildren(root, new CheckedNodeVisitor() {
 281         public void visit(CheckedTreeNode node) {
 282           apply(node);
 283         }
 284       });
 285     }
 286   }
 287
 288   public boolean isModified() {
 289     return isModified(getRoot());
 290   }
 291
 292   private static boolean isModified(CheckedTreeNode root) {
 293     Object userObject = root.getUserObject();
 294     if (userObject instanceof IntentionActionMetaData) {
 295       IntentionActionMetaData actionMetaData = (IntentionActionMetaData)userObject;
 296       boolean enabled = IntentionManagerSettings.getInstance().isEnabled(actionMetaData);
 297       return enabled != root.isChecked();
 298     }
 299     else {
 300       final boolean[] modified = new boolean[] { false };
 301       visitChildren(root, new CheckedNodeVisitor() {
 302         public void visit(CheckedTreeNode node) {
 303           modified[0] |= isModified(node);
 304         }
 305       });
 306       return modified[0];
 307     }
 308   }
 309
 310   public void dispose() {
 311     myFilter.dispose();
 312   }
 313
 314   public void setFilter(String filter){
 315     myFilter.setFilter(filter);
 316   }
 317
 318   public String getFilter() {
 319     return myFilter.getFilter();
 320   }
 321
 322   interface CheckedNodeVisitor {
 323     void visit(CheckedTreeNode node);
 324   }
 325   private static void visitChildren(CheckedTreeNode node, CheckedNodeVisitor visitor) {
 326     Enumeration children = node.children();
 327     while (children.hasMoreElements()) {
 328       final CheckedTreeNode child = (CheckedTreeNode)children.nextElement();
 329       visitor.visit(child);
 330     }
 331   }
 332
 333   private class MyFilterComponent extends FilterComponent {
 334     private final TreeExpansionMonitor<DefaultMutableTreeNode> myExpansionMonitor = TreeExpansionMonitor.install(myTree);
 335
 336     public MyFilterComponent() {
 337       super("INTENTION_FILTER_HISTORY", 10);
 338     }
 339
 340     public void filter() {
 341       final String filter = getFilter();
 342       if (filter != null && filter.length() > 0) {
 343         if (!myExpansionMonitor.isFreeze()) {
 344           myExpansionMonitor.freeze();
 345         }
 346       }
 347       IntentionSettingsTree.this.filter(filterModel(filter, true));
 348       if (myTree != null) {
 349         List<TreePath> expandedPaths = TreeUtil.collectExpandedPaths(myTree);
 350         ((DefaultTreeModel)myTree.getModel()).reload();
 351         TreeUtil.restoreExpandedPaths(myTree, expandedPaths);
 352       }
 353       SwingUtilities.invokeLater(new Runnable() {
 354         public void run() {
 355           myTree.setSelectionRow(0);
 356           myTree.requestFocus();
 357         }
 358       });
 359       TreeUtil.expandAll(myTree);
 360       if (filter == null || filter.length() == 0) {
 361         TreeUtil.collapseAll(myTree, 0);
 362         myExpansionMonitor.restore();
 363       }
 364     }
 365
 366     protected void onlineFilter() {
 367       final String filter = getFilter();
 368       if (filter != null && filter.length() > 0) {
 369         if (!myExpansionMonitor.isFreeze()) {
 370           myExpansionMonitor.freeze();
 371         }
 372       }
 373       IntentionSettingsTree.this.filter(filterModel(filter, true));
 374       TreeUtil.expandAll(myTree);
 375       if (filter == null || filter.length() == 0) {
 376         TreeUtil.collapseAll(myTree, 0);
 377         myExpansionMonitor.restore();
 378       }
 379     }
 380   }
 381
 382   public JPanel getToolbarPanel() {
 383     return myToolbarPanel;
 384   }
 385 }