diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/ChangeMethodSignatureFromUsageFix.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/ChangeMethodSignatureFromUsageFix.java index 42cac1dc6ea4..0cdd3e93ef25 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/ChangeMethodSignatureFromUsageFix.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/ChangeMethodSignatureFromUsageFix.java @@ -32,9 +32,8 @@ import com.intellij.codeInsight.intention.IntentionAction; import com.intellij.find.FindManager; import com.intellij.find.findUsages.FindUsagesHandler; import com.intellij.find.findUsages.FindUsagesManager; -import com.intellij.find.findUsages.JavaFindUsagesOptions; +import com.intellij.find.findUsages.JavaMethodFindUsagesOptions; import com.intellij.find.impl.FindManagerImpl; -import com.intellij.ide.DataManager; import com.intellij.ide.util.SuperMethodWarningUtil; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.command.undo.UndoUtil; @@ -144,9 +143,8 @@ public class ChangeMethodSignatureFromUsageFix implements IntentionAction { final FindUsagesHandler handler = findUsagesManager.getFindUsagesHandler(method, false); if (handler == null) return; //on failure or cancel (e.g. cancel of super methods dialog) - final JavaFindUsagesOptions options = new JavaFindUsagesOptions(project, editor == null? null : DataManager.getInstance().getDataContext(editor.getComponent())); + final JavaMethodFindUsagesOptions options = new JavaMethodFindUsagesOptions(project); options.isImplementingMethods = true; - options.isMethodsUsages = true; options.isOverridingMethods = true; options.isUsages = true; options.isSearchForTextOccurrences = false; diff --git a/java/java-impl/src/com/intellij/find/findUsages/FindClassUsagesDialog.java b/java/java-impl/src/com/intellij/find/findUsages/FindClassUsagesDialog.java index 4904eda03d39..2e21cbd786c1 100644 --- a/java/java-impl/src/com/intellij/find/findUsages/FindClassUsagesDialog.java +++ b/java/java-impl/src/com/intellij/find/findUsages/FindClassUsagesDialog.java @@ -25,7 +25,7 @@ import com.intellij.ui.StateRestoringCheckBox; import javax.swing.*; -public class FindClassUsagesDialog extends JavaFindUsagesDialog { +public class FindClassUsagesDialog extends JavaFindUsagesDialog { private StateRestoringCheckBox myCbUsages; private StateRestoringCheckBox myCbMethodsUsages; private StateRestoringCheckBox myCbFieldsUsages; @@ -43,7 +43,7 @@ public class FindClassUsagesDialog extends JavaFindUsagesDialog { return myCbUsages; } - public void calcFindUsagesOptions(JavaFindUsagesOptions options) { + public void calcFindUsagesOptions(JavaClassFindUsagesOptions options) { super.calcFindUsagesOptions(options); if (isToChange(myCbUsages)){ diff --git a/java/java-impl/src/com/intellij/find/findUsages/FindMethodUsagesDialog.java b/java/java-impl/src/com/intellij/find/findUsages/FindMethodUsagesDialog.java index 8ee9356d041f..32d01d0985e6 100644 --- a/java/java-impl/src/com/intellij/find/findUsages/FindMethodUsagesDialog.java +++ b/java/java-impl/src/com/intellij/find/findUsages/FindMethodUsagesDialog.java @@ -24,7 +24,7 @@ import org.jetbrains.annotations.Nullable; import javax.swing.*; -public class FindMethodUsagesDialog extends JavaFindUsagesDialog { +public class FindMethodUsagesDialog extends JavaFindUsagesDialog { private StateRestoringCheckBox myCbUsages; private StateRestoringCheckBox myCbImplementingMethods; private StateRestoringCheckBox myCbOverridingMethods; @@ -41,7 +41,7 @@ public class FindMethodUsagesDialog extends JavaFindUsagesDialog { return myHasFindWhatPanel ? myCbUsages : null; } - public void calcFindUsagesOptions(JavaFindUsagesOptions options) { + public void calcFindUsagesOptions(JavaMethodFindUsagesOptions options) { super.calcFindUsagesOptions(options); options.isUsages = isSelected(myCbUsages) || !myHasFindWhatPanel; diff --git a/java/java-impl/src/com/intellij/find/findUsages/FindPackageUsagesDialog.java b/java/java-impl/src/com/intellij/find/findUsages/FindPackageUsagesDialog.java index 88e37433a2e7..7cc36e7df3da 100644 --- a/java/java-impl/src/com/intellij/find/findUsages/FindPackageUsagesDialog.java +++ b/java/java-impl/src/com/intellij/find/findUsages/FindPackageUsagesDialog.java @@ -23,7 +23,7 @@ import com.intellij.ui.StateRestoringCheckBox; import javax.swing.*; -public class FindPackageUsagesDialog extends JavaFindUsagesDialog { +public class FindPackageUsagesDialog extends JavaFindUsagesDialog { private StateRestoringCheckBox myCbUsages; private StateRestoringCheckBox myCbClassesUsages; @@ -39,7 +39,7 @@ public class FindPackageUsagesDialog extends JavaFindUsagesDialog { return myCbUsages; } - public void calcFindUsagesOptions(JavaFindUsagesOptions options) { + public void calcFindUsagesOptions(JavaPackageFindUsagesOptions options) { super.calcFindUsagesOptions(options); options.isUsages = isSelected(myCbUsages); diff --git a/java/java-impl/src/com/intellij/find/findUsages/FindThrowUsagesDialog.java b/java/java-impl/src/com/intellij/find/findUsages/FindThrowUsagesDialog.java index 7ca78038b41c..d8791a22dfe0 100644 --- a/java/java-impl/src/com/intellij/find/findUsages/FindThrowUsagesDialog.java +++ b/java/java-impl/src/com/intellij/find/findUsages/FindThrowUsagesDialog.java @@ -25,7 +25,7 @@ import com.intellij.ui.StateRestoringCheckBox; import javax.swing.*; import java.awt.*; -public class FindThrowUsagesDialog extends JavaFindUsagesDialog { +public class FindThrowUsagesDialog extends JavaFindUsagesDialog { private StateRestoringCheckBox myCbUsages; private JComboBox myCbExns; private boolean myHasFindWhatPanel; @@ -62,10 +62,9 @@ public class FindThrowUsagesDialog extends JavaFindUsagesDialog { return panel; } - public void calcFindUsagesOptions(final JavaFindUsagesOptions options) { + public void calcFindUsagesOptions(final JavaThrowFindUsagesOptions options) { super.calcFindUsagesOptions(options); options.isUsages = isSelected(myCbUsages) || !myHasFindWhatPanel; - options.isThrowUsages = true; } protected JPanel createFindWhatPanel() { diff --git a/java/java-impl/src/com/intellij/find/findUsages/FindVariableUsagesDialog.java b/java/java-impl/src/com/intellij/find/findUsages/FindVariableUsagesDialog.java index 26ceefe818d7..cc33f9c6e069 100644 --- a/java/java-impl/src/com/intellij/find/findUsages/FindVariableUsagesDialog.java +++ b/java/java-impl/src/com/intellij/find/findUsages/FindVariableUsagesDialog.java @@ -21,7 +21,7 @@ import com.intellij.psi.PsiField; import javax.swing.*; -public class FindVariableUsagesDialog extends JavaFindUsagesDialog { +public class FindVariableUsagesDialog extends JavaFindUsagesDialog { public FindVariableUsagesDialog(PsiElement element, Project project, FindUsagesOptions findUsagesOptions, boolean toShowInNewTab, boolean mustOpenInNewTab, boolean isSingleFile, FindUsagesHandler handler){ @@ -32,7 +32,7 @@ public class FindVariableUsagesDialog extends JavaFindUsagesDialog { return myCbToSkipResultsWhenOneUsage; } - public void calcFindUsagesOptions(JavaFindUsagesOptions options) { + public void calcFindUsagesOptions(JavaVariableFindUsagesOptions options) { super.calcFindUsagesOptions(options); options.isReadAccess = true; diff --git a/java/java-impl/src/com/intellij/find/findUsages/JavaClassFindUsagesOptions.java b/java/java-impl/src/com/intellij/find/findUsages/JavaClassFindUsagesOptions.java new file mode 100644 index 000000000000..a3e72c680e43 --- /dev/null +++ b/java/java-impl/src/com/intellij/find/findUsages/JavaClassFindUsagesOptions.java @@ -0,0 +1,70 @@ +package com.intellij.find.findUsages; + +import com.intellij.find.FindBundle; +import com.intellij.openapi.project.Project; +import org.jetbrains.annotations.NotNull; + +import java.util.LinkedHashSet; + +/** + * @author peter + */ +public class JavaClassFindUsagesOptions extends JavaFindUsagesOptions { + public boolean isMethodsUsages = false; + public boolean isFieldsUsages = false; + public boolean isDerivedClasses = false; + public boolean isImplementingClasses = false; + public boolean isDerivedInterfaces = false; + public boolean isCheckDeepInheritance = true; + public boolean isIncludeInherited = false; + + public JavaClassFindUsagesOptions(@NotNull Project project) { + super(project); + } + + protected void addUsageTypes(LinkedHashSet strings) { + if (this.isUsages || this.isMethodsUsages || this.isFieldsUsages) { + strings.add(FindBundle.message("find.usages.panel.title.usages")); + } + if (this.isDerivedClasses) { + strings.add(FindBundle.message("find.usages.panel.title.derived.classes")); + } + if (this.isImplementingClasses) { + strings.add(FindBundle.message("find.usages.panel.title.implementing.classes")); + } + if (this.isDerivedInterfaces) { + strings.add(FindBundle.message("find.usages.panel.title.derived.interfaces")); + } + } + + public boolean equals(final Object o) { + if (this == o) return true; + if (!super.equals(this)) return false; + if (o == null || getClass() != o.getClass()) return false; + + final JavaClassFindUsagesOptions that = (JavaClassFindUsagesOptions)o; + + if (isCheckDeepInheritance != that.isCheckDeepInheritance) return false; + if (isDerivedClasses != that.isDerivedClasses) return false; + if (isDerivedInterfaces != that.isDerivedInterfaces) return false; + if (isFieldsUsages != that.isFieldsUsages) return false; + if (isImplementingClasses != that.isImplementingClasses) return false; + if (isIncludeInherited != that.isIncludeInherited) return false; + if (isMethodsUsages != that.isMethodsUsages) return false; + + return true; + } + + public int hashCode() { + int result = super.hashCode(); + result = 31 * result + (isMethodsUsages ? 1 : 0); + result = 31 * result + (isFieldsUsages ? 1 : 0); + result = 31 * result + (isDerivedClasses ? 1 : 0); + result = 31 * result + (isImplementingClasses ? 1 : 0); + result = 31 * result + (isDerivedInterfaces ? 1 : 0); + result = 31 * result + (isCheckDeepInheritance ? 1 : 0); + result = 31 * result + (isIncludeInherited ? 1 : 0); + return result; + } + +} diff --git a/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesDialog.java b/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesDialog.java index 8934bf3865f9..c56ee406e735 100644 --- a/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesDialog.java +++ b/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesDialog.java @@ -30,7 +30,7 @@ import com.intellij.usageView.UsageViewUtil; import javax.swing.*; -public abstract class JavaFindUsagesDialog extends AbstractFindUsagesDialog { +public abstract class JavaFindUsagesDialog extends AbstractFindUsagesDialog { protected final PsiElement myPsiElement; private StateRestoringCheckBox myCbIncludeOverloadedMethods; private boolean myIncludeOverloadedMethodsAvailable = false; @@ -48,14 +48,16 @@ public abstract class JavaFindUsagesDialog extends AbstractFindUsagesDialog { return FindUsagesUtil.isSearchForTextOccurencesAvailable(element, isSingleFile, handler); } - public void calcFindUsagesOptions(JavaFindUsagesOptions options) { - options.isIncludeOverloadUsages = - myIncludeOverloadedMethodsAvailable && isToChange(myCbIncludeOverloadedMethods) && myCbIncludeOverloadedMethods.isSelected(); + public void calcFindUsagesOptions(T options) { + if (options instanceof JavaMethodFindUsagesOptions) { + ((JavaMethodFindUsagesOptions)options).isIncludeOverloadUsages = + myIncludeOverloadedMethodsAvailable && isToChange(myCbIncludeOverloadedMethods) && myCbIncludeOverloadedMethods.isSelected(); + } } public void calcFindUsagesOptions(FindUsagesOptions options) { super.calcFindUsagesOptions(options); - calcFindUsagesOptions((JavaFindUsagesOptions)options); + calcFindUsagesOptions((T)options); } protected void doOKAction() { @@ -100,7 +102,7 @@ public abstract class JavaFindUsagesDialog extends AbstractFindUsagesDialog { HelpManager.getInstance().invokeHelp(FindUsagesManager.getHelpID(myPsiElement)); } - protected JavaFindUsagesOptions getFindUsagesOptions() { - return (JavaFindUsagesOptions)myFindUsagesOptions; + protected T getFindUsagesOptions() { + return (T)myFindUsagesOptions; } } diff --git a/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesHandler.java b/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesHandler.java index 7c1b2b733cc8..d284cb65d533 100644 --- a/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesHandler.java +++ b/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesHandler.java @@ -23,7 +23,6 @@ import com.intellij.openapi.application.ReadActionProcessor; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.progress.ProgressIndicator; import com.intellij.openapi.progress.ProgressManager; -import com.intellij.openapi.project.Project; import com.intellij.openapi.ui.DialogWrapper; import com.intellij.openapi.ui.Messages; import com.intellij.openapi.util.Comparing; @@ -63,69 +62,36 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ public static final String ACTION_STRING = FindBundle.message("find.super.method.warning.action.verb"); private final PsiElement[] myElementsToSearch; - private final FindUsagesOptions myFindPackageOptions; - private final FindUsagesOptions myFindClassOptions; - private final FindUsagesOptions myFindMethodOptions; - private final FindUsagesOptions myFindVariableOptions; - private final FindUsagesOptions myFindThrowOptions; + private final JavaFindUsagesHandlerFactory myFactory; - public JavaFindUsagesHandler(@NotNull PsiElement psiElement, - @NotNull FindUsagesOptions findClassOptions, - @NotNull FindUsagesOptions findMethodOptions, - @NotNull FindUsagesOptions findPackageOptions, - @NotNull FindUsagesOptions findThrowOptions, - @NotNull FindUsagesOptions findVariableOptions) { - this(psiElement, PsiElement.EMPTY_ARRAY, findClassOptions, findMethodOptions, findPackageOptions, findThrowOptions, findVariableOptions); + public JavaFindUsagesHandler(@NotNull PsiElement psiElement, JavaFindUsagesHandlerFactory factory) { + this(psiElement, PsiElement.EMPTY_ARRAY, factory); } - public JavaFindUsagesHandler(@NotNull PsiElement psiElement, - @NotNull PsiElement[] elementsToSearch, - @NotNull FindUsagesOptions findClassOptions, - @NotNull FindUsagesOptions findMethodOptions, - @NotNull FindUsagesOptions findPackageOptions, - @NotNull FindUsagesOptions findThrowOptions, - @NotNull FindUsagesOptions findVariableOptions) { + public JavaFindUsagesHandler(@NotNull PsiElement psiElement, @NotNull PsiElement[] elementsToSearch, JavaFindUsagesHandlerFactory factory) { super(psiElement); myElementsToSearch = elementsToSearch; - myFindClassOptions = findClassOptions; - myFindMethodOptions = findMethodOptions; - myFindPackageOptions = findPackageOptions; - myFindThrowOptions = findThrowOptions; - myFindVariableOptions = findVariableOptions; + myFactory = factory; } - @SuppressWarnings({"MethodOverridesStaticMethodOfSuperclass"}) - public static JavaFindUsagesOptions createFindUsagesOptions(final Project project) { - JavaFindUsagesOptions findUsagesOptions = new JavaFindUsagesOptions(project, null); - findUsagesOptions.isUsages = true; - findUsagesOptions.isIncludeOverloadUsages = false; - findUsagesOptions.isIncludeSubpackages = true; - findUsagesOptions.isReadAccess = true; - findUsagesOptions.isWriteAccess = true; - findUsagesOptions.isCheckDeepInheritance = true; - findUsagesOptions.isSearchForTextOccurrences = true; - return findUsagesOptions; - } - - @NotNull public AbstractFindUsagesDialog getFindUsagesDialog(boolean isSingleFile, boolean toShowInNewTab, boolean mustOpenInNewTab) { PsiElement element = getPsiElement(); if (element instanceof PsiPackage) { - return new FindPackageUsagesDialog(element, getProject(), myFindPackageOptions, toShowInNewTab, mustOpenInNewTab, isSingleFile, this); + return new FindPackageUsagesDialog(element, getProject(), myFactory.getFindPackageOptions(), toShowInNewTab, mustOpenInNewTab, isSingleFile, this); } if (element instanceof PsiClass) { - return new FindClassUsagesDialog(element, getProject(), myFindClassOptions, toShowInNewTab, mustOpenInNewTab, isSingleFile, this); + return new FindClassUsagesDialog(element, getProject(), myFactory.getFindClassOptions(), toShowInNewTab, mustOpenInNewTab, isSingleFile, this); } if (element instanceof PsiMethod) { - return new FindMethodUsagesDialog(element, getProject(), myFindMethodOptions, toShowInNewTab, mustOpenInNewTab, isSingleFile, this); + return new FindMethodUsagesDialog(element, getProject(), myFactory.getFindMethodOptions(), toShowInNewTab, mustOpenInNewTab, isSingleFile, this); } if (element instanceof PsiVariable) { - return new FindVariableUsagesDialog(element, getProject(), myFindVariableOptions, toShowInNewTab, mustOpenInNewTab, isSingleFile, this); + return new FindVariableUsagesDialog(element, getProject(), myFactory.getFindVariableOptions(), toShowInNewTab, mustOpenInNewTab, isSingleFile, this); } if (ThrowSearchUtil.isSearchable(element)) { - return new FindThrowUsagesDialog(element, getProject(), myFindThrowOptions, toShowInNewTab, mustOpenInNewTab, isSingleFile, this); + return new FindThrowUsagesDialog(element, getProject(), myFactory.getFindThrowOptions(), toShowInNewTab, mustOpenInNewTab, isSingleFile, this); } return super.getFindUsagesDialog(isSingleFile, toShowInNewTab, mustOpenInNewTab); } @@ -221,19 +187,19 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ public FindUsagesOptions getFindUsagesOptions() { PsiElement element = getPsiElement(); if (element instanceof PsiPackage) { - return myFindPackageOptions; + return myFactory.getFindPackageOptions(); } if (element instanceof PsiClass) { - return myFindClassOptions; + return myFactory.getFindClassOptions(); } if (element instanceof PsiMethod) { - return myFindMethodOptions; + return myFactory.getFindMethodOptions(); } if (element instanceof PsiVariable) { - return myFindVariableOptions; + return myFactory.getFindVariableOptions(); } if (ThrowSearchUtil.isSearchable(element)) { - return myFindThrowOptions; + return myFactory.getFindThrowOptions(); } return super.getFindUsagesOptions(); } @@ -278,12 +244,11 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ } @Override - public void processElementUsages(@NotNull final PsiElement element, @NotNull final Processor processor, @NotNull final FindUsagesOptions _options) { - final JavaFindUsagesOptions options = (JavaFindUsagesOptions) _options; - if (element instanceof PsiVariable){ - if (options.isReadAccess || options.isWriteAccess){ - if (options.isReadAccess && options.isWriteAccess){ - //todo[myakovlev] this also shows param in javadoc (PsiDocParamRef), but should not + public void processElementUsages(@NotNull final PsiElement element, @NotNull final Processor processor, @NotNull final FindUsagesOptions options) { + if (options instanceof JavaVariableFindUsagesOptions) { + final JavaVariableFindUsagesOptions varOptions = (JavaVariableFindUsagesOptions) options; + if (varOptions.isReadAccess || varOptions.isWriteAccess){ + if (varOptions.isReadAccess && varOptions.isWriteAccess){ addElementUsages(element, processor, options); } else{ @@ -291,12 +256,12 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ public boolean process(UsageInfo info) { final PsiElement element = info.getElement(); boolean isWrite = element instanceof PsiExpression && PsiUtil.isAccessedForWriting((PsiExpression)element); - if (isWrite == options.isWriteAccess) { + if (isWrite == varOptions.isWriteAccess) { if (!processor.process(info)) return false; } return true; } - }, options); + }, varOptions); } } } @@ -306,7 +271,7 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ ApplicationManager.getApplication().runReadAction(new Runnable() { public void run() { - if (ThrowSearchUtil.isSearchable (element) && options.isThrowUsages) { + if (ThrowSearchUtil.isSearchable (element) && options instanceof JavaThrowFindUsagesOptions && options.isUsages) { ThrowSearchUtil.Root root = options.getUserData(ThrowSearchUtil.THROW_SEARCH_ROOT_KEY); if (root == null) { final ThrowSearchUtil.Root[] roots = ThrowSearchUtil.getSearchRoots(element); @@ -321,46 +286,49 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ } }); - if (element instanceof PsiPackage && options.isClassesUsages){ - addClassesUsages((PsiPackage)element, processor, options); + if (options instanceof JavaPackageFindUsagesOptions && ((JavaPackageFindUsagesOptions)options).isClassesUsages){ + addClassesUsages((PsiPackage)element, processor, (JavaPackageFindUsagesOptions)options); } - if (element instanceof PsiClass && options.isMethodsUsages){ - addMethodsUsages((PsiClass)element, processor, options); - } - - if (element instanceof PsiClass && options.isFieldsUsages){ - addFieldsUsages((PsiClass)element, processor, options); - } - - if (element instanceof PsiClass){ - if (((PsiClass)element).isInterface()) { - if (options.isDerivedInterfaces){ - if (options.isImplementingClasses){ - addInheritors((PsiClass)element, processor, options); + if (options instanceof JavaClassFindUsagesOptions) { + final JavaClassFindUsagesOptions classOptions = (JavaClassFindUsagesOptions)options; + final PsiClass psiClass = (PsiClass)element; + if (classOptions.isMethodsUsages){ + addMethodsUsages(psiClass, processor, classOptions); + } + if (classOptions.isFieldsUsages){ + addFieldsUsages(psiClass, processor, classOptions); + } + if (psiClass.isInterface()) { + if (classOptions.isDerivedInterfaces){ + if (classOptions.isImplementingClasses){ + addInheritors(psiClass, processor, classOptions); } else{ - addDerivedInterfaces((PsiClass)element, processor, options); + addDerivedInterfaces(psiClass, processor, classOptions); } } - else if (options.isImplementingClasses){ - addImplementingClasses((PsiClass)element, processor, options); + else if (classOptions.isImplementingClasses){ + addImplementingClasses(psiClass, processor, classOptions); } } - else if (options.isDerivedClasses) { - addInheritors((PsiClass)element, processor, options); + else if (classOptions.isDerivedClasses) { + addInheritors(psiClass, processor, classOptions); } } - if (element instanceof PsiMethod){ + + + if (options instanceof JavaMethodFindUsagesOptions){ final PsiMethod psiMethod = (PsiMethod)element; boolean isAbstract = ApplicationManager.getApplication().runReadAction(new Computable() { public Boolean compute() { return psiMethod.hasModifierProperty(PsiModifier.ABSTRACT); } }); - if (isAbstract && options.isImplementingMethods || options.isOverridingMethods) { - processOverridingMethods(psiMethod, processor, options); + final JavaMethodFindUsagesOptions methodOptions = (JavaMethodFindUsagesOptions)options; + if (isAbstract && methodOptions.isImplementingMethods || methodOptions.isOverridingMethods) { + processOverridingMethods(psiMethod, processor, methodOptions); } } @@ -370,18 +338,18 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ } } - private static void processOverridingMethods(PsiMethod psiMethod, final Processor processor, final JavaFindUsagesOptions options) { + private static void processOverridingMethods(PsiMethod psiMethod, final Processor processor, final JavaMethodFindUsagesOptions options) { OverridingMethodsSearch.search(psiMethod, options.searchScope, options.isCheckDeepInheritance).forEach(new PsiElementProcessorAdapter( new PsiElementProcessor() { public boolean execute(PsiMethod element) { - addResult(processor, element.getNavigationElement(), options, null); + addResult(processor, element.getNavigationElement(), options); return true; } })); } - private static void addClassesUsages(PsiPackage aPackage, final Processor results, final JavaFindUsagesOptions options) { + private static void addClassesUsages(PsiPackage aPackage, final Processor results, final JavaPackageFindUsagesOptions options) { final HashSet filesSet = new HashSet(); final ArrayList files = new ArrayList(); ReferencesSearch.search(new ReferencesSearch.SearchParameters(aPackage, options.searchScope, false, options.fastTrack)).forEach(new ReadActionProcessor() { @@ -412,7 +380,7 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ } ReferencesSearch.search(new ReferencesSearch.SearchParameters(aClass, new LocalSearchScope(file), false, options.fastTrack)).forEach(new ReadActionProcessor() { public boolean processInReadAction(final PsiReference psiReference) { - return addResult(results, psiReference, options, aClass); + return addResult(results, psiReference, options); } }); } @@ -445,7 +413,7 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ }); } - private static void addMethodsUsages(final PsiClass aClass, final Processor results, final JavaFindUsagesOptions options) { + private static void addMethodsUsages(final PsiClass aClass, final Processor results, final JavaClassFindUsagesOptions options) { if (options.isIncludeInherited) { final PsiManager manager = aClass.getManager(); PsiMethod[] methods = aClass.getAllMethods(); @@ -462,10 +430,9 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ addElementUsages(methods[i], results, options); } else{ - boolean strictSignatureSearch = !options.isIncludeOverloadUsages; - MethodReferencesSearch.search(new MethodReferencesSearch.SearchParameters(method, options.searchScope, strictSignatureSearch, options.fastTrack)).forEach(new PsiReferenceProcessorAdapter(new PsiReferenceProcessor() { + MethodReferencesSearch.search(new MethodReferencesSearch.SearchParameters(method, options.searchScope, true, options.fastTrack)).forEach(new PsiReferenceProcessorAdapter(new PsiReferenceProcessor() { public boolean execute(PsiReference reference) { - addResultFromReference(reference, methodClass, manager, aClass, results, options, method); + addResultFromReference(reference, methodClass, manager, aClass, results, options); return true; } })); @@ -479,7 +446,7 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ } } - private static void addFieldsUsages(final PsiClass aClass, final Processor results, final JavaFindUsagesOptions options) { + private static void addFieldsUsages(final PsiClass aClass, final Processor results, final JavaClassFindUsagesOptions options) { if (options.isIncludeInherited) { final PsiManager manager = aClass.getManager(); PsiField[] fields = aClass.getAllFields(); @@ -497,7 +464,7 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ else { ReferencesSearch.search(new ReferencesSearch.SearchParameters(field, options.searchScope, false, options.fastTrack)).forEach(new ReadActionProcessor() { public boolean processInReadAction(final PsiReference reference) { - addResultFromReference(reference, fieldClass, manager, aClass, results, options, field); + addResultFromReference(reference, fieldClass, manager, aClass, results, options); return true; } }); @@ -544,23 +511,23 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ return null; } - private static void addInheritors(final PsiClass aClass, final Processor results, final JavaFindUsagesOptions options) { + private static void addInheritors(final PsiClass aClass, final Processor results, final JavaClassFindUsagesOptions options) { ClassInheritorsSearch.search(aClass, options.searchScope, options.isCheckDeepInheritance).forEach(new PsiElementProcessorAdapter( new PsiElementProcessor() { public boolean execute(PsiClass element) { - addResult(results, element, options, null); + addResult(results, element, options); return true; } })); } - private static void addDerivedInterfaces(PsiClass anInterface, final Processor results, final JavaFindUsagesOptions options) { + private static void addDerivedInterfaces(PsiClass anInterface, final Processor results, final JavaClassFindUsagesOptions options) { ClassInheritorsSearch.search(anInterface, options.searchScope, options.isCheckDeepInheritance).forEach(new PsiElementProcessorAdapter( new PsiElementProcessor() { public boolean execute(PsiClass inheritor) { if (inheritor.isInterface()) { - addResult(results, inheritor, options, null); + addResult(results, inheritor, options); } return true; } @@ -568,12 +535,12 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ })); } - private static void addImplementingClasses(PsiClass anInterface, final Processor results, final JavaFindUsagesOptions options) { + private static void addImplementingClasses(PsiClass anInterface, final Processor results, final JavaClassFindUsagesOptions options) { ClassInheritorsSearch.search(anInterface, options.searchScope, options.isCheckDeepInheritance).forEach(new PsiElementProcessorAdapter( new PsiElementProcessor() { public boolean execute(PsiClass inheritor) { if (!inheritor.isInterface()) { - addResult(results, inheritor, options, null); + addResult(results, inheritor, options); } return true; } @@ -586,29 +553,28 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ final PsiManager manager, final PsiClass aClass, final Processor results, - final FindUsagesOptions options, - final PsiElement element) { + final FindUsagesOptions options) { PsiElement refElement = reference.getElement(); if (refElement instanceof PsiReferenceExpression) { PsiClass usedClass = getFieldOrMethodAccessedClass((PsiReferenceExpression)refElement, methodClass); if (usedClass != null) { if (manager.areElementsEquivalent(usedClass, aClass) || usedClass.isInheritor(aClass, true)) { - addResult(results, refElement, (JavaFindUsagesOptions)options, element); + addResult(results, refElement, options); } } } } - public static void addElementUsages(final PsiElement element, final Processor result, final JavaFindUsagesOptions options) { + public static void addElementUsages(final PsiElement element, final Processor result, final FindUsagesOptions options) { final SearchScope searchScope = options.searchScope; if (element instanceof PsiMethod && ((PsiMethod)element).isConstructor()){ PsiMethod method = (PsiMethod)element; final PsiClass parentClass = method.getContainingClass(); if (parentClass != null) { - MethodReferencesSearch.search(new MethodReferencesSearch.SearchParameters(method, searchScope, !options.isIncludeOverloadUsages, options.fastTrack)).forEach(new ReadActionProcessor() { + MethodReferencesSearch.search(new MethodReferencesSearch.SearchParameters(method, searchScope, !((JavaMethodFindUsagesOptions)options).isIncludeOverloadUsages, options.fastTrack)).forEach(new ReadActionProcessor() { public boolean processInReadAction(final PsiReference ref) { - return addResult(result, ref, options, parentClass); + return addResult(result, ref, options); } }); } @@ -617,37 +583,37 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ final ReadActionProcessor consumer = new ReadActionProcessor() { public boolean processInReadAction(final PsiReference ref) { - return addResult(result, ref, options, element); + return addResult(result, ref, options); } }; if (element instanceof PsiMethod) { - final boolean strictSignatureSearch = !options.isIncludeOverloadUsages; + final boolean strictSignatureSearch = !((JavaMethodFindUsagesOptions)options).isIncludeOverloadUsages; MethodReferencesSearch.search(new MethodReferencesSearch.SearchParameters((PsiMethod)element, searchScope, strictSignatureSearch, options.fastTrack)).forEach(consumer); } else { ReferencesSearch.search(new ReferencesSearch.SearchParameters(element, searchScope, false, options.fastTrack)).forEach(consumer); } } - public static void addResult(Processor total, PsiElement element, JavaFindUsagesOptions options, PsiElement refElement) { - if (filterUsage(element, options, refElement)){ + public static void addResult(Processor total, PsiElement element, FindUsagesOptions options) { + if (filterUsage(element, options)){ total.process(new UsageInfo(element)); } } - public static boolean addResult(Processor results, PsiReference ref, JavaFindUsagesOptions options, PsiElement refElement) { - if (filterUsage(ref.getElement(), options, refElement)){ + public static boolean addResult(Processor results, PsiReference ref, FindUsagesOptions options) { + if (filterUsage(ref.getElement(), options)){ TextRange rangeInElement = ref.getRangeInElement(); return results.process(new UsageInfo(ref.getElement(), rangeInElement.getStartOffset(), rangeInElement.getEndOffset(), false)); } return true; } - private static boolean filterUsage(PsiElement usage, JavaFindUsagesOptions options, PsiElement refElement) { + private static boolean filterUsage(PsiElement usage, FindUsagesOptions options) { if (!(usage instanceof PsiJavaCodeReferenceElement)) { return true; } - if (refElement instanceof PsiPackage && !options.isIncludeSubpackages && + if (options instanceof JavaPackageFindUsagesOptions && !((JavaPackageFindUsagesOptions)options).isIncludeSubpackages && ((PsiReference)usage).resolve() instanceof PsiPackage) { PsiElement parent = usage.getParent(); if (parent instanceof PsiJavaCodeReferenceElement && ((PsiJavaCodeReferenceElement)parent).resolve() instanceof PsiPackage) { @@ -656,7 +622,7 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ } if (!(usage instanceof PsiReferenceExpression)){ - if (options.isSkipImportStatements){ + if (options instanceof JavaFindUsagesOptions && ((JavaFindUsagesOptions)options).isSkipImportStatements){ PsiElement parent = usage.getParent(); while(parent instanceof PsiJavaCodeReferenceElement){ parent = parent.getParent(); @@ -666,7 +632,7 @@ public class JavaFindUsagesHandler extends FindUsagesHandler{ } } - if (options.isSkipPackageStatements){ + if (options instanceof JavaPackageFindUsagesOptions && ((JavaPackageFindUsagesOptions)options).isSkipPackageStatements){ PsiElement parent = usage.getParent(); while(parent instanceof PsiJavaCodeReferenceElement){ parent = parent.getParent(); diff --git a/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesHandlerFactory.java b/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesHandlerFactory.java index 540a46200b8c..195c32909870 100644 --- a/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesHandlerFactory.java +++ b/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesHandlerFactory.java @@ -27,38 +27,22 @@ import org.jetbrains.annotations.NotNull; * @author peter */ public class JavaFindUsagesHandlerFactory extends FindUsagesHandlerFactory { - private final FindUsagesOptions myFindClassOptions; - private final FindUsagesOptions myFindMethodOptions; - private final FindUsagesOptions myFindPackageOptions; - private final FindUsagesOptions myFindThrowOptions; - private final FindUsagesOptions myFindVariableOptions; + private final JavaClassFindUsagesOptions myFindClassOptions; + private final JavaMethodFindUsagesOptions myFindMethodOptions; + private final JavaPackageFindUsagesOptions myFindPackageOptions; + private final JavaThrowFindUsagesOptions myFindThrowOptions; + private final JavaVariableFindUsagesOptions myFindVariableOptions; public static JavaFindUsagesHandlerFactory getInstance(@NotNull Project project) { return ContainerUtil.findInstance(Extensions.getExtensions(EP_NAME, project), JavaFindUsagesHandlerFactory.class); } public JavaFindUsagesHandlerFactory(Project project) { - final JavaFindUsagesOptions findClassOptions = JavaFindUsagesHandler.createFindUsagesOptions(project); - final JavaFindUsagesOptions findMethodOptions = JavaFindUsagesHandler.createFindUsagesOptions(project); - findMethodOptions.isCheckDeepInheritance = false; - findMethodOptions.isIncludeSubpackages = false; - findMethodOptions.isSearchForTextOccurrences = false; - final FindUsagesOptions findPackageOptions = JavaFindUsagesHandler.createFindUsagesOptions(project); - - final JavaFindUsagesOptions findThrowOptions = JavaFindUsagesHandler.createFindUsagesOptions(project); - findThrowOptions.isSearchForTextOccurrences = false; - findThrowOptions.isThrowUsages = true; - - final JavaFindUsagesOptions findVariableOptions = JavaFindUsagesHandler.createFindUsagesOptions(project); - findVariableOptions.isCheckDeepInheritance = false; - findVariableOptions.isIncludeSubpackages = false; - findVariableOptions.isSearchForTextOccurrences = false; - - myFindClassOptions = findClassOptions; - myFindMethodOptions = findMethodOptions; - myFindPackageOptions = findPackageOptions; - myFindThrowOptions = findThrowOptions; - myFindVariableOptions = findVariableOptions; + myFindClassOptions = new JavaClassFindUsagesOptions(project); + myFindMethodOptions = new JavaMethodFindUsagesOptions(project); + myFindPackageOptions = new JavaPackageFindUsagesOptions(project); + myFindThrowOptions = new JavaThrowFindUsagesOptions(project); + myFindVariableOptions = new JavaVariableFindUsagesOptions(project); } public boolean canFindUsages(@NotNull final PsiElement element) { @@ -68,46 +52,40 @@ public class JavaFindUsagesHandlerFactory extends FindUsagesHandlerFactory { public FindUsagesHandler createFindUsagesHandler(@NotNull final PsiElement element, final boolean forHighlightUsages) { if (element instanceof PsiDirectory) { final PsiPackage psiPackage = JavaDirectoryService.getInstance().getPackage((PsiDirectory)element); - return psiPackage == null - ? null - : new JavaFindUsagesHandler(psiPackage, myFindClassOptions, myFindMethodOptions, myFindPackageOptions, myFindThrowOptions, - myFindVariableOptions); + return psiPackage == null ? null : new JavaFindUsagesHandler(psiPackage, this); } if (element instanceof PsiMethod && !forHighlightUsages) { final PsiMethod[] methods = SuperMethodWarningUtil.checkSuperMethods((PsiMethod)element, JavaFindUsagesHandler.ACTION_STRING); if (methods.length > 1) { - return new JavaFindUsagesHandler(element, methods, myFindClassOptions, myFindMethodOptions, myFindPackageOptions, - myFindThrowOptions, myFindVariableOptions); + return new JavaFindUsagesHandler(element, methods, this); } if (methods.length == 1) { - return new JavaFindUsagesHandler(methods[0], myFindClassOptions, myFindMethodOptions, myFindPackageOptions, myFindThrowOptions, - myFindVariableOptions); + return new JavaFindUsagesHandler(methods[0], this); } return FindUsagesHandler.NULL_HANDLER; } - return new JavaFindUsagesHandler(element, myFindClassOptions, myFindMethodOptions, myFindPackageOptions, myFindThrowOptions, - myFindVariableOptions); + return new JavaFindUsagesHandler(element, this); } - public FindUsagesOptions getFindClassOptions() { + public JavaClassFindUsagesOptions getFindClassOptions() { return myFindClassOptions; } - public FindUsagesOptions getFindMethodOptions() { + public JavaMethodFindUsagesOptions getFindMethodOptions() { return myFindMethodOptions; } - public FindUsagesOptions getFindPackageOptions() { + public JavaPackageFindUsagesOptions getFindPackageOptions() { return myFindPackageOptions; } - public FindUsagesOptions getFindThrowOptions() { + public JavaThrowFindUsagesOptions getFindThrowOptions() { return myFindThrowOptions; } - public FindUsagesOptions getFindVariableOptions() { + public JavaVariableFindUsagesOptions getFindVariableOptions() { return myFindVariableOptions; } } diff --git a/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesOptions.java b/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesOptions.java index 723ab9ef8a1b..7aa91305d380 100644 --- a/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesOptions.java +++ b/java/java-impl/src/com/intellij/find/findUsages/JavaFindUsagesOptions.java @@ -1,38 +1,22 @@ package com.intellij.find.findUsages; import com.intellij.find.FindBundle; -import com.intellij.openapi.actionSystem.DataContext; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.text.StringUtil; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import java.util.ArrayList; +import java.util.LinkedHashSet; /** * @author peter */ -public class JavaFindUsagesOptions extends FindUsagesOptions { - public boolean isClassesUsages = false; - public boolean isMethodsUsages = false; - public boolean isFieldsUsages = false; - public boolean isDerivedClasses = false; - public boolean isImplementingClasses = false; - public boolean isDerivedInterfaces = false; - public boolean isOverridingMethods = false; - public boolean isImplementingMethods = false; - public boolean isIncludeSubpackages = true; +public abstract class JavaFindUsagesOptions extends FindUsagesOptions { public boolean isSkipImportStatements = false; - public boolean isSkipPackageStatements = false; - public boolean isCheckDeepInheritance = true; - public boolean isIncludeInherited = false; - public boolean isReadAccess = false; - public boolean isWriteAccess = false; - public boolean isIncludeOverloadUsages = false; - public boolean isThrowUsages = false; - public JavaFindUsagesOptions(@NotNull Project project, @Nullable DataContext dataContext) { - super(project, dataContext); + public JavaFindUsagesOptions(@NotNull Project project) { + super(project, null); + + isUsages = true; } public boolean equals(final Object o) { @@ -40,79 +24,26 @@ public class JavaFindUsagesOptions extends FindUsagesOptions { if (!super.equals(this)) return false; if (o == null || getClass() != o.getClass()) return false; - final JavaFindUsagesOptions that = (JavaFindUsagesOptions)o; - - if (isCheckDeepInheritance != that.isCheckDeepInheritance) return false; - if (isClassesUsages != that.isClassesUsages) return false; - if (isDerivedClasses != that.isDerivedClasses) return false; - if (isDerivedInterfaces != that.isDerivedInterfaces) return false; - if (isFieldsUsages != that.isFieldsUsages) return false; - if (isImplementingClasses != that.isImplementingClasses) return false; - if (isImplementingMethods != that.isImplementingMethods) return false; - if (isIncludeInherited != that.isIncludeInherited) return false; - if (isIncludeOverloadUsages != that.isIncludeOverloadUsages) return false; - if (isIncludeSubpackages != that.isIncludeSubpackages) return false; - if (isMethodsUsages != that.isMethodsUsages) return false; - if (isOverridingMethods != that.isOverridingMethods) return false; - if (isReadAccess != that.isReadAccess) return false; - if (isSearchForTextOccurrences != that.isSearchForTextOccurrences) return false; - if (isSkipImportStatements != that.isSkipImportStatements) return false; - if (isSkipPackageStatements != that.isSkipPackageStatements) return false; - if (isThrowUsages != that.isThrowUsages) return false; - if (isUsages != that.isUsages) return false; - if (isWriteAccess != that.isWriteAccess) return false; - if (searchScope != null ? !searchScope.equals(that.searchScope) : that.searchScope != null) return false; - - return true; + return isSkipImportStatements == ((JavaFindUsagesOptions)o).isSkipImportStatements; } public int hashCode() { int result = super.hashCode(); - result = 31 * result + (isClassesUsages ? 1 : 0); - result = 31 * result + (isMethodsUsages ? 1 : 0); - result = 31 * result + (isFieldsUsages ? 1 : 0); - result = 31 * result + (isDerivedClasses ? 1 : 0); - result = 31 * result + (isImplementingClasses ? 1 : 0); - result = 31 * result + (isDerivedInterfaces ? 1 : 0); - result = 31 * result + (isOverridingMethods ? 1 : 0); - result = 31 * result + (isImplementingMethods ? 1 : 0); - result = 31 * result + (isIncludeSubpackages ? 1 : 0); result = 31 * result + (isSkipImportStatements ? 1 : 0); - result = 31 * result + (isSkipPackageStatements ? 1 : 0); - result = 31 * result + (isCheckDeepInheritance ? 1 : 0); - result = 31 * result + (isIncludeInherited ? 1 : 0); - result = 31 * result + (isReadAccess ? 1 : 0); - result = 31 * result + (isWriteAccess ? 1 : 0); - result = 31 * result + (isIncludeOverloadUsages ? 1 : 0); - result = 31 * result + (isThrowUsages ? 1 : 0); return result; } + protected void addUsageTypes(LinkedHashSet to) { + if (this.isUsages) { + to.add(FindBundle.message("find.usages.panel.title.usages")); + } + } + @Override - public String generateUsagesString() { + public final String generateUsagesString() { String suffix = " " + FindBundle.message("find.usages.panel.title.separator") + " "; - ArrayList strings = new ArrayList(); - if (this.isUsages || this.isClassesUsages || this.isMethodsUsages || this.isFieldsUsages) { - strings.add(FindBundle.message("find.usages.panel.title.usages")); - } - if (this.isIncludeOverloadUsages) { - strings.add(FindBundle.message("find.usages.panel.title.overloaded.methods.usages")); - } - if (this.isDerivedClasses) { - strings.add(FindBundle.message("find.usages.panel.title.derived.classes")); - } - if (this.isDerivedInterfaces) { - strings.add(FindBundle.message("find.usages.panel.title.derived.interfaces")); - } - if (this.isImplementingClasses) { - strings.add(FindBundle.message("find.usages.panel.title.implementing.classes")); - } - if (this.isImplementingMethods) { - strings.add(FindBundle.message("find.usages.panel.title.implementing.methods")); - } - if (this.isOverridingMethods) { - strings.add(FindBundle.message("find.usages.panel.title.overriding.methods")); - } + LinkedHashSet strings = new LinkedHashSet(); + addUsageTypes(strings); if (strings.isEmpty()) { strings.add(FindBundle.message("find.usages.panel.title.usages")); } diff --git a/java/java-impl/src/com/intellij/find/findUsages/JavaMethodFindUsagesOptions.java b/java/java-impl/src/com/intellij/find/findUsages/JavaMethodFindUsagesOptions.java new file mode 100644 index 000000000000..6efafe155922 --- /dev/null +++ b/java/java-impl/src/com/intellij/find/findUsages/JavaMethodFindUsagesOptions.java @@ -0,0 +1,64 @@ +package com.intellij.find.findUsages; + +import com.intellij.find.FindBundle; +import com.intellij.openapi.project.Project; +import org.jetbrains.annotations.NotNull; + +import java.util.LinkedHashSet; + +/** + * @author peter + */ +public class JavaMethodFindUsagesOptions extends JavaFindUsagesOptions { + public boolean isOverridingMethods = false; + public boolean isImplementingMethods = false; + public boolean isCheckDeepInheritance = true; + public boolean isIncludeInherited = false; + public boolean isIncludeOverloadUsages = false; + + public JavaMethodFindUsagesOptions(@NotNull Project project) { + super(project); + isSearchForTextOccurrences = false; + } + + public boolean equals(final Object o) { + if (this == o) return true; + if (!super.equals(this)) return false; + if (o == null || getClass() != o.getClass()) return false; + + final JavaMethodFindUsagesOptions that = (JavaMethodFindUsagesOptions)o; + + if (isCheckDeepInheritance != that.isCheckDeepInheritance) return false; + if (isImplementingMethods != that.isImplementingMethods) return false; + if (isIncludeInherited != that.isIncludeInherited) return false; + if (isIncludeOverloadUsages != that.isIncludeOverloadUsages) return false; + if (isOverridingMethods != that.isOverridingMethods) return false; + + return true; + } + + public int hashCode() { + int result = super.hashCode(); + result = 31 * result + (isOverridingMethods ? 1 : 0); + result = 31 * result + (isImplementingMethods ? 1 : 0); + result = 31 * result + (isCheckDeepInheritance ? 1 : 0); + result = 31 * result + (isIncludeInherited ? 1 : 0); + result = 31 * result + (isIncludeOverloadUsages ? 1 : 0); + return result; + } + + @Override + protected void addUsageTypes(LinkedHashSet strings) { + super.addUsageTypes(strings); + if (this.isIncludeOverloadUsages) { + strings.add(FindBundle.message("find.usages.panel.title.overloaded.methods.usages")); + } + if (this.isImplementingMethods) { + strings.add(FindBundle.message("find.usages.panel.title.implementing.methods")); + } + if (this.isOverridingMethods) { + strings.add(FindBundle.message("find.usages.panel.title.overriding.methods")); + } + + } +} diff --git a/java/java-impl/src/com/intellij/find/findUsages/JavaPackageFindUsagesOptions.java b/java/java-impl/src/com/intellij/find/findUsages/JavaPackageFindUsagesOptions.java new file mode 100644 index 000000000000..846bf2c1b0d9 --- /dev/null +++ b/java/java-impl/src/com/intellij/find/findUsages/JavaPackageFindUsagesOptions.java @@ -0,0 +1,49 @@ +package com.intellij.find.findUsages; + +import com.intellij.find.FindBundle; +import com.intellij.openapi.project.Project; +import org.jetbrains.annotations.NotNull; + +import java.util.LinkedHashSet; + +/** + * @author peter + */ +public class JavaPackageFindUsagesOptions extends JavaFindUsagesOptions { + public boolean isClassesUsages = false; + public boolean isIncludeSubpackages = true; + public boolean isSkipPackageStatements = false; + + public JavaPackageFindUsagesOptions(@NotNull Project project) { + super(project); + } + + protected void addUsageTypes(LinkedHashSet to) { + if (this.isUsages || this.isClassesUsages) { + to.add(FindBundle.message("find.usages.panel.title.usages")); + } + } + + public boolean equals(final Object o) { + if (this == o) return true; + if (!super.equals(this)) return false; + if (o == null || getClass() != o.getClass()) return false; + + final JavaPackageFindUsagesOptions that = (JavaPackageFindUsagesOptions)o; + + if (isClassesUsages != that.isClassesUsages) return false; + if (isIncludeSubpackages != that.isIncludeSubpackages) return false; + if (isSkipPackageStatements != that.isSkipPackageStatements) return false; + + return true; + } + + public int hashCode() { + int result = super.hashCode(); + result = 31 * result + (isClassesUsages ? 1 : 0); + result = 31 * result + (isIncludeSubpackages ? 1 : 0); + result = 31 * result + (isSkipPackageStatements ? 1 : 0); + return result; + } + +} diff --git a/java/java-impl/src/com/intellij/find/findUsages/JavaThrowFindUsagesOptions.java b/java/java-impl/src/com/intellij/find/findUsages/JavaThrowFindUsagesOptions.java new file mode 100644 index 000000000000..c90c6a675dee --- /dev/null +++ b/java/java-impl/src/com/intellij/find/findUsages/JavaThrowFindUsagesOptions.java @@ -0,0 +1,16 @@ +package com.intellij.find.findUsages; + +import com.intellij.openapi.project.Project; +import org.jetbrains.annotations.NotNull; + +/** + * @author peter + */ +public class JavaThrowFindUsagesOptions extends JavaFindUsagesOptions { + + public JavaThrowFindUsagesOptions(@NotNull Project project) { + super(project); + isSearchForTextOccurrences = false; + } + +} diff --git a/java/java-impl/src/com/intellij/find/findUsages/JavaVariableFindUsagesOptions.java b/java/java-impl/src/com/intellij/find/findUsages/JavaVariableFindUsagesOptions.java new file mode 100644 index 000000000000..c39b664c6b7c --- /dev/null +++ b/java/java-impl/src/com/intellij/find/findUsages/JavaVariableFindUsagesOptions.java @@ -0,0 +1,38 @@ +package com.intellij.find.findUsages; + +import com.intellij.openapi.project.Project; +import org.jetbrains.annotations.NotNull; + +/** + * @author peter + */ +public class JavaVariableFindUsagesOptions extends JavaFindUsagesOptions { + public boolean isReadAccess = false; + public boolean isWriteAccess = false; + + public JavaVariableFindUsagesOptions(@NotNull Project project) { + super(project); + isSearchForTextOccurrences = false; + } + + public boolean equals(final Object o) { + if (this == o) return true; + if (!super.equals(this)) return false; + if (o == null || getClass() != o.getClass()) return false; + + final JavaVariableFindUsagesOptions that = (JavaVariableFindUsagesOptions)o; + + if (isReadAccess != that.isReadAccess) return false; + if (isWriteAccess != that.isWriteAccess) return false; + + return true; + } + + public int hashCode() { + int result = super.hashCode(); + result = 31 * result + (isReadAccess ? 1 : 0); + result = 31 * result + (isWriteAccess ? 1 : 0); + return result; + } + +} diff --git a/platform/lang-impl/src/com/intellij/find/findUsages/FindUsagesOptions.java b/platform/lang-impl/src/com/intellij/find/findUsages/FindUsagesOptions.java index 1591efd3c988..1c01130562e6 100644 --- a/platform/lang-impl/src/com/intellij/find/findUsages/FindUsagesOptions.java +++ b/platform/lang-impl/src/com/intellij/find/findUsages/FindUsagesOptions.java @@ -42,6 +42,10 @@ public class FindUsagesOptions extends UserDataHolderBase implements Cloneable { public boolean isUsages = false; public SearchRequestCollector fastTrack = null; + public FindUsagesOptions(@NotNull Project project) { + this(project, null); + } + public FindUsagesOptions(@NotNull Project project, @Nullable final DataContext dataContext) { String defaultScopeName = FindSettings.getInstance().getDefaultScopeName(); List predefined = ScopeChooserCombo.getPredefinedScopes(project, dataContext, true, false, false, false); diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/findUsages/GroovyFindUsagesHandlerFactory.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/findUsages/GroovyFindUsagesHandlerFactory.java index 9cfce6d91006..d3cbc97a606c 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/findUsages/GroovyFindUsagesHandlerFactory.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/findUsages/GroovyFindUsagesHandlerFactory.java @@ -52,8 +52,7 @@ public class GroovyFindUsagesHandlerFactory extends JavaFindUsagesHandlerFactory @Override public FindUsagesHandler createFindUsagesHandler(@NotNull PsiElement element, boolean forHighlightUsages) { - return new JavaFindUsagesHandler(element, getFindClassOptions(), getFindMethodOptions(), getFindPackageOptions(), getFindThrowOptions(), - getFindVariableOptions()) { + return new JavaFindUsagesHandler(element, this) { @NotNull @Override public PsiElement[] getSecondaryElements() {