Java TreeClassChooser类代码示例

import com.intellij.ide.util.TreeClassChooser; //导入依赖的package包/类
/** Ui for the user to pick the Main class. */
@NotNull
public TreeClassChooser chooseMainClassForProject() {
    logger.info("Choosing main class for project.");
    TreeClassChooser chooser;
    Project project = new ObjectFinder().findCurrentProject();
    while (true) {
        TreeClassChooserFactory factory = TreeClassChooserFactory.getInstance(project);
        GlobalSearchScope scope;
        scope = GlobalSearchScope.moduleScope(module);
        PsiClass ecClass = JavaPsiFacade.getInstance(project).findClass("", scope);
        ClassFilter filter = createClassFilter();
        chooser =
                factory.createInheritanceClassChooser(
                        "Choose main class", scope, ecClass, null, filter);
        chooser.showDialog();
        if (chooser.getSelected() == null
                || chooser.getSelected().findMethodsByName("main", true).length > 0) {
            logger.info("Choosing main class aborted.");
            break;
        }
    }
    logger.info("Main class chosen successfully.");
    return chooser;
}
 

import com.intellij.ide.util.TreeClassChooser; //导入依赖的package包/类
/**
 * Modifies the run configuration by adding parameters to it, such as a Main class which the
 * user selects.
 */
@NotNull
public ApplicationConfiguration configApplicationConfiguration(TreeClassChooser chooser) {
    if (configurationType.equals("Application")) {
        logger.info("Creating ApplicationConfiguration.");
        ApplicationConfiguration appCon =
                (ApplicationConfiguration)
                        runManager.getSelectedConfiguration().getConfiguration();
        logger.info("Setting main class and module to " + configurationType);
        appCon.setMainClass(chooser.getSelected());
        appCon.setModule(module);
        return appCon;
    }
    logger.info("No applicable configurationType was found.");
    return null;
}
 

import com.intellij.ide.util.TreeClassChooser; //导入依赖的package包/类
@Nullable
@Override
public XBreakpoint<JavaExceptionBreakpointProperties> addBreakpoint(final Project project, JComponent parentComponent) {
  final PsiClass throwableClass =
    JavaPsiFacade.getInstance(project).findClass(CommonClassNames.JAVA_LANG_THROWABLE, GlobalSearchScope.allScope(project));
  TreeClassChooser chooser = TreeClassChooserFactory.getInstance(project)
    .createInheritanceClassChooser(DebuggerBundle.message("add.exception.breakpoint.classchooser.title"),
                                   GlobalSearchScope.allScope(project), throwableClass, true, true, null);
  chooser.showDialog();
  final PsiClass selectedClass = chooser.getSelected();
  final String qName = selectedClass == null ? null : JVMNameUtil.getNonAnonymousClassName(selectedClass);

  if (qName != null && qName.length() > 0) {
    return ApplicationManager.getApplication().runWriteAction(new Computable<XBreakpoint<JavaExceptionBreakpointProperties>>() {
     @Override
     public XBreakpoint<JavaExceptionBreakpointProperties> compute() {
       return XDebuggerManager.getInstance(project).getBreakpointManager().addBreakpoint(
         JavaExceptionBreakpointType.this, new JavaExceptionBreakpointProperties(qName, ((PsiClassOwner)selectedClass.getContainingFile()).getPackageName()));
     }
   });
  }
  return null;
}
 

import com.intellij.ide.util.TreeClassChooser; //导入依赖的package包/类
private void chooseAnnotation(String title, JBList list) {
  final TreeClassChooser chooser = TreeClassChooserFactory.getInstance(myProject)
    .createNoInnerClassesScopeChooser("Choose " + title + " annotation", GlobalSearchScope.allScope(myProject), new ClassFilter() {
      @Override
      public boolean isAccepted(PsiClass aClass) {
        return aClass.isAnnotationType();
      }
    }, null);
  chooser.showDialog();
  final PsiClass selected = chooser.getSelected();
  if (selected == null) {
    return;
  }
  final String qualifiedName = selected.getQualifiedName();
  final DefaultListModel model = (DefaultListModel)list.getModel();
  final int index = model.indexOf(qualifiedName);
  if (index < 0) {
    model.addElement(qualifiedName);
  } else {
    myList.setSelectedIndex(index);
  }
}
 

import com.intellij.ide.util.TreeClassChooser; //导入依赖的package包/类
@Override
protected DomElement createElement(final T context, final Editor editor, PsiFile file, final Project project) {
  PsiClass selectedClass;
  if (!ApplicationManager.getApplication().isUnitTestMode()) {
    PsiClass baseClass = getBaseClass(context, project, myBaseClass);
    TreeClassChooser chooser = TreeClassChooserFactory.getInstance(project)
      .createInheritanceClassChooser(getChooserTitle(), GlobalSearchScope.allScope(project), baseClass, null, new ClassFilter() {
        @Override
        public boolean isAccepted(PsiClass aClass) {
          return !aClass.isInterface() && !aClass.hasModifierProperty(PsiModifier.ABSTRACT);
        }
      });
    chooser.showDialog();
    selectedClass = chooser.getSelected();
  }
  else {
    selectedClass = getBaseClass(context, project, myBaseClass == null ? CommonClassNames.JAVA_LANG_OBJECT : myBaseClass);
  }
  if (selectedClass == null) return null;

  return createElement(context, editor, file, project, selectedClass);
}
 

