Added filter for import statements to UsageView

UsageView/src/com/intellij/usages/impl/UsageFilteringRuleProviderImpl.java

@@ -0,0 +1,78 @@
+package com.intellij.usages.impl;
+
+import com.intellij.openapi.actionSystem.AnAction;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.actionSystem.ToggleAction;
+import com.intellij.openapi.actionSystem.CustomShortcutSet;
+import com.intellij.openapi.components.ApplicationComponent;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.*;
+import com.intellij.usages.impl.rules.ImportFilteringRule;
+import com.intellij.usages.rules.UsageFilteringRule;
+import com.intellij.usages.rules.UsageFilteringRuleProvider;
+import org.jdom.Element;
+
+import javax.swing.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.awt.event.KeyEvent;
+
+/**
+ * Created by IntelliJ IDEA.
+ * User: max
+ * Date: Dec 27, 2004
+ * Time: 8:20:57 PM
+ * To change this template use File | Settings | File Templates.
+ */
+public class UsageFilteringRuleProviderImpl extends UsageFilteringRuleProvider implements ApplicationComponent, JDOMExternalizable {
+  public boolean FILTER_IMPORTS = false;
+
+  public UsageFilteringRule[] getActiveRules(Project project) {
+    final List<UsageFilteringRule> rules = new ArrayList<UsageFilteringRule>();
+    if (FILTER_IMPORTS) {
+      rules.add(new ImportFilteringRule());
+    }
+    return rules.toArray(new UsageFilteringRule[rules.size()]);
+  }
+
+  public AnAction[] createFilteringActions(UsageViewImpl view) {
+    final ShowImportsAction showImportsAction = new ShowImportsAction(view);
+    showImportsAction.registerCustomShortcutSet(new CustomShortcutSet(KeyStroke.getKeyStroke(KeyEvent.VK_I, KeyEvent.CTRL_DOWN_MASK)), view.getComponent());
+    return new AnAction[] {
+      showImportsAction,
+    };
+  }
+
+  private class ShowImportsAction extends ToggleAction {
+    private UsageViewImpl myView;
+
+    public ShowImportsAction(UsageViewImpl view) {
+      super("Show import statements", null, IconLoader.getIcon("/actions/showImportStatements.png"));
+      myView = view;
+    }
+
+    public boolean isSelected(AnActionEvent e) {
+      return !FILTER_IMPORTS;
+    }
+
+    public void setSelected(AnActionEvent e, boolean state) {
+      FILTER_IMPORTS = !state;
+      myView.rulesChanged();
+    }
+  }
+
+  public String getComponentName() {
+    return "UsageFilteringRuleProvider";
+  }
+
+  public void readExternal(Element element) throws InvalidDataException {
+    DefaultJDOMExternalizer.readExternal(this, element);
+  }
+
+  public void writeExternal(Element element) throws WriteExternalException {
+    DefaultJDOMExternalizer.writeExternal(this, element);
+  }
+
+  public void initComponent() {}
+  public void disposeComponent() {}
+}

UsageView/src/com/intellij/usages/impl/UsageGroupingRuleProviderImpl.java

@@ -40,7 +40,6 @@ public class UsageGroupingRuleProviderImpl extends UsageGroupingRuleProvider imp
       rules.add(new PackageGroupingRule(project));
     }
     if (GROUP_BY_FILE_STRUCTURE) {
-      //rules.add(new FileOrClassCompositeGroupingRule(project));
       rules.add(new ClassGroupingRule());
       rules.add(new MethodGroupingRule());
     }

UsageView/src/com/intellij/usages/impl/UsageNodeTreeBuilder.java

@@ -3,6 +3,7 @@ package com.intellij.usages.impl;
 import com.intellij.usages.Usage;
 import com.intellij.usages.UsageGroup;
 import com.intellij.usages.rules.UsageGroupingRule;
+import com.intellij.usages.rules.UsageFilteringRule;
 
 import java.util.Enumeration;
 
