lang-impl/src/com/intellij/codeInspection/ex/InspectionManagerEx.java

   1 /*
   2  * Author: max
   3  * Date: Oct 9, 2001
   4  * Time: 8:43:17 PM
   5  */
   6
   7 package com.intellij.codeInspection.ex;
   8
   9 import com.intellij.codeInspection.*;
  10 import com.intellij.codeInspection.lang.InspectionExtensionsFactory;
  11 import com.intellij.ide.impl.ContentManagerWatcher;
  12 import com.intellij.openapi.application.ApplicationManager;
  13 import com.intellij.openapi.components.ProjectComponent;
  14 import com.intellij.openapi.extensions.Extensions;
  15 import com.intellij.openapi.project.Project;
  16 import com.intellij.openapi.util.*;
  17 import com.intellij.openapi.wm.ToolWindow;
  18 import com.intellij.openapi.wm.ToolWindowAnchor;
  19 import com.intellij.openapi.wm.ToolWindowId;
  20 import com.intellij.openapi.wm.ToolWindowManager;
  21 import com.intellij.profile.codeInspection.InspectionProfileManager;
  22 import com.intellij.profile.codeInspection.InspectionProjectProfileManager;
  23 import com.intellij.psi.PsiElement;
  24 import com.intellij.ui.content.ContentFactory;
  25 import com.intellij.ui.content.ContentManager;
  26 import com.intellij.ui.content.TabbedPaneContentUI;
  27 import org.jdom.Element;
  28 import org.jetbrains.annotations.NonNls;
  29 import org.jetbrains.annotations.NotNull;
  30 import org.jetbrains.annotations.Nullable;
  31
  32 import java.util.HashSet;
  33 import java.util.Set;
  34
  35 public class InspectionManagerEx extends InspectionManager implements JDOMExternalizable, ProjectComponent {
  36   private GlobalInspectionContextImpl myGlobalInspectionContext = null;
  37   private final Project myProject;
  38   @NonNls private String myCurrentProfileName;
  39   private ContentManager myContentManager = null;
  40
  41   private final Set<GlobalInspectionContextImpl> myRunningContexts = new HashSet<GlobalInspectionContextImpl>();
  42
  43   public InspectionManagerEx(Project project) {
  44     myProject = project;
  45   }
  46
  47   @NotNull
  48   public Project getProject() {
  49     return myProject;
  50   }
  51
  52
  53   public void initComponent() {
  54   }
  55
  56   public void disposeComponent() {
  57   }
  58
  59   public void projectOpened() {
  60     myContentManager = ContentFactory.SERVICE.getInstance().createContentManager(new TabbedPaneContentUI(), true, myProject);
  61     if (!ApplicationManager.getApplication().isHeadlessEnvironment()) { //headless environment
  62       ToolWindowManager toolWindowManager = ToolWindowManager.getInstance(myProject);
  63       ToolWindow toolWindow =
  64         toolWindowManager.registerToolWindow(ToolWindowId.INSPECTION, myContentManager.getComponent(), ToolWindowAnchor.BOTTOM);
  65       toolWindow.setIcon(IconLoader.getIcon("/general/toolWindowInspection.png"));
  66       new ContentManagerWatcher(toolWindow, myContentManager);
  67     }
  68   }
  69
  70
  71   public void projectClosed() {
  72     if (ApplicationManager.getApplication().isHeadlessEnvironment()) return;
  73     ToolWindowManager.getInstance(myProject).unregisterToolWindow(ToolWindowId.INSPECTION);
  74   }
  75
  76
  77   public void readExternal(@NonNls Element element) throws InvalidDataException {
  78     DefaultJDOMExternalizer.readExternal(this, element);
  79   }
  80
  81   public void writeExternal(Element element) throws WriteExternalException {
  82     DefaultJDOMExternalizer.writeExternal(this, element);
  83   }
  84
  85   @NotNull
  86   public CommonProblemDescriptor createProblemDescriptor(@NotNull String descriptionTemplate, QuickFix... fixes) {
  87     return new CommonProblemDescriptorImpl(fixes, descriptionTemplate);
  88   }
  89
  90   @NotNull
  91   public ProblemDescriptor createProblemDescriptor(@NotNull PsiElement psiElement,
  92                                                    @NotNull String descriptionTemplate,
  93                                                    LocalQuickFix fix,
  94                                                    ProblemHighlightType highlightType) {
  95     LocalQuickFix[] quickFixes = fix != null ? new LocalQuickFix[]{fix} : null;
  96     return createProblemDescriptor(psiElement, descriptionTemplate, quickFixes, highlightType);
  97   }
  98
  99   @NotNull
 100   public ProblemDescriptor createProblemDescriptor(@NotNull PsiElement psiElement,
 101                                                    @NotNull String descriptionTemplate,
 102                                                    LocalQuickFix[] fixes,
 103                                                    ProblemHighlightType highlightType) {
 104     return createProblemDescriptor(psiElement, descriptionTemplate, fixes, highlightType, false);
 105   }
 106
 107   @NotNull
 108   public ProblemDescriptor createProblemDescriptor(@NotNull PsiElement psiElement,
 109                                                    @NotNull String descriptionTemplate,
 110                                                    LocalQuickFix[] fixes,
 111                                                    ProblemHighlightType highlightType,
 112                                                    boolean isAfterEndOfLine) {
 113     return new ProblemDescriptorImpl(psiElement, psiElement, descriptionTemplate, fixes, highlightType, isAfterEndOfLine, null);
 114   }
 115
 116   @NotNull
 117   public ProblemDescriptor createProblemDescriptor(@NotNull PsiElement startElement,
 118                                                    @NotNull PsiElement endElement,
 119                                                    @NotNull String descriptionTemplate,
 120                                                    ProblemHighlightType highlightType,
 121                                                    LocalQuickFix... fixes) {
 122     return new ProblemDescriptorImpl(startElement, endElement, descriptionTemplate, fixes, highlightType, false, null);
 123   }
 124
 125   public ProblemDescriptor createProblemDescriptor(@NotNull final PsiElement psiElement,
 126                                                    final TextRange rangeInElement,
 127                                                    @NotNull final String descriptionTemplate,
 128                                                    final ProblemHighlightType highlightType,
 129                                                    final LocalQuickFix... fixes) {
 130     return new ProblemDescriptorImpl(psiElement, psiElement, descriptionTemplate, fixes, highlightType, false, rangeInElement);
 131   }
 132
 133   public ProblemDescriptor createProblemDescriptor(@NotNull final PsiElement psiElement, @NotNull final String descriptionTemplate, final ProblemHighlightType highlightType,
 134                                                    @Nullable final HintAction hintAction,
 135                                                    final LocalQuickFix... fixes) {
 136
 137     return new ProblemDescriptorImpl(psiElement, psiElement, descriptionTemplate, fixes, highlightType, false, null, hintAction);
 138   }
 139
 140
 141   @NotNull
 142   public String getComponentName() {
 143     return "InspectionManager";
 144   }
 145
 146   public GlobalInspectionContextImpl createNewGlobalContext(boolean reuse) {
 147     if (reuse) {
 148       if (myGlobalInspectionContext == null) {
 149         myGlobalInspectionContext = new GlobalInspectionContextImpl(myProject, myContentManager);
 150       }
 151       myRunningContexts.add(myGlobalInspectionContext);
 152       return myGlobalInspectionContext;
 153     }
 154     final GlobalInspectionContextImpl inspectionContext = new GlobalInspectionContextImpl(myProject, myContentManager);
 155     myRunningContexts.add(inspectionContext);
 156     return inspectionContext;
 157   }
 158
 159   public void setProfile(final String name) {
 160     myCurrentProfileName = name;
 161   }
 162
 163   public String getCurrentProfile() {
 164     if (myCurrentProfileName == null) {
 165       final InspectionProjectProfileManager profileManager = InspectionProjectProfileManager.getInstance(myProject);
 166       if (profileManager.useProjectLevelProfileSettings()) {
 167         myCurrentProfileName = profileManager.getProjectProfile();
 168       }
 169       if (myCurrentProfileName == null) {
 170         myCurrentProfileName = InspectionProfileManager.getInstance().getRootProfile().getName();
 171       }
 172     }
 173     return myCurrentProfileName;
 174   }
 175
 176   public void closeRunningContext(GlobalInspectionContextImpl globalInspectionContext){
 177     myRunningContexts.remove(globalInspectionContext);
 178   }
 179
 180   public Set<GlobalInspectionContextImpl> getRunningContexts() {
 181     return myRunningContexts;
 182   }
 183
 184   public static boolean inspectionResultSuppressed(PsiElement place, LocalInspectionTool tool) {
 185     if (tool instanceof CustomSuppressableInspectionTool) {
 186       return ((CustomSuppressableInspectionTool)tool).isSuppressedFor(place);
 187     }
 188     return isSuppressed(place, tool.getID());
 189   }
 190
 191   public static boolean canRunInspections(final Project project, final boolean online) {
 192     for (InspectionExtensionsFactory factory : Extensions.getExtensions(InspectionExtensionsFactory.EP_NAME)) {
 193       if (!factory.isProjectConfiguredToRunInspections(project, online)) {
 194         return false;
 195       }
 196     }
 197     return true;
 198   }
 199
 200   public static boolean isSuppressed(PsiElement psiElement, String id) {
 201     for (InspectionExtensionsFactory factory : Extensions.getExtensions(InspectionExtensionsFactory.EP_NAME)) {
 202       if (!factory.isToCheckMember(psiElement, id)) {
 203         return true;
 204       }
 205     }
 206     return false;
 207   }
 208 }