Added python exception breakpoints. TreeClassChooserDialog refactored.

java/compiler/impl/src/com/intellij/packaging/impl/elements/ManifestFileUtil.java

@@ -16,6 +16,7 @@
 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;
@@ -332,7 +333,7 @@ public class ManifestFileUtil {
     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) {
@@ -346,7 +347,7 @@ public class ManifestFileUtil {
     });
   }
 
-  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);
     }

java/debugger/impl/src/com/intellij/debugger/impl/DebuggerUtilsImpl.java

@@ -114,7 +114,7 @@ public class DebuggerUtilsImpl extends DebuggerUtilsEx{
   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) {

java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/AddFieldBreakpointDialog.java

@@ -75,7 +75,7 @@ abstract class AddFieldBreakpointDialog extends DialogWrapper {
           }
         }
         chooser.showDialog();
-        PsiClass selectedClass = chooser.getSelectedClass();
+        PsiClass selectedClass = chooser.getSelected();
         if (selectedClass != null) {
           myClassChooser.setText(selectedClass.getQualifiedName());
         }

java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointPropertiesPanel.java

@@ -30,7 +30,7 @@ import com.intellij.debugger.settings.DebuggerSettings;
 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;
@@ -40,7 +40,6 @@ import com.intellij.psi.PsiClass;
 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;
@@ -63,8 +62,8 @@ public abstract class BreakpointPropertiesPanel {
   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;
@@ -221,7 +220,7 @@ public abstract class BreakpointPropertiesPanel {
       public void actionPerformed(ActionEvent e) {
         reloadClassFilters();
 
-        TreeClassChooser.ClassFilter classFilter;
+        ClassFilter classFilter;
         classFilter = createClassConditionFilter();
 
         EditClassFiltersDialog _dialog = new EditClassFiltersDialog(myProject, classFilter);
@@ -298,10 +297,10 @@ public abstract class BreakpointPropertiesPanel {
     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);
         }
@@ -476,14 +475,14 @@ public abstract class BreakpointPropertiesPanel {
   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());
       }
@@ -506,8 +505,8 @@ public abstract class BreakpointPropertiesPanel {
   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))){
@@ -515,24 +514,24 @@ public abstract class BreakpointPropertiesPanel {
       } 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) {

java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/EditClassFiltersDialog.java

@@ -20,10 +20,9 @@
  */
 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;
@@ -35,13 +34,13 @@ public class EditClassFiltersDialog extends DialogWrapper {
   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;
@@ -75,7 +74,7 @@ public class EditClassFiltersDialog extends DialogWrapper {
     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);
   }
@@ -84,11 +83,11 @@ public class EditClassFiltersDialog extends DialogWrapper {
     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();
   }
 }

java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/ExceptionBreakpointFactory.java

@@ -114,7 +114,7 @@ public class ExceptionBreakpointFactory extends BreakpointFactory{
           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) {

java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/ExceptionBreakpointPropertiesPanel.java

@@ -21,7 +21,7 @@
 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.*;
@@ -38,7 +38,7 @@ public class ExceptionBreakpointPropertiesPanel extends BreakpointPropertiesPane
     super(project, ExceptionBreakpoint.CATEGORY);
   }
 