import com.intellij.ide.util.TreeClassChooser; //导入依赖的package包/类
@Nullable
protected String showDialog() {
  final ClassFilter.ClassFilterWithScope classFilter;
  try {
    classFilter = getFilter();
  }
  catch (NoFilterException e) {
    final MessagesEx.MessageInfo info = e.getMessageInfo();
    info.showNow();
    return null;
  }
  final TreeClassChooser dialog = createClassChooser(classFilter);
  configureDialog(dialog);
  dialog.showDialog();
  final PsiClass psiClass = dialog.getSelected();
  if (psiClass == null) return null;
  onClassChoosen(psiClass);
  return psiClass.getQualifiedName();
}
 

import com.intellij.ide.util.TreeClassChooser; //导入依赖的package包/类
public static ClassBrowser createAppletClassBrowser(final Project project,
                                                    final ConfigurationModuleSelector moduleSelector) {
  final String title = ExecutionBundle.message("choose.applet.class.dialog.title");
  return new MainClassBrowser(project, moduleSelector, title) {

    @Override
    protected TreeClassChooser createClassChooser(ClassFilter.ClassFilterWithScope classFilter) {
      final Module module = moduleSelector.getModule();
      final GlobalSearchScope scope =
        module == null ? GlobalSearchScope.allScope(myProject) : GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module);
      final PsiClass appletClass = JavaPsiFacade.getInstance(project).findClass("java.applet.Applet", scope);
      return TreeClassChooserFactory.getInstance(getProject())
        .createInheritanceClassChooser(title, classFilter.getScope(), appletClass, false, false,
                                       ConfigurationUtil.PUBLIC_INSTANTIATABLE_CLASS);
    }
  };
}
 

import com.intellij.ide.util.TreeClassChooser; //导入依赖的package包/类
public void actionPerformed(ActionEvent e) {
  TreeClassChooser chooser = TreeClassChooserFactory.getInstance(myProject).createWithInnerClassesScopeChooser(myChooserTitle,
                                                                                                               GlobalSearchScope.projectScope(myProject),
                                                                                                               new ClassFilter() {
    public boolean isAccepted(PsiClass aClass) {
      return aClass.getParent() instanceof PsiJavaFile || aClass.hasModifierProperty(PsiModifier.STATIC);
    }
  }, null);
  if (mySelectedClass != null) {
    chooser.selectDirectory(mySelectedClass.getContainingFile().getContainingDirectory());
  }
  chooser.showDialog();
  mySelectedClass = chooser.getSelected();
  if (mySelectedClass != null) {
    setText(mySelectedClass.getQualifiedName());
  }
}
 

import com.intellij.ide.util.TreeClassChooser; //导入依赖的package包/类
@Override
protected TreeClassChooser createTreeClassChooser(@NotNull Project project,
                                                  @NotNull GlobalSearchScope scope,
                                                  @Nullable PsiClass initialSelection,
                                                  @NotNull final ClassFilter classFilter) {
  final PsiClass baseClass = JavaPsiFacade.getInstance(project).findClass(myBaseClassName, ProjectScope.getAllScope(project));

  if (baseClass == null) {
    Messages.showErrorDialog(project, AndroidBundle.message("cant.find.class.error", myBaseClassName), CommonBundle.getErrorTitle());
    return null;
  }
  return TreeClassChooserFactory.getInstance(project).createInheritanceClassChooser(
    myDialogTitle, scope, baseClass, initialSelection, new ClassFilter() {
    @Override
    public boolean isAccepted(PsiClass aClass) {
      if (aClass.getManager().areElementsEquivalent(aClass, baseClass)) {
        return false;
      }
      return classFilter.isAccepted(aClass);
    }
  });
}
 

import com.intellij.ide.util.TreeClassChooser; //导入依赖的package包/类
@Override
protected String showDialog() {
  Project project = getProject();
  final JavaPsiFacade facade = JavaPsiFacade.getInstance(project);
  Module module = myModuleSelector.getModule();
  if (module == null) {
    Messages.showErrorDialog(project, ExecutionBundle.message("module.not.specified.error.text"), CommonBundle.getErrorTitle());
    return null;
  }
  GlobalSearchScope scope =
    myIncludeLibraryClasses ? module.getModuleWithDependenciesAndLibrariesScope(true) : module.getModuleWithDependenciesScope();
  PsiClass initialSelection = facade.findClass(getText(), scope);
  TreeClassChooser chooser = createTreeClassChooser(project, scope, initialSelection, new ClassFilter() {
    @Override
    public boolean isAccepted(PsiClass aClass) {
      if (aClass.isInterface()) return false;
      final PsiModifierList modifierList = aClass.getModifierList();
      return modifierList == null || !modifierList.hasModifierProperty(PsiModifier.ABSTRACT);
    }
  });
  if (chooser == null) return null;
  chooser.showDialog();
  PsiClass selClass = chooser.getSelected();
  return selClass != null ? selClass.getQualifiedName() : null;
}
 

