java/execution/impl/src/com/intellij/execution/junit2/configuration/ClassBrowser.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 package com.intellij.execution.junit2.configuration;
  17
  18 import com.intellij.execution.ExecutionBundle;
  19 import com.intellij.execution.JavaExecutionUtil;
  20 import com.intellij.execution.configuration.BrowseModuleValueActionListener;
  21 import com.intellij.execution.configurations.ConfigurationUtil;
  22 import com.intellij.ide.util.TreeClassChooser;
  23 import com.intellij.ide.util.TreeClassChooserDialog;
  24 import com.intellij.ide.util.TreeClassChooserFactory;
  25 import com.intellij.openapi.module.Module;
  26 import com.intellij.openapi.project.Project;
  27 import com.intellij.openapi.ui.ex.MessagesEx;
  28 import com.intellij.psi.JavaPsiFacade;
  29 import com.intellij.psi.PsiClass;
  30 import com.intellij.psi.PsiDirectory;
  31 import com.intellij.psi.search.GlobalSearchScope;
  32 import com.intellij.psi.util.PsiMethodUtil;
  33 import org.jetbrains.annotations.Nullable;
  34
  35 public abstract class ClassBrowser extends BrowseModuleValueActionListener {
  36   private final String myTitle;
  37
  38   public ClassBrowser(final Project project, final String title) {
  39     super(project);
  40     myTitle = title;
  41   }
  42
  43   @Nullable
  44   protected String showDialog() {
  45     final TreeClassChooser.ClassFilterWithScope classFilter;
  46     try {
  47       classFilter = getFilter();
  48     }
  49     catch (NoFilterException e) {
  50       final MessagesEx.MessageInfo info = e.getMessageInfo();
  51       info.showNow();
  52       return null;
  53     }
  54     final TreeClassChooser dialog = TreeClassChooserFactory.getInstance(getProject()).createWithInnerClassesScopeChooser(myTitle, classFilter.getScope(), classFilter, null);
  55     configureDialog(dialog);
  56     dialog.showDialog();
  57     final PsiClass psiClass = dialog.getSelectedClass();
  58     if (psiClass == null) return null;
  59     onClassChoosen(psiClass);
  60     return JavaExecutionUtil.getRuntimeQualifiedName(psiClass);
  61   }
  62
  63   protected abstract TreeClassChooser.ClassFilterWithScope getFilter() throws NoFilterException;
  64
  65   protected void onClassChoosen(final PsiClass psiClass) { }
  66
  67   private void configureDialog(final TreeClassChooser dialog) {
  68     final String className = getText();
  69     final PsiClass psiClass = findClass(className);
  70     if (psiClass == null) return;
  71     final PsiDirectory directory = psiClass.getContainingFile().getContainingDirectory();
  72     if (directory != null) dialog.selectDirectory(directory);
  73     dialog.selectClass(psiClass);
  74   }
  75
  76   protected abstract PsiClass findClass(String className);
  77
  78   public static ClassBrowser createApplicationClassBrowser(final Project project,
  79                                                            final ConfigurationModuleSelector moduleSelector) {
  80     final TreeClassChooser.ClassFilter applicationClass = new TreeClassChooser.ClassFilter() {
  81       public boolean isAccepted(final PsiClass aClass) {
  82         return ConfigurationUtil.MAIN_CLASS.value(aClass) && PsiMethodUtil.findMainMethod(aClass) != null;
  83       }
  84     };
  85     return new MainClassBrowser(project, moduleSelector, ExecutionBundle.message("choose.main.class.dialog.title")){
  86       protected TreeClassChooser.ClassFilter createFilter(final Module module) {
  87         return applicationClass;
  88       }
  89     };
  90   }
  91
  92   public static ClassBrowser createAppletClassBrowser(final Project project,
  93                                                       final ConfigurationModuleSelector moduleSelector) {
  94     return new MainClassBrowser(project, moduleSelector, ExecutionBundle.message("choose.applet.class.dialog.title")) {
  95       protected TreeClassChooser.ClassFilter createFilter(final Module module) {
  96         final GlobalSearchScope scope =
  97             module == null ? GlobalSearchScope.allScope(myProject) : GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module);
  98         final PsiClass appletClass = JavaPsiFacade.getInstance(project).findClass("java.applet.Applet", scope);
  99         return new TreeClassChooserDialog.InheritanceClassFilterImpl(appletClass, false, false, ConfigurationUtil.PUBLIC_INSTANTIATABLE_CLASS);
 100       }
 101     };
 102   }
 103
 104   private abstract static class MainClassBrowser extends ClassBrowser {
 105     protected final Project myProject;
 106     private final ConfigurationModuleSelector myModuleSelector;
 107
 108     public MainClassBrowser(final Project project,
 109                             final ConfigurationModuleSelector moduleSelector,
 110                             final String title) {
 111       super(project, title);
 112       myProject = project;
 113       myModuleSelector = moduleSelector;
 114     }
 115
 116     protected PsiClass findClass(final String className) {
 117       return myModuleSelector.findClass(className);
 118     }
 119
 120     protected TreeClassChooser.ClassFilterWithScope getFilter() throws NoFilterException {
 121       final Module module = myModuleSelector.getModule();
 122       final GlobalSearchScope scope;
 123       if (module == null) scope = GlobalSearchScope.allScope(myProject);
 124       else scope = GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module);
 125       final TreeClassChooser.ClassFilter filter = createFilter(module);
 126       return new TreeClassChooser.ClassFilterWithScope() {
 127         public GlobalSearchScope getScope() {
 128           return scope;
 129         }
 130
 131         public boolean isAccepted(final PsiClass aClass) {
 132           return filter == null || filter.isAccepted(aClass);
 133         }
 134       };
 135     }
 136
 137     protected TreeClassChooser.ClassFilter createFilter(final Module module) { return null; }
 138   }
 139
 140   public static class NoFilterException extends Exception {
 141     private final MessagesEx.MessageInfo myMessageInfo;
 142
 143     public NoFilterException(final MessagesEx.MessageInfo messageInfo) {
 144       super(messageInfo.getMessage());
 145       myMessageInfo = messageInfo;
 146     }
 147
 148     public MessagesEx.MessageInfo getMessageInfo() {
 149       return myMessageInfo;
 150     }
 151
 152     public static NoFilterException noJUnitInModule(final Module module) {
 153       return new NoFilterException(new MessagesEx.MessageInfo(
 154         module.getProject(),
 155         ExecutionBundle.message("junit.not.found.in.module.error.message", module.getName()),
 156         ExecutionBundle.message("cannot.browse.test.inheritors.dialog.title")));
 157     }
 158
 159     public static NoFilterException moduleDoesntExist(final ConfigurationModuleSelector moduleSelector) {
 160       final Project project = moduleSelector.getProject();
 161       return new NoFilterException(new MessagesEx.MessageInfo(
 162         project,
 163         ExecutionBundle.message("module.does.not.exists", moduleSelector.getModuleName(), project.getName()),
 164         ExecutionBundle.message("cannot.browse.test.inheritors.dialog.title")));
 165     }
 166   }
 167 }