-  protected TreeClassChooser.ClassFilter createClassConditionFilter() {
+  protected ClassFilter createClassConditionFilter() {
     return null;
   }
 

java/execution/impl/src/com/intellij/execution/ui/ClassBrowser.java

@@ -19,6 +19,7 @@ import com.intellij.execution.ExecutionBundle;
 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;
@@ -41,7 +42,7 @@ public abstract class ClassBrowser extends BrowseModuleValueActionListener {
 
   @Nullable
   protected String showDialog() {
-    final TreeClassChooser.ClassFilterWithScope classFilter;
+    final ClassFilter.ClassFilterWithScope classFilter;
     try {
       classFilter = getFilter();
     }
@@ -53,17 +54,17 @@ public abstract class ClassBrowser extends BrowseModuleValueActionListener {
     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) { }
 
@@ -73,20 +74,20 @@ public abstract class ClassBrowser extends BrowseModuleValueActionListener {
     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;
       }
     };
@@ -98,7 +99,7 @@ public abstract class ClassBrowser extends BrowseModuleValueActionListener {
     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);
@@ -124,13 +125,13 @@ public abstract class ClassBrowser extends BrowseModuleValueActionListener {
       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;
         }
@@ -141,7 +142,7 @@ public abstract class ClassBrowser extends BrowseModuleValueActionListener {
       };
     }
 
-    protected TreeClassChooser.ClassFilter createFilter(final Module module) { return null; }
+    protected ClassFilter createFilter(final Module module) { return null; }
   }
 
   public static class NoFilterException extends Exception {

java/java-impl/java-impl.iml

@@ -27,6 +27,7 @@
     <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>

java/java-impl/src/com/intellij/ide/util/TreeClassChooserFactoryImpl.java

@@ -38,32 +38,32 @@ public class TreeClassChooserFactoryImpl extends TreeClassChooserFactory {
   @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
@@ -73,8 +73,8 @@ public class TreeClassChooserFactoryImpl extends TreeClassChooserFactory {
                                                         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
@@ -84,8 +84,8 @@ public class TreeClassChooserFactoryImpl extends TreeClassChooserFactory {
 
   @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

java/java-impl/src/com/intellij/ide/util/TreeJavaClassChooserDialog.java

@@ -0,0 +1,165 @@
+/*
+ * 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);
+    }
+  }
+}

java/java-impl/src/com/intellij/ide/util/scopeChooser/ClassHierarchyScopeDescriptor.java

@@ -55,7 +55,7 @@ public class ClassHierarchyScopeDescriptor extends ScopeDescriptor {
 
       chooser.showDialog();
 
-      PsiClass aClass = chooser.getSelectedClass();
+      PsiClass aClass = chooser.getSelected();
       if (aClass == null) return null;
 
       List<PsiElement> classesToSearch = new LinkedList<PsiElement>();

java/java-impl/src/com/intellij/refactoring/introduceField/IntroduceConstantDialog.java

@@ -17,6 +17,7 @@ package com.intellij.refactoring.introduceField;
 
 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;
@@ -432,7 +433,7 @@ class IntroduceConstantDialog extends DialogWrapper {
 
   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);
         }
@@ -441,7 +442,7 @@ class IntroduceConstantDialog extends DialogWrapper {
         chooser.selectDirectory(myTargetClass.getContainingFile().getContainingDirectory());
       }
       chooser.showDialog();
-      PsiClass aClass = chooser.getSelectedClass();
+      PsiClass aClass = chooser.getSelected();
       if (aClass != null) {
         myTfTargetClassName.setText(aClass.getQualifiedName());
       }

java/java-impl/src/com/intellij/refactoring/introduceparameterobject/IntroduceParameterObjectDialog.java

@@ -15,7 +15,7 @@
  */
 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;
@@ -288,15 +288,15 @@ public class IntroduceParameterObjectDialog extends RefactoringDialog {
       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);

java/java-impl/src/com/intellij/refactoring/move/moveMembers/MoveMembersDialog.java

@@ -15,6 +15,7 @@
  */
 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;
@@ -379,7 +380,7 @@ public class MoveMembersDialog extends RefactoringDialog implements MoveMembersO
   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);
         }
@@ -395,7 +396,7 @@ public class MoveMembersDialog extends RefactoringDialog implements MoveMembersO
       }
 
       chooser.showDialog();
-      PsiClass aClass = chooser.getSelectedClass();
+      PsiClass aClass = chooser.getSelected();
       if (aClass != null) {
         myTfTargetClassName.setText(aClass.getQualifiedName());
         myMemberInfoModel.updateTargetClass();

java/java-impl/src/com/intellij/refactoring/replaceConstructorWithBuilder/ReplaceConstructorWithBuilderDialog.java

@@ -230,10 +230,10 @@ public class ReplaceConstructorWithBuilderDialog extends RefactoringDialog {
         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());
         }

java/java-impl/src/com/intellij/refactoring/replaceConstructorWithFactory/ReplaceConstructorWithFactoryDialog.java

@@ -170,7 +170,7 @@ public class ReplaceConstructorWithFactoryDialog extends RefactoringDialog {
         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());
       }

java/java-impl/src/com/intellij/refactoring/ui/ClassNameReferenceEditor.java