@@ -15,10 +16,12 @@ import java.util.Enumeration;
  */
 public class UsageNodeTreeBuilder {
   private GroupNode myRoot;
-  private UsageGroupingRule[] myRules;
+  private UsageGroupingRule[] myGroupingRules;
+  private UsageFilteringRule[] myFilteringRules;
 
-  public UsageNodeTreeBuilder(UsageGroupingRule[] rules, GroupNode root) {
-    myRules = rules;
+  public UsageNodeTreeBuilder(UsageGroupingRule[] groupingRules, UsageFilteringRule[] filteringRules, GroupNode root) {
+    myGroupingRules = groupingRules;
+    myFilteringRules = filteringRules;
     myRoot = root;
   }
 
@@ -29,20 +32,29 @@ public class UsageNodeTreeBuilder {
     }
   }
 
-  public void setRules(UsageGroupingRule[] rules) {
-    myRules = rules;
+  public void setGroupingRules(UsageGroupingRule[] rules) {
+    myGroupingRules = rules;
+  }
+
+  public void setFilteringRules(UsageFilteringRule[] rules) {
+    myFilteringRules = rules;
   }
 
   public UsageNode appendUsage(Usage usage) {
-    GroupNode lastGroupNode = myRoot;
-    for (int i = 0; i < myRules.length; i++) {
-      UsageGroupingRule rule = myRules[i];
-      UsageGroup group = rule.groupUsage(usage);
-      if (group == null) { continue; }
-
-      lastGroupNode = lastGroupNode.addGroup(group, i);
+    for (int idx = 0; idx < myFilteringRules.length; idx++) {
+      final UsageFilteringRule rule = myFilteringRules[idx];
+      if (!rule.isVisible(usage)) {
+        return null;
+      }
+    }
+    GroupNode lastGroupNode = myRoot;
+    for (int i = 0; i < myGroupingRules.length; i++) {
+      final UsageGroupingRule rule = myGroupingRules[i];
+      final UsageGroup group = rule.groupUsage(usage);
+      if (group != null) {
+        lastGroupNode = lastGroupNode.addGroup(group, i);
+      }
     }
-
     return lastGroupNode.addUsage(usage);
   }
 

UsageView/src/com/intellij/usages/impl/UsageViewImpl.java

@@ -20,10 +20,7 @@ import com.intellij.ui.ScrollPaneFactory;
 import com.intellij.ui.SmartExpander;
 import com.intellij.ui.content.Content;
 import com.intellij.usages.*;
-import com.intellij.usages.rules.MergeableUsage;
-import com.intellij.usages.rules.UsageGroupingRuleProvider;
-import com.intellij.usages.rules.UsageInFile;
-import com.intellij.usages.rules.UsageInFiles;
+import com.intellij.usages.rules.*;
 import com.intellij.util.Alarm;
 import com.intellij.util.EditSourceOnDoubleClickHandler;
 import com.intellij.util.Processor;
@@ -79,7 +76,7 @@ public class UsageViewImpl implements UsageView {
     myRootPanel = new MyPanel(myTree);
 
     UsageViewTreeModelBuilder model = new UsageViewTreeModelBuilder(myPresentation, targets);
-    myBuilder = new UsageNodeTreeBuilder(getRuleProvider().getActiveRules(project), (GroupNode)model.getRoot());
+    myBuilder = new UsageNodeTreeBuilder(getGroupingRuleProvider().getActiveRules(project), getFilteringRuleProvider().getActiveRules(project), (GroupNode)model.getRoot());
     myTree.setModel(model);
 
     myRootPanel.setLayout(new BorderLayout());
@@ -171,14 +168,20 @@ public class UsageViewImpl implements UsageView {
   }
 
   private JComponent createFiltersToolbar() {
-    DefaultActionGroup group = new DefaultActionGroup();
-    AnAction[] actions = createGroupingActions();
-    for (int i = 0; i < actions.length; i++) {
-      group.add(actions[i]);
+    final DefaultActionGroup group = new DefaultActionGroup();
+
+    final AnAction[] groupingActions = createGroupingActions();
+    for (int i = 0; i < groupingActions.length; i++) {
+      group.add(groupingActions[i]);
     }
 
     group.add(new MergeDupLines());
 
+    final AnAction[] filteringActions = createFilteringActions();
+    for (int i = 0; i < filteringActions.length; i++) {
+      group.add(filteringActions[i]);
+    }
+
     ActionToolbar actionToolbar = ActionManager.getInstance().createActionToolbar(ActionPlaces.USAGE_VIEW_TOOLBAR,
                                                                                   group, false);
     return actionToolbar.getComponent();
@@ -219,18 +222,27 @@ public class UsageViewImpl implements UsageView {
     };
   }
 
-  private UsageGroupingRuleProviderImpl getRuleProvider() {
+  private UsageGroupingRuleProviderImpl getGroupingRuleProvider() {
     return (UsageGroupingRuleProviderImpl)ApplicationManager.getApplication().getComponent(UsageGroupingRuleProvider.class);
   }
 
+  private UsageFilteringRuleProviderImpl getFilteringRuleProvider() {
+    return (UsageFilteringRuleProviderImpl)ApplicationManager.getApplication().getComponent(UsageFilteringRuleProvider.class);
+  }
+
   private AnAction[] createGroupingActions() {
-    return getRuleProvider().createFilteringActions(this);
+    return getGroupingRuleProvider().createFilteringActions(this);
+  }
+
+  private AnAction[] createFilteringActions() {
+    return getFilteringRuleProvider().createFilteringActions(this);
   }
 
   public void rulesChanged() {
     Collection<Usage> allUsages = myUsageNodes.keySet();
     reset();
-    myBuilder.setRules(getRuleProvider().getActiveRules(myProject));
+    myBuilder.setGroupingRules(getGroupingRuleProvider().getActiveRules(myProject));
+    myBuilder.setFilteringRules(getFilteringRuleProvider().getActiveRules(myProject));
     for (Iterator<Usage> i = allUsages.iterator(); i.hasNext();) {
       Usage usage = i.next();
       if (usage instanceof MergeableUsage) {

UsageView/src/com/intellij/usages/impl/rules/ImportFilteringRule.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2000-2004 by JetBrains s.r.o. All Rights Reserved.
+ * Use is subject to license terms.
+ */
+package com.intellij.usages.impl.rules;
+
+import com.intellij.usages.rules.UsageFilteringRule;
+import com.intellij.usages.rules.PsiElementUsage;
+import com.intellij.usages.Usage;
+import com.intellij.psi.*;
+import com.intellij.psi.util.PsiTreeUtil;
+
+/**
+ * @author Eugene Zhuravlev
+ *         Date: Jan 17, 2005
+ */
+public class ImportFilteringRule implements UsageFilteringRule{
+  public boolean isVisible(Usage usage) {
+    if (usage instanceof PsiElementUsage) {
+      final PsiElement psiElement = ((PsiElementUsage)usage).getElement();
+      final PsiFile containingFile = psiElement.getContainingFile();
+      if (containingFile instanceof PsiJavaFile) {
+        // check whether the element is in the import list
+        final PsiImportList importList = PsiTreeUtil.getParentOfType(psiElement, PsiImportList.class, true);
+        return importList == null;
+      }
+    }
+    return true;
+  }
+}

UsageView/src/com/intellij/usages/rules/UsageFilteringRule.java

@@ -0,0 +1,10 @@
+package com.intellij.usages.rules;
+
+import com.intellij.usages.Usage;
+import com.intellij.usages.UsageGroup;
+
+public interface UsageFilteringRule {
+  UsageFilteringRule[] EMPTY_ARRAY = new UsageFilteringRule[0];
+
+  boolean isVisible(Usage usage);
+}

UsageView/src/com/intellij/usages/rules/UsageFilteringRuleProvider.java

@@ -0,0 +1,9 @@
+package com.intellij.usages.rules;
+
+import com.intellij.openapi.project.Project;
+
+public abstract class UsageFilteringRuleProvider {
+  public abstract UsageFilteringRule[] getActiveRules(Project project);
+
+
+}

UsageView/src/com/intellij/usages/rules/UsageGroupingRule.java

@@ -3,13 +3,7 @@ package com.intellij.usages.rules;
 import com.intellij.usages.Usage;
 import com.intellij.usages.UsageGroup;
 
-/**
- * Created by IntelliJ IDEA.
- * User: max
- * Date: Dec 16, 2004
- * Time: 5:25:54 PM
- * To change this template use File | Settings | File Templates.
- */
 public interface UsageGroupingRule {
+  UsageGroupingRule[] EMPTY_ARRAY = new UsageGroupingRule[0];
   UsageGroup groupUsage(Usage usage);
 }

UsageView/testSource/com/intellij/usages/impl/UsageNodeTreeBuilderTest.java

@@ -7,6 +7,7 @@ import com.intellij.usages.UsageGroup;
 import com.intellij.usages.UsagePresentation;
 import com.intellij.usages.UsageView;
 import com.intellij.usages.rules.UsageGroupingRule;
+import com.intellij.usages.rules.UsageFilteringRule;
 import junit.framework.TestCase;
 
 import javax.swing.*;
@@ -82,7 +83,7 @@ public class UsageNodeTreeBuilderTest extends TestCase {
     DefaultTreeModel model = new DefaultTreeModel(new DefaultMutableTreeNode("temp"));
     GroupNode rootNode = new GroupNode(null, 0, model);
     model.setRoot(rootNode);
-    UsageNodeTreeBuilder usageNodeTreeBuilder = new UsageNodeTreeBuilder(rules, rootNode);
+    UsageNodeTreeBuilder usageNodeTreeBuilder = new UsageNodeTreeBuilder(rules, UsageFilteringRule.EMPTY_ARRAY, rootNode);
     usageNodeTreeBuilder.appendUsages(usages);
     return rootNode;
   }

resources/src/componentSets/Misc.xml

@@ -45,6 +45,10 @@
       <interface-class>com.intellij.usages.rules.UsageGroupingRuleProvider</interface-class>
       <implementation-class>com.intellij.usages.impl.UsageGroupingRuleProviderImpl</implementation-class>
     </component>
+    <component>
+      <interface-class>com.intellij.usages.rules.UsageFilteringRuleProvider</interface-class>
+      <implementation-class>com.intellij.usages.impl.UsageFilteringRuleProviderImpl</implementation-class>
+    </component>
   </application-components>
 
   <project-components>