import com.intellij.ide.util.TreeClassChooser; //导入依赖的package包/类
@Nullable
protected String selectListenerClass() {
  GlobalSearchScope searchScope = getSearchScope(config.getModules());
  if (searchScope == null) {
    searchScope = GlobalSearchScope.allScope(project);
  }
  final TestListenerFilter filter = new TestListenerFilter(searchScope, project);

  TreeClassChooser chooser = TreeClassChooserFactory.getInstance(project)
    .createWithInnerClassesScopeChooser("Choose Listener Class", filter.getScope(), filter, null);
  chooser.showDialog();
  PsiClass psiclass = chooser.getSelected();
  if (psiclass == null) {
    return null;
  }
  else {
    return JavaExecutionUtil.getRuntimeQualifiedName(psiclass);
  }
}
 

import com.intellij.ide.util.TreeClassChooser; //导入依赖的package包/类
@Override
protected String showDialog() {
  ClassFilter.ClassFilterWithScope filter;
  try {
    filter = getFilter();
  }
  catch (MessageInfoException e) {
    MessagesEx.MessageInfo message = e.getMessageInfo();
    message.showNow();
    return null;
  }
  TreeClassChooser chooser = TreeClassChooserFactory.getInstance(getProject()).createWithInnerClassesScopeChooser("Choose Test Class", filter.getScope(), filter, null);
  init(chooser);
  chooser.showDialog();
  PsiClass psiclass = chooser.getSelected();
  if (psiclass == null) {
    return null;
  } else {
    onClassChoosen(psiclass);
    return psiclass.getQualifiedName();
  }
}
 

import com.intellij.ide.util.TreeClassChooser; //导入依赖的package包/类
@Override
public Breakpoint addBreakpoint(Project project) {
  ExceptionBreakpoint breakpoint = null;
  final PsiClass throwableClass =
    JavaPsiFacade.getInstance(project).findClass("java.lang.Throwable", GlobalSearchScope.allScope(project));
  TreeClassChooser chooser = TreeClassChooserFactory.getInstance(project)
    .createInheritanceClassChooser(DebuggerBundle.message("add.exception.breakpoint.classchooser.title"),
                                   GlobalSearchScope.allScope(project), throwableClass, true, true, null);
  chooser.showDialog();
  PsiClass selectedClass = chooser.getSelected();
  String qName = selectedClass == null ? null : JVMNameUtil.getNonAnonymousClassName(selectedClass);

  if (qName != null && qName.length() > 0) {
    breakpoint = DebuggerManagerEx.getInstanceEx(project).getBreakpointManager()
      .addExceptionBreakpoint(qName, ((PsiClassOwner)selectedClass.getContainingFile()).getPackageName());
  }
  return breakpoint;
}
 

import com.intellij.ide.util.TreeClassChooser; //导入依赖的package包/类
@Nullable
protected String showDialog() {
  final ClassFilter.ClassFilterWithScope classFilter;
  try {
    classFilter = getFilter();
  }
  catch (NoFilterException e) {
    final MessagesEx.MessageInfo info = e.getMessageInfo();
    info.showNow();
    return null;
  }
  final TreeClassChooser dialog = createClassChooser(classFilter);
  configureDialog(dialog);
  dialog.showDialog();
  final PsiClass psiClass = dialog.getSelected();
  if (psiClass == null) return null;
  onClassChoosen(psiClass);
  return JavaExecutionUtil.getRuntimeQualifiedName(psiClass);
}
 

import com.intellij.ide.util.TreeClassChooser; //导入依赖的package包/类
@Nullable
public SearchScope getScope() {
  if (myCachedScope == null) {
    TreeClassChooser chooser = TreeClassChooserFactory.getInstance(myProject).createAllProjectScopeChooser(IdeBundle.message("prompt.choose.base.class.of.the.hierarchy"));

    chooser.showDialog();

    PsiClass aClass = chooser.getSelected();
    if (aClass == null) return null;

    List<PsiElement> classesToSearch = new LinkedList<PsiElement>();
    classesToSearch.add(aClass);

    classesToSearch.addAll(ClassInheritorsSearch.search(aClass, true).findAll());

    myCachedScope = new LocalSearchScope(PsiUtilCore.toPsiElementArray(classesToSearch),
                                         IdeBundle.message("scope.hierarchy", ClassPresentationUtil.getNameForClass(aClass, true)));
  }

  return myCachedScope;
}