@@ -15,6 +15,7 @@
  */
 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;
@@ -72,7 +73,7 @@ public class ClassNameReferenceEditor extends ReferenceEditorWithBrowseButton {
     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);
         }
@@ -81,7 +82,7 @@ public class ClassNameReferenceEditor extends ReferenceEditorWithBrowseButton {
         chooser.selectDirectory(mySelectedClass.getContainingFile().getContainingDirectory());
       }
       chooser.showDialog();
-      mySelectedClass = chooser.getSelectedClass();
+      mySelectedClass = chooser.getSelected();
       if (mySelectedClass != null) {
         setText(mySelectedClass.getQualifiedName());
       }

java/java-impl/src/com/intellij/refactoring/wrapreturnvalue/WrapReturnValueDialog.java

@@ -267,10 +267,10 @@ class WrapReturnValueDialog extends RefactoringDialog {
         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());
         }

java/java-impl/src/com/intellij/testIntegration/createTest/CreateTestDialog.java

@@ -495,7 +495,7 @@ public class CreateTestDialog extends DialogWrapper {
       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());
       }

java/java-impl/src/com/intellij/util/xml/ui/PsiClassControl.java

@@ -15,6 +15,7 @@
  */
 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;
@@ -78,11 +79,11 @@ public class PsiClassControl extends EditorTextFieldControl<PsiClassPanel> {
         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;
           }
         }
 
@@ -96,7 +97,7 @@ public class PsiClassControl extends EditorTextFieldControl<PsiClassPanel> {
         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());
         }

java/java-impl/src/com/intellij/util/xml/ui/PsiClassTableCellEditor.java

@@ -78,7 +78,7 @@ public class PsiClassTableCellEditor extends AbstractTableCellEditor {
         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());
         }

java/openapi/src/com/intellij/ide/util/ClassFilter.java

@@ -0,0 +1,42 @@
+/*
+ * 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();
+  }
+}

java/openapi/src/com/intellij/ide/util/TreeClassChooser.java

@@ -17,43 +17,19 @@ package com.intellij.ide.util;
 
 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{
-  }
 }

java/openapi/src/com/intellij/ide/util/TreeClassChooserFactory.java

@@ -39,14 +39,14 @@ public abstract class TreeClassChooserFactory {
   @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);
 
 
@@ -81,7 +81,7 @@ public abstract class TreeClassChooserFactory {
                                                                  GlobalSearchScope scope,
                                                                  PsiClass base,
                                                                  PsiClass initialClass,
-                                                                 TreeClassChooser.ClassFilter classFilter);
+                                                                 ClassFilter classFilter);
 
 
   @NotNull

java/openapi/src/com/intellij/ui/classFilter/ClassFilterEditor.java

@@ -20,8 +20,8 @@
  */
 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;
@@ -55,13 +55,13 @@ public class ClassFilterEditor extends JPanel {
   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());
@@ -144,11 +144,11 @@ public class ClassFilterEditor extends JPanel {
     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();
   }
 
@@ -170,11 +170,11 @@ public class ClassFilterEditor extends JPanel {
   }
 
   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);
@@ -182,26 +182,26 @@ public class ClassFilterEditor extends JPanel {
       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);
@@ -216,7 +216,7 @@ public class ClassFilterEditor extends JPanel {
     }
 
     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;
       }
@@ -227,7 +227,7 @@ public class ClassFilterEditor extends JPanel {
     }
 
     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() : "");
       }
