package com.intellij.packaging.impl.elements;
import com.intellij.CommonBundle;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.ide.util.TreeClassChooser;
import com.intellij.ide.util.TreeClassChooserFactory;
import com.intellij.openapi.application.ApplicationManager;
final TreeClassChooser chooser =
chooserFactory.createWithInnerClassesScopeChooser("Select Main Class", searchScope, new MainClassFilter(), aClass);
chooser.showDialog();
- return chooser.getSelectedClass();
+ return chooser.getSelected();
}
public static void setupMainClassField(final Project project, final TextFieldWithBrowseButton field) {
});
}
- private static class MainClassFilter implements TreeClassChooser.ClassFilter {
+ private static class MainClassFilter implements ClassFilter {
public boolean isAccepted(PsiClass aClass) {
return PsiMethodUtil.MAIN_CLASS.value(aClass) && PsiMethodUtil.hasMainMethod(aClass);
}
public PsiClass chooseClassDialog(String title, Project project) {
TreeClassChooser dialog = TreeClassChooserFactory.getInstance(project).createAllProjectScopeChooser(title);
dialog.showDialog();
- return dialog.getSelectedClass();
+ return dialog.getSelected();
}
public CompletionEditor createEditor(Project project, PsiElement context, String recentsId) {
}
}
chooser.showDialog();
- PsiClass selectedClass = chooser.getSelectedClass();
+ PsiClass selectedClass = chooser.getSelected();
if (selectedClass != null) {
myClassChooser.setText(selectedClass.getQualifiedName());
}
import com.intellij.debugger.ui.CompletionEditor;
import com.intellij.debugger.ui.DebuggerExpressionComboBox;
import com.intellij.debugger.ui.DebuggerStatementEditor;
-import com.intellij.ide.util.TreeClassChooser;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.ui.ComboBox;
import com.intellij.openapi.ui.DialogWrapper;
import com.intellij.psi.PsiElement;
import com.intellij.ui.FieldPanel;
import com.intellij.ui.MultiLineTooltipUI;
-import com.intellij.ui.classFilter.ClassFilter;
import com.intellij.xdebugger.impl.ui.DebuggerUIUtil;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
private final FieldPanel myInstanceFiltersField;
private final FieldPanel myClassFiltersField;
- private ClassFilter[] myClassFilters;
- private ClassFilter[] myClassExclusionFilters;
+ private com.intellij.ui.classFilter.ClassFilter[] myClassFilters;
+ private com.intellij.ui.classFilter.ClassFilter[] myClassExclusionFilters;
private InstanceFilter[] myInstanceFilters;
private JCheckBox myLogExpressionCheckBox;
public void actionPerformed(ActionEvent e) {
reloadClassFilters();
- TreeClassChooser.ClassFilter classFilter;
+ ClassFilter classFilter;
classFilter = createClassConditionFilter();
EditClassFiltersDialog _dialog = new EditClassFiltersDialog(myProject, classFilter);
mySuspendNoneRadio.setFont(DebuggerSettings.SUSPEND_NONE.equals(defPolicy)? boldFont : font);
}
- protected TreeClassChooser.ClassFilter createClassConditionFilter() {
- TreeClassChooser.ClassFilter classFilter;
+ protected ClassFilter createClassConditionFilter() {
+ ClassFilter classFilter;
if(myBreakpointPsiClass != null) {
- classFilter = new TreeClassChooser.ClassFilter() {
+ classFilter = new ClassFilter() {
public boolean isAccepted(PsiClass aClass) {
return myBreakpointPsiClass == aClass || aClass.isInheritor(myBreakpointPsiClass, true);
}
private void updateClassFilterEditor(boolean updateText) {
List<String> filters = new ArrayList<String>();
for (int i = 0; i < myClassFilters.length; i++) {
- ClassFilter classFilter = myClassFilters[i];
+ com.intellij.ui.classFilter.ClassFilter classFilter = myClassFilters[i];
if(classFilter.isEnabled()) {
filters.add(classFilter.getPattern());
}
}
List<String> excludeFilters = new ArrayList<String>();
for (int i = 0; i < myClassExclusionFilters.length; i++) {
- ClassFilter classFilter = myClassExclusionFilters[i];
+ com.intellij.ui.classFilter.ClassFilter classFilter = myClassExclusionFilters[i];
if(classFilter.isEnabled()) {
excludeFilters.add("-" + classFilter.getPattern());
}
private void reloadClassFilters() {
String filtersText = myClassFiltersField.getText();
- ArrayList<ClassFilter> classFilters = new ArrayList<ClassFilter>();
- ArrayList<ClassFilter> exclusionFilters = new ArrayList<ClassFilter>();
+ ArrayList<com.intellij.ui.classFilter.ClassFilter> classFilters = new ArrayList<com.intellij.ui.classFilter.ClassFilter>();
+ ArrayList<com.intellij.ui.classFilter.ClassFilter> exclusionFilters = new ArrayList<com.intellij.ui.classFilter.ClassFilter>();
int startFilter = -1;
for(int i = 0; i <= filtersText.length(); i++) {
if(i < filtersText.length() && !Character.isWhitespace(filtersText.charAt(i))){
} else {
if(startFilter >=0) {
if(filtersText.charAt(startFilter) == '-'){
- exclusionFilters.add(new ClassFilter(filtersText.substring(startFilter + 1, i)));
+ exclusionFilters.add(new com.intellij.ui.classFilter.ClassFilter(filtersText.substring(startFilter + 1, i)));
} else {
- classFilters.add(new ClassFilter(filtersText.substring(startFilter, i)));
+ classFilters.add(new com.intellij.ui.classFilter.ClassFilter(filtersText.substring(startFilter, i)));
}
startFilter = -1;
}
}
}
for (int i = 0; i < myClassFilters.length; i++) {
- ClassFilter classFilter = myClassFilters[i];
+ com.intellij.ui.classFilter.ClassFilter classFilter = myClassFilters[i];
if(!classFilter.isEnabled()) classFilters.add(classFilter);
}
for (int i = 0; i < myClassExclusionFilters.length; i++) {
- ClassFilter classFilter = myClassExclusionFilters[i];
+ com.intellij.ui.classFilter.ClassFilter classFilter = myClassExclusionFilters[i];
if(!classFilter.isEnabled()) exclusionFilters.add(classFilter);
}
- myClassFilters = classFilters .toArray(new ClassFilter[classFilters .size()]);
- myClassExclusionFilters = exclusionFilters.toArray(new ClassFilter[exclusionFilters.size()]);
+ myClassFilters = classFilters .toArray(new com.intellij.ui.classFilter.ClassFilter[classFilters .size()]);
+ myClassExclusionFilters = exclusionFilters.toArray(new com.intellij.ui.classFilter.ClassFilter[exclusionFilters.size()]);
}
public void setEnabled(boolean enabled) {
*/
package com.intellij.debugger.ui.breakpoints;
-import com.intellij.ui.classFilter.ClassFilter;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.ui.classFilter.ClassFilterEditor;
import com.intellij.debugger.DebuggerBundle;
-import com.intellij.ide.util.TreeClassChooser;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.ui.DialogWrapper;
import com.intellij.ui.IdeBorderFactory;
private ClassFilterEditor myClassFilterEditor;
private ClassFilterEditor myClassExclusionFilterEditor;
private Project myProject;
- private TreeClassChooser.ClassFilter myChooserFilter;
+ private ClassFilter myChooserFilter;
public EditClassFiltersDialog(Project project) {
this(project, null);
}
- public EditClassFiltersDialog(Project project, TreeClassChooser.ClassFilter filter) {
+ public EditClassFiltersDialog(Project project, ClassFilter filter) {
super(project, true);
myChooserFilter = filter;
myProject = project;
super.dispose();
}
- public void setFilters(ClassFilter[] filters, ClassFilter[] inverseFilters) {
+ public void setFilters(com.intellij.ui.classFilter.ClassFilter[] filters, com.intellij.ui.classFilter.ClassFilter[] inverseFilters) {
myClassFilterEditor.setFilters(filters);
myClassExclusionFilterEditor.setFilters(inverseFilters);
}
return "#com.intellij.debugger.ui.breakpoints.EditClassFiltersDialog";
}
- public ClassFilter[] getFilters() {
+ public com.intellij.ui.classFilter.ClassFilter[] getFilters() {
return myClassFilterEditor.getFilters();
}
- public ClassFilter[] getExclusionFilters() {
+ public com.intellij.ui.classFilter.ClassFilter[] getExclusionFilters() {
return myClassExclusionFilterEditor.getFilters();
}
}
\ No newline at end of file
DebuggerBundle.message("add.exception.breakpoint.classchooser.title"), GlobalSearchScope.allScope(myProject),
throwableClass, true, true, null);
chooser.showDialog();
- PsiClass selectedClass = chooser.getSelectedClass();
+ PsiClass selectedClass = chooser.getSelected();
String qName = selectedClass == null ? null : JVMNameUtil.getNonAnonymousClassName(selectedClass);
if (qName != null && qName.length() > 0) {
package com.intellij.debugger.ui.breakpoints;
import com.intellij.debugger.DebuggerBundle;
-import com.intellij.ide.util.TreeClassChooser;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.openapi.project.Project;
import javax.swing.*;
super(project, ExceptionBreakpoint.CATEGORY);
}
- protected TreeClassChooser.ClassFilter createClassConditionFilter() {
+ protected ClassFilter createClassConditionFilter() {
return null;
}
import com.intellij.execution.JavaExecutionUtil;
import com.intellij.execution.configuration.BrowseModuleValueActionListener;
import com.intellij.execution.configurations.ConfigurationUtil;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.ide.util.TreeClassChooser;
import com.intellij.ide.util.TreeClassChooserFactory;
import com.intellij.openapi.module.Module;
@Nullable
protected String showDialog() {
- final TreeClassChooser.ClassFilterWithScope classFilter;
+ final ClassFilter.ClassFilterWithScope classFilter;
try {
classFilter = getFilter();
}
final TreeClassChooser dialog = createClassChooser(classFilter);
configureDialog(dialog);
dialog.showDialog();
- final PsiClass psiClass = dialog.getSelectedClass();
+ final PsiClass psiClass = dialog.getSelected();
if (psiClass == null) return null;
onClassChoosen(psiClass);
return JavaExecutionUtil.getRuntimeQualifiedName(psiClass);
}
- protected TreeClassChooser createClassChooser(TreeClassChooser.ClassFilterWithScope classFilter) {
+ protected TreeClassChooser createClassChooser(ClassFilter.ClassFilterWithScope classFilter) {
return TreeClassChooserFactory.getInstance(getProject()).createWithInnerClassesScopeChooser(myTitle, classFilter.getScope(), classFilter, null);
}
- protected abstract TreeClassChooser.ClassFilterWithScope getFilter() throws NoFilterException;
+ protected abstract ClassFilter.ClassFilterWithScope getFilter() throws NoFilterException;
protected void onClassChoosen(final PsiClass psiClass) { }
if (psiClass == null) return;
final PsiDirectory directory = psiClass.getContainingFile().getContainingDirectory();
if (directory != null) dialog.selectDirectory(directory);
- dialog.selectClass(psiClass);
+ dialog.select(psiClass);
}
protected abstract PsiClass findClass(String className);
public static ClassBrowser createApplicationClassBrowser(final Project project,
final ConfigurationModuleSelector moduleSelector) {
- final TreeClassChooser.ClassFilter applicationClass = new TreeClassChooser.ClassFilter() {
+ final ClassFilter applicationClass = new ClassFilter() {
public boolean isAccepted(final PsiClass aClass) {
return ConfigurationUtil.MAIN_CLASS.value(aClass) && PsiMethodUtil.findMainMethod(aClass) != null;
}
};
return new MainClassBrowser(project, moduleSelector, ExecutionBundle.message("choose.main.class.dialog.title")){
- protected TreeClassChooser.ClassFilter createFilter(final Module module) {
+ protected ClassFilter createFilter(final Module module) {
return applicationClass;
}
};
return new MainClassBrowser(project, moduleSelector, title) {
@Override
- protected TreeClassChooser createClassChooser(TreeClassChooser.ClassFilterWithScope classFilter) {
+ protected TreeClassChooser createClassChooser(ClassFilter.ClassFilterWithScope classFilter) {
final Module module = moduleSelector.getModule();
final GlobalSearchScope scope =
module == null ? GlobalSearchScope.allScope(myProject) : GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module);
return myModuleSelector.findClass(className);
}
- protected TreeClassChooser.ClassFilterWithScope getFilter() throws NoFilterException {
+ protected ClassFilter.ClassFilterWithScope getFilter() throws NoFilterException {
final Module module = myModuleSelector.getModule();
final GlobalSearchScope scope;
if (module == null) scope = GlobalSearchScope.allScope(myProject);
else scope = GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module);
- final TreeClassChooser.ClassFilter filter = createFilter(module);
- return new TreeClassChooser.ClassFilterWithScope() {
+ final ClassFilter filter = createFilter(module);
+ return new ClassFilter.ClassFilterWithScope() {
public GlobalSearchScope getScope() {
return scope;
}
};
}
- protected TreeClassChooser.ClassFilter createFilter(final Module module) { return null; }
+ protected ClassFilter createFilter(final Module module) { return null; }
}
public static class NoFilterException extends Exception {
<orderEntry type="module" module-name="icons" />
<orderEntry type="library" name="jcip" level="project" />
<orderEntry type="library" name="Groovy" level="project" />
+ <orderEntry type="library" name="Guava" level="project" />
</component>
<component name="copyright">
<Base>
@NotNull
public TreeClassChooser createWithInnerClassesScopeChooser(String title,
GlobalSearchScope scope,
- final TreeClassChooser.ClassFilter classFilter,
+ final ClassFilter classFilter,
PsiClass initialClass) {
- return TreeClassChooserDialog.withInnerClasses(title, myProject, scope, classFilter, initialClass);
+ return TreeJavaClassChooserDialog.withInnerClasses(title, myProject, scope, classFilter, initialClass);
}
@NotNull
public TreeClassChooser createNoInnerClassesScopeChooser(String title,
GlobalSearchScope scope,
- TreeClassChooser.ClassFilter classFilter,
+ ClassFilter classFilter,
PsiClass initialClass) {
- return new TreeClassChooserDialog(title, myProject, scope, classFilter, initialClass);
+ return new TreeJavaClassChooserDialog(title, myProject, scope, classFilter, initialClass);
}
@NotNull
public TreeClassChooser createProjectScopeChooser(String title, PsiClass initialClass) {
- return new TreeClassChooserDialog(title, myProject, initialClass);
+ return new TreeJavaClassChooserDialog(title, myProject, initialClass);
}
@NotNull
public TreeClassChooser createProjectScopeChooser(String title) {
- return new TreeClassChooserDialog(title, myProject);
+ return new TreeJavaClassChooserDialog(title, myProject);
}
@NotNull
public TreeClassChooser createAllProjectScopeChooser(String title) {
- return new TreeClassChooserDialog(title, myProject, GlobalSearchScope.allScope(myProject), null, null);
+ return new TreeJavaClassChooserDialog(title, myProject, GlobalSearchScope.allScope(myProject), null, null);
}
@NotNull
boolean acceptsSelf,
boolean acceptInner,
Condition<? super PsiClass> additionalCondition) {
- TreeClassChooser.ClassFilter classFilter = new TreeClassChooserDialog.InheritanceClassFilterImpl(base, acceptsSelf, acceptInner, additionalCondition);
- return new TreeClassChooserDialog(title, myProject, scope, classFilter, base, null, null);
+ ClassFilter classFilter = new TreeJavaClassChooserDialog.InheritanceJavaClassFilterImpl(base, acceptsSelf, acceptInner, additionalCondition);
+ return new TreeJavaClassChooserDialog(title, myProject, scope, classFilter, base, null, false);
}
@NotNull
@NotNull
public TreeClassChooser createInheritanceClassChooser(String title, GlobalSearchScope scope, PsiClass base, PsiClass initialClass,
- TreeClassChooser.ClassFilter classFilter) {
- return new TreeClassChooserDialog(title, myProject, scope, classFilter, base, initialClass, null);
+ ClassFilter classFilter) {
+ return new TreeJavaClassChooserDialog(title, myProject, scope, classFilter, base, initialClass, false);
}
@NotNull
--- /dev/null
+/*
+ * Copyright 2000-2010 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.ide.util;
+
+import com.google.common.collect.Lists;
+import com.intellij.ide.projectView.impl.nodes.ClassTreeNode;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Condition;
+import com.intellij.openapi.util.Conditions;
+import com.intellij.psi.JavaPsiFacade;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiJavaFile;
+import com.intellij.psi.search.GlobalSearchScope;
+import com.intellij.psi.search.PsiShortNamesCache;
+import com.intellij.psi.search.searches.ClassInheritorsSearch;
+import com.intellij.util.Query;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import javax.swing.tree.DefaultMutableTreeNode;
+import java.util.List;
+
+/**
+ * @author traff
+ */
+public class TreeJavaClassChooserDialog extends AbstractTreeClassChooserDialog<PsiClass> implements TreeClassChooser {
+ public TreeJavaClassChooserDialog(String title, Project project) {
+ super(title, project);
+ }
+
+ public TreeJavaClassChooserDialog(String title, Project project, @Nullable PsiClass initialClass) {
+ super(title, project, initialClass);
+ }
+
+ public TreeJavaClassChooserDialog(String title,
+ Project project,
+ GlobalSearchScope scope,
+ final ClassFilter classFilter, @Nullable PsiClass initialClass) {
+ super(title, project, scope, createFilter(classFilter), initialClass);
+ }
+
+
+ @Override
+ @Nullable
+ protected PsiClass getSelectedFromTreeUserObject(DefaultMutableTreeNode node) {
+ Object userObject = node.getUserObject();
+ if (!(userObject instanceof ClassTreeNode)) return null;
+ ClassTreeNode descriptor = (ClassTreeNode)userObject;
+ return descriptor.getPsiClass();
+ }
+
+ public TreeJavaClassChooserDialog(String title,
+ Project project,
+ GlobalSearchScope scope,
+ final ClassFilter classFilter,
+ PsiClass baseClass,
+ @Nullable PsiClass initialClass, boolean isShowMembers) {
+ super(title, project, scope, createFilter(classFilter), baseClass, initialClass, isShowMembers);
+ }
+
+ public static TreeJavaClassChooserDialog withInnerClasses(String title,
+ Project project,
+ GlobalSearchScope scope,
+ final ClassFilter classFilter,
+ @Nullable PsiClass initialClass) {
+ return new TreeJavaClassChooserDialog(title, project, scope, classFilter, null, initialClass, true);
+ }
+
+ @Nullable
+ private static Filter<PsiClass> createFilter(@Nullable final ClassFilter classFilter) {
+ if (classFilter == null) {
+ return null;
+ }
+ else {
+ return new Filter<PsiClass>() {
+ @Override
+ public boolean isAccepted(PsiClass element) {
+ return classFilter.isAccepted(element);
+ }
+ };
+ }
+ }
+
+ @NotNull
+ protected List<PsiClass> getClassesByName(final String name,
+ final boolean checkBoxState,
+ final String pattern,
+ final GlobalSearchScope searchScope) {
+ final PsiShortNamesCache cache = JavaPsiFacade.getInstance(getProject()).getShortNamesCache();
+ PsiClass[] classes =
+ cache.getClassesByName(name, checkBoxState ? searchScope : GlobalSearchScope.projectScope(getProject()).intersectWith(searchScope));
+ return Lists.newArrayList(classes);
+ }
+
+ @NotNull
+ @Override
+ protected BaseClassInheritorsProvider<PsiClass> getInheritorsProvider() {
+ return new JavaInheritorsProvider(getProject(), getBaseClass(), getScope());
+ }
+
+ private static class JavaInheritorsProvider extends BaseClassInheritorsProvider<PsiClass> {
+ private final Project myProject;
+
+ public JavaInheritorsProvider(Project project, PsiClass baseClass, GlobalSearchScope scope) {
+ super(baseClass, scope);
+ myProject = project;
+ }
+
+ @NotNull
+ @Override
+ protected Query<PsiClass> searchForInheritors(PsiClass baseClass, GlobalSearchScope searchScope, boolean checkDeep) {
+ return ClassInheritorsSearch.search(baseClass, searchScope, checkDeep);
+ }
+
+ @Override
+ protected boolean isInheritor(PsiClass clazz, PsiClass baseClass, boolean checkDeep) {
+ return clazz.isInheritor(baseClass, checkDeep);
+ }
+
+ @Override
+ protected String[] getNames() {
+ return JavaPsiFacade.getInstance(myProject).getShortNamesCache().getAllClassNames();
+ }
+ }
+
+ public static class InheritanceJavaClassFilterImpl implements ClassFilter {
+ private final PsiClass myBase;
+ private final boolean myAcceptsSelf;
+ private final boolean myAcceptsInner;
+ private final Condition<? super PsiClass> myAdditionalCondition;
+
+ public InheritanceJavaClassFilterImpl(PsiClass base,
+ boolean acceptsSelf,
+ boolean acceptInner,
+ Condition<? super PsiClass> additionalCondition) {
+ myAcceptsSelf = acceptsSelf;
+ myAcceptsInner = acceptInner;
+ if (additionalCondition == null) {
+ additionalCondition = Conditions.alwaysTrue();
+ }
+ myAdditionalCondition = additionalCondition;
+ myBase = base;
+ }
+
+ public boolean isAccepted(PsiClass aClass) {
+ if (!myAcceptsInner && !(aClass.getParent() instanceof PsiJavaFile)) return false;
+ if (!myAdditionalCondition.value(aClass)) return false;
+ // we've already checked for inheritance
+ return myAcceptsSelf || !aClass.getManager().areElementsEquivalent(aClass, myBase);
+ }
+ }
+}
chooser.showDialog();
- PsiClass aClass = chooser.getSelectedClass();
+ PsiClass aClass = chooser.getSelected();
if (aClass == null) return null;
List<PsiElement> classesToSearch = new LinkedList<PsiElement>();
import com.intellij.codeInsight.AnnotationUtil;
import com.intellij.codeInsight.completion.JavaCompletionUtil;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.ide.util.PropertiesComponent;
import com.intellij.ide.util.TreeClassChooser;
import com.intellij.ide.util.TreeClassChooserFactory;
private class ChooseClassAction implements ActionListener {
public void actionPerformed(ActionEvent e) {
- TreeClassChooser chooser = TreeClassChooserFactory.getInstance(myProject).createWithInnerClassesScopeChooser(RefactoringBundle.message("choose.destination.class"), GlobalSearchScope.projectScope(myProject), new TreeClassChooser.ClassFilter() {
+ TreeClassChooser chooser = TreeClassChooserFactory.getInstance(myProject).createWithInnerClassesScopeChooser(RefactoringBundle.message("choose.destination.class"), GlobalSearchScope.projectScope(myProject), new ClassFilter() {
public boolean isAccepted(PsiClass aClass) {
return aClass.getParent() instanceof PsiJavaFile || aClass.hasModifierProperty(PsiModifier.STATIC);
}
chooser.selectDirectory(myTargetClass.getContainingFile().getContainingDirectory());
}
chooser.showDialog();
- PsiClass aClass = chooser.getSelectedClass();
+ PsiClass aClass = chooser.getSelected();
if (aClass != null) {
myTfTargetClassName.setText(aClass.getQualifiedName());
}
*/
package com.intellij.refactoring.introduceparameterobject;
-import com.intellij.ide.util.TreeClassChooserDialog;
+import com.intellij.ide.util.TreeJavaClassChooserDialog;
import com.intellij.openapi.editor.Document;
import com.intellij.openapi.help.HelpManager;
import com.intellij.openapi.options.ConfigurationException;
public void actionPerformed(ActionEvent e) {
final Project project = sourceMethod.getProject();
final GlobalSearchScope scope = GlobalSearchScope.allScope(project);
- final TreeClassChooserDialog chooser =
- new TreeClassChooserDialog(RefactorJBundle.message("select.wrapper.class"), project, scope, null, null);
+ final TreeJavaClassChooserDialog chooser =
+ new TreeJavaClassChooserDialog(RefactorJBundle.message("select.wrapper.class"), project, scope, null, null);
final String classText = existingClassField.getText();
final PsiClass currentClass = JavaPsiFacade.getInstance(project).findClass(classText, GlobalSearchScope.allScope(project));
if (currentClass != null) {
- chooser.selectClass(currentClass);
+ chooser.select(currentClass);
}
chooser.show();
- final PsiClass selectedClass = chooser.getSelectedClass();
+ final PsiClass selectedClass = chooser.getSelected();
if (selectedClass != null) {
final String className = selectedClass.getQualifiedName();
existingClassField.setText(className);
*/
package com.intellij.refactoring.move.moveMembers;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.ide.util.PackageUtil;
import com.intellij.ide.util.TreeClassChooser;
import com.intellij.ide.util.TreeClassChooserFactory;
private class ChooseClassAction implements ActionListener {
public void actionPerformed(ActionEvent e) {
TreeClassChooser chooser = TreeClassChooserFactory.getInstance(myProject).createWithInnerClassesScopeChooser(
- RefactoringBundle.message("choose.destination.class"), GlobalSearchScope.projectScope(myProject), new TreeClassChooser.ClassFilter() {
+ RefactoringBundle.message("choose.destination.class"), GlobalSearchScope.projectScope(myProject), new ClassFilter() {
public boolean isAccepted(PsiClass aClass) {
return aClass.getParent() instanceof PsiFile || aClass.hasModifierProperty(PsiModifier.STATIC);
}
}
chooser.showDialog();
- PsiClass aClass = chooser.getSelectedClass();
+ PsiClass aClass = chooser.getSelected();
if (aClass != null) {
myTfTargetClassName.setText(aClass.getQualifiedName());
myMemberInfoModel.updateTargetClass();
final String classText = myExistentClassTF.getText();
final PsiClass currentClass = JavaPsiFacade.getInstance(myProject).findClass(classText, GlobalSearchScope.allScope(myProject));
if (currentClass != null) {
- chooser.selectClass(currentClass);
+ chooser.select(currentClass);
}
chooser.showDialog();
- final PsiClass selectedClass = chooser.getSelectedClass();
+ final PsiClass selectedClass = chooser.getSelected();
if (selectedClass != null) {
myExistentClassTF.setText(selectedClass.getQualifiedName());
}
RefactoringBundle.message("choose.destination.class"));
chooser.selectDirectory(myContainingClass.getContainingFile().getContainingDirectory());
chooser.showDialog();
- PsiClass aClass = chooser.getSelectedClass();
+ PsiClass aClass = chooser.getSelected();
if (aClass != null) {
myTfTargetClassName.setText(aClass.getQualifiedName());
}
*/
package com.intellij.refactoring.ui;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.ide.util.TreeClassChooser;
import com.intellij.ide.util.TreeClassChooserFactory;
import com.intellij.openapi.editor.Document;
public void actionPerformed(ActionEvent e) {
TreeClassChooser chooser = TreeClassChooserFactory.getInstance(myProject).createWithInnerClassesScopeChooser(myChooserTitle,
GlobalSearchScope.projectScope(myProject),
- new TreeClassChooser.ClassFilter() {
+ new ClassFilter() {
public boolean isAccepted(PsiClass aClass) {
return aClass.getParent() instanceof PsiJavaFile || aClass.hasModifierProperty(PsiModifier.STATIC);
}
chooser.selectDirectory(mySelectedClass.getContainingFile().getContainingDirectory());
}
chooser.showDialog();
- mySelectedClass = chooser.getSelectedClass();
+ mySelectedClass = chooser.getSelected();
if (mySelectedClass != null) {
setText(mySelectedClass.getQualifiedName());
}
final String classText = existingClassField.getText();
final PsiClass currentClass = JavaPsiFacade.getInstance(myProject).findClass(classText, GlobalSearchScope.allScope(myProject));
if (currentClass != null) {
- chooser.selectClass(currentClass);
+ chooser.select(currentClass);
}
chooser.showDialog();
- final PsiClass selectedClass = chooser.getSelectedClass();
+ final PsiClass selectedClass = chooser.getSelected();
if (selectedClass != null) {
existingClassField.setText(selectedClass.getQualifiedName());
}
TreeClassChooser dialog =
f.createAllProjectScopeChooser(CodeInsightBundle.message("intention.create.test.dialog.choose.super.class"));
dialog.showDialog();
- PsiClass aClass = dialog.getSelectedClass();
+ PsiClass aClass = dialog.getSelected();
if (aClass != null) {
mySuperClassField.setText(aClass.getQualifiedName());
}
*/
package com.intellij.util.xml.ui;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.ide.util.TreeClassChooser;
import com.intellij.ide.util.TreeClassChooserFactory;
import com.intellij.openapi.editor.Document;
final DomElement domElement = control.getDomElement();
ExtendClass extend = domElement.getAnnotation(ExtendClass.class);
PsiClass baseClass = null;
- TreeClassChooser.ClassFilter filter = null;
+ ClassFilter filter = null;
if (extend != null) {
baseClass = JavaPsiFacade.getInstance(control.getProject()).findClass(extend.value(), resolveScope);
if (extend.instantiatable()) {
- filter = TreeClassChooser.INSTANTIATABLE;
+ filter = ClassFilter.INSTANTIABLE;
}
}
TreeClassChooser chooser = TreeClassChooserFactory.getInstance(control.getProject())
.createInheritanceClassChooser(UIBundle.message("choose.class"), resolveScope, baseClass, initialClass, filter);
chooser.showDialog();
- final PsiClass psiClass = chooser.getSelectedClass();
+ final PsiClass psiClass = chooser.getSelected();
if (psiClass != null) {
control.setValue(psiClass.getQualifiedName());
}
TreeClassChooser chooser = TreeClassChooserFactory.getInstance(myProject)
.createInheritanceClassChooser(UIBundle.message("choose.class"), mySearchScope, null, true, true, Conditions.alwaysTrue());
chooser.showDialog();
- final PsiClass psiClass = chooser.getSelectedClass();
+ final PsiClass psiClass = chooser.getSelected();
if (psiClass != null) {
myEditor.setText(psiClass.getQualifiedName());
}
--- /dev/null
+/*
+ * Copyright 2000-2010 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.ide.util;
+
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.search.GlobalSearchScope;
+import com.intellij.psi.util.PsiUtil;
+
+/**
+* @author traff
+*/
+public interface ClassFilter {
+ ClassFilter INSTANTIABLE = new ClassFilter() {
+ public boolean isAccepted(PsiClass aClass) {
+ return PsiUtil.isInstantiatable(aClass);
+ }
+ };
+
+ boolean isAccepted(PsiClass aClass);
+ ClassFilter ALL = new ClassFilter() {
+ public boolean isAccepted(PsiClass aClass) {
+ return true;
+ }
+ };
+
+ interface ClassFilterWithScope extends ClassFilter {
+ GlobalSearchScope getScope();
+ }
+}
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiDirectory;
-import com.intellij.psi.util.PsiUtil;
-import com.intellij.psi.search.GlobalSearchScope;
/**
* User: anna
* Date: Jan 24, 2005
*/
-public interface TreeClassChooser{
- ClassFilter INSTANTIATABLE = new ClassFilter() {
- public boolean isAccepted(PsiClass aClass) {
- return PsiUtil.isInstantiatable(aClass);
- }
- };
+public interface TreeClassChooser extends TreeChooser<PsiClass> {
+ PsiClass getSelected();
- PsiClass getSelectedClass();
-
- void selectClass(final PsiClass aClass);
+ void select(final PsiClass aClass);
void selectDirectory(final PsiDirectory directory);
void showDialog();
void showPopup();
-
- interface ClassFilter {
- boolean isAccepted(PsiClass aClass);
- ClassFilter ALL = new ClassFilter() {
- public boolean isAccepted(PsiClass aClass) {
- return true;
- }
- };
- }
-
- interface ClassFilterWithScope extends ClassFilter {
- GlobalSearchScope getScope();
- }
-
- interface InheritanceClassFilter extends ClassFilter{
- }
}
@NotNull
public abstract TreeClassChooser createWithInnerClassesScopeChooser(String title,
GlobalSearchScope scope,
- final TreeClassChooser.ClassFilter classFilter,
+ final ClassFilter classFilter,
@Nullable PsiClass initialClass);
@NotNull
public abstract TreeClassChooser createNoInnerClassesScopeChooser(String title,
GlobalSearchScope scope,
- TreeClassChooser.ClassFilter classFilter,
+ ClassFilter classFilter,
@Nullable PsiClass initialClass);
GlobalSearchScope scope,
PsiClass base,
PsiClass initialClass,
- TreeClassChooser.ClassFilter classFilter);
+ ClassFilter classFilter);
@NotNull
*/
package com.intellij.ui.classFilter;
-import com.intellij.ide.util.TreeClassChooser;
-import com.intellij.ide.util.TreeClassChooserFactory;
+import com.intellij.ide.util.*;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiClass;
import com.intellij.psi.search.GlobalSearchScope;
protected JButton myAddPatternButton;
private JButton myRemoveButton;
protected Project myProject;
- private TreeClassChooser.ClassFilter myChooserFilter;
+ private ClassFilter myChooserFilter;
public ClassFilterEditor(Project project) {
this (project, null);
}
- public ClassFilterEditor(Project project, TreeClassChooser.ClassFilter classFilter) {
+ public ClassFilterEditor(Project project, com.intellij.ide.util.ClassFilter classFilter) {
super(new GridBagLayout());
myAddClassButton = new JButton(getAddButtonText());
myAddPatternButton = new JButton(getAddPatternButtonText());
return UIBundle.message("button.add.pattern");
}
- public void setFilters(ClassFilter[] filters) {
+ public void setFilters(com.intellij.ui.classFilter.ClassFilter[] filters) {
myTableModel.setFilters(filters);
}
- public ClassFilter[] getFilters() {
+ public com.intellij.ui.classFilter.ClassFilter[] getFilters() {
return myTableModel.getFilters();
}
}
protected final class FilterTableModel extends AbstractTableModel implements ItemRemovable{
- private final List<ClassFilter> myFilters = new LinkedList<ClassFilter>();
+ private final List<com.intellij.ui.classFilter.ClassFilter> myFilters = new LinkedList<com.intellij.ui.classFilter.ClassFilter>();
public static final int CHECK_MARK = 0;
public static final int FILTER = 1;
- public final void setFilters(ClassFilter[] filters) {
+ public final void setFilters(com.intellij.ui.classFilter.ClassFilter[] filters) {
myFilters.clear();
if (filters != null) {
ContainerUtil.addAll(myFilters, filters);
fireTableDataChanged();
}
- public ClassFilter[] getFilters() {
- for (Iterator<ClassFilter> it = myFilters.iterator(); it.hasNext();) {
- ClassFilter filter = it.next();
+ public com.intellij.ui.classFilter.ClassFilter[] getFilters() {
+ for (Iterator<com.intellij.ui.classFilter.ClassFilter> it = myFilters.iterator(); it.hasNext();) {
+ com.intellij.ui.classFilter.ClassFilter filter = it.next();
String pattern = filter.getPattern();
if (pattern == null || "".equals(pattern)) {
it.remove();
}
}
- return myFilters.toArray(new ClassFilter[myFilters.size()]);
+ return myFilters.toArray(new com.intellij.ui.classFilter.ClassFilter[myFilters.size()]);
}
- public ClassFilter getFilterAt(int index) {
+ public com.intellij.ui.classFilter.ClassFilter getFilterAt(int index) {
return myFilters.get(index);
}
- public int getFilterIndex(ClassFilter filter) {
+ public int getFilterIndex(com.intellij.ui.classFilter.ClassFilter filter) {
return myFilters.indexOf(filter);
}
- public void addRow(ClassFilter filter) {
+ public void addRow(com.intellij.ui.classFilter.ClassFilter filter) {
myFilters.add(filter);
int row = myFilters.size() - 1;
fireTableRowsInserted(row, row);
}
public Object getValueAt(int rowIndex, int columnIndex) {
- ClassFilter filter = myFilters.get(rowIndex);
+ com.intellij.ui.classFilter.ClassFilter filter = myFilters.get(rowIndex);
if (columnIndex == FILTER) {
return filter;
}
}
public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
- ClassFilter filter = myFilters.get(rowIndex);
+ com.intellij.ui.classFilter.ClassFilter filter = myFilters.get(rowIndex);
if (columnIndex == FILTER) {
filter.setPattern(aValue != null? aValue.toString() : "");
}
((JLabel)component).setBorder(noFocusBorder);
}
UIManager.put(UIUtil.TABLE_FOCUS_CELL_BACKGROUND_PROPERTY, color);
- ClassFilter filter = (ClassFilter)table.getValueAt(row, FilterTableModel.FILTER);
+ com.intellij.ui.classFilter.ClassFilter filter = (com.intellij.ui.classFilter.ClassFilter)table.getValueAt(row, FilterTableModel.FILTER);
component.setEnabled(ClassFilterEditor.this.isEnabled() && filter.isEnabled());
return component;
}
}
@NotNull
- protected ClassFilter createFilter(String pattern){
- return new ClassFilter(pattern);
+ protected com.intellij.ui.classFilter.ClassFilter createFilter(String pattern){
+ return new com.intellij.ui.classFilter.ClassFilter(pattern);
}
protected void addPatternFilter() {
if (dialog.isOK()) {
String pattern = dialog.getPattern();
if (pattern != null) {
- ClassFilter filter = createFilter(pattern);
+ com.intellij.ui.classFilter.ClassFilter filter = createFilter(pattern);
myTableModel.addRow(filter);
int row = myTableModel.getRowCount() - 1;
myTable.getSelectionModel().setSelectionInterval(row, row);
TreeClassChooser chooser = TreeClassChooserFactory.getInstance(myProject).createNoInnerClassesScopeChooser(
UIBundle.message("class.filter.editor.choose.class.title"), GlobalSearchScope.allScope(myProject), myChooserFilter, null);
chooser.showDialog();
- PsiClass selectedClass = chooser.getSelectedClass();
+ PsiClass selectedClass = chooser.getSelected();
if (selectedClass != null) {
- ClassFilter filter = createFilter(getJvmClassName(selectedClass));
+ com.intellij.ui.classFilter.ClassFilter filter = createFilter(getJvmClassName(selectedClass));
myTableModel.addRow(filter);
int row = myTableModel.getRowCount() - 1;
myTable.getSelectionModel().setSelectionInterval(row, row);
}
public void addPattern(String pattern) {
- ClassFilter filter = createFilter(pattern);
+ com.intellij.ui.classFilter.ClassFilter filter = createFilter(pattern);
myTableModel.addRow(filter);
}
}
}
chooser.showDialog();
- PsiClass selectedClass = chooser.getSelectedClass();
+ PsiClass selectedClass = chooser.getSelected();
if (selectedClass != null) {
myClassName.setText(selectedClass.getQualifiedName());
}
*/
package com.intellij.util.xml.actions;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.ide.util.TreeClassChooser;
import com.intellij.ide.util.TreeClassChooserFactory;
import com.intellij.openapi.application.ApplicationManager;
if (!ApplicationManager.getApplication().isUnitTestMode()) {
PsiClass baseClass = getBaseClass(context, project, myBaseClass);
TreeClassChooser chooser = TreeClassChooserFactory.getInstance(project)
- .createInheritanceClassChooser(getChooserTitle(), GlobalSearchScope.allScope(project), baseClass, null, new TreeClassChooser.ClassFilter() {
+ .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.getSelectedClass();
+ selectedClass = chooser.getSelected();
}
else {
selectedClass = getBaseClass(context, project, myBaseClass == null ? "java.lang.Object" : myBaseClass);
private final MyFileStatusListener myFileStatusListener;
private final CopyPasteUtil.DefaultCopyPasteListener myCopyPasteListener;
- //private final PropertiesFileListener myPropertiesFileListener;
private final WolfTheProblemSolver.ProblemListener myProblemListener;
public ProjectTreeBuilder(final Project project, JTree tree, DefaultTreeModel treeModel, Comparator<NodeDescriptor> comparator, ProjectAbstractTreeStructureBase treeStructure) {
myCopyPasteListener = new CopyPasteUtil.DefaultCopyPasteListener(getUpdater());
CopyPasteManager.getInstance().addContentChangedListener(myCopyPasteListener);
- /*myPropertiesFileListener = new PropertiesFileListener();
- final PropertiesFilesManager propertiesFilesManager = PropertiesFilesManager.getInstance();
- if (propertiesFilesManager != null) {
- propertiesFilesManager.addPropertiesFileListener(myPropertiesFileListener);
- }*/
myProblemListener = new MyProblemListener();
WolfTheProblemSolver.getInstance(project).addProblemListener(myProblemListener);
PsiManager.getInstance(myProject).removePsiTreeChangeListener(myPsiTreeChangeListener);
FileStatusManager.getInstance(myProject).removeFileStatusListener(myFileStatusListener);
CopyPasteManager.getInstance().removeContentChangedListener(myCopyPasteListener);
- /* final PropertiesFilesManager propertiesFilesManager = PropertiesFilesManager.getInstance();
- if (propertiesFilesManager != null) {
- propertiesFilesManager.removePropertiesFileListener(myPropertiesFileListener);
- }*/
WolfTheProblemSolver.getInstance(myProject).removeProblemListener(myProblemListener);
}
return element;
}
- /* private class PropertiesFileListener implements PropertiesFilesManager.PropertiesFileListener {
- public void fileAdded(VirtualFile propertiesFile) {
- fileChanged(propertiesFile, null);
- }
-
- public void fileRemoved(VirtualFile propertiesFile) {
- fileChanged(propertiesFile, null);
- }
-
- public void fileChanged(VirtualFile propertiesFile, final VirtualFilePropertyEvent event) {
- if (!myProject.isDisposed()) {
- VirtualFile parent = propertiesFile.getParent();
- if (parent != null && parent.isValid()) {
- PsiDirectory dir = PsiManager.getInstance(myProject).findDirectory(parent);
- myUpdater.addSubtreeToUpdateByElement(dir);
- }
- }
- }
- }*/
-
private class MyProblemListener extends WolfTheProblemSolver.ProblemListener {
private final Alarm myUpdateProblemAlarm = new Alarm();
private final Collection<VirtualFile> myFilesToRefresh = new THashSet<VirtualFile>();
/*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2010 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import com.intellij.ide.IdeBundle;
import com.intellij.ide.projectView.BaseProjectTreeBuilder;
-import com.intellij.ide.projectView.PsiClassChildrenSource;
import com.intellij.ide.projectView.impl.AbstractProjectTreeStructure;
import com.intellij.ide.projectView.impl.ProjectAbstractTreeStructureBase;
import com.intellij.ide.projectView.impl.ProjectTreeBuilder;
-import com.intellij.ide.projectView.impl.nodes.ClassTreeNode;
import com.intellij.ide.util.gotoByName.*;
import com.intellij.ide.util.treeView.AlphaComparator;
import com.intellij.ide.util.treeView.NodeRenderer;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.ui.DialogWrapper;
import com.intellij.openapi.ui.Messages;
-import com.intellij.openapi.util.Condition;
-import com.intellij.openapi.util.Conditions;
import com.intellij.openapi.util.Disposer;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.wm.ex.IdeFocusTraversalPolicy;
import com.intellij.pom.Navigatable;
-import com.intellij.psi.*;
+import com.intellij.psi.PsiDirectory;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiNamedElement;
import com.intellij.psi.presentation.java.SymbolPresentationUtil;
import com.intellij.psi.search.GlobalSearchScope;
-import com.intellij.psi.search.PsiShortNamesCache;
-import com.intellij.psi.search.searches.ClassInheritorsSearch;
import com.intellij.psi.util.PsiUtilBase;
import com.intellij.ui.ScrollPaneFactory;
import com.intellij.ui.TabbedPaneWrapper;
import com.intellij.ui.treeStructure.Tree;
import com.intellij.util.ArrayUtil;
import com.intellij.util.Processor;
+import com.intellij.util.Query;
import com.intellij.util.ui.UIUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.ArrayList;
import java.util.List;
-public class TreeClassChooserDialog extends DialogWrapper implements TreeClassChooser{
+abstract public class AbstractTreeClassChooserDialog<T extends PsiNamedElement> extends DialogWrapper implements TreeChooser<T> {
private Tree myTree;
- private PsiClass mySelectedClass = null;
+ private T mySelectedClass = null;
private final Project myProject;
private BaseProjectTreeBuilder myBuilder;
private TabbedPaneWrapper myTabbedPane;
private ChooseByNamePanel myGotoByNamePanel;
private final GlobalSearchScope myScope;
- @NotNull private final ClassFilter myClassFilter;
- private final PsiClass myBaseClass;
- private PsiClass myInitialClass;
- private final PsiClassChildrenSource myClassChildren;
+ @NotNull private final Filter<T> myClassFilter;
+ private final T myBaseClass;
+ private T myInitialClass;
+ private final boolean myIsShowMembers;
- public TreeClassChooserDialog(String title, Project project) {
+ public AbstractTreeClassChooserDialog(String title, Project project) {
this(title, project, null);
}
- public TreeClassChooserDialog(String title, Project project, @Nullable PsiClass initialClass) {
+ public AbstractTreeClassChooserDialog(String title, Project project, @Nullable T initialClass) {
this(title, project, GlobalSearchScope.projectScope(project), null, initialClass);
}
- public TreeClassChooserDialog(String title, Project project, GlobalSearchScope scope, @Nullable ClassFilter classFilter, @Nullable PsiClass initialClass) {
- this(title, project, scope, classFilter, null, initialClass, PsiClassChildrenSource.NONE);
+ public AbstractTreeClassChooserDialog(String title,
+ Project project,
+ GlobalSearchScope scope,
+ @Nullable Filter<T> classFilter,
+ @Nullable T initialClass) {
+ this(title, project, scope, classFilter, null, initialClass, false);
}
- public TreeClassChooserDialog(String title,
- Project project,
- GlobalSearchScope scope,
- @Nullable ClassFilter classFilter,
- PsiClass baseClass,
- @Nullable PsiClass initialClass,
- PsiClassChildrenSource classChildren) {
+ public AbstractTreeClassChooserDialog(String title,
+ Project project,
+ GlobalSearchScope scope,
+ @Nullable Filter<T> classFilter,
+ T baseClass,
+ @Nullable T initialClass,
+ boolean isShowMembers) {
super(project, true);
myScope = scope;
- myClassFilter = classFilter == null ? ClassFilter.ALL : classFilter;
+ myClassFilter = classFilter == null ? allFilter() : classFilter;
myBaseClass = baseClass;
myInitialClass = initialClass;
- myClassChildren = classChildren;
+ myIsShowMembers = isShowMembers;
setTitle(title);
myProject = project;
init();
if (initialClass != null) {
- selectClass(initialClass);
+ select(initialClass);
}
handleSelectionChanged();
}
- public static TreeClassChooserDialog withInnerClasses(String title,
- Project project,
- GlobalSearchScope scope,
- final ClassFilter classFilter,
- @Nullable PsiClass initialClass) {
- return new TreeClassChooserDialog(title, project, scope, classFilter, null, initialClass, new PsiClassChildrenSource() {
- public void addChildren(PsiClass psiClass, List<PsiElement> children) {
- ArrayList<PsiElement> innerClasses = new ArrayList<PsiElement>();
- PsiClassChildrenSource.CLASSES.addChildren(psiClass, innerClasses);
- for (PsiElement innerClass : innerClasses) {
- if (classFilter.isAccepted((PsiClass)innerClass)) children.add(innerClass);
- }
+ private Filter<T> allFilter() {
+ return new Filter<T>() {
+ public boolean isAccepted(T element) {
+ return true;
}
- });
+ };
}
protected JComponent createCenterPanel() {
}
public boolean isShowMembers() {
- return myClassChildren != PsiClassChildrenSource.NONE;
+ return myIsShowMembers;
}
public boolean isHideEmptyMiddlePackages() {
}
protected ChooseByNameModel createChooseByNameModel() {
- return myBaseClass == null ? new MyGotoClassModel(myProject) : new SubclassGotoClassModel(myProject);
+ if (myBaseClass == null) {
+ return new MyGotoClassModel(myProject, this);
+ }
+ else {
+ BaseClassInheritorsProvider<T> inheritorsProvider = getInheritorsProvider();
+ if (inheritorsProvider != null) {
+ return new SubclassGotoClassModel(myProject, this, inheritorsProvider);
+ }
+ else {
+ throw new IllegalStateException("inheritors provider is null");
+ }
+ }
}
- private void handleSelectionChanged(){
- PsiClass selection = calcSelectedClass();
+ @Nullable
+ protected abstract BaseClassInheritorsProvider<T> getInheritorsProvider();
+
+ private void handleSelectionChanged() {
+ T selection = calcSelectedClass();
setOKActionEnabled(selection != null);
}
protected void doOKAction() {
mySelectedClass = calcSelectedClass();
if (mySelectedClass == null) return;
- if (!myClassFilter.isAccepted(mySelectedClass)){
- Messages.showErrorDialog(myTabbedPane.getComponent(), SymbolPresentationUtil.getSymbolPresentableText(mySelectedClass) + " is not acceptable");
+ if (!myClassFilter.isAccepted(mySelectedClass)) {
+ Messages.showErrorDialog(myTabbedPane.getComponent(),
+ SymbolPresentationUtil.getSymbolPresentableText(mySelectedClass) + " is not acceptable");
return;
}
super.doOKAction();
}
- public PsiClass getSelectedClass() {
+ public T getSelected() {
return mySelectedClass;
}
- public void selectClass(@NotNull final PsiClass aClass) {
+ public void select(@NotNull final T aClass) {
selectElementInTree(aClass);
}
ChooseByNamePopup popup = ChooseByNamePopup.createPopup(myProject, createChooseByNameModel(), getContext());
popup.invoke(new ChooseByNamePopupComponent.Callback() {
public void elementChosen(Object element) {
- mySelectedClass = (PsiClass)element;
+ mySelectedClass = (T)element;
((Navigatable)element).navigate(true);
}
}, getModalityState(), true);
}
- private PsiClass getContext() {
+ private T getContext() {
return myBaseClass != null ? myBaseClass : myInitialClass != null ? myInitialClass : null;
}
- private void selectElementInTree(@NotNull final PsiElement element) {
+ private <E extends PsiElement> void selectElementInTree(@NotNull final PsiElement element) {
ApplicationManager.getApplication().invokeLater(new Runnable() {
public void run() {
if (myBuilder == null) return;
return ModalityState.stateForComponent(getRootPane());
}
+
@Nullable
- private PsiClass calcSelectedClass() {
- if (myTabbedPane.getSelectedIndex() == 0) {
- return (PsiClass)myGotoByNamePanel.getChosenElement();
+ protected T calcSelectedClass() {
+ if (getTabbedPane().getSelectedIndex() == 0) {
+ return (T)getGotoByNamePanel().getChosenElement();
}
else {
- TreePath path = myTree.getSelectionPath();
+ TreePath path = getTree().getSelectionPath();
if (path == null) return null;
DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent();
- Object userObject = node.getUserObject();
- if (!(userObject instanceof ClassTreeNode)) return null;
- ClassTreeNode descriptor = (ClassTreeNode)userObject;
- return descriptor.getPsiClass();
+ return getSelectedFromTreeUserObject(node);
}
}
+ protected abstract T getSelectedFromTreeUserObject(DefaultMutableTreeNode node);
+
public void dispose() {
if (myBuilder != null) {
return myGotoByNamePanel.getPreferredFocusedComponent();
}
- private class MyGotoClassModel extends GotoClassModel2 {
- public MyGotoClassModel(Project project) {
+ protected Project getProject() {
+ return myProject;
+ }
+
+ GlobalSearchScope getScope() {
+ return myScope;
+ }
+
+ @NotNull
+ protected Filter<T> getFilter() {
+ return myClassFilter;
+ }
+
+ T getBaseClass() {
+ return myBaseClass;
+ }
+
+ T getInitialClass() {
+ return myInitialClass;
+ }
+
+ protected TabbedPaneWrapper getTabbedPane() {
+ return myTabbedPane;
+ }
+
+ protected Tree getTree() {
+ return myTree;
+ }
+
+ protected ChooseByNamePanel getGotoByNamePanel() {
+ return myGotoByNamePanel;
+ }
+
+ protected static class MyGotoClassModel<T extends PsiNamedElement> extends GotoClassModel2 {
+ private final AbstractTreeClassChooserDialog<T> myTreeClassChooserDialog;
+
+ AbstractTreeClassChooserDialog<T> getTreeClassChooserDialog() {
+ return myTreeClassChooserDialog;
+ }
+
+ public MyGotoClassModel(Project project,
+ AbstractTreeClassChooserDialog<T> treeClassChooserDialog) {
super(project);
+ myTreeClassChooserDialog = treeClassChooserDialog;
}
public Object[] getElementsByName(final String name, final boolean checkBoxState, final String pattern) {
- final PsiShortNamesCache cache = JavaPsiFacade.getInstance(myProject).getShortNamesCache();
- PsiClass[] classes = cache.getClassesByName(name, checkBoxState ? myScope : GlobalSearchScope.projectScope(myProject).intersectWith(myScope));
- if (classes.length == 0) return ArrayUtil.EMPTY_OBJECT_ARRAY;
- if (classes.length == 1) {
- return isAccepted(classes[0]) ? classes : ArrayUtil.EMPTY_OBJECT_ARRAY;
+ List<T> classes = myTreeClassChooserDialog.getClassesByName(name, checkBoxState, pattern, myTreeClassChooserDialog.getScope());
+ if (classes.size() == 0) return ArrayUtil.EMPTY_OBJECT_ARRAY;
+ if (classes.size() == 1) {
+ return isAccepted(classes.get(0)) ? classes.toArray(new Object[classes.size()]) : ArrayUtil.EMPTY_OBJECT_ARRAY;
}
- List<PsiClass> list = new ArrayList<PsiClass>(classes.length);
- for (PsiClass aClass : classes) {
+ List<T> list = new ArrayList<T>(classes.size());
+ for (T aClass : classes) {
if (isAccepted(aClass)) {
list.add(aClass);
}
}
- return list.toArray(new PsiClass[list.size()]);
+ return list.toArray(new Object[list.size()]);
}
@Nullable
return null;
}
- protected boolean isAccepted(PsiClass aClass) {
- return myClassFilter.isAccepted(aClass);
+ protected boolean isAccepted(T aClass) {
+ return myTreeClassChooserDialog.getFilter().isAccepted(aClass);
+ }
+ }
+
+
+ @NotNull
+ abstract protected List<T> getClassesByName(final String name,
+ final boolean checkBoxState,
+ final String pattern,
+ final GlobalSearchScope searchScope);
+
+ public static abstract class BaseClassInheritorsProvider<T> {
+ private final T myBaseClass;
+ private final GlobalSearchScope myScope;
+
+ public T getBaseClass() {
+ return myBaseClass;
+ }
+
+ public GlobalSearchScope getScope() {
+ return myScope;
+ }
+
+ public BaseClassInheritorsProvider(T baseClass, GlobalSearchScope scope) {
+ myBaseClass = baseClass;
+ myScope = scope;
+ }
+
+ @NotNull
+ abstract protected Query<T> searchForInheritors(T baseClass, GlobalSearchScope searchScope, boolean checkDeep);
+
+ abstract protected boolean isInheritor(T clazz, T baseClass, boolean checkDeep);
+
+ abstract protected String[] getNames();
+
+ protected Query<T> searchForInheritorsOfBaseClass() {
+ return searchForInheritors(myBaseClass, myScope, true);
+ }
+
+ protected boolean isInheritorOfBaseClass(T aClass) {
+ return isInheritor(aClass, myBaseClass, true);
}
}
- private class SubclassGotoClassModel extends MyGotoClassModel {
+ private static class SubclassGotoClassModel<T extends PsiNamedElement> extends MyGotoClassModel<T> {
+ private final BaseClassInheritorsProvider<T> myInheritorsProvider;
private boolean myFastMode = true;
- public SubclassGotoClassModel(final Project project) {
- super(project);
- assert myBaseClass != null;
+ public SubclassGotoClassModel(@NotNull final Project project,
+ @NotNull final AbstractTreeClassChooserDialog<T> treeClassChooserDialog,
+ @NotNull BaseClassInheritorsProvider<T> inheritorsProvider) {
+ super(project, treeClassChooserDialog);
+ myInheritorsProvider = inheritorsProvider;
+ assert myInheritorsProvider.getBaseClass() != null;
}
public String[] getNames(boolean checkBoxState) {
if (!myFastMode) {
- return JavaPsiFacade.getInstance(myProject).getShortNamesCache().getAllClassNames();
+ return myInheritorsProvider.getNames();
}
final List<String> names = new ArrayList<String>();
- myFastMode = ClassInheritorsSearch.search(myBaseClass, myScope, true).forEach(new Processor<PsiClass>() {
+
+ myFastMode = myInheritorsProvider.searchForInheritorsOfBaseClass().forEach(new Processor<T>() {
private int count;
+
@Override
- public boolean process(PsiClass aClass) {
+ public boolean process(T aClass) {
if (count++ > 1000) {
return false;
}
- if ((myClassFilter.isAccepted(aClass)) && aClass.getName() != null) {
+ if ((getTreeClassChooserDialog().getFilter().isAccepted(aClass)) && aClass.getName() != null) {
names.add(aClass.getName());
}
return true;
if (!myFastMode) {
return getNames(checkBoxState);
}
- if ((myClassFilter.isAccepted(myBaseClass)) && myBaseClass.getName() != null) {
- names.add(myBaseClass.getName());
+ if ((getTreeClassChooserDialog().getFilter().isAccepted(myInheritorsProvider.getBaseClass())) &&
+ myInheritorsProvider.getBaseClass().getName() != null) {
+ names.add(myInheritorsProvider.getBaseClass().getName());
}
return names.toArray(new String[names.size()]);
}
- protected boolean isAccepted(PsiClass aClass) {
+
+ protected boolean isAccepted(T aClass) {
if (myFastMode) {
- return myClassFilter.isAccepted(aClass);
+ return getTreeClassChooserDialog().getFilter().isAccepted(aClass);
}
else {
- return (aClass == myBaseClass || aClass.isInheritor(myBaseClass, true)) && myClassFilter.isAccepted(aClass);
+ return (aClass == getTreeClassChooserDialog().getBaseClass() ||
+ myInheritorsProvider.isInheritorOfBaseClass(aClass)) &&
+ getTreeClassChooserDialog().getFilter().isAccepted(
+ aClass);
}
}
}
+
private class MyCallback extends ChooseByNamePopupComponent.Callback {
public void elementChosen(Object element) {
- mySelectedClass = (PsiClass)element;
+ mySelectedClass = (T)element;
close(OK_EXIT_CODE);
}
}
-
- public static class InheritanceClassFilterImpl implements InheritanceClassFilter{
- private final PsiClass myBase;
- private final boolean myAcceptsSelf;
- private final boolean myAcceptsInner;
- private final Condition<? super PsiClass> myAdditionalCondition;
-
- public InheritanceClassFilterImpl(PsiClass base,
- boolean acceptsSelf,
- boolean acceptInner,
- Condition<? super PsiClass> additionalCondition) {
- myAcceptsSelf = acceptsSelf;
- myAcceptsInner = acceptInner;
- if (additionalCondition == null) {
- additionalCondition = Conditions.alwaysTrue();
- }
- myAdditionalCondition = additionalCondition;
- myBase = base;
- }
-
- public boolean isAccepted(PsiClass aClass) {
- if (!myAcceptsInner && !(aClass.getParent() instanceof PsiJavaFile)) return false;
- if (!myAdditionalCondition.value(aClass)) return false;
- // we've already checked for inheritance
- return myAcceptsSelf || !aClass.getManager().areElementsEquivalent(aClass, myBase);
- }
- }
}
protected void doClose(final boolean ok) {
if (myDisposedFlag) return;
- if (posponeCloseWhenListReady(ok)) return;
+ if (postponeCloseWhenListReady(ok)) return;
cancelListUpdater();
close(ok);
myListUpdater.cancelAll();
}
- private boolean posponeCloseWhenListReady(boolean ok) {
+ private boolean postponeCloseWhenListReady(boolean ok) {
if (!isToFixLostTyping()) return false;
final String text = myTextField.getText();
}
}
- private static int indentWithInVisualColumns(String indent, int tabSize) {
+ private static int indentWithInVisualColumns(@NotNull String indent, int tabSize) {
if (tabSize <= 1) {
return indent.length();
}
--- /dev/null
+/*
+ * Copyright 2000-2010 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.ide.util;
+
+import com.intellij.psi.PsiDirectory;
+
+public interface TreeChooser<T> {
+ T getSelected();
+
+ void select(final T aClass);
+
+ void selectDirectory(final PsiDirectory directory);
+
+ void showDialog();
+
+ void showPopup();
+
+ interface Filter<T> {
+ boolean isAccepted(T element);
+ }
+}
import com.intellij.codeInspection.ui.ListTable;
import com.intellij.codeInspection.ui.ListWrappingTableModel;
import com.intellij.ide.DataManager;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.ide.util.TreeClassChooser;
import com.intellij.ide.util.TreeClassChooserFactory;
import com.intellij.openapi.actionSystem.DataContext;
}
final TreeClassChooserFactory chooserFactory =
TreeClassChooserFactory.getInstance(project);
- final TreeClassChooser.ClassFilter filter;
+ final ClassFilter filter;
if (ancestorClasses.length == 0) {
- filter = TreeClassChooser.ClassFilter.ALL;
+ filter = ClassFilter.ALL;
} else {
- filter = new TreeClassChooser.ClassFilter() {
+ filter = new ClassFilter() {
public boolean isAccepted(PsiClass aClass) {
for (String ancestorClass : ancestorClasses) {
if (ClassUtils.isSubclass(aClass, ancestorClass)) {
chooserFactory.createWithInnerClassesScopeChooser(chooserTitle,
GlobalSearchScope.allScope(project), filter, null);
classChooser.showDialog();
- final PsiClass selectedClass = classChooser.getSelectedClass();
+ final PsiClass selectedClass = classChooser.getSelected();
if (selectedClass == null) {
return;
}
import com.intellij.codeInspection.ui.ListTable;
import com.intellij.codeInspection.ui.ListWrappingTableModel;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.ide.util.TreeClassChooser;
import com.intellij.ide.util.TreeClassChooserFactory;
import com.intellij.openapi.actionSystem.*;
public static ActionToolbar createAddRemoveTreeClassChooserToolbar(
ListTable table, String chooserTitle,
@NonNls String... ancestorClasses) {
- final TreeClassChooser.ClassFilter filter;
+ final ClassFilter filter;
if (ancestorClasses.length == 0) {
- filter = TreeClassChooser.ClassFilter.ALL;
+ filter = ClassFilter.ALL;
} else {
filter = new SubclassFilter(ancestorClasses);
}
public static ActionToolbar createAddRemoveTreeAnnotationChooserToolbar(
ListTable table, String chooserTitle) {
- final TreeClassChooser.ClassFilter filter =
- new TreeClassChooser.ClassFilter() {
+ final ClassFilter filter =
+ new ClassFilter() {
public boolean isAccepted(PsiClass psiClass) {
return psiClass.isAnnotationType();
}
private final ListTable table;
private final String chooserTitle;
- private final TreeClassChooser.ClassFilter filter;
+ private final ClassFilter myFilter;
public TreeClassChooserAction(
@NotNull ListTable table, @NotNull String chooserTitle,
- @NotNull TreeClassChooser.ClassFilter filter) {
+ @NotNull ClassFilter filter) {
super(InspectionGadgetsBundle.message("button.add"), "",
Icons.ADD_ICON);
this.table = table;
this.chooserTitle = chooserTitle;
- this.filter = filter;
+ this.myFilter = filter;
}
@Override
TreeClassChooserFactory.getInstance(project);
final TreeClassChooser classChooser =
chooserFactory.createWithInnerClassesScopeChooser(chooserTitle,
- GlobalSearchScope.allScope(project), filter, null);
+ GlobalSearchScope.allScope(project), myFilter, null);
classChooser.showDialog();
- final PsiClass selectedClass = classChooser.getSelectedClass();
+ final PsiClass selectedClass = classChooser.getSelected();
if (selectedClass == null) {
return;
}
}
}
- private static class SubclassFilter implements TreeClassChooser.ClassFilter {
+ private static class SubclassFilter implements ClassFilter {
private final String[] ancestorClasses;
package org.intellij.plugins.intelliLang;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.ide.util.TreeClassChooser;
import com.intellij.ide.util.TreeClassChooserFactory;
import com.intellij.openapi.editor.Document;
final GlobalSearchScope scope = GlobalSearchScope.allScope(myProject);
final PsiClass aClass = JavaPsiFacade.getInstance(myProject).findClass(myField.getText(), scope);
final TreeClassChooser chooser =
- factory.createNoInnerClassesScopeChooser("Select Annotation Class", scope, new TreeClassChooser.ClassFilter() {
+ factory.createNoInnerClassesScopeChooser("Select Annotation Class", scope, new ClassFilter() {
public boolean isAccepted(PsiClass aClass) {
return aClass.isAnnotationType();
}
}, aClass);
chooser.showDialog();
- final PsiClass psiClass = chooser.getSelectedClass();
+ final PsiClass psiClass = chooser.getSelected();
if (psiClass != null) {
myField.setText(psiClass.getQualifiedName());
}
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.util.*;
-import java.util.List;
public class MethodParameterPanel extends AbstractInjectionPanel<MethodParameterInjection> {
final TreeClassChooserFactory factory = TreeClassChooserFactory.getInstance(myProject);
final TreeClassChooser chooser = factory.createAllProjectScopeChooser("Select Class");
chooser.showDialog();
- final PsiClass psiClass = chooser.getSelectedClass();
+ final PsiClass psiClass = chooser.getSelected();
if (psiClass != null) {
setPsiClass(psiClass.getQualifiedName());
updateParamTree();
import com.intellij.execution.ExecutionBundle;
import com.intellij.execution.configuration.BrowseModuleValueActionListener;
import com.intellij.execution.ui.ConfigurationModuleSelector;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.ide.util.TreeClassChooser;
import com.intellij.ide.util.TreeClassChooserFactory;
import com.intellij.openapi.module.Module;
public class AndroidClassBrowser extends BrowseModuleValueActionListener {
private final ConfigurationModuleSelector myModuleSelector;
private final String myBaseClassName;
- private final TreeClassChooser.ClassFilter myAdditionalFilter;
+ private final ClassFilter myAdditionalFilter;
private final String myDialogTitle;
private final boolean myIncludeLibraryClasses;
String baseClassName,
String dialogTitle,
boolean includeLibraryClasses,
- @Nullable TreeClassChooser.ClassFilter additionalFilter) {
+ @Nullable ClassFilter additionalFilter) {
super(project);
myModuleSelector = moduleSelector;
myBaseClassName = baseClassName;
myIncludeLibraryClasses ? module.getModuleWithDependenciesAndLibrariesScope(true) : module.getModuleWithDependenciesScope();
PsiClass initialSelection = facade.findClass(getText(), scope);
TreeClassChooser chooser = TreeClassChooserFactory.getInstance(project)
- .createInheritanceClassChooser(myDialogTitle, scope, baseClass, initialSelection, new TreeClassChooser.ClassFilter() {
+ .createInheritanceClassChooser(myDialogTitle, scope, baseClass, initialSelection, new ClassFilter() {
public boolean isAccepted(PsiClass aClass) {
if (aClass.getManager().areElementsEquivalent(aClass, baseClass)) {
return false;
}
});
chooser.showDialog();
- PsiClass selClass = chooser.getSelectedClass();
+ PsiClass selClass = chooser.getSelected();
return selClass != null ? selClass.getQualifiedName() : null;
}
}
import com.intellij.execution.ExecutionBundle;
import com.intellij.execution.ui.ConfigurationModuleSelector;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.ide.util.TreeClassChooser;
import com.intellij.ide.util.TreeClassChooserFactory;
import com.intellij.openapi.module.Module;
private final ConfigurationModuleSelector myModuleSelector;
- private class ActivityClassFilter implements TreeClassChooser.ClassFilter {
+ private class ActivityClassFilter implements ClassFilter {
public boolean isAccepted(PsiClass c) {
Module module = myModuleSelector.getModule();
if (module != null) {
.createInheritanceClassChooser("Select activity class", module.getModuleWithDependenciesScope(), activityBaseClass,
initialSelection, new ActivityClassFilter());
chooser.showDialog();
- PsiClass selClass = chooser.getSelectedClass();
+ PsiClass selClass = chooser.getSelected();
if (selClass != null) {
myActivityField.setText(selClass.getQualifiedName());
}
CodeInsightBundle.message("inspection.i18n.option.ignore.for.specified.exception.constructor.arguments"), scope,
JavaPsiFacade.getInstance(project).findClass("java.lang.Throwable", scope), true, true, null);
chooser.showDialog();
- PsiClass selectedClass = chooser.getSelectedClass();
+ PsiClass selectedClass = chooser.getSelected();
return selectedClass != null ? selectedClass.getQualifiedName() : null;
}
};
package com.intellij.execution.junit;
-import com.intellij.codeInsight.TestUtil;
import com.intellij.compiler.CompilerConfiguration;
import com.intellij.execution.configurations.ConfigurationUtil;
import com.intellij.execution.testframework.SourceScope;
-import com.intellij.ide.util.TreeClassChooser;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiClass;
import com.intellij.psi.util.PsiUtilBase;
import org.jetbrains.annotations.NotNull;
-public class TestClassFilter implements TreeClassChooser.ClassFilterWithScope {
+public class TestClassFilter implements ClassFilter.ClassFilterWithScope {
private final PsiClass myBase;
private final Project myProject;
private final GlobalSearchScope myScope;
import com.intellij.execution.ui.ClassBrowser;
import com.intellij.execution.ui.CommonJavaParametersPanel;
import com.intellij.execution.ui.ConfigurationModuleSelector;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.ide.util.PackageChooserDialog;
-import com.intellij.ide.util.TreeClassChooser;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.options.SettingsEditor;
import com.intellij.openapi.project.Project;
return getModuleSelector().findClass(className);
}
- protected TreeClassChooser.ClassFilterWithScope getFilter() throws NoFilterException {
+ protected ClassFilter.ClassFilterWithScope getFilter() throws NoFilterException {
final ConfigurationModuleSelector moduleSelector = getModuleSelector();
final Module module = moduleSelector.getModule();
if (module == null) {
throw NoFilterException.moduleDoesntExist(moduleSelector);
}
- final TreeClassChooser.ClassFilterWithScope classFilter;
+ final ClassFilter.ClassFilterWithScope classFilter;
try {
final JUnitConfiguration configurationCopy = new JUnitConfiguration(ExecutionBundle.message("default.junit.configuration.name"), getProject(), JUnitConfigurationType.getInstance().getConfigurationFactories()[0]);
applyEditorTo(configurationCopy);
TreeClassChooser chooser = TreeClassChooserFactory.getInstance(project).createWithInnerClassesScopeChooser("Choose Listener Class", filter.getScope(), filter, null);
chooser.showDialog();
- PsiClass psiclass = chooser.getSelectedClass();
+ PsiClass psiclass = chooser.getSelected();
if (psiclass == null) {
return null;
} else {
import com.intellij.execution.JavaExecutionUtil;
import com.intellij.execution.configuration.BrowseModuleValueActionListener;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.ide.util.TreeClassChooser;
import com.intellij.ide.util.TreeClassChooserFactory;
import com.intellij.openapi.module.Module;
@Override
protected String showDialog() {
- TreeClassChooser.ClassFilterWithScope filter;
+ ClassFilter.ClassFilterWithScope filter;
try {
filter = getFilter();
}
TreeClassChooser chooser = TreeClassChooserFactory.getInstance(getProject()).createWithInnerClassesScopeChooser("Choose Test Class", filter.getScope(), filter, null);
init(chooser);
chooser.showDialog();
- PsiClass psiclass = chooser.getSelectedClass();
+ PsiClass psiclass = chooser.getSelected();
if (psiclass == null) {
return null;
} else {
return editor.getModuleSelector().findClass(className);
}
- protected TreeClassChooser.ClassFilterWithScope getFilter() throws MessageInfoException {
+ protected ClassFilter.ClassFilterWithScope getFilter() throws MessageInfoException {
TestNGConfiguration config = new TestNGConfiguration("<no-name>", getProject(), TestNGConfigurationType.getInstance().getConfigurationFactories()[0]);
editor.applyEditorTo(config);
GlobalSearchScope scope = getSearchScope(config.getModules());
com.intellij.psi.PsiDirectory psidirectory = psiclass.getContainingFile().getContainingDirectory();
if (psidirectory != null)
chooser.selectDirectory(psidirectory);
- chooser.selectClass(psiclass);
+ chooser.select(psiclass);
}
}
*/
package com.theoryinpractice.testng.model;
-import com.intellij.ide.util.TreeClassChooser;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.psi.PsiClass;
import com.intellij.openapi.project.Project;
* Date: Jul 21, 2005
* Time: 9:03:06 PM
*/
-public class TestClassFilter implements TreeClassChooser.ClassFilterWithScope
+public class TestClassFilter implements ClassFilter.ClassFilterWithScope
{
private final GlobalSearchScope scope;
private final Project project;
package com.theoryinpractice.testng.model;
import com.intellij.execution.configurations.ConfigurationUtil;
-import com.intellij.ide.util.TreeClassChooser;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiClass;
import com.intellij.psi.search.GlobalSearchScope;
/**
* @author Mark Derricutt
*/
-public class TestListenerFilter implements TreeClassChooser.ClassFilterWithScope
+public class TestListenerFilter implements ClassFilter.ClassFilterWithScope
{
private final GlobalSearchScope scope;
private final Project project;
GlobalSearchScope.allScope(myProject), JavaPsiFacade.getInstance(myProject).findClass(
JComponent.class.getName(), GlobalSearchScope.allScope(myProject)), true, true, null);
chooser.showDialog();
- final PsiClass result = chooser.getSelectedClass();
+ final PsiClass result = chooser.getSelected();
if (result != null) {
setEditorText(result.getQualifiedName());
}
*/
package com.intellij.uiDesigner.propertyInspector.properties;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.ide.util.TreeClassChooser;
import com.intellij.ide.util.TreeClassChooserFactory;
import com.intellij.openapi.actionSystem.AnAction;
final TreeClassChooser chooser = TreeClassChooserFactory.getInstance(project).createWithInnerClassesScopeChooser(
UIDesignerBundle.message("title.choose.class.to.bind"),
GlobalSearchScope.projectScope(project),
- new TreeClassChooser.ClassFilter() { // we need show classes from the sources roots only
+ new ClassFilter() { // we need show classes from the sources roots only
public boolean isAccepted(final PsiClass aClass) {
final VirtualFile vFile = aClass.getContainingFile().getVirtualFile();
return vFile != null && fileIndex.isInSource(vFile);
);
chooser.showDialog();
- final PsiClass result = chooser.getSelectedClass();
+ final PsiClass result = chooser.getSelected();
if (result != null) {
setEditorText(result.getQualifiedName());
}
*/
package com.intellij.uiDesigner.wizard;
+import com.intellij.ide.util.ClassFilter;
import com.intellij.ide.util.PackageChooserDialog;
import com.intellij.ide.util.TreeClassChooser;
import com.intellij.ide.util.TreeClassChooserFactory;
final TreeClassChooser chooser = TreeClassChooserFactory.getInstance(myData.myProject).createWithInnerClassesScopeChooser(
UIDesignerBundle.message("title.choose.bean.class"),
GlobalSearchScope.projectScope(myData.myProject),
- new TreeClassChooser.ClassFilter() {
+ new ClassFilter() {
public boolean isAccepted(final PsiClass aClass) {
return aClass.getParent() instanceof PsiJavaFile;
}
},
null);
chooser.showDialog();
- final PsiClass aClass = chooser.getSelectedClass();
+ final PsiClass aClass = chooser.getSelected();
if (aClass == null) {
return;
}
projects / idea / community.git / commitdiff