@@ -265,7 +265,7 @@ public class ClassFilterEditor extends JPanel {
         ((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;
     }
@@ -287,8 +287,8 @@ public class ClassFilterEditor extends JPanel {
   }
 
   @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() {
@@ -297,7 +297,7 @@ public class ClassFilterEditor extends JPanel {
     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);
@@ -312,9 +312,9 @@ public class ClassFilterEditor extends JPanel {
     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);
@@ -338,7 +338,7 @@ public class ClassFilterEditor extends JPanel {
   }
 
   public void addPattern(String pattern) {
-    ClassFilter filter = createFilter(pattern);
+    com.intellij.ui.classFilter.ClassFilter filter = createFilter(pattern);
     myTableModel.addRow(filter);
   }
 

java/openapi/src/com/intellij/ui/classFilter/ClassFilterEditorAddDialog.java

@@ -81,7 +81,7 @@ class ClassFilterEditorAddDialog extends DialogWrapper {
           }
         }
         chooser.showDialog();
-        PsiClass selectedClass = chooser.getSelectedClass();
+        PsiClass selectedClass = chooser.getSelected();
         if (selectedClass != null) {
           myClassName.setText(selectedClass.getQualifiedName());
         }

java/openapi/src/com/intellij/util/xml/actions/CreateClassMappingAction.java

@@ -15,6 +15,7 @@
  */
 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;
@@ -54,14 +55,14 @@ public abstract class CreateClassMappingAction<T extends DomElement> extends Cre
     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);

platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectTreeBuilder.java

@@ -57,7 +57,6 @@ public class ProjectTreeBuilder extends BaseProjectTreeBuilder {
   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) {
@@ -82,11 +81,6 @@ public class ProjectTreeBuilder extends BaseProjectTreeBuilder {
     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);
 
@@ -100,10 +94,6 @@ public class ProjectTreeBuilder extends BaseProjectTreeBuilder {
     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);
   }
 
@@ -188,26 +178,6 @@ public class ProjectTreeBuilder extends BaseProjectTreeBuilder {
     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>();

platform/lang-impl/src/com/intellij/ide/util/AbstractTreeClassChooserDialog.java

@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -17,11 +17,9 @@ package com.intellij.ide.util;
 
 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;
@@ -30,17 +28,15 @@ import com.intellij.openapi.application.ModalityState;
 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;
@@ -48,6 +44,7 @@ import com.intellij.ui.TreeSpeedSearch;
 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;
@@ -69,68 +66,64 @@ import java.awt.event.MouseEvent;
 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() {
@@ -143,7 +136,7 @@ public class TreeClassChooserDialog extends DialogWrapper implements TreeClassCh
       }
 
       public boolean isShowMembers() {
-        return myClassChildren != PsiClassChildrenSource.NONE;
+        return myIsShowMembers;
       }
 
       public boolean isHideEmptyMiddlePackages() {
@@ -266,29 +259,44 @@ public class TreeClassChooserDialog extends DialogWrapper implements TreeClassCh
   }
 
   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);
   }
 
@@ -304,18 +312,18 @@ public class TreeClassChooserDialog extends DialogWrapper implements TreeClassCh
     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;
@@ -329,22 +337,22 @@ public class TreeClassChooserDialog extends DialogWrapper implements TreeClassCh
     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) {
@@ -362,25 +370,65 @@ public class TreeClassChooserDialog extends DialogWrapper implements TreeClassCh
     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
@@ -388,33 +436,79 @@ public class TreeClassChooserDialog extends DialogWrapper implements TreeClassCh
       return null;
     }
 
-    protected boolean isAccepted(PsiClass aClass) {
-      return myClassFilter.isAccepted(aClass);
+    protected boolean isAccepted(T aClass) {
+      return myTreeClassChooserDialog.getFilter().isAccepted(aClass);
     }
   }
 
-  private class SubclassGotoClassModel extends MyGotoClassModel {
+
+  @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 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;
@@ -423,52 +517,31 @@ public class TreeClassChooserDialog extends DialogWrapper implements TreeClassCh
       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);
-    }
-  }
 }

platform/lang-impl/src/com/intellij/ide/util/gotoByName/ChooseByNameBase.java

@@ -510,7 +510,7 @@ public abstract class ChooseByNameBase {
   protected void doClose(final boolean ok) {
     if (myDisposedFlag) return;
 
-    if (posponeCloseWhenListReady(ok)) return;
+    if (postponeCloseWhenListReady(ok)) return;
 
     cancelListUpdater();
     close(ok);
@@ -522,7 +522,7 @@ public abstract class ChooseByNameBase {
     myListUpdater.cancelAll();
   }
 
-  private boolean posponeCloseWhenListReady(boolean ok) {
+  private boolean postponeCloseWhenListReady(boolean ok) {
     if (!isToFixLostTyping()) return false;
 
     final String text = myTextField.getText();

platform/lang-impl/src/com/intellij/psi/impl/source/codeStyle/CodeStyleManagerImpl.java

@@ -181,7 +181,7 @@ public class CodeStyleManagerImpl extends CodeStyleManager {
     }
   }
   
-  private static int indentWithInVisualColumns(String indent, int tabSize) {
+  private static int indentWithInVisualColumns(@NotNull String indent, int tabSize) {
     if (tabSize <= 1) {
       return indent.length();
     }

platform/platform-impl/src/com/intellij/ide/util/TreeChooser.java

@@ -0,0 +1,34 @@
+/*
+ * 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);
+  }
+}

plugins/InspectionGadgets/src/com/siyeh/ig/ui/TreeClassChooserAction.java

@@ -18,6 +18,7 @@ package com.siyeh.ig.ui;
 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;
@@ -61,11 +62,11 @@ public class TreeClassChooserAction extends AbstractAction {
         }
         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)) {
@@ -80,7 +81,7 @@ public class TreeClassChooserAction extends AbstractAction {
                 chooserFactory.createWithInnerClassesScopeChooser(chooserTitle,
                         GlobalSearchScope.allScope(project), filter, null);
         classChooser.showDialog();
-        final PsiClass selectedClass = classChooser.getSelectedClass();
+        final PsiClass selectedClass = classChooser.getSelected();
         if (selectedClass == null) {
             return;
         }

plugins/InspectionGadgets/src/com/siyeh/ig/ui/UiUtils.java

@@ -17,6 +17,7 @@ package com.siyeh.ig.ui;
 
 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.*;
@@ -50,9 +51,9 @@ public class UiUtils {
     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);
         }
@@ -68,8 +69,8 @@ public class UiUtils {
 
     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();
                     }
@@ -88,16 +89,16 @@ public class UiUtils {
 
         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
@@ -111,9 +112,9 @@ public class UiUtils {
                     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;
             }
@@ -240,7 +241,7 @@ public class UiUtils {
         }
     }
 
-    private static class SubclassFilter implements TreeClassChooser.ClassFilter {
+    private static class SubclassFilter implements ClassFilter {
 
         private final String[] ancestorClasses;
 

plugins/IntelliLang/java-support/org/intellij/plugins/intelliLang/AdvancedSettingsUI.java

@@ -16,6 +16,7 @@
 
 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;
@@ -207,14 +208,14 @@ public class AdvancedSettingsUI implements Configurable {
       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());
       }

plugins/IntelliLang/java-support/org/intellij/plugins/intelliLang/inject/config/ui/MethodParameterPanel.java

@@ -54,7 +54,6 @@ import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.awt.event.KeyEvent;
 import java.util.*;
-import java.util.List;
 
 public class MethodParameterPanel extends AbstractInjectionPanel<MethodParameterInjection> {
 
@@ -378,7 +377,7 @@ public class MethodParameterPanel extends AbstractInjectionPanel<MethodParameter
       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();

plugins/android/src/org/jetbrains/android/run/AndroidClassBrowser.java

@@ -20,6 +20,7 @@ import com.intellij.CommonBundle;
 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;
@@ -44,7 +45,7 @@ import org.jetbrains.annotations.Nullable;
 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;
 
@@ -53,7 +54,7 @@ public class AndroidClassBrowser extends BrowseModuleValueActionListener {
                              String baseClassName,
                              String dialogTitle,
                              boolean includeLibraryClasses,
-                             @Nullable TreeClassChooser.ClassFilter additionalFilter) {
+                             @Nullable ClassFilter additionalFilter) {
     super(project);
     myModuleSelector = moduleSelector;
     myBaseClassName = baseClassName;
@@ -85,7 +86,7 @@ public class AndroidClassBrowser extends BrowseModuleValueActionListener {
       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;
@@ -99,7 +100,7 @@ public class AndroidClassBrowser extends BrowseModuleValueActionListener {
         }
       });
     chooser.showDialog();
-    PsiClass selClass = chooser.getSelectedClass();
+    PsiClass selClass = chooser.getSelected();
     return selClass != null ? selClass.getQualifiedName() : null;
   }
 }

plugins/android/src/org/jetbrains/android/run/ApplicationRunParameters.java

@@ -18,6 +18,7 @@ package org.jetbrains.android.run;
 
 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;
@@ -52,7 +53,7 @@ class ApplicationRunParameters implements ConfigurationSpecificEditor<AndroidRun
 
   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) {
@@ -82,7 +83,7 @@ class ApplicationRunParameters implements ConfigurationSpecificEditor<AndroidRun
           .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());
         }

plugins/java-i18n/src/com/intellij/codeInspection/i18n/I18nInspection.java

@@ -270,7 +270,7 @@ public class I18nInspection extends BaseLocalInspectionTool {
                 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;
           }
         };

plugins/junit/src/com/intellij/execution/junit/TestClassFilter.java

@@ -16,11 +16,10 @@
 
 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;
@@ -29,7 +28,7 @@ import com.intellij.psi.search.GlobalSearchScope;
 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;

plugins/junit/src/com/intellij/execution/junit2/configuration/JUnitConfigurable.java

@@ -27,8 +27,8 @@ import com.intellij.execution.ui.AlternativeJREPanel;
 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;
@@ -307,13 +307,13 @@ public class JUnitConfigurable extends SettingsEditor<JUnitConfiguration> {
       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);

plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGConfigurationEditor.java

@@ -440,7 +440,7 @@ public class TestNGConfigurationEditor extends SettingsEditor<TestNGConfiguratio
 
       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 {

plugins/testng/src/com/theoryinpractice/testng/configuration/browser/TestClassBrowser.java

@@ -17,6 +17,7 @@ package com.theoryinpractice.testng.configuration.browser;
 
 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;
@@ -44,7 +45,7 @@ public class TestClassBrowser extends BrowseModuleValueActionListener
 
   @Override
   protected String showDialog() {
-    TreeClassChooser.ClassFilterWithScope filter;
+    ClassFilter.ClassFilterWithScope filter;
     try {
       filter = getFilter();
     }
@@ -56,7 +57,7 @@ public class TestClassBrowser extends BrowseModuleValueActionListener
     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 {
@@ -72,7 +73,7 @@ public class TestClassBrowser extends BrowseModuleValueActionListener
     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());
@@ -99,6 +100,6 @@ public class TestClassBrowser extends BrowseModuleValueActionListener
     com.intellij.psi.PsiDirectory psidirectory = psiclass.getContainingFile().getContainingDirectory();
     if (psidirectory != null)
       chooser.selectDirectory(psidirectory);
-    chooser.selectClass(psiclass);
+    chooser.select(psiclass);
   }
 }

plugins/testng/src/com/theoryinpractice/testng/model/TestClassFilter.java

@@ -15,7 +15,7 @@
  */
 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;
@@ -27,7 +27,7 @@ import com.theoryinpractice.testng.util.TestNGUtil;
  *         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;

plugins/testng/src/com/theoryinpractice/testng/model/TestListenerFilter.java

@@ -16,7 +16,7 @@
 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;
@@ -25,7 +25,7 @@ import com.theoryinpractice.testng.util.TestNGUtil;
 /**
  * @author Mark Derricutt
  */
-public class TestListenerFilter implements TreeClassChooser.ClassFilterWithScope
+public class TestListenerFilter implements ClassFilter.ClassFilterWithScope
 {
   private final GlobalSearchScope scope;
   private final Project project;

plugins/ui-designer/src/com/intellij/uiDesigner/palette/ComponentItemDialog.java

@@ -371,7 +371,7 @@ public final class ComponentItemDialog extends DialogWrapper {
                                                                              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());
       }

plugins/ui-designer/src/com/intellij/uiDesigner/propertyInspector/properties/ClassToBindProperty.java

@@ -15,6 +15,7 @@
  */
 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;
@@ -157,7 +158,7 @@ public final class ClassToBindProperty extends Property<RadRootContainer, String
         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);
@@ -167,7 +168,7 @@ public final class ClassToBindProperty extends Property<RadRootContainer, String
         );
         chooser.showDialog();
 
-        final PsiClass result = chooser.getSelectedClass();
+        final PsiClass result = chooser.getSelected();
         if (result != null) {
           setEditorText(result.getQualifiedName());
         }

plugins/ui-designer/src/com/intellij/uiDesigner/wizard/BeanStep.java

@@ -15,6 +15,7 @@
  */
 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;
@@ -77,14 +78,14 @@ final class BeanStep extends StepAdapter{
           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;
           }