diff --git a/java/idea-ui/src/com/intellij/framework/library/DownloadableLibraryTypeBase.java b/java/idea-ui/src/com/intellij/framework/library/DownloadableLibraryTypeBase.java index 8bb6b82b60f5..a3b54aa69713 100644 --- a/java/idea-ui/src/com/intellij/framework/library/DownloadableLibraryTypeBase.java +++ b/java/idea-ui/src/com/intellij/framework/library/DownloadableLibraryTypeBase.java @@ -34,7 +34,7 @@ public abstract class DownloadableLibraryTypeBase extends DownloadableLibraryTyp @NotNull String groupId, @NotNull Icon icon, @NotNull URL... localUrls) { - super(new PersistentLibraryKind(libraryTypeId, false) { + super(new PersistentLibraryKind(libraryTypeId) { @NotNull @Override public LibraryVersionProperties createDefaultProperties() { diff --git a/java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/libraryEditor/ItemElementDescriptor.java b/java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/libraryEditor/ItemElementDescriptor.java index 15f28ee10549..aba61f0ce177 100644 --- a/java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/libraryEditor/ItemElementDescriptor.java +++ b/java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/libraryEditor/ItemElementDescriptor.java @@ -37,7 +37,7 @@ class ItemElementDescriptor extends NodeDescriptor { myElement = element; final String url = element.getUrl(); myName = getPresentablePath(url).replace('/', File.separatorChar); - myIcon = getIconForUrl(url, element.isValid(), element.isJarDirectory()); + setIcon(getIconForUrl(url, element.isValid(), element.isJarDirectory())); } public boolean update() { diff --git a/java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/libraryEditor/OrderRootTypeElementDescriptor.java b/java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/libraryEditor/OrderRootTypeElementDescriptor.java index cd179217f421..edc55c74e7a8 100644 --- a/java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/libraryEditor/OrderRootTypeElementDescriptor.java +++ b/java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/libraryEditor/OrderRootTypeElementDescriptor.java @@ -26,7 +26,7 @@ public class OrderRootTypeElementDescriptor extends NodeDescriptor { + public static class OverrideableSpace extends TailTypeDecorator { private final TailType myTail; public OverrideableSpace(LookupElement keyword, TailType tail) { diff --git a/java/java-impl/src/com/intellij/codeInspection/magicConstant/MagicConstantInspection.java b/java/java-impl/src/com/intellij/codeInspection/magicConstant/MagicConstantInspection.java index 0d5f66a5964a..a349d47bf869 100644 --- a/java/java-impl/src/com/intellij/codeInspection/magicConstant/MagicConstantInspection.java +++ b/java/java-impl/src/com/intellij/codeInspection/magicConstant/MagicConstantInspection.java @@ -19,12 +19,9 @@ import com.intellij.analysis.AnalysisScope; import com.intellij.codeInsight.AnnotationUtil; import com.intellij.codeInsight.ExternalAnnotationsManager; import com.intellij.codeInsight.daemon.GroupNames; -import com.intellij.codeInspection.BaseJavaLocalInspectionTool; -import com.intellij.codeInspection.LocalInspectionToolSession; -import com.intellij.codeInspection.ProblemsHolder; +import com.intellij.codeInspection.*; import com.intellij.ide.util.treeView.AbstractTreeNode; import com.intellij.openapi.application.ApplicationManager; -import com.intellij.openapi.application.ModalityState; import com.intellij.openapi.application.PathManager; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.project.Project; @@ -88,8 +85,12 @@ public class MagicConstantInspection extends BaseJavaLocalInspectionTool { public PsiElementVisitor buildVisitor(@NotNull final ProblemsHolder holder, boolean isOnTheFly, @NotNull LocalInspectionToolSession session) { - checkAnnotationsJarAttached(session); return new JavaElementVisitor() { + @Override + public void visitJavaFile(PsiJavaFile file) { + checkAnnotationsJarAttached(file, holder); + } + @Override public void visitCallExpression(PsiCallExpression callExpression) { checkCall(callExpression, holder); @@ -156,8 +157,7 @@ public class MagicConstantInspection extends BaseJavaLocalInspectionTool { }; } - private static void checkAnnotationsJarAttached(@NotNull LocalInspectionToolSession session) { - PsiFile file = session.getFile(); + private static void checkAnnotationsJarAttached(@NotNull PsiFile file, @NotNull ProblemsHolder holder) { final Project project = file.getProject(); PsiClass event = JavaPsiFacade.getInstance(project).findClass("java.awt.event.InputEvent", GlobalSearchScope.allScope(project)); if (event == null) return; // no jdk to attach @@ -177,24 +177,36 @@ public class MagicConstantInspection extends BaseJavaLocalInspectionTool { } } if (jdk == null) return; // no jdk to attach + final Sdk finalJdk = jdk; - if (!ApplicationManager.getApplication().isUnitTestMode()) { - final Sdk finalJdk = jdk; - ApplicationManager.getApplication().invokeLater(new Runnable() { - @Override - public void run() { - ApplicationManager.getApplication().runWriteAction(new Runnable() { - @Override - public void run() { - attachJdkAnnotations(finalJdk); - } - }); - } - }, ModalityState.NON_MODAL, project.getDisposed()); - } + String path = finalJdk.getHomePath(); + String text = "No annotations attached to the JDK " + finalJdk.getName() + (path == null ? "" : " (" + FileUtil.toSystemDependentName(path) + ")"); + holder.registerProblem(file, text, ProblemHighlightType.GENERIC_ERROR_OR_WARNING, new LocalQuickFix() { + @NotNull + @Override + public String getName() { + return "Attach annotations to the JDK"; + } + + @NotNull + @Override + public String getFamilyName() { + return getName(); + } + + @Override + public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { + ApplicationManager.getApplication().runWriteAction(new Runnable() { + @Override + public void run() { + attachJdkAnnotations(finalJdk); + } + }); + } + }); } - private static void attachJdkAnnotations(Sdk jdk) { + private static void attachJdkAnnotations(@NotNull Sdk jdk) { LocalFileSystem lfs = LocalFileSystem.getInstance(); // community idea under idea VirtualFile root = lfs.findFileByPath(FileUtil.toSystemIndependentName(PathManager.getHomePath()) + "/java/jdkAnnotations"); @@ -282,7 +294,7 @@ public class MagicConstantInspection extends BaseJavaLocalInspectionTool { } @Override public int hashCode() { - int result = values != null ? Arrays.hashCode(values) : 0; + int result = Arrays.hashCode(values); result = 31 * result + (canBeOred ? 1 : 0); return result; } diff --git a/java/java-impl/src/com/intellij/ide/hierarchy/call/CallHierarchyNodeDescriptor.java b/java/java-impl/src/com/intellij/ide/hierarchy/call/CallHierarchyNodeDescriptor.java index 092bafb4b38e..c5847afc8a01 100644 --- a/java/java-impl/src/com/intellij/ide/hierarchy/call/CallHierarchyNodeDescriptor.java +++ b/java/java-impl/src/com/intellij/ide/hierarchy/call/CallHierarchyNodeDescriptor.java @@ -90,7 +90,7 @@ public final class CallHierarchyNodeDescriptor extends HierarchyNodeDescriptor i public final boolean update(){ final CompositeAppearance oldText = myHighlightedText; - final Icon oldIcon = myIcon; + final Icon oldIcon = getIcon(); int flags = Iconable.ICON_FLAG_VISIBILITY; if (isMarkReadOnly()) { @@ -109,13 +109,14 @@ public final class CallHierarchyNodeDescriptor extends HierarchyNodeDescriptor i return true; } - myIcon = enclosingElement.getIcon(flags); + Icon newIcon = enclosingElement.getIcon(flags); if (changes && myIsBase) { final LayeredIcon icon = new LayeredIcon(2); - icon.setIcon(myIcon, 0); + icon.setIcon(newIcon, 0); icon.setIcon(AllIcons.Hierarchy.Base, 1, -AllIcons.Hierarchy.Base.getIconWidth() / 2, 0); - myIcon = icon; + newIcon = icon; } + setIcon(newIcon); myHighlightedText = new CompositeAppearance(); TextAttributes mainTextAttributes = null; @@ -168,7 +169,7 @@ public final class CallHierarchyNodeDescriptor extends HierarchyNodeDescriptor i if ( !Comparing.equal(myHighlightedText, oldText) || - !Comparing.equal(myIcon, oldIcon) + !Comparing.equal(getIcon(), oldIcon) ){ changes = true; } diff --git a/java/java-impl/src/com/intellij/ide/hierarchy/method/MethodHierarchyNodeDescriptor.java b/java/java-impl/src/com/intellij/ide/hierarchy/method/MethodHierarchyNodeDescriptor.java index 103a233c2805..3e0a0e164dd7 100644 --- a/java/java-impl/src/com/intellij/ide/hierarchy/method/MethodHierarchyNodeDescriptor.java +++ b/java/java-impl/src/com/intellij/ide/hierarchy/method/MethodHierarchyNodeDescriptor.java @@ -123,7 +123,7 @@ public final class MethodHierarchyNodeDescriptor extends HierarchyNodeDescriptor newIcon = icon; } - myIcon = newIcon; + setIcon(newIcon); } final CompositeAppearance oldText = myHighlightedText; diff --git a/java/java-impl/src/com/intellij/ide/hierarchy/type/TypeHierarchyNodeDescriptor.java b/java/java-impl/src/com/intellij/ide/hierarchy/type/TypeHierarchyNodeDescriptor.java index ed1eff86cb2f..042326439e34 100644 --- a/java/java-impl/src/com/intellij/ide/hierarchy/type/TypeHierarchyNodeDescriptor.java +++ b/java/java-impl/src/com/intellij/ide/hierarchy/type/TypeHierarchyNodeDescriptor.java @@ -56,9 +56,9 @@ public final class TypeHierarchyNodeDescriptor extends HierarchyNodeDescriptor { if (changes && myIsBase) { final LayeredIcon icon = new LayeredIcon(2); - icon.setIcon(myIcon, 0); + icon.setIcon(getIcon(), 0); icon.setIcon(AllIcons.Hierarchy.Base, 1, -AllIcons.Hierarchy.Base.getIconWidth() / 2, 0); - myIcon = icon; + setIcon(icon); } final PsiClass psiClass = getPsiClass(); diff --git a/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaRearranger.java b/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaRearranger.java index 462b4efbc455..e24f27fb89a3 100644 --- a/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaRearranger.java +++ b/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaRearranger.java @@ -21,6 +21,7 @@ import com.intellij.openapi.util.TextRange; import com.intellij.psi.PsiElement; import com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryType; import com.intellij.psi.codeStyle.arrangement.match.ArrangementModifier; +import com.intellij.psi.codeStyle.arrangement.match.StdArrangementEntryMatcher; import com.intellij.psi.codeStyle.arrangement.model.*; import com.intellij.psi.codeStyle.arrangement.settings.ArrangementConditionsGrouper; import com.intellij.psi.codeStyle.arrangement.settings.ArrangementStandardSettingsAware; @@ -67,6 +68,42 @@ public class JavaRearranger implements Rearranger, MODIFIERS_BY_TYPE.put(FIELD, concat(commonModifiers, TRANSIENT, VOLATILE)); } + private static final List DEFAULT_RULES = new ArrayList(); + static { + ArrangementModifier[] visibility = {PUBLIC, PROTECTED, PACKAGE_PRIVATE, PRIVATE}; + for (ArrangementModifier modifier : visibility) { + and(FIELD, STATIC, FINAL, modifier); + } + for (ArrangementModifier modifier : visibility) { + and(FIELD, STATIC, modifier); + } + for (ArrangementModifier modifier : visibility) { + and(FIELD, FINAL, modifier); + } + for (ArrangementModifier modifier : visibility) { + and(FIELD, modifier); + } + and(METHOD); + and(ENUM); + and(INTERFACE); + and(CLASS); + } + + private static void and(@NotNull Object... conditions) { + if (conditions.length == 1) { + DEFAULT_RULES.add(new StdArrangementRule(new StdArrangementEntryMatcher(new ArrangementAtomMatchCondition( + ArrangementUtil.parseType(conditions[0]), conditions[0] + )))); + return; + } + + ArrangementCompositeMatchCondition composite = new ArrangementCompositeMatchCondition(ArrangementOperator.AND); + for (Object condition : conditions) { + composite.addOperand(new ArrangementAtomMatchCondition(ArrangementUtil.parseType(condition), condition)); + } + DEFAULT_RULES.add(new StdArrangementRule(new StdArrangementEntryMatcher(composite))); + } + @NotNull private static Set concat(@NotNull Set base, ArrangementModifier... modifiers) { EnumSet result = EnumSet.copyOf(base); @@ -169,4 +206,10 @@ public class JavaRearranger implements Rearranger, }); return result.get(); } + + @Nullable + @Override + public List getDefaultRules() { + return DEFAULT_RULES; + } } diff --git a/java/java-impl/src/com/intellij/refactoring/rename/RenameJavaMemberProcessor.java b/java/java-impl/src/com/intellij/refactoring/rename/RenameJavaMemberProcessor.java index f24207a89585..f0c8ec34d296 100644 --- a/java/java-impl/src/com/intellij/refactoring/rename/RenameJavaMemberProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/rename/RenameJavaMemberProcessor.java @@ -37,7 +37,7 @@ import java.util.Set; public abstract class RenameJavaMemberProcessor extends RenamePsiElementProcessor { private static final Logger LOG = Logger.getInstance("#com.intellij.refactoring.rename.RenameJavaMemberProcessor"); - protected static void qualifyMember(PsiMember member, PsiElement occurence, String newName) throws IncorrectOperationException { + public static void qualifyMember(PsiMember member, PsiElement occurence, String newName) throws IncorrectOperationException { qualifyMember(occurence, newName, member.getContainingClass(), member.hasModifierProperty(PsiModifier.STATIC)); } diff --git a/java/java-impl/src/com/intellij/refactoring/rename/inplace/JavaResolveSnapshot.java b/java/java-impl/src/com/intellij/refactoring/rename/inplace/JavaResolveSnapshot.java index 074b03d841ee..bd1c657d813f 100644 --- a/java/java-impl/src/com/intellij/refactoring/rename/inplace/JavaResolveSnapshot.java +++ b/java/java-impl/src/com/intellij/refactoring/rename/inplace/JavaResolveSnapshot.java @@ -20,6 +20,7 @@ import com.intellij.openapi.editor.Document; import com.intellij.openapi.project.Project; import com.intellij.psi.*; import com.intellij.psi.util.PsiTreeUtil; +import com.intellij.refactoring.rename.RenameJavaMemberProcessor; import com.intellij.refactoring.util.RefactoringUtil; import com.intellij.util.IncorrectOperationException; import com.intellij.util.containers.HashMap; @@ -74,28 +75,7 @@ class JavaResolveSnapshot extends ResolveSnapshotProvider.ResolveSnapshot { if (!ref.isQualified() && hidingLocalName.equals(ref.getReferenceName())) { final PsiElement newlyResolved = ref.resolve(); if (referee.getManager().areElementsEquivalent(newlyResolved, referee)) return; - PsiClass refereeClass = ((PsiField) referee).getContainingClass(); - PsiClass referentClass = PsiTreeUtil.getParentOfType(referent, PsiClass.class); - if (refereeClass != null && referentClass != null && - PsiTreeUtil.isAncestor(refereeClass, referentClass, false)) { - if (refereeClass == referentClass || - refereeClass.getName() != null) { //otherwise cannot qualify anonymous referee class - @NonNls String qualifer; - if (RefactoringUtil.isInStaticContext(ref, refereeClass)) { - qualifer = refereeClass.getName(); - } else { - qualifer = refereeClass == referentClass ? "this" : refereeClass.getName() + ".this"; - } - String qualifiedRefText = qualifer + "." + ref.getText(); - PsiElementFactory elementFactory = JavaPsiFacade.getInstance(referentClass.getProject()).getElementFactory(); - try { - PsiReferenceExpression qualifiedRef = (PsiReferenceExpression) elementFactory.createExpressionFromText(qualifiedRefText, null); - ref.replace(qualifiedRef); - } catch (IncorrectOperationException e) { - LOG.error(e); - } - } - } + RenameJavaMemberProcessor.qualifyMember((PsiField)referee, referent, hidingLocalName); } } } diff --git a/java/java-impl/src/com/intellij/refactoring/rename/naming/AutomaticVariableRenamer.java b/java/java-impl/src/com/intellij/refactoring/rename/naming/AutomaticVariableRenamer.java index 6796b02445ee..ff2375dbdb63 100644 --- a/java/java-impl/src/com/intellij/refactoring/rename/naming/AutomaticVariableRenamer.java +++ b/java/java-impl/src/com/intellij/refactoring/rename/naming/AutomaticVariableRenamer.java @@ -39,6 +39,7 @@ public class AutomaticVariableRenamer extends AutomaticRenamer { private final Set myToUnpluralize = new HashSet(); public AutomaticVariableRenamer(PsiClass aClass, String newClassName, Collection usages) { + final String oldClassName = aClass.getName(); for (final UsageInfo info : usages) { final PsiElement element = info.getElement(); if (!(element instanceof PsiJavaCodeReferenceElement)) continue; @@ -46,23 +47,23 @@ public class AutomaticVariableRenamer extends AutomaticRenamer { if (statement != null) { for(PsiElement declaredElement: statement.getDeclaredElements()) { if (declaredElement instanceof PsiVariable) { - checkRenameVariable(element, (PsiVariable) declaredElement); + checkRenameVariable(element, (PsiVariable) declaredElement, oldClassName); } } } else { PsiVariable variable = PsiTreeUtil.getParentOfType(element, PsiVariable.class); if (variable != null) { - checkRenameVariable(element, variable); + checkRenameVariable(element, variable, oldClassName); if (variable instanceof PsiField) { for(PsiField field: getFieldsInSameDeclaration((PsiField) variable)) { - checkRenameVariable(element, field); + checkRenameVariable(element, field, oldClassName); } } } } } - suggestAllNames(aClass.getName(), newClassName); + suggestAllNames(oldClassName, newClassName); } private static List getFieldsInSameDeclaration(final PsiField variable) { @@ -81,11 +82,13 @@ public class AutomaticVariableRenamer extends AutomaticRenamer { return result; } - private void checkRenameVariable(final PsiElement element, final PsiVariable variable) { + private void checkRenameVariable(final PsiElement element, final PsiVariable variable, final String oldClassName) { final PsiTypeElement typeElement = variable.getTypeElement(); if (typeElement == null) return; final PsiJavaCodeReferenceElement ref = typeElement.getInnermostComponentReferenceElement(); if (ref == null) return; + final String variableName = variable.getName(); + if (variableName != null && !StringUtil.containsIgnoreCase(variableName, oldClassName)) return; if (ref.equals(element)) { myElements.add(variable); if (variable.getType() instanceof PsiArrayType) { diff --git a/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java b/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java index 54dcde0d0566..f7d47c8088d1 100644 --- a/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java +++ b/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java @@ -262,7 +262,16 @@ public class LambdaUtil { public static boolean dependsOnTypeParams(PsiType type, PsiLambdaExpression expr, PsiTypeParameter param2Check) { - final TypeParamsChecker visitor = new TypeParamsChecker(expr); + return depends(type, param2Check, new TypeParamsChecker(expr)); + } + + public static boolean dependsOnTypeParams(PsiType type, + PsiClass aClass, + PsiMethod aMethod) { + return depends(type, null, new TypeParamsChecker(aMethod, aClass)); + } + + private static boolean depends(PsiType type, PsiTypeParameter param2Check, TypeParamsChecker visitor) { if (!visitor.startedInference()) return false; final Boolean accept = type.accept(visitor); if (param2Check != null) { @@ -328,8 +337,8 @@ public class LambdaUtil { } final PsiElement gParent = expressionList.getParent(); - if (gParent instanceof PsiMethodCallExpression) { - final PsiMethodCallExpression contextCall = (PsiMethodCallExpression)gParent; + if (gParent instanceof PsiCallExpression) { + final PsiCallExpression contextCall = (PsiCallExpression)gParent; final JavaResolveResult resolveResult = contextCall.resolveMethodGenerics(); final PsiElement resolve = resolveResult.getElement(); if (resolve instanceof PsiMethod) { @@ -403,6 +412,11 @@ public class LambdaUtil { private final PsiClass myClass; private final Set myUsedTypeParams = new HashSet(); + private TypeParamsChecker(PsiMethod method, PsiClass aClass) { + myMethod = method; + myClass = aClass; + } + public TypeParamsChecker(PsiLambdaExpression expression) { myClass = PsiUtil.resolveGenericsClassInType(getFunctionalInterfaceType(expression, false)).getElement(); PsiElement parent = expression.getParent(); diff --git a/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java b/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java index 119848351dd4..c706017ec1f5 100644 --- a/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java +++ b/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaMethodsConflictResolver.java @@ -106,8 +106,21 @@ public class JavaMethodsConflictResolver implements PsiConflictResolver{ if (method != null) { final PsiParameter[] methodParameters = method.getParameterList().getParameters(); final PsiParameter param = i < methodParameters.length ? methodParameters[i] : methodParameters[methodParameters.length - 1]; - if (!LambdaUtil.isAcceptable(lambdaExpression, param.getType())) { + final PsiType paramType = param.getType(); + if (!LambdaUtil.isAcceptable(lambdaExpression, paramType)) { iterator.remove(); + } else { + /*todo + final PsiClassType.ClassResolveResult resolveResult = PsiUtil.resolveGenericsClassInType(paramType); + final PsiMethod functionalInterfaceMethod = LambdaUtil.getFunctionalInterfaceMethod(paramType); + if (functionalInterfaceMethod != null) { + for (PsiParameter parameter : functionalInterfaceMethod.getParameterList().getParameters()) { + if (LambdaUtil.dependsOnTypeParams(resolveResult.getSubstitutor().substitute(parameter.getType()), resolveResult.getElement(), method)) { + iterator.remove(); + break; + } + } + }*/ } } } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/Ambiguity2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/Ambiguity2.java new file mode 100644 index 000000000000..7e41c5ba7f2e --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/Ambiguity2.java @@ -0,0 +1,207 @@ +/* + * Copyright 2000-2012 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. + */ + +import java.util.*; + +class Test { + interface Foo { + void foo(T t); + } + + interface IntFoo { + void foo(int i); + } + + interface ObjectFoo { + void foo(int i); + } + + interface FooList { + void foo(List tList); + } + + void f(Foo foo) { + System.out.println("Foo"); + } + + void f(FooList foo) { + System.out.println("FooList"); + } + /*void f(IntFoo foo) { + System.out.println("IntFoo"); + }*/ + + /*void f(ObjectFoo foo) { + System.out.println("ObjectFoo"); + }*/ + + public static void main(String[] args) { + new Test().f(null); + new Test().f(x -> {}); + } +} + +class Test1 { + interface Foo { + void foo(T t); + } + + interface IntFoo { + void foo(int i); + } + + interface ObjectFoo { + void foo(int i); + } + + interface FooList { + void foo(List tList); + } + + void f(Foo foo) { + System.out.println("Foo"); + } + + void f(FooList foo) { + System.out.println("FooList"); + } + + void f(IntFoo foo) { + System.out.println("IntFoo"); + } + + /*void f(ObjectFoo foo) { + System.out.println("ObjectFoo"); + }*/ + + public static void main(String[] args) { + new Test1().f(null); + new Test1().f(x -> {}); + } +} + +class Test2 { + interface Foo { + void foo(T t); + } + + interface IntFoo { + void foo(int i); + } + + interface ObjectFoo { + void foo(int i); + } + + interface FooList { + void foo(List tList); + } + + void f(Foo foo) { + System.out.println("Foo"); + } + + void f(FooList foo) { + System.out.println("FooList"); + } + void f(IntFoo foo) { + System.out.println("IntFoo"); + } + + void f(ObjectFoo foo) { + System.out.println("ObjectFoo"); + } + + public static void main(String[] args) { + new Test2().f(null); + new Test2().f(x -> {}); + } +} + + +class Test3 { + interface Foo { + void foo(T t); + } + + interface IntFoo { + void foo(int i); + } + + interface ObjectFoo { + void foo(int i); + } + + interface FooList { + void foo(List tList); + } + + void f(Foo foo) { + System.out.println("Foo"); + } + + void f(FooList foo) { + System.out.println("FooList"); + } + /*void f(IntFoo foo) { + System.out.println("IntFoo"); + }*/ + + void f(ObjectFoo foo) { + System.out.println("ObjectFoo"); + } + + public static void main(String[] args) { + new Test3().f(null); + new Test3().f(x -> {}); + } +} + + +class Test { + interface Foo { + void foo(T t, T t1); + } + interface Foo1 { + void foo(T t, String t1); + } + interface Foo2 { + void foo(String t, String t1); + } + + void f(Foo foo) { + System.out.println("Foo"); + } + + void f(Foo1 foo) { + System.out.println("FooList"); + } + void f(Foo2 foo) { + System.out.println("FooList"); + } + public static void main(String[] args) { + new Test().f((String x, String y) -> {}); + } +} + + + + + + + + + diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/TypeArgsConsistencyMisc2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/TypeArgsConsistencyMisc2.java index 03054e759060..a544348dea64 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/TypeArgsConsistencyMisc2.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/TypeArgsConsistencyMisc2.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - +import java.util.*; class Test1 { { Comparable c = (Integer o)->{ @@ -46,3 +46,13 @@ class Test2 { } } +class TestNewExpression { + public TestNewExpression(Comparator comparator) { + //some code + } + public static void main(String[] args) { + TestNewExpression strs = new TestNewExpression((o1, o2) -> { + return o2.compareToIgnoreCase(o1); + }); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterComparable.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterComparable.java index 796facea0b6e..c4186c9efb5e 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterComparable.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterComparable.java @@ -1,7 +1,7 @@ // "Replace with lambda" "true" class Test { { - Comparable c = o->{ + Comparable c = o -> { return 0; }; } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterComparableNeedToBeFinal.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterComparableNeedToBeFinal.java index 89fb61af4415..14128b82d518 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterComparableNeedToBeFinal.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterComparableNeedToBeFinal.java @@ -1,7 +1,7 @@ // "Replace with lambda" "true" class Test { { - Comparable c = o->{ + Comparable c = o -> { Runnable r = new Runnable() { @Override public void run() { diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterFormalTypes.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterFormalTypes.java index abca2a8fe10c..d6372aa4b089 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterFormalTypes.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterFormalTypes.java @@ -9,7 +9,7 @@ class Test2 { static I bar(I i){return i;} { - bar((List list)->{ + bar((List list) -> { return null; //To change body of implemented methods use File | Settings | File Templates. }); } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterRunnable.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterRunnable.java index 8dd623c95780..e361f202ca4f 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterRunnable.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterRunnable.java @@ -1,7 +1,7 @@ // "Replace with lambda" "true" class Test { { - Runnable r = ()->{ + Runnable r = () -> { System.out.println(""); }; } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterRunnableInArrayInitializer.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterRunnableInArrayInitializer.java index cc46e26e1bf7..61172027433a 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterRunnableInArrayInitializer.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/anonymous2lambda/afterRunnableInArrayInitializer.java @@ -1,7 +1,7 @@ // "Replace with lambda" "true" class Test { { - Runnable[] r = new Runnable[] {()->{ + Runnable[] r = new Runnable[] {() -> { System.out.println(""); }}; } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterAssignment.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterAssignment.java index 91ad98052b5f..dd9055e78ecb 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterAssignment.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterAssignment.java @@ -1,6 +1,6 @@ // "Remove redundant types" "true" class Test { { - Comparable r = o-> 1; + Comparable r = o -> 1; } } \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterCallWithTypeArgs.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterCallWithTypeArgs.java index 872ebab8624c..e1b619590a18 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterCallWithTypeArgs.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterCallWithTypeArgs.java @@ -11,6 +11,6 @@ class Test2 { static I bar(I i){return i;} { - Test2.bar(y-> y.t); + Test2.bar(y -> y.t); } } \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterInferredFromOtherArgs.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterInferredFromOtherArgs.java index 7e5d950f7665..0b4c56a12d9c 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterInferredFromOtherArgs.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterInferredFromOtherArgs.java @@ -10,6 +10,6 @@ class ReturnTypeCompatibility { } public static void main(String[] args) { - call("", i-> ""); + call("", i -> ""); } } \ No newline at end of file diff --git a/java/java-tests/testData/refactoring/introduceVariable/LambdaExpr.after.java b/java/java-tests/testData/refactoring/introduceVariable/LambdaExpr.after.java index 39338e0ef223..5858567d4d88 100644 --- a/java/java-tests/testData/refactoring/introduceVariable/LambdaExpr.after.java +++ b/java/java-tests/testData/refactoring/introduceVariable/LambdaExpr.after.java @@ -4,7 +4,7 @@ interface SAM { class Foo { void test() { - SAM c = (i, j)->i + j; + SAM c = (i, j) -> i + j; m(c); } void m(SAM s) { } diff --git a/java/java-tests/testData/refactoring/introduceVariable/LambdaExprNotAccepted.after.java b/java/java-tests/testData/refactoring/introduceVariable/LambdaExprNotAccepted.after.java index f297b9e364b5..e8d77020330b 100644 --- a/java/java-tests/testData/refactoring/introduceVariable/LambdaExprNotAccepted.after.java +++ b/java/java-tests/testData/refactoring/introduceVariable/LambdaExprNotAccepted.after.java @@ -4,7 +4,7 @@ interface SAM { class Foo { void test() { - SAM c = (i, j)->"" + i + j; + SAM c = (i, j) -> "" + i + j; SAM s3 = m(c); } SAM m(SAM s) { return null; } diff --git a/java/java-tests/testData/refactoring/renameLocal/RenameInPlaceThisNeeded.java b/java/java-tests/testData/refactoring/renameLocal/RenameInPlaceThisNeeded.java new file mode 100644 index 000000000000..2e4c855edf6b --- /dev/null +++ b/java/java-tests/testData/refactoring/renameLocal/RenameInPlaceThisNeeded.java @@ -0,0 +1,25 @@ +/* + * Copyright 2000-2012 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. + */ +class Test1 { + class A { + int a; + } + class B extends A { + B(int b) { + a = b; + } + } +} diff --git a/java/java-tests/testData/refactoring/renameLocal/RenameInPlaceThisNeeded_after.java b/java/java-tests/testData/refactoring/renameLocal/RenameInPlaceThisNeeded_after.java new file mode 100644 index 000000000000..dcb10a8e5af0 --- /dev/null +++ b/java/java-tests/testData/refactoring/renameLocal/RenameInPlaceThisNeeded_after.java @@ -0,0 +1,25 @@ +/* + * Copyright 2000-2012 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. + */ +class Test1 { + class A { + int a; + } + class B extends A { + B(int a) { + this.a = a; + } + } +} diff --git a/java/java-tests/testSrc/com/intellij/application/options/codeStyle/arrangement/AbstractArrangementRuleEditingModelTest.java b/java/java-tests/testSrc/com/intellij/application/options/codeStyle/arrangement/AbstractArrangementRuleEditingModelTest.java index f8226e985767..149dc2c8371a 100644 --- a/java/java-tests/testSrc/com/intellij/application/options/codeStyle/arrangement/AbstractArrangementRuleEditingModelTest.java +++ b/java/java-tests/testSrc/com/intellij/application/options/codeStyle/arrangement/AbstractArrangementRuleEditingModelTest.java @@ -17,8 +17,10 @@ package com.intellij.application.options.codeStyle.arrangement; import com.intellij.openapi.util.Pair; import com.intellij.psi.codeStyle.arrangement.JavaRearranger; +import com.intellij.psi.codeStyle.arrangement.StdArrangementRule; import com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryType; import com.intellij.psi.codeStyle.arrangement.match.ArrangementModifier; +import com.intellij.psi.codeStyle.arrangement.match.StdArrangementEntryMatcher; import com.intellij.psi.codeStyle.arrangement.model.ArrangementAtomMatchCondition; import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition; import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingType; @@ -57,7 +59,9 @@ public abstract class AbstractArrangementRuleEditingModelTest { } protected void configure(@NotNull ArrangementMatchCondition matchCondition) { - Pair pair = myBuilder.build(matchCondition, myTree, myRoot, null, myGrouper); + Pair pair = myBuilder.build( + new StdArrangementRule(new StdArrangementEntryMatcher(matchCondition)), myTree, myRoot, null, myGrouper + ); myRowMappings.put(pair.first.getRow(), pair.first); } diff --git a/java/java-tests/testSrc/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModelImplTest.java b/java/java-tests/testSrc/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModelImplTest.java index 458d70b42f27..87b91a6e16e9 100644 --- a/java/java-tests/testSrc/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModelImplTest.java +++ b/java/java-tests/testSrc/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModelImplTest.java @@ -42,7 +42,7 @@ public class ArrangementRuleEditingModelImplTest extends AbstractArrangementRule assertNotNull(child); ArrangementMatchCondition expectedMatchCondition = and(atom(PUBLIC), atom(STATIC)); assertEquals(expectedMatchCondition, child.getBackingCondition()); - assertEquals(expectedMatchCondition, model.getMatchCondition()); + assertEquals(expectedMatchCondition, model.getCondition()); } @Test @@ -55,7 +55,7 @@ public class ArrangementRuleEditingModelImplTest extends AbstractArrangementRule model.addAndCondition(atom(FIELD)); assertEquals(2, model.getRow()); - assertEquals(and(atom(FIELD), atom(PUBLIC)), model.getMatchCondition()); + assertEquals(and(atom(FIELD), atom(PUBLIC)), model.getCondition()); ArrangementTreeNode fieldNode = myRoot.getFirstChild(); assertNotNull(fieldNode); @@ -77,7 +77,7 @@ public class ArrangementRuleEditingModelImplTest extends AbstractArrangementRule assertEquals(1, myRowMappings.size()); assertSame(model, myRowMappings.get(2)); - assertEquals(and(atom(FIELD), atom(PUBLIC), atom(STATIC)), model.getMatchCondition()); + assertEquals(and(atom(FIELD), atom(PUBLIC), atom(STATIC)), model.getCondition()); ArrangementTreeNode fieldNode = myRoot.getFirstChild(); assertNotNull(fieldNode); @@ -99,7 +99,7 @@ public class ArrangementRuleEditingModelImplTest extends AbstractArrangementRule assertEquals(1, myRowMappings.size()); assertSame(model, myRowMappings.get(2)); - assertEquals(and(atom(FIELD), atom(STATIC)), model.getMatchCondition()); + assertEquals(and(atom(FIELD), atom(STATIC)), model.getCondition()); ArrangementTreeNode fieldNode = myRoot.getFirstChild(); assertNotNull(fieldNode); @@ -122,7 +122,7 @@ public class ArrangementRuleEditingModelImplTest extends AbstractArrangementRule model.removeAndCondition(atom(PUBLIC)); assertEquals(1, model.getRow()); - assertEquals(atom(FIELD), model.getMatchCondition()); + assertEquals(atom(FIELD), model.getCondition()); ArrangementTreeNode fieldNode = myRoot.getFirstChild(); assertNotNull(fieldNode); @@ -146,10 +146,10 @@ public class ArrangementRuleEditingModelImplTest extends AbstractArrangementRule modelToChange.removeAndCondition(atom(PUBLIC)); assertSame(1, modelToChange.getRow()); - assertEquals(atom(FIELD), modelToChange.getMatchCondition()); + assertEquals(atom(FIELD), modelToChange.getCondition()); assertSame(3, siblingModel.getRow()); - assertEquals(and(atom(FIELD), atom(STATIC)), siblingModel.getMatchCondition()); + assertEquals(and(atom(FIELD), atom(STATIC)), siblingModel.getCondition()); ArrangementTreeNode atomFieldNode = myRoot.getFirstChild(); assertNotNull(atomFieldNode); @@ -180,10 +180,10 @@ public class ArrangementRuleEditingModelImplTest extends AbstractArrangementRule assertEquals(2, myRowMappings.size()); assertSame(siblingModel, myRowMappings.get(2)); - assertEquals(and(atom(FIELD), atom(PUBLIC)), siblingModel.getMatchCondition()); + assertEquals(and(atom(FIELD), atom(PUBLIC)), siblingModel.getCondition()); assertSame(modelToChange, myRowMappings.get(3)); - assertEquals(atom(FIELD), modelToChange.getMatchCondition()); + assertEquals(atom(FIELD), modelToChange.getCondition()); ArrangementTreeNode compositeFieldNode = myRoot.getFirstChild(); assertNotNull(compositeFieldNode); diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java index cdcb57152409..210ceefe15ca 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaHighlightingTest.java @@ -72,6 +72,10 @@ public class LambdaHighlightingTest extends LightDaemonAnalyzerTestCase { public void testAmbiguity1() throws Exception { doTest(); } + + public void _testAmbiguity2() throws Exception { + doTest(); + } public void testAmbiguityVarargs() throws Exception { doTest(); diff --git a/java/java-tests/testSrc/com/intellij/roots/DirectoryIndexImplTest.java b/java/java-tests/testSrc/com/intellij/openapi/roots/impl/DirectoryIndexImplTest.java similarity index 91% rename from java/java-tests/testSrc/com/intellij/roots/DirectoryIndexImplTest.java rename to java/java-tests/testSrc/com/intellij/openapi/roots/impl/DirectoryIndexImplTest.java index de1eeb8e5b96..310a92e8a239 100644 --- a/java/java-tests/testSrc/com/intellij/roots/DirectoryIndexImplTest.java +++ b/java/java-tests/testSrc/com/intellij/openapi/roots/impl/DirectoryIndexImplTest.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.intellij.roots; +package com.intellij.openapi.roots.impl; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.command.WriteCommandAction; @@ -25,8 +25,6 @@ import com.intellij.openapi.module.ModuleManager; import com.intellij.openapi.module.StdModuleTypes; import com.intellij.openapi.roots.*; import com.intellij.openapi.roots.ex.ProjectRootManagerEx; -import com.intellij.openapi.roots.impl.DirectoryIndex; -import com.intellij.openapi.roots.impl.DirectoryInfo; import com.intellij.openapi.util.EmptyRunnable; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.*; @@ -38,7 +36,12 @@ import org.jetbrains.annotations.Nullable; import java.io.File; import java.io.IOException; -import java.util.*; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; + +import static java.util.Collections.singletonList; @PlatformTestCase.WrapInCommand public class DirectoryIndexImplTest extends IdeaTestCase { @@ -57,6 +60,9 @@ public class DirectoryIndexImplTest extends IdeaTestCase { private VirtualFile myTestSrc1; private VirtualFile myPack1Dir; private VirtualFile myPack2Dir; + private VirtualFile myFileLibDir; + private VirtualFile myFileLibSrc; + private VirtualFile myFileLibCls; private VirtualFile myLibDir; private VirtualFile myLibSrcDir; private VirtualFile myLibClsDir; @@ -75,10 +81,11 @@ public class DirectoryIndexImplTest extends IdeaTestCase { @Override public void run() { try { - myRootVFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(root); - assertNotNull(myRootVFile); /* root + lib + file.src + file.cls module1 src1 pack1 @@ -95,16 +102,21 @@ public class DirectoryIndexImplTest extends IdeaTestCase { out module1 */ + myRootVFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(root); + assertNotNull(myRootVFile); + myFileLibDir = myRootVFile.createChildDirectory(DirectoryIndexImplTest.this, "lib"); + myFileLibSrc = myFileLibDir.createChildData(DirectoryIndexImplTest.this, "file.src"); + myFileLibCls = myFileLibDir.createChildData(DirectoryIndexImplTest.this, "file.cls"); myModule1Dir = myRootVFile.createChildDirectory(DirectoryIndexImplTest.this, "module1"); mySrcDir1 = myModule1Dir.createChildDirectory(DirectoryIndexImplTest.this, "src1"); myPack1Dir = mySrcDir1.createChildDirectory(DirectoryIndexImplTest.this, "pack1"); myTestSrc1 = mySrcDir1.createChildDirectory(DirectoryIndexImplTest.this, "testSrc"); myPack2Dir = myTestSrc1.createChildDirectory(DirectoryIndexImplTest.this, "pack2"); + myLibDir = myModule1Dir.createChildDirectory(DirectoryIndexImplTest.this, "lib"); myLibSrcDir = myLibDir.createChildDirectory(DirectoryIndexImplTest.this, "src"); myLibClsDir = myLibDir.createChildDirectory(DirectoryIndexImplTest.this, "cls"); - myModule2Dir = myModule1Dir.createChildDirectory(DirectoryIndexImplTest.this, "module2"); mySrcDir2 = myModule2Dir.createChildDirectory(DirectoryIndexImplTest.this, "src2"); myCvsDir = mySrcDir2.createChildDirectory(DirectoryIndexImplTest.this, "CVS"); @@ -116,6 +128,7 @@ public class DirectoryIndexImplTest extends IdeaTestCase { myModule1OutputDir = myOutputDir.createChildDirectory(DirectoryIndexImplTest.this, "module1"); getCompilerProjectExtension().setCompilerOutputUrl(myOutputDir.getUrl()); + ModuleManager moduleManager = ModuleManager.getInstance(myProject); // fill roots of module1 { @@ -123,10 +136,10 @@ public class DirectoryIndexImplTest extends IdeaTestCase { PsiTestUtil.addContentRoot(myModule, myModule1Dir); PsiTestUtil.addSourceRoot(myModule, mySrcDir1); PsiTestUtil.addSourceRoot(myModule, myTestSrc1, true); + ModuleRootModificationUtil.addModuleLibrary(myModule, "lib.js", + singletonList(myFileLibCls.getUrl()), singletonList(myFileLibSrc.getUrl())); } - ModuleManager moduleManager = ModuleManager.getInstance(myProject); - // fill roots of module2 { VirtualFile moduleFile = myModule2Dir.createChildData(DirectoryIndexImplTest.this, "module2.iml"); @@ -135,8 +148,8 @@ public class DirectoryIndexImplTest extends IdeaTestCase { PsiTestUtil.addContentRoot(myModule2, myModule2Dir); PsiTestUtil.addSourceRoot(myModule2, mySrcDir2); PsiTestUtil.addExcludedRoot(myModule2, myExcludeDir); - ModuleRootModificationUtil.addModuleLibrary(myModule2, "lib", Collections.singletonList(myLibClsDir.getUrl()), - Collections.singletonList(myLibSrcDir.getUrl())); + ModuleRootModificationUtil.addModuleLibrary(myModule2, "lib", + singletonList(myLibClsDir.getUrl()), singletonList(myLibSrcDir.getUrl())); } // fill roots of module3 @@ -166,28 +179,32 @@ public class DirectoryIndexImplTest extends IdeaTestCase { public void testDirInfos() { checkInfoNull(myRootVFile); - checkInfo(myModule1Dir, myModule, false, false, false, false, null, new Module[]{}); - checkInfo(mySrcDir1, myModule, true, false, false, false, "", new Module[]{myModule}); - checkInfo(myPack1Dir, myModule, true, false, false, false, "pack1", new Module[]{myModule}); - checkInfo(myTestSrc1, myModule, true, true, false, false, "", new Module[]{myModule}); - checkInfo(myPack2Dir, myModule, true, true, false, false, "pack2", new Module[]{myModule}); - checkInfo(myLibDir, myModule, false, false, false, false, null, new Module[]{}); + // beware: files in directory index + checkInfo(myFileLibSrc, null, false, false, false, true, ""); + checkInfo(myFileLibCls, null, false, false, true, false, ""); - checkInfo(myLibSrcDir, myModule, false, false, false, true, "", new Module[]{myModule2}); - checkInfo(myLibClsDir, myModule, false, false, true, false, "", new Module[]{myModule2}); + checkInfo(myModule1Dir, myModule, false, false, false, false, null); + checkInfo(mySrcDir1, myModule, true, false, false, false, "", myModule); + checkInfo(myPack1Dir, myModule, true, false, false, false, "pack1", myModule); + checkInfo(myTestSrc1, myModule, true, true, false, false, "", myModule); + checkInfo(myPack2Dir, myModule, true, true, false, false, "pack2", myModule); - checkInfo(myModule2Dir, myModule2, false, false, false, false, null, new Module[]{}); - checkInfo(mySrcDir2, myModule2, true, false, false, false, "", new Module[]{myModule2, myModule3}); + checkInfo(myLibDir, myModule, false, false, false, false, null); + checkInfo(myLibSrcDir, myModule, false, false, false, true, "", myModule2); + checkInfo(myLibClsDir, myModule, false, false, true, false, "", myModule2); + + checkInfo(myModule2Dir, myModule2, false, false, false, false, null); + checkInfo(mySrcDir2, myModule2, true, false, false, false, "", myModule2, myModule3); checkInfoNull(myCvsDir); checkInfoNull(myExcludeDir); - checkInfo(myModule3Dir, myModule3, false, false, false, false, null, new Module[]{}); + checkInfo(myModule3Dir, myModule3, false, false, false, false, null); } public void testDirsByPackageName() { - checkPackage(new VirtualFile[]{mySrcDir1, myTestSrc1, myLibSrcDir, myLibClsDir, mySrcDir2}, ""); - checkPackage(new VirtualFile[]{myPack1Dir}, "pack1"); - checkPackage(new VirtualFile[]{myPack2Dir}, "pack2"); + checkPackage("", myFileLibSrc, myFileLibCls, mySrcDir1, myTestSrc1, myLibSrcDir, myLibClsDir, mySrcDir2); + checkPackage("pack1", myPack1Dir); + checkPackage("pack2", myPack2Dir); } public void testCreateDir() throws Exception { @@ -312,8 +329,8 @@ public class DirectoryIndexImplTest extends IdeaTestCase { myIndex.checkConsistency(); - checkInfo(myModule2Dir, myModule2, false, false, false, false, null, new Module[]{}); - checkInfo(mySrcDir2, myModule2, true, false, false, false, "", new Module[]{myModule2, myModule3}); + checkInfo(myModule2Dir, myModule2, false, false, false, false, null); + checkInfo(mySrcDir2, myModule2, true, false, false, false, "", myModule2, myModule3); } public void testResettingProjectOutputPath() throws Exception { @@ -466,8 +483,8 @@ public class DirectoryIndexImplTest extends IdeaTestCase { myIndex.checkConsistency(); - checkInfo(myModule1Dir, myModule, false, false, true, false, "", new Module[]{myModule}); - checkInfo(mySrcDir1, myModule, true, false, true, false, "", new Module[]{myModule}); + checkInfo(myModule1Dir, myModule, false, false, true, false, "", myModule); + checkInfo(mySrcDir1, myModule, true, false, true, false, "", myModule); } @@ -479,13 +496,13 @@ public class DirectoryIndexImplTest extends IdeaTestCase { } private void checkInfo(VirtualFile dir, - Module module, + @Nullable Module module, boolean isInModuleSource, boolean isTestSource, boolean isInLibrary, boolean isInLibrarySource, @Nullable String packageName, - Module[] modulesOfOrderEntries) { + Module... modulesOfOrderEntries) { DirectoryInfo info = myIndex.getInfoForDirectory(dir); assertNotNull(info); assertEquals(module, info.module); @@ -495,7 +512,9 @@ public class DirectoryIndexImplTest extends IdeaTestCase { assertEquals(isInLibrarySource, info.isInLibrarySource); final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(myProject).getFileIndex(); - assertEquals(packageName, fileIndex.getPackageNameByDirectory(dir)); + if (dir.isDirectory()) { + assertEquals(packageName, fileIndex.getPackageNameByDirectory(dir)); + } assertEquals(modulesOfOrderEntries.length, info.getOrderEntries().size()); for (Module aModule : modulesOfOrderEntries) { @@ -515,7 +534,7 @@ public class DirectoryIndexImplTest extends IdeaTestCase { assertNull(info); } - private void checkPackage(VirtualFile[] expectedDirs, String packageName) { + private void checkPackage(String packageName, VirtualFile... expectedDirs) { VirtualFile[] actualDirs = myIndex.getDirectoriesByPackageName(packageName, true).toArray(VirtualFile.EMPTY_ARRAY); assertNotNull(actualDirs); HashSet set1 = new HashSet(); diff --git a/java/java-tests/testSrc/com/intellij/psi/codeStyle/arrangement/JavaRearrangerByTypeTest.groovy b/java/java-tests/testSrc/com/intellij/psi/codeStyle/arrangement/JavaRearrangerByTypeTest.groovy index d563a57cf880..c3853406ab17 100644 --- a/java/java-tests/testSrc/com/intellij/psi/codeStyle/arrangement/JavaRearrangerByTypeTest.groovy +++ b/java/java-tests/testSrc/com/intellij/psi/codeStyle/arrangement/JavaRearrangerByTypeTest.groovy @@ -54,7 +54,7 @@ class Test2 { public void test() { } }''', - [new ArrangementRule(atom(ArrangementEntryType.FIELD))] + [rule(atom(ArrangementEntryType.FIELD))] ) } @@ -98,7 +98,7 @@ class Test { return null; } }''', - [new ArrangementRule(atom(ArrangementEntryType.FIELD))] + [rule(atom(ArrangementEntryType.FIELD))] ) } @@ -136,7 +136,7 @@ class Test { }); } }''', - [new ArrangementRule(atom(ArrangementEntryType.FIELD))] + [rule(atom(ArrangementEntryType.FIELD))] ) } @@ -174,7 +174,7 @@ class Test { }); } }''', - [new ArrangementRule(atom(ArrangementEntryType.FIELD))] + [rule(atom(ArrangementEntryType.FIELD))] ) } } diff --git a/java/java-tests/testSrc/com/intellij/refactoring/RenameLocalTest.java b/java/java-tests/testSrc/com/intellij/refactoring/RenameLocalTest.java index 3aeefbe1459d..66e186925ee9 100644 --- a/java/java-tests/testSrc/com/intellij/refactoring/RenameLocalTest.java +++ b/java/java-tests/testSrc/com/intellij/refactoring/RenameLocalTest.java @@ -74,6 +74,10 @@ public class RenameLocalTest extends LightRefactoringTestCase { public void testRenameInPlaceQualifyFieldReference() throws Exception { doTestInplaceRename("myI"); } + + public void testRenameInPlaceThisNeeded() throws Exception { + doTestInplaceRename("a"); + } public void testRenameInPlaceParamInOverriderAutomaticRenamer() throws Exception { doTestInplaceRename("pp"); diff --git a/platform/core-api/src/com/intellij/psi/PsiDocumentManager.java b/platform/core-api/src/com/intellij/psi/PsiDocumentManager.java index 0973bca9e97d..d2526e421e61 100644 --- a/platform/core-api/src/com/intellij/psi/PsiDocumentManager.java +++ b/platform/core-api/src/com/intellij/psi/PsiDocumentManager.java @@ -30,8 +30,8 @@ public abstract class PsiDocumentManager { public abstract boolean isCommitted(@NotNull Document document); /** - * Defer action until all documents are committed - * must be called from EDT only + * Defer action until all documents are committed. + * Must be called from the EDT only. * * @param action to run when all documents committed * @return true if action was run immediately (i.e. all documents are already committed) diff --git a/platform/core-impl/src/com/intellij/psi/impl/source/tree/CompositeElement.java b/platform/core-impl/src/com/intellij/psi/impl/source/tree/CompositeElement.java index e871618a3fea..09b3e324b1ef 100644 --- a/platform/core-impl/src/com/intellij/psi/impl/source/tree/CompositeElement.java +++ b/platform/core-impl/src/com/intellij/psi/impl/source/tree/CompositeElement.java @@ -32,7 +32,10 @@ import com.intellij.psi.PsiFile; import com.intellij.psi.PsiLock; import com.intellij.psi.impl.DebugUtil; import com.intellij.psi.impl.FreeThreadedFileViewProvider; -import com.intellij.psi.impl.source.*; +import com.intellij.psi.impl.source.DummyHolder; +import com.intellij.psi.impl.source.DummyHolderElement; +import com.intellij.psi.impl.source.DummyHolderFactory; +import com.intellij.psi.impl.source.SourceTreeToPsiMap; import com.intellij.psi.impl.source.codeStyle.CodeEditUtil; import com.intellij.psi.tree.IElementType; import com.intellij.psi.tree.TokenSet; @@ -102,9 +105,19 @@ public class CompositeElement extends TreeElement { @Override public void clearCaches() { + assertThreading(); + myCachedLength = NOT_CACHED; + + myModificationsCount++; + myHC = -1; + + clearRelativeOffsets(rawFirstChild()); + } + + public void assertThreading() { if (ASSERT_THREADING) { boolean ok = ApplicationManager.getApplication().isWriteAccessAllowed() || - Thread.holdsLock(START_OFFSET_LOCK) || + //Thread.holdsLock(START_OFFSET_LOCK) || isNonPhysicalOrInjected(); if (!ok) { FileElement fileElement; @@ -122,12 +135,6 @@ public class CompositeElement extends TreeElement { ); } } - myCachedLength = NOT_CACHED; - - myModificationsCount++; - myHC = -1; - - clearRelativeOffsets(rawFirstChild()); } private boolean isNonPhysicalOrInjected() { diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/CommonCodeStyleSettings.java b/platform/lang-api/src/com/intellij/psi/codeStyle/CommonCodeStyleSettings.java index 57c3d79cb85f..e4922520c36b 100644 --- a/platform/lang-api/src/com/intellij/psi/codeStyle/CommonCodeStyleSettings.java +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/CommonCodeStyleSettings.java @@ -21,6 +21,7 @@ import com.intellij.openapi.fileTypes.FileType; import com.intellij.openapi.util.*; import com.intellij.psi.codeStyle.arrangement.ArrangementRule; import com.intellij.psi.codeStyle.arrangement.ArrangementUtil; +import com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryMatcher; import com.intellij.util.xmlb.SkipDefaultValuesSerializationFilters; import com.intellij.util.xmlb.XmlSerializer; import org.intellij.lang.annotations.MagicConstant; @@ -45,7 +46,8 @@ public class CommonCodeStyleSettings { @NonNls private static final String ARRANGEMENT_ELEMENT_NAME = "arrangementRules"; - private final List myArrangementRules = new ArrayList(); + private final List myArrangementRules + = new ArrayList(); private final Language myLanguage; private CodeStyleSettings myRootSettings; private IndentOptions myIndentOptions; @@ -126,11 +128,12 @@ public class CommonCodeStyleSettings { return myArrangementRules; } - public void setArrangementRules(@NotNull List rules) { + public void setArrangementRules(@NotNull List rules) { myArrangementRules.clear(); myArrangementRules.addAll(rules); } + @SuppressWarnings("unchecked") public CommonCodeStyleSettings clone(@NotNull CodeStyleSettings rootSettings) { CommonCodeStyleSettings commonSettings = new CommonCodeStyleSettings(myLanguage, getFileType()); copyPublicFields(this, commonSettings); @@ -139,6 +142,9 @@ public class CommonCodeStyleSettings { IndentOptions targetIndentOptions = commonSettings.initIndentOptions(); targetIndentOptions.copyFrom(myIndentOptions); } + if (!myArrangementRules.isEmpty()) { + rootSettings.setArrangementRules(getArrangementRules()); + } return commonSettings; } diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/ArrangementRule.java b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/ArrangementRule.java index 292493e29e94..47aa0c6ea1a1 100644 --- a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/ArrangementRule.java +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/ArrangementRule.java @@ -16,8 +16,6 @@ package com.intellij.psi.codeStyle.arrangement; import com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryMatcher; -import com.intellij.psi.codeStyle.arrangement.match.StdArrangementEntryMatcher; -import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition; import com.intellij.psi.codeStyle.arrangement.order.ArrangementEntryOrderType; import org.jetbrains.annotations.NotNull; @@ -33,20 +31,18 @@ import org.jetbrains.annotations.NotNull; */ public class ArrangementRule { - @NotNull private final ArrangementEntryMatcher myMatcher; - @NotNull private final ArrangementEntryOrderType mySortType; + @NotNull public static final ArrangementEntryOrderType DEFAULT_ORDER_TYPE = ArrangementEntryOrderType.KEEP; - public ArrangementRule(@NotNull ArrangementMatchCondition condition) { - this(new StdArrangementEntryMatcher(condition)); - } + @NotNull private final ArrangementEntryMatcher myMatcher; + @NotNull private final ArrangementEntryOrderType myOrderType; public ArrangementRule(@NotNull ArrangementEntryMatcher matcher) { - this(matcher, ArrangementEntryOrderType.KEEP); + this(matcher, DEFAULT_ORDER_TYPE); } public ArrangementRule(@NotNull ArrangementEntryMatcher matcher, @NotNull ArrangementEntryOrderType type) { myMatcher = matcher; - mySortType = type; + myOrderType = type; } @NotNull @@ -55,14 +51,14 @@ public class ArrangementRule { } @NotNull - public ArrangementEntryOrderType getSorter() { - return mySortType; + public ArrangementEntryOrderType getOrderType() { + return myOrderType; } @Override public int hashCode() { int result = myMatcher.hashCode(); - result = 31 * result + mySortType.hashCode(); + result = 31 * result + myOrderType.hashCode(); return result; } @@ -72,11 +68,11 @@ public class ArrangementRule { if (o == null || getClass() != o.getClass()) return false; ArrangementRule that = (ArrangementRule)o; - return mySortType == that.mySortType && myMatcher.equals(that.myMatcher); + return myOrderType == that.myOrderType && myMatcher.equals(that.myMatcher); } @Override public String toString() { - return String.format("matcher: %s, sort type: %s", myMatcher, mySortType); + return String.format("matcher: %s, sort type: %s", myMatcher, myOrderType); } } diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/ArrangementUtil.java b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/ArrangementUtil.java index 0908eb51f1a1..3381ccc5bfb6 100644 --- a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/ArrangementUtil.java +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/ArrangementUtil.java @@ -18,10 +18,9 @@ package com.intellij.psi.codeStyle.arrangement; import com.intellij.lang.Language; import com.intellij.openapi.util.TextRange; import com.intellij.openapi.util.text.StringUtil; -import com.intellij.psi.codeStyle.arrangement.model.ArrangementAtomMatchCondition; -import com.intellij.psi.codeStyle.arrangement.model.ArrangementCompositeMatchCondition; -import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition; -import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchConditionVisitor; +import com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryType; +import com.intellij.psi.codeStyle.arrangement.match.ArrangementModifier; +import com.intellij.psi.codeStyle.arrangement.model.*; import org.jdom.Element; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -211,4 +210,19 @@ public class ArrangementUtil { return TextRange.create(startOffsetToUse, endOffsetToUse); } //endregion + + @NotNull + public static ArrangementSettingType parseType(@NotNull Object condition) throws IllegalArgumentException { + if (condition instanceof ArrangementEntryType) { + return ArrangementSettingType.TYPE; + } + else if (condition instanceof ArrangementModifier) { + return ArrangementSettingType.MODIFIER; + } + else { + throw new IllegalArgumentException(String.format( + "Can't parse type for the given condition of class '%s': %s", condition.getClass(), condition + )); + } + } } diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/DefaultArrangementRuleSerializer.java b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/DefaultArrangementRuleSerializer.java index d19e13612a22..4f8fa7f664fb 100644 --- a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/DefaultArrangementRuleSerializer.java +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/DefaultArrangementRuleSerializer.java @@ -15,8 +15,8 @@ */ package com.intellij.psi.codeStyle.arrangement; -import com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryMatcher; import com.intellij.psi.codeStyle.arrangement.match.DefaultArrangementEntryMatcherSerializer; +import com.intellij.psi.codeStyle.arrangement.match.StdArrangementEntryMatcher; import com.intellij.psi.codeStyle.arrangement.order.ArrangementEntryOrderType; import org.jdom.Element; import org.jetbrains.annotations.NonNls; @@ -30,22 +30,21 @@ public class DefaultArrangementRuleSerializer implements ArrangementRuleSerializ public static final ArrangementRuleSerializer INSTANCE = new DefaultArrangementRuleSerializer(); - @NotNull @NonNls private static final String RULE_ELEMENT_NAME = "rule"; - @NotNull @NonNls private static final String MATCHER_ELEMENT_NAME = "match"; - @NotNull @NonNls private static final String SORT_TYPE_ELEMENT_NAME = "sort"; + @NotNull @NonNls private static final String RULE_ELEMENT_NAME = "rule"; + @NotNull @NonNls private static final String MATCHER_ELEMENT_NAME = "match"; + @NotNull @NonNls private static final String ORDER_TYPE_ELEMENT_NAME = "order"; @NotNull private final DefaultArrangementEntryMatcherSerializer myMatcherSerializer = new DefaultArrangementEntryMatcherSerializer(); - @Nullable @Override - public ArrangementRule deserialize(@NotNull Element element) { + public StdArrangementRule deserialize(@NotNull Element element) { Element matcherElement = element.getChild(MATCHER_ELEMENT_NAME); if (matcherElement == null) { return null; } - ArrangementEntryMatcher matcher = null; + StdArrangementEntryMatcher matcher = null; for (Object o : matcherElement.getChildren()) { matcher = myMatcherSerializer.deserialize((Element)o); if (matcher != null) { @@ -57,13 +56,13 @@ public class DefaultArrangementRuleSerializer implements ArrangementRuleSerializ return null; } - Element sortElement = element.getChild(SORT_TYPE_ELEMENT_NAME); - ArrangementEntryOrderType sortType = ArrangementEntryOrderType.KEEP; - if (sortElement != null) { - sortType = ArrangementEntryOrderType.valueOf(sortElement.getText()); + Element orderTypeElement = element.getChild(ORDER_TYPE_ELEMENT_NAME); + ArrangementEntryOrderType orderType = ArrangementRule.DEFAULT_ORDER_TYPE; + if (orderTypeElement != null) { + orderType = ArrangementEntryOrderType.valueOf(orderTypeElement.getText()); } - return new ArrangementRule(matcher, sortType); + return new StdArrangementRule(matcher, orderType); } @Nullable @@ -76,7 +75,9 @@ public class DefaultArrangementRuleSerializer implements ArrangementRuleSerializ Element result = new Element(RULE_ELEMENT_NAME); result.addContent(new Element(MATCHER_ELEMENT_NAME).addContent(matcherElement)); - result.addContent(new Element(SORT_TYPE_ELEMENT_NAME).setText(rule.getSorter().toString())); + if (rule.getOrderType() != ArrangementRule.DEFAULT_ORDER_TYPE) { + result.addContent(new Element(ORDER_TYPE_ELEMENT_NAME).setText(rule.getOrderType().toString())); + } return result; } } diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/StdArrangementRule.java b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/StdArrangementRule.java new file mode 100644 index 000000000000..65774900997b --- /dev/null +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/StdArrangementRule.java @@ -0,0 +1,45 @@ +/* + * Copyright 2000-2012 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.psi.codeStyle.arrangement; + +import com.intellij.psi.codeStyle.arrangement.match.StdArrangementEntryMatcher; +import com.intellij.psi.codeStyle.arrangement.order.ArrangementEntryOrderType; +import org.jetbrains.annotations.NotNull; + +/** + * Arrangement rule which uses {@link StdArrangementEntryMatcher standard settings-based matcher}. + *

+ * Not thread-safe. + * + * @author Denis Zhdanov + * @since 8/28/12 2:59 PM + */ +public class StdArrangementRule extends ArrangementRule { + + public StdArrangementRule(@NotNull StdArrangementEntryMatcher matcher) { + super(matcher); + } + + public StdArrangementRule(@NotNull StdArrangementEntryMatcher matcher, @NotNull ArrangementEntryOrderType type) { + super(matcher, type); + } + + @NotNull + @Override + public StdArrangementEntryMatcher getMatcher() { + return (StdArrangementEntryMatcher)super.getMatcher(); + } +} diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/ArrangementEntryMatcher.java b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/ArrangementEntryMatcher.java index 93a92b321561..a73078284f35 100644 --- a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/ArrangementEntryMatcher.java +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/ArrangementEntryMatcher.java @@ -32,6 +32,14 @@ import org.jetbrains.annotations.NotNull; */ public interface ArrangementEntryMatcher { + @NotNull + ArrangementEntryMatcher EMPTY = new ArrangementEntryMatcher() { + @Override + public boolean isMatched(@NotNull ArrangementEntry entry) { + return false; + } + }; + /** * Allows to check if given entry is matched by the current rule. *

diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/DefaultArrangementEntryMatcherSerializer.java b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/DefaultArrangementEntryMatcherSerializer.java index 3d72f23932d5..65dd9618e063 100644 --- a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/DefaultArrangementEntryMatcherSerializer.java +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/DefaultArrangementEntryMatcherSerializer.java @@ -65,7 +65,7 @@ public class DefaultArrangementEntryMatcherSerializer { @SuppressWarnings("MethodMayBeStatic") @Nullable - public ArrangementEntryMatcher deserialize(@NotNull Element matcherElement) { + public StdArrangementEntryMatcher deserialize(@NotNull Element matcherElement) { ArrangementMatchCondition condition = deserializeCondition(matcherElement); return condition == null ? null : new StdArrangementEntryMatcher(condition); } diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/StdArrangementEntryMatcher.java b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/StdArrangementEntryMatcher.java index 94d1f5091824..f0090494a3be 100644 --- a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/StdArrangementEntryMatcher.java +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/StdArrangementEntryMatcher.java @@ -57,6 +57,29 @@ public class StdArrangementEntryMatcher implements ArrangementEntryMatcher { return myDelegate.isMatched(entry); } + @Override + public int hashCode() { + return myCondition.hashCode(); + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + + StdArrangementEntryMatcher matcher = (StdArrangementEntryMatcher)o; + return myCondition.equals(matcher.myCondition); + } + + @Override + public String toString() { + return myCondition.toString(); + } + @NotNull private static ArrangementEntryMatcher doBuildMatcher(@NotNull ArrangementMatchCondition condition) { MyVisitor visitor = new MyVisitor(); @@ -103,7 +126,9 @@ public class StdArrangementEntryMatcher implements ArrangementEntryMatcher { public ArrangementEntryMatcher getMatcher() { ByTypeArrangementEntryMatcher byType = myTypes.isEmpty() ? null : new ByTypeArrangementEntryMatcher(myTypes); ByModifierArrangementEntryMatcher byModifiers = myModifiers.isEmpty() ? null : new ByModifierArrangementEntryMatcher(myModifiers); - assert byType != null || byModifiers != null || (myOperator != null && !myMatchers.isEmpty()); + if (byType == null && byModifiers == null && (myOperator == null || myMatchers.isEmpty())) { + return ArrangementEntryMatcher.EMPTY; + } if (myMatchers.isEmpty() && (byType == null ^ byModifiers == null)) { return byModifiers == null ? byType : byModifiers; } diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/model/ArrangementCompositeMatchCondition.java b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/model/ArrangementCompositeMatchCondition.java index 451c83c9a6dc..ca70fb31e7fc 100644 --- a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/model/ArrangementCompositeMatchCondition.java +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/model/ArrangementCompositeMatchCondition.java @@ -44,8 +44,8 @@ public class ArrangementCompositeMatchCondition implements ArrangementMatchCondi return myOperands; } - public ArrangementCompositeMatchCondition addOperand(@NotNull ArrangementMatchCondition node) { - myOperands.add(node); + public ArrangementCompositeMatchCondition addOperand(@NotNull ArrangementMatchCondition condition) { + myOperands.add(condition); return this; } diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/settings/ArrangementStandardSettingsAware.java b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/settings/ArrangementStandardSettingsAware.java index 8ad1ef6ae44d..9452229f2937 100644 --- a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/settings/ArrangementStandardSettingsAware.java +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/settings/ArrangementStandardSettingsAware.java @@ -15,6 +15,7 @@ */ package com.intellij.psi.codeStyle.arrangement.settings; +import com.intellij.psi.codeStyle.arrangement.StdArrangementRule; import com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryType; import com.intellij.psi.codeStyle.arrangement.match.ArrangementModifier; import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition; @@ -22,6 +23,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.util.Collection; +import java.util.List; import java.util.Set; /** @@ -32,6 +34,13 @@ import java.util.Set; * @since 8/6/12 2:26 PM */ public interface ArrangementStandardSettingsAware { + + /** + * @return list of rules to use by default, i.e. when a user hasn't been explicitly modified arrangement settings; + * null as an indication that no default rules are available + */ + @Nullable + List getDefaultRules(); /** * Allows to answer if given entry type can be applied for the rule specified by the given settings node. diff --git a/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementConfigUtil.java b/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementConfigUtil.java index 29f88a313366..b4b02a12158a 100644 --- a/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementConfigUtil.java +++ b/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementConfigUtil.java @@ -56,8 +56,8 @@ public class ArrangementConfigUtil { * @return map which contains information on what new new settings are available at the current situation */ @NotNull - public static Map> buildAvailableOptions(@NotNull ArrangementStandardSettingsAware filter, - @Nullable ArrangementMatchCondition condition) + public static Map> buildAvailableConditions(@NotNull ArrangementStandardSettingsAware filter, + @Nullable ArrangementMatchCondition condition) { Map> result = new EnumMap>(ArrangementSettingType.class); processData(filter, condition, result, ArrangementSettingType.TYPE, ArrangementEntryType.values()); diff --git a/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementNodeDisplayManager.java b/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementNodeDisplayManager.java index e8605715854f..9ed734aa12e0 100644 --- a/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementNodeDisplayManager.java +++ b/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementNodeDisplayManager.java @@ -49,7 +49,7 @@ public class ArrangementNodeDisplayManager { @NotNull ArrangementStandardSettingsRepresentationAware representationManager) { myRepresentationManager = representationManager; - Map> map = ArrangementConfigUtil.buildAvailableOptions(filter, null); + Map> map = ArrangementConfigUtil.buildAvailableConditions(filter, null); for (Map.Entry> entry : map.entrySet()) { myMaxWidths.put(entry.getKey(), maxWidth(entry.getValue())); } diff --git a/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModel.java b/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModel.java index 10b52602b114..d5ec0835524b 100644 --- a/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModel.java +++ b/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModel.java @@ -15,9 +15,13 @@ */ package com.intellij.application.options.codeStyle.arrangement; +import com.intellij.psi.codeStyle.arrangement.ArrangementOperator; +import com.intellij.psi.codeStyle.arrangement.StdArrangementRule; import com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryType; import com.intellij.psi.codeStyle.arrangement.match.ArrangementModifier; +import com.intellij.psi.codeStyle.arrangement.match.StdArrangementEntryMatcher; import com.intellij.psi.codeStyle.arrangement.model.ArrangementAtomMatchCondition; +import com.intellij.psi.codeStyle.arrangement.model.ArrangementCompositeMatchCondition; import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition; import org.jetbrains.annotations.NotNull; @@ -31,9 +35,17 @@ import org.jetbrains.annotations.NotNull; * @since 8/15/12 1:04 PM */ public interface ArrangementRuleEditingModel { - + @NotNull - ArrangementMatchCondition getMatchCondition(); + StdArrangementRule EMPTY_RULE = new StdArrangementRule(new StdArrangementEntryMatcher( + new ArrangementCompositeMatchCondition(ArrangementOperator.AND) + )); + + @NotNull + ArrangementMatchCondition getCondition(); + + @NotNull + StdArrangementRule getRule(); /** * Asks current model to destroy itself. @@ -41,17 +53,17 @@ public interface ArrangementRuleEditingModel { * The key concern here is to perform necessary tree modification. */ void destroy(); - + /** * Allows to answer if current model has a registered condition for the given key. A key is expected to be one of the standard * keys, e.g. {@link ArrangementEntryType type}, {@link ArrangementModifier modifier} etc. - * + * * @param key target key * @return true if current model has a registered mapping for the given key; * false otherwise */ boolean hasCondition(@NotNull Object key); - + void addAndCondition(@NotNull ArrangementAtomMatchCondition condition); void removeAndCondition(@NotNull ArrangementMatchCondition condition); @@ -60,12 +72,12 @@ public interface ArrangementRuleEditingModel { * We need to be able to replace one condition by another. Most of the time it can be simulated by * {@link #removeAndCondition(ArrangementMatchCondition) 'remove old'} and * {@link #addAndCondition(ArrangementAtomMatchCondition) 'add new'} actions sequence but that doesn't work when - * {@link #getMatchCondition() underlying condition} has the only atom condition. Removing it eliminates the condition at all. - * + * {@link #getRule() underlying condition} has the only atom condition. Removing it eliminates the condition at all. + * * @param from condition which should be replaced * @param to replacement condition * @throws IllegalArgumentException when given 'from' condition is not a part of the - * {@link #getMatchCondition() underlying match condition} + * {@link #getRule() underlying match condition} */ void replaceCondition(@NotNull ArrangementAtomMatchCondition from, @NotNull ArrangementAtomMatchCondition to) throws IllegalArgumentException; diff --git a/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModelBuilder.java b/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModelBuilder.java index d3f04dadd968..3efd2a7cd3d5 100644 --- a/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModelBuilder.java +++ b/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModelBuilder.java @@ -16,6 +16,7 @@ package com.intellij.application.options.codeStyle.arrangement; import com.intellij.openapi.util.Pair; +import com.intellij.psi.codeStyle.arrangement.StdArrangementRule; import com.intellij.psi.codeStyle.arrangement.match.ArrangementModifier; import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition; import com.intellij.psi.codeStyle.arrangement.model.HierarchicalArrangementConditionNode; @@ -58,7 +59,7 @@ public class ArrangementRuleEditingModelBuilder { * * * - * @param matchCondition target settings to process + * @param rule target rule to process * @param tree UI tree which shows arrangement matcher rules * @param root UI tree settings root to use (may be not the same as the tree root) * @param anchor node after which should be previous sibling for the root node of the inserted condition; @@ -70,13 +71,13 @@ public class ArrangementRuleEditingModelBuilder { */ @SuppressWarnings("MethodMayBeStatic") public Pair build( - @NotNull ArrangementMatchCondition matchCondition, + @NotNull StdArrangementRule rule, @NotNull JTree tree, @NotNull ArrangementTreeNode root, @Nullable ArrangementTreeNode anchor, @NotNull ArrangementConditionsGrouper grouper) { - HierarchicalArrangementConditionNode grouped = grouper.group(matchCondition); + HierarchicalArrangementConditionNode grouped = grouper.group(rule.getMatcher().getCondition()); DefaultTreeModel treeModel = (DefaultTreeModel)tree.getModel(); Pair pair = ArrangementConfigUtil.map(null, grouped, null); ArrangementTreeNode topMostNode = ArrangementConfigUtil.getRoot(pair.first); @@ -95,7 +96,7 @@ public class ArrangementRuleEditingModelBuilder { int row = ArrangementConfigUtil.getRow(pair.first, tree.isRootVisible()); ArrangementRuleEditingModelImpl model = new ArrangementRuleEditingModelImpl( treeModel, - matchCondition, + rule, topMostNode, pair.first, grouper, diff --git a/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModelImpl.java b/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModelImpl.java index afb4c69a7611..9d28aafc83e3 100644 --- a/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModelImpl.java +++ b/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModelImpl.java @@ -18,6 +18,8 @@ package com.intellij.application.options.codeStyle.arrangement; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.util.Pair; import com.intellij.psi.codeStyle.arrangement.ArrangementUtil; +import com.intellij.psi.codeStyle.arrangement.StdArrangementRule; +import com.intellij.psi.codeStyle.arrangement.match.StdArrangementEntryMatcher; import com.intellij.psi.codeStyle.arrangement.model.*; import com.intellij.psi.codeStyle.arrangement.settings.ArrangementConditionsGrouper; import com.intellij.util.containers.hash.HashSet; @@ -46,17 +48,17 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo @NotNull private final ArrangementConditionsGrouper myGrouper; private final boolean myRootVisible; - @NotNull private ArrangementTreeNode myTopMost; - @NotNull private ArrangementTreeNode myBottomMost; - @NotNull private ArrangementMatchCondition myMatchCondition; - private int myRow; + @NotNull private ArrangementTreeNode myTopMost; + @NotNull private ArrangementTreeNode myBottomMost; + @NotNull private StdArrangementRule myRule; + private int myRow; /** * Creates new ArrangementRuleEditingModelImpl object. * * @param model tree model which holds target ui nodes. Basically, we need to perform ui nodes modification via it in order * to generate corresponding events automatically - * @param node backing settings node + * @param rule backing arrangement rule * @param topMost there is a possible case that a single settings node is shown in more than one visual line * ({@link HierarchicalArrangementConditionNode}). This argument is the top-most UI node used for the * settings node representation @@ -66,7 +68,7 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo * @param rootVisible determines if the root should be count during rows calculations */ public ArrangementRuleEditingModelImpl(@NotNull DefaultTreeModel model, - @NotNull ArrangementMatchCondition node, + @NotNull StdArrangementRule rule, @NotNull ArrangementTreeNode topMost, @NotNull ArrangementTreeNode bottomMost, @NotNull ArrangementConditionsGrouper grouper, @@ -74,7 +76,7 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo boolean rootVisible) { myTreeModel = model; - myMatchCondition = node; + myRule = rule; myTopMost = topMost; myBottomMost = bottomMost; myGrouper = grouper; @@ -87,7 +89,7 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo myConditions.clear(); CONDITIONS_BUILDER.conditions = myConditions; try { - myMatchCondition.invite(CONDITIONS_BUILDER); + getCondition().invite(CONDITIONS_BUILDER); } finally { CONDITIONS_BUILDER.conditions = null; @@ -96,8 +98,14 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo @NotNull @Override - public ArrangementMatchCondition getMatchCondition() { - return myMatchCondition; + public ArrangementMatchCondition getCondition() { + return myRule.getMatcher().getCondition(); + } + + @NotNull + @Override + public StdArrangementRule getRule() { + return myRule; } public int getRow() { @@ -143,10 +151,10 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo public void addAndCondition(@NotNull ArrangementAtomMatchCondition condition) { if (ArrangementConstants.LOG_RULE_MODIFICATION) { LOG.info(String.format( - "Arrangement rule modification - adding a condition '%s'. Model: '%s', row: %d", condition, myMatchCondition, myRow + "Arrangement rule modification - adding a condition '%s'. Model: '%s', row: %d", condition, myRule, myRow )); } - ArrangementMatchCondition newCondition = ArrangementUtil.and(myMatchCondition.clone(), condition); + ArrangementMatchCondition newCondition = ArrangementUtil.and(getCondition().clone(), condition); applyNewCondition(newCondition); } @@ -154,16 +162,17 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo public void removeAndCondition(@NotNull ArrangementMatchCondition condition) { if (ArrangementConstants.LOG_RULE_MODIFICATION) { LOG.info(String.format( - "Arrangement rule modification - removing a condition '%s'. Model: '%s', row: %d", condition, myMatchCondition, myRow + "Arrangement rule modification - removing a condition '%s'. Model: '%s', row: %d", condition, myRule, myRow )); } - if (myMatchCondition.equals(condition)) { + ArrangementMatchCondition matchCondition = getCondition(); + if (matchCondition.equals(condition)) { destroy(); return; } - assert myMatchCondition instanceof ArrangementCompositeMatchCondition; - ArrangementMatchCondition newCondition = myMatchCondition.clone(); + assert matchCondition instanceof ArrangementCompositeMatchCondition; + ArrangementMatchCondition newCondition = matchCondition.clone(); ArrangementCompositeMatchCondition composite = (ArrangementCompositeMatchCondition)newCondition; composite.getOperands().remove(condition); if (composite.getOperands().size() == 1) { @@ -172,9 +181,9 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo applyNewCondition(newCondition); } - private void applyNewCondition(@NotNull ArrangementMatchCondition newNode) { - myMatchCondition = newNode; - HierarchicalArrangementConditionNode grouped = myGrouper.group(newNode); + private void applyNewCondition(@NotNull ArrangementMatchCondition newCondition) { + myRule = new StdArrangementRule(new StdArrangementEntryMatcher(newCondition)); + HierarchicalArrangementConditionNode grouped = myGrouper.group(newCondition); Pair replacement = ArrangementConfigUtil.map(null, grouped, null); ArrangementTreeNode newBottom = replacement.first; ArrangementTreeNode newTop = ArrangementConfigUtil.getRoot(newBottom); @@ -193,7 +202,7 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo } if (ArrangementConstants.LOG_RULE_MODIFICATION) { - LOG.info(String.format("Arrangement rule is modified: '%s', row: %d", myMatchCondition, myRow)); + LOG.info(String.format("Arrangement rule is modified: '%s', row: %d", myRule, myRow)); } } @@ -201,16 +210,17 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo public void replaceCondition(@NotNull ArrangementAtomMatchCondition from, @NotNull ArrangementAtomMatchCondition to) { if (ArrangementConstants.LOG_RULE_MODIFICATION) { LOG.info(String.format( - "Arrangement rule modification - replacing condition '%s' by '%s'. Model: '%s', row: %d", from, to, myMatchCondition, myRow + "Arrangement rule modification - replacing condition '%s' by '%s'. Model: '%s', row: %d", from, to, myRule, myRow )); } ArrangementMatchCondition newCondition; - if (myMatchCondition.equals(from)) { + ArrangementMatchCondition matchCondition = getCondition(); + if (matchCondition.equals(from)) { newCondition = to; } else { - assert myMatchCondition instanceof ArrangementCompositeMatchCondition; - ArrangementCompositeMatchCondition composite = (ArrangementCompositeMatchCondition)myMatchCondition; + assert matchCondition instanceof ArrangementCompositeMatchCondition; + ArrangementCompositeMatchCondition composite = (ArrangementCompositeMatchCondition)matchCondition; ArrangementCompositeMatchCondition newComposite = composite.clone(); newComposite.getOperands().remove(from); newComposite.getOperands().add(to); @@ -222,7 +232,7 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo @Override public void destroy() { if (ArrangementConstants.LOG_RULE_MODIFICATION) { - LOG.info(String.format("Arrangement rule modification - destroy. Model: '%s', row: %d", myMatchCondition, myRow)); + LOG.info(String.format("Arrangement rule modification - destroy. Model: '%s', row: %d", myRule, myRow)); } for (Listener listener : myListeners) { listener.beforeModelDestroy(this); @@ -239,7 +249,7 @@ public class ArrangementRuleEditingModelImpl implements ArrangementRuleEditingMo @Override public String toString() { - return "model for " + myMatchCondition; + return "model for " + myRule; } private static class MyConditionsBuilder implements ArrangementMatchConditionVisitor { diff --git a/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditor.java b/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditor.java index 528bf40563e4..b242d6c1cc01 100644 --- a/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditor.java +++ b/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditor.java @@ -63,7 +63,7 @@ public class ArrangementRuleEditor extends JPanel { private void init(@NotNull ArrangementNodeDisplayManager displayManager) { setLayout(new GridBagLayout()); - Map> supportedSettings = ArrangementConfigUtil.buildAvailableOptions(myFilter, null); + Map> supportedSettings = ArrangementConfigUtil.buildAvailableConditions(myFilter, null); addRowIfPossible(ArrangementSettingType.TYPE, supportedSettings, displayManager); addRowIfPossible(ArrangementSettingType.MODIFIER, supportedSettings, displayManager); } @@ -109,7 +109,7 @@ public class ArrangementRuleEditor extends JPanel { return; } - Map> available = ArrangementConfigUtil.buildAvailableOptions(myFilter, model.getMatchCondition()); + Map> available = ArrangementConfigUtil.buildAvailableConditions(myFilter, model.getRule().getMatcher().getCondition()); for (Collection ids : available.values()) { for (Object id : ids) { ArrangementAtomNodeComponent component = myComponents.get(id); @@ -157,7 +157,7 @@ public class ArrangementRuleEditor extends JPanel { myModel.replaceCondition(componentToDeselect.getMatchCondition(), chosenCondition); for (ArrangementAtomNodeComponent componentToCheck : myComponents.values()) { Object value = componentToCheck.getMatchCondition().getValue(); - if (myModel.hasCondition(value) && !ArrangementConfigUtil.isEnabled(value, myFilter, myModel.getMatchCondition())) { + if (myModel.hasCondition(value) && !ArrangementConfigUtil.isEnabled(value, myFilter, myModel.getCondition())) { myModel.removeAndCondition(componentToCheck.getMatchCondition()); } } diff --git a/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleTree.java b/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleTree.java index c148e2071329..a1dfd129ad7d 100644 --- a/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleTree.java +++ b/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleTree.java @@ -18,13 +18,10 @@ package com.intellij.application.options.codeStyle.arrangement; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.util.Condition; import com.intellij.openapi.util.Pair; -import com.intellij.psi.codeStyle.arrangement.ArrangementOperator; -import com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryType; -import com.intellij.psi.codeStyle.arrangement.match.ArrangementModifier; +import com.intellij.psi.codeStyle.arrangement.StdArrangementRule; import com.intellij.psi.codeStyle.arrangement.model.ArrangementAtomMatchCondition; import com.intellij.psi.codeStyle.arrangement.model.ArrangementCompositeMatchCondition; import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition; -import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingType; import com.intellij.psi.codeStyle.arrangement.settings.ArrangementConditionsGrouper; import com.intellij.ui.treeStructure.Tree; import com.intellij.util.Alarm; @@ -42,6 +39,7 @@ import java.awt.event.ActionEvent; import java.awt.event.MouseAdapter; import java.awt.event.MouseEvent; import java.util.ArrayList; +import java.util.Arrays; import java.util.Enumeration; import java.util.List; @@ -79,7 +77,10 @@ public class ArrangementRuleTree { private boolean myExplicitSelectionChange; private boolean mySkipSelectionChange; - public ArrangementRuleTree(@NotNull ArrangementConditionsGrouper grouper, @NotNull ArrangementNodeDisplayManager displayManager) { + public ArrangementRuleTree(@NotNull List rules, + @NotNull ArrangementConditionsGrouper grouper, + @NotNull ArrangementNodeDisplayManager displayManager) + { myGrouper = grouper; myFactory = new ArrangementNodeComponentFactory(displayManager, new Consumer() { @Override @@ -179,37 +180,10 @@ public class ArrangementRuleTree { } }); - List rules = new ArrayList(); - rules.add(new ArrangementCompositeMatchCondition(ArrangementOperator.AND) - .addOperand(new ArrangementAtomMatchCondition(ArrangementSettingType.TYPE, ArrangementEntryType.FIELD)) - .addOperand(new ArrangementAtomMatchCondition(ArrangementSettingType.MODIFIER, ArrangementModifier.PUBLIC)) - .addOperand(new ArrangementAtomMatchCondition(ArrangementSettingType.MODIFIER, ArrangementModifier.STATIC)) - .addOperand(new ArrangementAtomMatchCondition(ArrangementSettingType.MODIFIER, ArrangementModifier.FINAL))); - rules.add(new ArrangementCompositeMatchCondition(ArrangementOperator.AND) - .addOperand(new ArrangementAtomMatchCondition(ArrangementSettingType.TYPE, ArrangementEntryType.FIELD)) - .addOperand(new ArrangementAtomMatchCondition(ArrangementSettingType.MODIFIER, ArrangementModifier.PRIVATE))); - rules.add(new ArrangementCompositeMatchCondition(ArrangementOperator.AND) - .addOperand(new ArrangementAtomMatchCondition(ArrangementSettingType.TYPE, ArrangementEntryType.METHOD)) - .addOperand(new ArrangementAtomMatchCondition(ArrangementSettingType.MODIFIER, ArrangementModifier.PUBLIC))); - rules.add(new ArrangementCompositeMatchCondition(ArrangementOperator.AND) - .addOperand(new ArrangementAtomMatchCondition(ArrangementSettingType.TYPE, ArrangementEntryType.METHOD)) - .addOperand(new ArrangementAtomMatchCondition(ArrangementSettingType.MODIFIER, ArrangementModifier.PRIVATE))); - map(rules); - - expandAll(myTree, new TreePath(myRoot)); + setRules(rules); + myTree.setShowsRootHandles(false); myTree.setCellRenderer(new MyCellRenderer()); - - if (ArrangementConstants.LOG_RULE_MODIFICATION) { - LOG.info("Arrangement tree is constructed. Models:"); - myModels.forEachValue(new TObjectProcedure() { - @Override - public boolean execute(ArrangementRuleEditingModelImpl model) { - LOG.info(String.format(" row %d, model '%s'", model.getRow(), model.getMatchCondition())); - return true; - } - }); - } } private void selectPreviousRule() { @@ -335,9 +309,9 @@ public class ArrangementRuleTree { tree.expandPath(parent); } - private void map(@NotNull List matchConditions) { - for (ArrangementMatchCondition matchCondition : matchConditions) { - Pair pair = myModelBuilder.build(matchCondition, myTree, myRoot, null, myGrouper); + private void map(@NotNull List rules) { + for (StdArrangementRule rule : rules) { + Pair pair = myModelBuilder.build(rule, myTree, myRoot, null, myGrouper); myModels.put(pair.first.getRow(), pair.first); pair.first.addListener(myModelChangeListener); } @@ -377,6 +351,44 @@ public class ArrangementRuleTree { return myTree; } + /** + * @return rules configured at the current tree at the moment + */ + @NotNull + public List getRules() { + int[] rows = myModels.keys(); + Arrays.sort(rows); + List result = new ArrayList(); + for (int row : rows) { + result.add(myModels.get(row).getRule()); + } + return result; + } + + public void setRules(@NotNull List rules) { + myRenderers.clear(); + myModels.clear(); + while (myRoot.getChildCount() > 0) + myTreeModel.removeNodeFromParent(myRoot.getFirstChild()); + map(rules); + expandAll(myTree, new TreePath(myRoot)); + + if (ArrangementConstants.LOG_RULE_MODIFICATION) { + LOG.info("Arrangement tree is refreshed. Given rules:"); + for (StdArrangementRule rule : rules) { + LOG.info(" " + rule.toString()); + } + LOG.info("Following models have been built:"); + myModels.forEachValue(new TObjectProcedure() { + @Override + public boolean execute(ArrangementRuleEditingModelImpl model) { + LOG.info(String.format(" row %d, model '%s'", model.getRow(), model.getRule())); + return true; + } + }); + } + } + @NotNull private ArrangementNodeComponent getNodeComponentAt(int row, @NotNull ArrangementMatchCondition condition) { ArrangementNodeComponent result = myRenderers.get(row); @@ -547,7 +559,7 @@ public class ArrangementRuleTree { final ArrangementTreeNode anchor = activeModel == null ? null : activeModel.getBottomMost(); doClearSelection(); Pair pair = myModelBuilder.build( - new ArrangementCompositeMatchCondition(ArrangementOperator.AND), myTree, myRoot, anchor, myGrouper + ArrangementRuleEditingModel.EMPTY_RULE, myTree, myRoot, anchor, myGrouper ); processRowChanges(pair.second); myModels.put(pair.first.getRow(), pair.first); @@ -690,7 +702,7 @@ public class ArrangementRuleTree { boolean emptyRuleRemoved = false; for (Object value : values) { ArrangementRuleEditingModelImpl model = (ArrangementRuleEditingModelImpl)value; - if (model != null && model != activeModel && isEmptyCondition(model.getMatchCondition())) { + if (model != null && model != activeModel && model.getRule() == ArrangementRuleEditingModel.EMPTY_RULE) { model.destroy(); emptyRuleRemoved = true; } @@ -702,7 +714,7 @@ public class ArrangementRuleTree { for (Object value : myModels.getValues()) { ArrangementRuleEditingModelImpl model = (ArrangementRuleEditingModelImpl)value; - if (activeModel.getMatchCondition().equals(model.getMatchCondition())) { + if (activeModel.getRule().equals(model.getRule())) { mySelectionModel.setSelectionPath(new TreePath(activeModel.getBottomMost().getPath())); } } diff --git a/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementSettingsPanel.java b/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementSettingsPanel.java index 93b88b08ff21..2e0f2adce2d7 100644 --- a/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementSettingsPanel.java +++ b/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementSettingsPanel.java @@ -20,12 +20,16 @@ import com.intellij.application.options.codeStyle.arrangement.action.AddArrangem import com.intellij.application.options.codeStyle.arrangement.action.RemoveArrangementRuleAction; import com.intellij.ide.DataManager; import com.intellij.ide.ui.customization.CustomizationUtil; +import com.intellij.lang.Language; import com.intellij.openapi.actionSystem.*; import com.intellij.openapi.application.ApplicationBundle; import com.intellij.openapi.editor.colors.EditorColorsScheme; import com.intellij.openapi.editor.highlighter.EditorHighlighter; import com.intellij.openapi.util.Ref; import com.intellij.psi.codeStyle.CodeStyleSettings; +import com.intellij.psi.codeStyle.arrangement.ArrangementRule; +import com.intellij.psi.codeStyle.arrangement.Rearranger; +import com.intellij.psi.codeStyle.arrangement.StdArrangementRule; import com.intellij.psi.codeStyle.arrangement.settings.*; import com.intellij.ui.IdeBorderFactory; import com.intellij.ui.SideBorder; @@ -42,6 +46,7 @@ import java.awt.*; import java.beans.PropertyChangeEvent; import java.beans.PropertyChangeListener; import java.util.ArrayList; +import java.util.Collections; import java.util.List; /** @@ -54,16 +59,24 @@ public abstract class ArrangementSettingsPanel extends CodeStyleAbstractPanel { @NotNull private final JPanel myContent = new JPanel(new GridBagLayout()); - public ArrangementSettingsPanel(@NotNull CodeStyleSettings settings, @NotNull final ArrangementStandardSettingsAware filter) { + @NotNull private final Language myLanguage; + @NotNull private final ArrangementStandardSettingsAware mySettingsAware; + @NotNull private final ArrangementRuleTree myRuleTree; + + public ArrangementSettingsPanel(@NotNull CodeStyleSettings settings, @NotNull Language language) { super(settings); + myLanguage = language; + Rearranger rearranger = Rearranger.EXTENSION.forLanguage(language); + assert rearranger instanceof ArrangementStandardSettingsAware; + mySettingsAware = (ArrangementStandardSettingsAware)rearranger; ArrangementStandardSettingsRepresentationAware representationManager = DefaultArrangementSettingsRepresentationManager.INSTANCE; - if (filter instanceof ArrangementStandardSettingsRepresentationAware) { - representationManager = (ArrangementStandardSettingsRepresentationAware)filter; + if (mySettingsAware instanceof ArrangementStandardSettingsRepresentationAware) { + representationManager = (ArrangementStandardSettingsRepresentationAware)mySettingsAware; } - final ArrangementNodeDisplayManager displayManager = new ArrangementNodeDisplayManager(filter, representationManager); + final ArrangementNodeDisplayManager displayManager = new ArrangementNodeDisplayManager(mySettingsAware, representationManager); ArrangementConditionsGrouper grouper = DefaultArrangementSettingsGrouper.INSTANCE; - if (filter instanceof ArrangementConditionsGrouper) { - grouper = (ArrangementConditionsGrouper)filter; + if (mySettingsAware instanceof ArrangementConditionsGrouper) { + grouper = (ArrangementConditionsGrouper)mySettingsAware; } final ActionManager actionManager = ActionManager.getInstance(); @@ -73,9 +86,9 @@ public abstract class ArrangementSettingsPanel extends CodeStyleAbstractPanel { toolbarControl.add(actionToolbar.getComponent(), new GridBag().anchor(GridBagConstraints.WEST).weightx(1).fillCellHorizontally()); toolbarControl.setBorder(IdeBorderFactory.createBorder(SideBorder.LEFT | SideBorder.TOP | SideBorder.RIGHT)); myContent.add(toolbarControl, new GridBag().weightx(1).fillCellHorizontally().coverLine()); - - final ArrangementRuleTree ruleTree = new ArrangementRuleTree(grouper, displayManager); - final Tree treeComponent = ruleTree.getTreeComponent(); + + myRuleTree = new ArrangementRuleTree(getRules(settings), grouper, displayManager); + final Tree treeComponent = myRuleTree.getTreeComponent(); actionToolbar.setTargetComponent(treeComponent); myContent.add(new JBScrollPane(treeComponent), new GridBag().weightx(1).weighty(1).fillCell().coverLine()); CustomizationUtil.installPopupHandler( @@ -83,13 +96,22 @@ public abstract class ArrangementSettingsPanel extends CodeStyleAbstractPanel { ); final JXTaskPane editorPane = new JXTaskPane(ApplicationBundle.message("arrangement.title.editor")); - final ArrangementRuleEditor ruleEditor = new ArrangementRuleEditor(filter, displayManager); + final ArrangementRuleEditor ruleEditor = new ArrangementRuleEditor(mySettingsAware, displayManager); ruleEditor.applyBackground(treeComponent.getBackground()); editorPane.getContentPane().setBackground(treeComponent.getBackground()); editorPane.add(ruleEditor); editorPane.setCollapsed(true); - final Ref resetEditor = new Ref(Boolean.TRUE); myContent.add(editorPane, new GridBag().weightx(1).fillCellHorizontally().coverLine()); + final Ref resetEditor = new Ref(Boolean.TRUE); + linkTreeAndEditor(editorPane, ruleEditor, resetEditor); + setupRuleManagementActions(treeComponent, editorPane, ruleEditor, resetEditor); + setupKeyboardActions(actionManager, treeComponent); + } + + private void linkTreeAndEditor(@NotNull final JXTaskPane editorPane, + @NotNull final ArrangementRuleEditor ruleEditor, + @NotNull final Ref resetEditor) + { editorPane.addPropertyChangeListener("collapsed", new PropertyChangeListener() { @Override public void propertyChange(PropertyChangeEvent evt) { @@ -98,7 +120,7 @@ public abstract class ArrangementSettingsPanel extends CodeStyleAbstractPanel { } } }); - ruleTree.addEditingListener(new ArrangementRuleSelectionListener() { + myRuleTree.addEditingListener(new ArrangementRuleSelectionListener() { @Override public void onSelected(@NotNull ArrangementRuleEditingModel model) { ruleEditor.updateState(model); @@ -116,11 +138,18 @@ public abstract class ArrangementSettingsPanel extends CodeStyleAbstractPanel { editorPane.setCollapsed(true); } }); + } + + private void setupRuleManagementActions(@NotNull final Tree treeComponent, + @NotNull final JXTaskPane editorPane, + @NotNull final ArrangementRuleEditor ruleEditor, + @NotNull final Ref resetEditor) + { final Runnable newRuleFunction = new Runnable() { @Override public void run() { treeComponent.requestFocus(); - ArrangementRuleEditingModel model = ruleTree.newModel(); + ArrangementRuleEditingModel model = myRuleTree.newModel(); ruleEditor.updateState(model); resetEditor.set(Boolean.FALSE); try { @@ -135,7 +164,7 @@ public abstract class ArrangementSettingsPanel extends CodeStyleAbstractPanel { @Override public void run() { treeComponent.requestFocus(); - ArrangementRuleEditingModelImpl model = ruleTree.getActiveModel(); + ArrangementRuleEditingModelImpl model = myRuleTree.getActiveModel(); if (model != null) { model.destroy(); } @@ -154,7 +183,29 @@ public abstract class ArrangementSettingsPanel extends CodeStyleAbstractPanel { return null; } }); - setupKeyboardActions(actionManager, treeComponent); + } + + @SuppressWarnings("unchecked") + @NotNull + private List getRules(@NotNull CodeStyleSettings settings) { + List storedRules = settings.getCommonSettings(myLanguage).getArrangementRules(); + if (storedRules.isEmpty()) { + List defaultRules = mySettingsAware.getDefaultRules(); + if (defaultRules != null) { + return defaultRules; + } + } + else { + // We use unchecked cast here in assumption that current rearranger is based on standard settings if it uses standard + // settings-based rule editor. + // Note: unchecked cast for the whole collection doesn't work here (compiler error). + List result = new ArrayList(); + for (ArrangementRule rule : storedRules) { + result.add((StdArrangementRule)rule); + } + return result; + } + return Collections.emptyList(); } private static void setupKeyboardActions(@NotNull ActionManager actionManager, @NotNull Tree treeComponent) { @@ -180,19 +231,18 @@ public abstract class ArrangementSettingsPanel extends CodeStyleAbstractPanel { } @Override - public boolean isModified(CodeStyleSettings settings) { - // TODO den implement - return false; + public boolean isModified(@NotNull CodeStyleSettings settings) { + return !getRules(settings).equals(myRuleTree.getRules()); } @Override - public void apply(CodeStyleSettings settings) { - // TODO den implement + public void apply(@NotNull CodeStyleSettings settings) { + settings.getCommonSettings(myLanguage).setArrangementRules(myRuleTree.getRules()); } @Override - protected void resetImpl(CodeStyleSettings settings) { - // TODO den implement + protected void resetImpl(@NotNull CodeStyleSettings settings) { + myRuleTree.setRules(getRules(settings)); } @Override diff --git a/platform/lang-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.java b/platform/lang-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.java index 740a61efb1ca..bdb13ea1b78e 100644 --- a/platform/lang-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.java +++ b/platform/lang-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.java @@ -322,8 +322,7 @@ public class ExecutionManagerImpl extends ExecutionManager implements ProjectCom private void forgetRunContentDescriptor(RunContentDescriptor runContentDescriptor) { for (Trinity trinity : myRunningConfigurations) { if (trinity.getFirst() == runContentDescriptor) { - //runContentDescriptor.dispose(); - myRunningConfigurations.remove(trinity); + Disposer.dispose(runContentDescriptor); return; } } diff --git a/platform/lang-impl/src/com/intellij/ide/bookmarks/BookmarkManager.java b/platform/lang-impl/src/com/intellij/ide/bookmarks/BookmarkManager.java index b3264e0daaaa..fd269be607d2 100644 --- a/platform/lang-impl/src/com/intellij/ide/bookmarks/BookmarkManager.java +++ b/platform/lang-impl/src/com/intellij/ide/bookmarks/BookmarkManager.java @@ -143,6 +143,7 @@ public class BookmarkManager extends AbstractProjectComponent implements Persist } + @NotNull public List getValidBookmarks() { List answer = new ArrayList(); for (Bookmark bookmark : myBookmarks) { @@ -258,6 +259,7 @@ public class BookmarkManager extends AbstractProjectComponent implements Persist Collections.reverse(reversed); for (Bookmark bookmark : reversed) { + if (!bookmark.isValid()) continue; Element bookmarkElement = new Element("bookmark"); bookmarkElement.setAttribute("url", bookmark.getFile().getUrl()); @@ -286,7 +288,8 @@ public class BookmarkManager extends AbstractProjectComponent implements Persist * * @return bookmark list after moving */ - public List moveBookmarkUp(Bookmark bookmark) { + @NotNull + public List moveBookmarkUp(@NotNull Bookmark bookmark) { int index = myBookmarks.indexOf(bookmark); if (index > 0) { Collections.swap(myBookmarks, index, index - 1); @@ -301,7 +304,8 @@ public class BookmarkManager extends AbstractProjectComponent implements Persist * * @return bookmark list after moving */ - public List moveBookmarkDown(Bookmark bookmark) { + @NotNull + public List moveBookmarkDown(@NotNull Bookmark bookmark) { int index = myBookmarks.indexOf(bookmark); if (index < myBookmarks.size() - 1) { Collections.swap(myBookmarks, index, index + 1); @@ -311,7 +315,7 @@ public class BookmarkManager extends AbstractProjectComponent implements Persist } @Nullable - public Bookmark getNextBookmark(Editor editor, boolean isWrapped) { + public Bookmark getNextBookmark(@NotNull Editor editor, boolean isWrapped) { Bookmark[] bookmarksForDocument = getBookmarksForDocument(editor.getDocument()); int lineNumber = editor.getCaretModel().getLogicalPosition().line; for (Bookmark bookmark : bookmarksForDocument) { @@ -324,7 +328,7 @@ public class BookmarkManager extends AbstractProjectComponent implements Persist } @Nullable - public Bookmark getPreviousBookmark(Editor editor, boolean isWrapped) { + public Bookmark getPreviousBookmark(@NotNull Editor editor, boolean isWrapped) { Bookmark[] bookmarksForDocument = getBookmarksForDocument(editor.getDocument()); int lineNumber = editor.getCaretModel().getLogicalPosition().line; for (int i = bookmarksForDocument.length - 1; i >= 0; i--) { @@ -337,7 +341,8 @@ public class BookmarkManager extends AbstractProjectComponent implements Persist return null; } - private Bookmark[] getBookmarksForDocument(Document document) { + @NotNull + private Bookmark[] getBookmarksForDocument(@NotNull Document document) { ArrayList answer = new ArrayList(); for (Bookmark bookmark : getValidBookmarks()) { if (document.equals(bookmark.getDocument())) { diff --git a/platform/lang-impl/src/com/intellij/ide/commander/CommanderPanel.java b/platform/lang-impl/src/com/intellij/ide/commander/CommanderPanel.java index 289818283749..ac9536c28917 100644 --- a/platform/lang-impl/src/com/intellij/ide/commander/CommanderPanel.java +++ b/platform/lang-impl/src/com/intellij/ide/commander/CommanderPanel.java @@ -45,7 +45,7 @@ import com.intellij.openapi.wm.ToolWindowManager; import com.intellij.pom.Navigatable; import com.intellij.psi.PsiDirectory; import com.intellij.psi.PsiElement; -import com.intellij.psi.util.PsiUtilBase; +import com.intellij.psi.util.PsiUtilCore; import com.intellij.ui.*; import com.intellij.ui.components.JBList; import com.intellij.util.ArrayUtil; @@ -60,6 +60,7 @@ import javax.swing.border.BevelBorder; import java.awt.*; import java.awt.event.*; import java.util.ArrayList; +import java.util.Collections; import java.util.List; /** @@ -91,7 +92,7 @@ public class CommanderPanel extends JPanel { private boolean myActive = true; private final List myHistoryListeners = ContainerUtil.createEmptyCOWList(); private boolean myMoveFocus = false; - private boolean myEnableSearchHighlighting; + private final boolean myEnableSearchHighlighting; public CommanderPanel(final Project project, final boolean enablePopupMenu, final boolean enableSearchHighlighting) { super(new BorderLayout()); @@ -103,6 +104,7 @@ public class CommanderPanel extends JPanel { if (enablePopupMenu) { myCopyPasteDelegator = new CopyPasteDelegator(myProject, myList) { + @Override @NotNull protected PsiElement[] getSelectedElements() { return CommanderPanel.this.getSelectedElements(); @@ -116,16 +118,18 @@ public class CommanderPanel extends JPanel { ListScrollingUtil.installActions(myList); myList.registerKeyboardAction(new ActionListener() { + @Override public void actionPerformed(final ActionEvent e) { if (myBuilder == null) return; myBuilder.buildRoot(); } - }, KeyStroke.getKeyStroke(KeyEvent.VK_BACK_SLASH, SystemInfo.isMac ? KeyEvent.META_MASK : KeyEvent.CTRL_MASK), JComponent.WHEN_FOCUSED); + }, KeyStroke.getKeyStroke(KeyEvent.VK_BACK_SLASH, SystemInfo.isMac ? InputEvent.META_MASK : InputEvent.CTRL_MASK), JComponent.WHEN_FOCUSED); myList.getInputMap(WHEN_FOCUSED).put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), ACTION_DRILL_DOWN); myList.getInputMap(WHEN_FOCUSED) - .put(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_DOWN, SystemInfo.isMac ? KeyEvent.META_MASK : KeyEvent.CTRL_MASK), ACTION_DRILL_DOWN); + .put(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_DOWN, SystemInfo.isMac ? InputEvent.META_MASK : InputEvent.CTRL_MASK), ACTION_DRILL_DOWN); myList.getActionMap().put(ACTION_DRILL_DOWN, new AbstractAction() { + @Override public void actionPerformed(final ActionEvent e) { drillDown(); } @@ -139,15 +143,17 @@ public class CommanderPanel extends JPanel { }.installOn(myList); myList.getInputMap(WHEN_FOCUSED) - .put(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, SystemInfo.isMac ? KeyEvent.META_MASK : KeyEvent.CTRL_MASK), ACTION_GO_UP); + .put(KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, SystemInfo.isMac ? InputEvent.META_MASK : InputEvent.CTRL_MASK), ACTION_GO_UP); myList.getInputMap(WHEN_FOCUSED).put(KeyStroke.getKeyStroke(KeyEvent.VK_BACK_SPACE, 0), ACTION_GO_UP); myList.getActionMap().put(ACTION_GO_UP, new AbstractAction() { + @Override public void actionPerformed(final ActionEvent e) { goUp(); } }); myList.getActionMap().put("selectAll", new AbstractAction() { + @Override public void actionPerformed(final ActionEvent e) { } }); @@ -155,6 +161,7 @@ public class CommanderPanel extends JPanel { if (enablePopupMenu) { myList.addMouseListener(new PopupHandler() { + @Override public void invokePopup(final Component comp, final int x, final int y) { CommanderPanel.this.invokePopup(comp, x, y); } @@ -162,10 +169,12 @@ public class CommanderPanel extends JPanel { } myList.addFocusListener(new FocusAdapter() { + @Override public void focusGained(final FocusEvent e) { setActive(true); } + @Override public void focusLost(final FocusEvent e) { setActive(false); } @@ -177,15 +186,11 @@ public class CommanderPanel extends JPanel { return myEnableSearchHighlighting; } - public ListSpeedSearch getListSpeedSearch() { - return myListSpeedSearch; - } - - public void addHistoryListener(CommanderHistoryListener listener) { + void addHistoryListener(@NotNull CommanderHistoryListener listener) { myHistoryListeners.add(listener); } - public void removeHistoryListener(CommanderHistoryListener listener) { + private void removeHistoryListener(CommanderHistoryListener listener) { myHistoryListeners.remove(listener); } @@ -227,7 +232,7 @@ public class CommanderPanel extends JPanel { } final AbstractTreeNode element = getSelectedNode(); - if (element.getChildren().size() == 0) { + if (element.getChildren().isEmpty()) { if (!shouldDrillDownOnEmptyElement(element)) { navigateSelectedElement(); return; @@ -292,10 +297,12 @@ public class CommanderPanel extends JPanel { // TODO[vova,anton] it seems that the code below performs double focus request. Is it OK? myTitlePanel.addMouseListener(new MouseAdapter() { + @Override public void mouseClicked(final MouseEvent e) { myList.requestFocus(); } + @Override public void mousePressed(final MouseEvent e) { myList.requestFocus(); } @@ -327,8 +334,9 @@ public class CommanderPanel extends JPanel { return elementAtIndex instanceof AbstractTreeNode ? (AbstractTreeNode)elementAtIndex : null; } - private ArrayList getSelectedNodes() { - if (myBuilder == null) return null; + @NotNull + private List getSelectedNodes() { + if (myBuilder == null) return Collections.emptyList(); final int[] indices = myList.getSelectedIndices(); ArrayList result = new ArrayList(); for (int index : indices) { @@ -359,7 +367,7 @@ public class CommanderPanel extends JPanel { } } - return PsiUtilBase.toPsiElementArray(elements); + return PsiUtilCore.toPsiElementArray(elements); } private static Object getValueAtIndex(AbstractTreeNode node) { @@ -440,39 +448,39 @@ public class CommanderPanel extends JPanel { if (LangDataKeys.PSI_ELEMENT_ARRAY.is(dataId)) { return filterInvalidElements(getSelectedElements()); } - else if (LangDataKeys.PASTE_TARGET_PSI_ELEMENT.is(dataId)) { + if (LangDataKeys.PASTE_TARGET_PSI_ELEMENT.is(dataId)) { final AbstractTreeNode parentNode = myBuilder.getParentNode(); final Object element = parentNode != null ? parentNode.getValue() : null; return element instanceof PsiElement && ((PsiElement)element).isValid() ? element : null; } - else if (PlatformDataKeys.NAVIGATABLE_ARRAY.is(dataId)) { + if (PlatformDataKeys.NAVIGATABLE_ARRAY.is(dataId)) { return getNavigatables(); } - else if (PlatformDataKeys.COPY_PROVIDER.is(dataId)) { + if (PlatformDataKeys.COPY_PROVIDER.is(dataId)) { return myCopyPasteDelegator != null ? myCopyPasteDelegator.getCopyProvider() : null; } - else if (PlatformDataKeys.CUT_PROVIDER.is(dataId)) { + if (PlatformDataKeys.CUT_PROVIDER.is(dataId)) { return myCopyPasteDelegator != null ? myCopyPasteDelegator.getCutProvider() : null; } - else if (PlatformDataKeys.PASTE_PROVIDER.is(dataId)) { + if (PlatformDataKeys.PASTE_PROVIDER.is(dataId)) { return myCopyPasteDelegator != null ? myCopyPasteDelegator.getPasteProvider() : null; } - else if (LangDataKeys.IDE_VIEW.is(dataId)) { + if (LangDataKeys.IDE_VIEW.is(dataId)) { return myIdeView; } - else if (PlatformDataKeys.DELETE_ELEMENT_PROVIDER.is(dataId)) { + if (PlatformDataKeys.DELETE_ELEMENT_PROVIDER.is(dataId)) { return myDeleteElementProvider; } - else if (LangDataKeys.MODULE.is(dataId)) { + if (LangDataKeys.MODULE.is(dataId)) { return selectedValue instanceof Module ? selectedValue : null; } - else if (ModuleGroup.ARRAY_DATA_KEY.is(dataId)) { + if (ModuleGroup.ARRAY_DATA_KEY.is(dataId)) { return selectedValue instanceof ModuleGroup ? new ModuleGroup[]{(ModuleGroup)selectedValue} : null; } - else if (LibraryGroupElement.ARRAY_DATA_KEY.is(dataId)) { + if (LibraryGroupElement.ARRAY_DATA_KEY.is(dataId)) { return selectedValue instanceof LibraryGroupElement ? new LibraryGroupElement[]{(LibraryGroupElement)selectedValue} : null; } - else if (NamedLibraryElement.ARRAY_DATA_KEY.is(dataId)) { + if (NamedLibraryElement.ARRAY_DATA_KEY.is(dataId)) { return selectedValue instanceof NamedLibraryElement ? new NamedLibraryElement[]{(NamedLibraryElement)selectedValue} : null; } @@ -511,7 +519,7 @@ public class CommanderPanel extends JPanel { validElements.add(element); } } - return validElements.size() == elements.length ? elements : PsiUtilBase.toPsiElementArray(validElements); + return validElements.size() == elements.length ? elements : PsiUtilCore.toPsiElementArray(validElements); } protected final Navigatable createEditSourceDescriptor() { @@ -529,18 +537,20 @@ public class CommanderPanel extends JPanel { myPanel = panel; } + @Override public void setText(String text) { - if (text == null || text.length() == 0) { + if (text == null || text.isEmpty()) { text = " "; } super.setText(text); if (myPanel != null) { - myPanel.setToolTipText(text.trim().length() == 0 ? null : text); + myPanel.setToolTipText(text.trim().isEmpty() ? null : text); } } } private final class MyDeleteElementProvider implements DeleteProvider { + @Override public void deleteElement(@NotNull final DataContext dataContext) { LocalHistoryAction a = LocalHistory.getInstance().startAction(IdeBundle.message("progress.deleting")); try { @@ -552,6 +562,7 @@ public class CommanderPanel extends JPanel { } } + @Override public boolean canDeleteElement(@NotNull final DataContext dataContext) { final PsiElement[] elements = getSelectedElements(); return DeleteHandler.shouldEnableDeleteAction(elements); @@ -559,16 +570,19 @@ public class CommanderPanel extends JPanel { } private final class MyIdeView implements IdeView { + @Override public void selectElement(final PsiElement element) { final boolean isDirectory = element instanceof PsiDirectory; if (!isDirectory) { EditorHelper.openInEditor(element); } ApplicationManager.getApplication().invokeLater(new Runnable() { + @Override public void run() { - myBuilder.selectElement(element, PsiUtilBase.getVirtualFile(element)); + myBuilder.selectElement(element, PsiUtilCore.getVirtualFile(element)); if (!isDirectory) { ApplicationManager.getApplication().invokeLater(new Runnable() { + @Override public void run() { if (myMoveFocus) { ToolWindowManager.getInstance(myProject).activateEditorComponent(); @@ -593,11 +607,13 @@ public class CommanderPanel extends JPanel { } } + @Override public PsiDirectory[] getDirectories() { PsiDirectory directory = getDirectory(); return directory == null ? PsiDirectory.EMPTY_ARRAY : new PsiDirectory[]{directory}; } + @Override public PsiDirectory getOrChooseDirectory() { return DirectoryChooserUtil.getOrChooseDirectory(this); } @@ -605,6 +621,7 @@ public class CommanderPanel extends JPanel { public static final class MyModel extends AbstractListModel implements AbstractListBuilder.Model{ final List myElements = new ArrayList(); + @Override public void removeAllElements() { int index1 = myElements.size()-1; myElements.clear(); @@ -613,30 +630,36 @@ public class CommanderPanel extends JPanel { } } + @Override public void addElement(final Object obj) { int index = myElements.size(); myElements.add(obj); fireIntervalAdded(this, index, index); } + @Override public void replaceElements(final List newElements) { removeAllElements(); myElements.addAll(newElements); fireIntervalAdded(this, 0, newElements.size()); } + @Override public Object[] toArray() { return ArrayUtil.toObjectArray(myElements); } + @Override public int indexOf(final Object o) { return myElements.indexOf(o); } + @Override public int getSize() { return myElements.size(); } + @Override public Object getElementAt(final int index) { return myElements.get(index); } diff --git a/platform/lang-impl/src/com/intellij/ide/commander/TopLevelNode.java b/platform/lang-impl/src/com/intellij/ide/commander/TopLevelNode.java index 1782c28b8ad7..e31bb60b61b4 100644 --- a/platform/lang-impl/src/com/intellij/ide/commander/TopLevelNode.java +++ b/platform/lang-impl/src/com/intellij/ide/commander/TopLevelNode.java @@ -33,7 +33,7 @@ public class TopLevelNode extends AbstractTreeNode { public TopLevelNode(Project project, Object value) { super(project, value); myName = "[ .. ]"; - myIcon = AllIcons.Nodes.UpLevel; + setIcon(AllIcons.Nodes.UpLevel); } @NotNull diff --git a/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/actions/FavoritesToolbarButtonAction.java b/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/actions/FavoritesToolbarButtonAction.java index 6cf1fb60c1a6..543034ad1333 100644 --- a/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/actions/FavoritesToolbarButtonAction.java +++ b/platform/lang-impl/src/com/intellij/ide/favoritesTreeView/actions/FavoritesToolbarButtonAction.java @@ -38,6 +38,7 @@ public abstract class FavoritesToolbarButtonAction extends AnActionButton implem super(name, icon); myBuilder = builder; mySettings = FavoritesManager.getInstance(project).getViewSettings(); + setContextComponent(myBuilder.getTree()); Disposer.register(project, new Disposable() { @Override public void dispose() { diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/BaseProjectTreeBuilder.java b/platform/lang-impl/src/com/intellij/ide/projectView/BaseProjectTreeBuilder.java index 19ba52d5bae3..4d8c78426320 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/BaseProjectTreeBuilder.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/BaseProjectTreeBuilder.java @@ -81,14 +81,17 @@ public abstract class BaseProjectTreeBuilder extends AbstractTreeBuilder { final VirtualFile finalVFile = vFile; final FocusRequestor focusRequestor = IdeFocusManager.getInstance(myProject).getFurtherRequestor(); batch(new Progressive() { + @Override public void run(@NotNull ProgressIndicator indicator) { final Ref target = new Ref(); _select(value, finalVFile, false, Conditions.alwaysTrue(), cb, indicator, target, focusRequestor, false); cb.doWhenDone(new Runnable() { + @Override public void run() { result.setDone(target.get()); } }).doWhenRejected(new Runnable() { + @Override public void run() { result.setRejected(); } @@ -102,14 +105,17 @@ public abstract class BaseProjectTreeBuilder extends AbstractTreeBuilder { } + @Override protected boolean isAlwaysShowPlus(NodeDescriptor nodeDescriptor) { return ((AbstractTreeNode)nodeDescriptor).isAlwaysShowPlus(); } + @Override protected boolean isAutoExpandNode(NodeDescriptor nodeDescriptor) { return nodeDescriptor.getParentDescriptor() == null || ((AbstractTreeNode)nodeDescriptor).isAlwaysExpand(); } + @Override protected final void expandNodeChildren(final DefaultMutableTreeNode node) { final NodeDescriptor userObject = (NodeDescriptor)node.getUserObject(); if (userObject == null) return; @@ -185,8 +191,10 @@ public abstract class BaseProjectTreeBuilder extends AbstractTreeBuilder { UiActivityMonitor.getInstance().addActivity(myProject, new UiActivity.AsyncBgOperation("projectViewSelect"), getUpdater().getModalityState()); cancelUpdate().doWhenDone(new Runnable() { + @Override public void run() { batch(new Progressive() { + @Override public void run(@NotNull ProgressIndicator indicator) { _select(element, file, requestFocus, nonStopCondition, result, indicator, null, requestor, false); UiActivityMonitor.getInstance().removeActivity(myProject, new UiActivity.AsyncBgOperation("projectViewSelect")); @@ -212,6 +220,7 @@ public abstract class BaseProjectTreeBuilder extends AbstractTreeBuilder { final AbstractTreeNode alreadySelected = alreadySelectedNode(element); final Runnable onDone = new Runnable() { + @Override public void run() { if (requestFocus && virtualSelectTarget == null && getUi().isReady()) { focusRequestor.requestFocus(getTree(), true); @@ -222,6 +231,7 @@ public abstract class BaseProjectTreeBuilder extends AbstractTreeBuilder { }; final Condition condition = new Condition() { + @Override public boolean value(AbstractTreeNode abstractTreeNode) { if (result.isProcessed()) return false; return nonStopCondition.value(abstractTreeNode); @@ -231,6 +241,7 @@ public abstract class BaseProjectTreeBuilder extends AbstractTreeBuilder { if (alreadySelected == null) { expandPathTo(file, (AbstractTreeNode)getTreeStructure().getRootElement(), element, condition, indicator, virtualSelectTarget) .doWhenDone(new AsyncResult.Handler() { + @Override public void run(AbstractTreeNode node) { if (virtualSelectTarget == null) { select(node, onDone); @@ -294,6 +305,7 @@ public abstract class BaseProjectTreeBuilder extends AbstractTreeBuilder { if (root.canRepresent(element)) { if (target == null) { expand(root, new Runnable() { + @Override public void run() { async.setDone(root); } @@ -313,6 +325,7 @@ public abstract class BaseProjectTreeBuilder extends AbstractTreeBuilder { if (target == null) { expand(root, new Runnable() { + @Override public void run() { indicator.checkCanceled(); @@ -342,6 +355,7 @@ public abstract class BaseProjectTreeBuilder extends AbstractTreeBuilder { } yield(new Runnable() { + @Override public void run() { if (isDisposed()) return; expandChild(kids, 0, nonStopCondition, file, element, async, indicator, target); @@ -371,12 +385,14 @@ public abstract class BaseProjectTreeBuilder extends AbstractTreeBuilder { if (nonStopCondition.value(eachKid)) { expandPathTo(file, eachKid, element, nonStopCondition, indicator, virtualSelectTarget).doWhenDone(new AsyncResult.Handler() { + @Override public void run(AbstractTreeNode abstractTreeNode) { indicator.checkCanceled(); async.setDone(abstractTreeNode); } }).doWhenRejected(new Runnable() { + @Override public void run() { indicator.checkCanceled(); @@ -391,6 +407,7 @@ public abstract class BaseProjectTreeBuilder extends AbstractTreeBuilder { } } + @Override protected boolean validateNode(final Object child) { if (child == null) { return false; @@ -402,6 +419,7 @@ public abstract class BaseProjectTreeBuilder extends AbstractTreeBuilder { return true; } + @Override @NotNull protected ProgressIndicator createProgressIndicator() { return new StatusBarProgress(); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/ProjectViewPsiTreeChangeListener.java b/platform/lang-impl/src/com/intellij/ide/projectView/ProjectViewPsiTreeChangeListener.java index dec90ca3c785..40b16760831b 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/ProjectViewPsiTreeChangeListener.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/ProjectViewPsiTreeChangeListener.java @@ -44,18 +44,21 @@ public abstract class ProjectViewPsiTreeChangeListener extends PsiTreeChangeAdap protected abstract DefaultMutableTreeNode getRootNode(); + @Override public final void childRemoved(@NotNull PsiTreeChangeEvent event) { PsiElement child = event.getOldChild(); if (child instanceof PsiWhiteSpace) return; //optimization childrenChanged(event.getParent(), true); } + @Override public final void childAdded(@NotNull PsiTreeChangeEvent event) { PsiElement child = event.getNewChild(); if (child instanceof PsiWhiteSpace) return; //optimization childrenChanged(event.getParent(), true); } + @Override public final void childReplaced(@NotNull PsiTreeChangeEvent event) { PsiElement oldChild = event.getOldChild(); PsiElement newChild = event.getNewChild(); @@ -63,11 +66,13 @@ public abstract class ProjectViewPsiTreeChangeListener extends PsiTreeChangeAdap childrenChanged(event.getParent(), true); } + @Override public final void childMoved(@NotNull PsiTreeChangeEvent event) { childrenChanged(event.getOldParent(), false); childrenChanged(event.getNewParent(), true); } + @Override public final void childrenChanged(@NotNull PsiTreeChangeEvent event) { childrenChanged(event.getParent(), true); } @@ -105,6 +110,7 @@ public abstract class ProjectViewPsiTreeChangeListener extends PsiTreeChangeAdap } } + @Override public void propertyChanged(@NotNull PsiTreeChangeEvent event) { String propertyName = event.getPropertyName(); PsiElement element = event.getElement(); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/actions/ChangeProjectViewAction.java b/platform/lang-impl/src/com/intellij/ide/projectView/actions/ChangeProjectViewAction.java index 9c5681c35974..1030e6c50278 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/actions/ChangeProjectViewAction.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/actions/ChangeProjectViewAction.java @@ -26,6 +26,7 @@ import com.intellij.openapi.wm.ToolWindowId; import com.intellij.openapi.wm.ToolWindowManager; public final class ChangeProjectViewAction extends AnAction { + @Override public void actionPerformed(AnActionEvent e) { Project project = PlatformDataKeys.PROJECT.getData(e.getDataContext()); if (project == null) { @@ -35,6 +36,7 @@ public final class ChangeProjectViewAction extends AnAction { projectView.changeView(); } + @Override public void update(AnActionEvent event){ Presentation presentation = event.getPresentation(); Project project = PlatformDataKeys.PROJECT.getData(event.getDataContext()); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/actions/MoveModulesOutsideGroupAction.java b/platform/lang-impl/src/com/intellij/ide/projectView/actions/MoveModulesOutsideGroupAction.java index da639e23a87e..c5b9df3c8a02 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/actions/MoveModulesOutsideGroupAction.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/actions/MoveModulesOutsideGroupAction.java @@ -32,6 +32,7 @@ public class MoveModulesOutsideGroupAction extends AnAction { super(IdeBundle.message("action.move.module.outside.any.group")); } + @Override public void actionPerformed(AnActionEvent e) { final DataContext dataContext = e.getDataContext(); final Module[] modules = LangDataKeys.MODULE_CONTEXT_ARRAY.getData(dataContext); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/actions/MoveModulesToGroupAction.java b/platform/lang-impl/src/com/intellij/ide/projectView/actions/MoveModulesToGroupAction.java index 68616eeedefa..16ba0d5645f6 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/actions/MoveModulesToGroupAction.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/actions/MoveModulesToGroupAction.java @@ -39,6 +39,7 @@ public class MoveModulesToGroupAction extends AnAction { myModuleGroup = moduleGroup; } + @Override public void update(AnActionEvent e) { Presentation presentation = getTemplatePresentation(); final DataContext dataContext = e.getDataContext(); @@ -52,6 +53,7 @@ public class MoveModulesToGroupAction extends AnAction { return modules.length == 1 ? IdeBundle.message("message.module", modules[0].getName()) : IdeBundle.message("message.modules"); } + @Override public void actionPerformed(AnActionEvent e) { final DataContext dataContext = e.getDataContext(); final Module[] modules = LangDataKeys.MODULE_CONTEXT_ARRAY.getData(dataContext); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/actions/MoveModulesToSubGroupAction.java b/platform/lang-impl/src/com/intellij/ide/projectView/actions/MoveModulesToSubGroupAction.java index d44e47b60329..e6c022e97749 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/actions/MoveModulesToSubGroupAction.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/actions/MoveModulesToSubGroupAction.java @@ -34,12 +34,14 @@ public class MoveModulesToSubGroupAction extends MoveModulesToGroupAction { super(moduleGroup, moduleGroup == null ? IdeBundle.message("action.move.module.new.top.level.group") : IdeBundle.message("action.move.module.to.new.sub.group")); } + @Override public void update(AnActionEvent e) { Presentation presentation = e.getPresentation(); String description = IdeBundle.message("action.description.create.new.module.group"); presentation.setDescription(description); } + @Override public void actionPerformed(AnActionEvent e) { final DataContext dataContext = e.getDataContext(); final Module[] modules = LangDataKeys.MODULE_CONTEXT_ARRAY.getData(dataContext); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/AbstractProjectTreeStructure.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/AbstractProjectTreeStructure.java index 6d6839ec8620..cfc7169d7c78 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/AbstractProjectTreeStructure.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/AbstractProjectTreeStructure.java @@ -35,31 +35,35 @@ public abstract class AbstractProjectTreeStructure extends ProjectAbstractTreeSt return new ProjectViewProjectNode(myProject, this); } + @Override public abstract boolean isShowMembers(); + @Override public final Object getRootElement() { return myRoot; } + @Override public final void commit() { PsiDocumentManager.getInstance(myProject).commitAllDocuments(); } + @Override public final boolean hasSomethingToCommit() { - if (myProject.isDisposed()) return false; - return PsiDocumentManager.getInstance(myProject).hasUncommitedDocuments(); + return !myProject.isDisposed() + && PsiDocumentManager.getInstance(myProject).hasUncommitedDocuments(); } + @Override public boolean isStructureView() { return false; } + @Override public boolean isAlwaysLeaf(Object element) { if (element instanceof ProjectViewNode) { return ((ProjectViewNode)element).isAlwaysLeaf(); } - else { - return super.isAlwaysLeaf(element); - } + return super.isAlwaysLeaf(element); } } \ No newline at end of file diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/AbstractProjectViewPSIPane.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/AbstractProjectViewPSIPane.java index 1cbb4e554756..ee2727818c35 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/AbstractProjectViewPSIPane.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/AbstractProjectViewPSIPane.java @@ -62,6 +62,7 @@ public abstract class AbstractProjectViewPSIPane extends AbstractProjectViewPane super(project); } + @Override public JComponent createComponent() { if (myComponent != null) return myComponent; @@ -78,6 +79,7 @@ public abstract class AbstractProjectViewPSIPane extends AbstractProjectViewPane return myComponent; } + @Override public final void dispose() { myComponent = null; super.dispose(); @@ -97,23 +99,28 @@ public abstract class AbstractProjectViewPSIPane extends AbstractProjectViewPane TreeUtil.installActions(myTree); myTree.getSelectionModel().addTreeSelectionListener(new TreeSelectionListener() { + @Override public void valueChanged(TreeSelectionEvent e) { fireTreeChangeListener(); } }); myTree.getModel().addTreeModelListener(new TreeModelListener() { + @Override public void treeNodesChanged(TreeModelEvent e) { fireTreeChangeListener(); } + @Override public void treeNodesInserted(TreeModelEvent e) { fireTreeChangeListener(); } + @Override public void treeNodesRemoved(TreeModelEvent e) { fireTreeChangeListener(); } + @Override public void treeStructureChanged(TreeModelEvent e) { fireTreeChangeListener(); } @@ -122,6 +129,7 @@ public abstract class AbstractProjectViewPSIPane extends AbstractProjectViewPane new MySpeedSearch(myTree); myTree.addKeyListener(new KeyAdapter() { + @Override public void keyPressed(KeyEvent e) { if (KeyEvent.VK_ENTER == e.getKeyCode()) { @@ -147,6 +155,7 @@ public abstract class AbstractProjectViewPSIPane extends AbstractProjectViewPane CustomizationUtil.installPopupHandler(myTree, IdeActions.GROUP_PROJECT_VIEW_POPUP, ActionPlaces.PROJECT_VIEW_POPUP); } + @Override public final ActionCallback updateFromRoot(boolean restoreExpandedPaths) { final ArrayList pathsToExpand = new ArrayList(); final ArrayList selectionPaths = new ArrayList(); @@ -155,6 +164,7 @@ public abstract class AbstractProjectViewPSIPane extends AbstractProjectViewPane if (restoreExpandedPaths) { TreeBuilderUtil.storePaths(getTreeBuilder(), (DefaultMutableTreeNode)myTree.getModel().getRoot(), pathsToExpand, selectionPaths, true); afterUpdate = new Runnable() { + @Override public void run() { if (myTree != null && getTreeBuilder() != null && !getTreeBuilder().isDisposed()) { myTree.setSelectionPaths(new TreePath[0]); @@ -166,6 +176,7 @@ public abstract class AbstractProjectViewPSIPane extends AbstractProjectViewPane } else { afterUpdate = new Runnable() { + @Override public void run() { cb.setDone(); } @@ -178,6 +189,7 @@ public abstract class AbstractProjectViewPSIPane extends AbstractProjectViewPane return cb; } + @Override public void select(Object element, VirtualFile file, boolean requestFocus) { selectCB(element, file, requestFocus); } @@ -192,6 +204,7 @@ public abstract class AbstractProjectViewPSIPane extends AbstractProjectViewPane @NotNull protected BaseProjectTreeBuilder createBuilder(DefaultTreeModel treeModel) { return new ProjectTreeBuilder(myProject, myTree, treeModel, null, (ProjectAbstractTreeStructureBase)myTreeStructure) { + @Override protected AbstractTreeUpdater createUpdater() { return createTreeUpdater(this); } @@ -210,6 +223,7 @@ public abstract class AbstractProjectViewPSIPane extends AbstractProjectViewPane super(tree); } + @Override protected boolean isMatchingElement(Object element, String pattern) { Object userObject = ((DefaultMutableTreeNode)((TreePath)element).getLastPathComponent()).getUserObject(); if (userObject instanceof PsiDirectoryNode) { diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/AbstractProjectViewPane.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/AbstractProjectViewPane.java index 1b3f96eba136..c69e3d08f357 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/AbstractProjectViewPane.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/AbstractProjectViewPane.java @@ -184,6 +184,7 @@ public abstract class AbstractProjectViewPane implements DataProvider, Disposabl TreeUtil.selectPath(myTree, treePath); } + @Override public void dispose() { if (myDndManager != null) { if (myDropTarget != null) { @@ -211,12 +212,14 @@ public abstract class AbstractProjectViewPane implements DataProvider, Disposabl private void doSelectModuleOrGroup(final Object toSelect, final boolean requestFocus) { ToolWindowManager windowManager=ToolWindowManager.getInstance(myProject); final Runnable runnable = new Runnable() { + @Override public void run() { ProjectView projectView = ProjectView.getInstance(myProject); if (requestFocus) { projectView.changeView(getId(), getSubId()); } ((BaseProjectTreeBuilder)getTreeBuilder()).selectInWidth(toSelect, requestFocus, new Condition(){ + @Override public boolean value(final AbstractTreeNode node) { return node instanceof AbstractModuleNode || node instanceof ModuleGroupNode || node instanceof AbstractProjectNode; } @@ -260,6 +263,7 @@ public abstract class AbstractProjectViewPane implements DataProvider, Disposabl return result; } + @Override public Object getData(String dataId) { if (PlatformDataKeys.NAVIGATABLE_ARRAY.is(dataId)) { TreePath[] paths = getSelectionPaths(); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/DirectoryUrl.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/DirectoryUrl.java index 27c6f18f0a1d..9c431c9a0630 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/DirectoryUrl.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/DirectoryUrl.java @@ -45,6 +45,7 @@ public class DirectoryUrl extends AbstractUrl { return new DirectoryUrl(virtualFile.getUrl(), module != null ? module.getName() : null); } + @Override public Object[] createPath(final Project project) { if (moduleName != null) { final Module module = ApplicationManager.getApplication().runReadAction(new Computable() { @@ -70,10 +71,12 @@ public class DirectoryUrl extends AbstractUrl { return new Object[]{directory}; } + @Override protected AbstractUrl createUrl(String moduleName, String url) { return new DirectoryUrl(url, moduleName); } + @Override public AbstractUrl createUrlByElement(Object element) { if (element instanceof PsiDirectory) { return create((PsiDirectory)element); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/FavoritesViewToolWindowFactory.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/FavoritesViewToolWindowFactory.java index a0b12e1bf188..17aa1b673f0c 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/FavoritesViewToolWindowFactory.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/FavoritesViewToolWindowFactory.java @@ -29,6 +29,7 @@ import com.intellij.ui.content.ContentManager; * @author Konstantin Bulenkov */ public class FavoritesViewToolWindowFactory implements ToolWindowFactory, DumbAware { + @Override public void createToolWindowContent(Project project, ToolWindow toolWindow) { if (toolWindow != null) { final ContentManager contentManager = toolWindow.getContentManager(); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/GroupByTypeComparator.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/GroupByTypeComparator.java index 7b8bb0753383..162f1ee76be0 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/GroupByTypeComparator.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/GroupByTypeComparator.java @@ -42,6 +42,7 @@ public class GroupByTypeComparator implements Comparator { myForceSortByType = forceSortByType; } + @Override public int compare(NodeDescriptor descriptor1, NodeDescriptor descriptor2) { if (!isSortByType() && descriptor1 instanceof ProjectViewNode && ((ProjectViewNode) descriptor1).isSortByFirstChild()) { final Collection children = ((ProjectViewNode)descriptor1).getChildren(); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/LibraryModuleGroupUrl.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/LibraryModuleGroupUrl.java index 5dd36d673ea1..360a86ad0fef 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/LibraryModuleGroupUrl.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/LibraryModuleGroupUrl.java @@ -31,16 +31,19 @@ public class LibraryModuleGroupUrl extends AbstractUrl { super(null, moduleName, ELEMENT_TYPE); } + @Override public Object[] createPath(Project project) { final Module module = moduleName != null ? ModuleManager.getInstance(project).findModuleByName(moduleName) : null; if (module == null) return null; return new Object[]{new LibraryGroupElement(module)}; } + @Override protected AbstractUrl createUrl(String moduleName, String url) { return new LibraryModuleGroupUrl(moduleName); } + @Override public AbstractUrl createUrlByElement(Object element) { if (element instanceof LibraryGroupElement) { LibraryGroupElement libraryGroupElement = (LibraryGroupElement)element; diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ModuleGroupUrl.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ModuleGroupUrl.java index e674da95e0f4..2e4c6f9fe167 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ModuleGroupUrl.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ModuleGroupUrl.java @@ -27,15 +27,18 @@ public class ModuleGroupUrl extends AbstractUrl { super(url, null, ELEMENT_TYPE); } + @Override public Object[] createPath(Project project) { final String[] groupPath = url.split(";"); return new Object[]{new ModuleGroup(groupPath)}; } + @Override protected AbstractUrl createUrl(String moduleName, String url) { return new ModuleGroupUrl(url); } + @Override public AbstractUrl createUrlByElement(Object element) { if (element instanceof ModuleGroup) { ModuleGroup group = (ModuleGroup)element; diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ModuleUrl.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ModuleUrl.java index 10006025827d..e41093b023e9 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ModuleUrl.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ModuleUrl.java @@ -31,16 +31,19 @@ public class ModuleUrl extends AbstractUrl { super(url, moduleName,ELEMENT_TYPE); } + @Override public Object[] createPath(Project project) { final Module module = moduleName != null ? ModuleManager.getInstance(project).findModuleByName(moduleName) : null; if (module == null) return null; return new Object[]{module}; } + @Override protected AbstractUrl createUrl(String moduleName, String url) { return new ModuleUrl(url, moduleName); } + @Override public AbstractUrl createUrlByElement(Object element) { if (element instanceof Module) { Module module = (Module)element; diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/MoveModuleToGroup.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/MoveModuleToGroup.java index 70752bf5c459..97d52d8a4e13 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/MoveModuleToGroup.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/MoveModuleToGroup.java @@ -41,6 +41,7 @@ public class MoveModuleToGroup extends ActionGroup { setPopup(true); } + @Override public void update(AnActionEvent e){ final DataContext dataContext = e.getDataContext(); final Project project = PlatformDataKeys.PROJECT.getData(dataContext); @@ -51,12 +52,14 @@ public class MoveModuleToGroup extends ActionGroup { presentation.setText(myModuleGroup.presentableText()); } + @Override @NotNull public AnAction[] getChildren(@Nullable AnActionEvent e) { if (e == null) return EMPTY_ARRAY; List children = new ArrayList(myModuleGroup.childGroups(e.getDataContext())); Collections.sort ( children, new Comparator() { + @Override public int compare(final ModuleGroup moduleGroup1, final ModuleGroup moduleGroup2) { assert moduleGroup1.getGroupPath().length == moduleGroup2.getGroupPath().length; return moduleGroup1.toString().compareToIgnoreCase(moduleGroup2.toString()); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/MoveModuleToGroupTopLevel.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/MoveModuleToGroupTopLevel.java index 3b529b5d33af..a54ec6ae5fa0 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/MoveModuleToGroupTopLevel.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/MoveModuleToGroupTopLevel.java @@ -32,6 +32,7 @@ import org.jetbrains.annotations.Nullable; import java.util.*; public class MoveModuleToGroupTopLevel extends ActionGroup { + @Override public void update(AnActionEvent e){ final DataContext dataContext = e.getDataContext(); final Project project = PlatformDataKeys.PROJECT.getData(dataContext); @@ -40,6 +41,7 @@ public class MoveModuleToGroupTopLevel extends ActionGroup { e.getPresentation().setVisible(active); } + @Override @NotNull public AnAction[] getChildren(@Nullable AnActionEvent e) { if (e == null) { diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/NamedLibraryUrl.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/NamedLibraryUrl.java index 8f6d3fd82cb7..d109c6ad69a6 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/NamedLibraryUrl.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/NamedLibraryUrl.java @@ -34,6 +34,7 @@ public class NamedLibraryUrl extends AbstractUrl { super(url, moduleName, ELEMENT_TYPE); } + @Override public Object[] createPath(Project project) { final Module module = moduleName != null ? ModuleManager.getInstance(project).findModuleByName(moduleName) : null; if (module == null) return null; @@ -45,10 +46,12 @@ public class NamedLibraryUrl extends AbstractUrl { return null; } + @Override protected AbstractUrl createUrl(String moduleName, String url) { return new NamedLibraryUrl(url, moduleName); } + @Override public AbstractUrl createUrlByElement(Object element) { if (element instanceof NamedLibraryElement) { NamedLibraryElement libraryElement = (NamedLibraryElement)element; diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectAbstractTreeStructureBase.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectAbstractTreeStructureBase.java index 601daa4d9c94..54e08152ba06 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectAbstractTreeStructureBase.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectAbstractTreeStructureBase.java @@ -31,6 +31,7 @@ public abstract class ProjectAbstractTreeStructureBase extends AbstractTreeStruc super(project); } + @Override public List getProviders() { if (myProviders == null) { final TreeStructureProvider[] providers = Extensions.getExtensions(TreeStructureProvider.EP_NAME, myProject); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectTreeStructure.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectTreeStructure.java index 5eed68d2ddba..d8a654fa04d2 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectTreeStructure.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectTreeStructure.java @@ -31,26 +31,32 @@ public abstract class ProjectTreeStructure extends AbstractProjectTreeStructure myId = ID; } + @Override public boolean isFlattenPackages() { return ProjectView.getInstance(myProject).isFlattenPackages(myId); } + @Override public boolean isShowMembers() { return ProjectView.getInstance(myProject).isShowMembers(myId); } + @Override public boolean isHideEmptyMiddlePackages() { return ProjectView.getInstance(myProject).isHideEmptyMiddlePackages(myId); } + @Override public boolean isAbbreviatePackageNames() { return ProjectView.getInstance(myProject).isAbbreviatePackageNames(myId); } + @Override public boolean isShowLibraryContents() { return ProjectView.getInstance(myProject).isShowLibraryContents(myId); } + @Override public boolean isShowModules() { return ProjectView.getInstance(myProject).isShowModules(myId); } diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewDropTarget.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewDropTarget.java index e47ca4e2b21a..362ad0123f54 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewDropTarget.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewDropTarget.java @@ -232,10 +232,12 @@ class ProjectViewDropTarget implements DnDNativeTarget { } public abstract class MoveCopyDropHandler implements DropHandler { + @Override public boolean isValidSource(@NotNull final TreeNode[] sourceNodes, TreeNode targetNode) { return canDrop(sourceNodes, targetNode); } + @Override public boolean isValidTarget(@NotNull final TreeNode[] sourceNodes, final @NotNull TreeNode targetNode) { return canDrop(sourceNodes, targetNode); } @@ -279,6 +281,7 @@ class ProjectViewDropTarget implements DnDNativeTarget { } private class MoveDropHandler extends MoveCopyDropHandler { + @Override protected boolean canDrop(@NotNull final TreeNode[] sourceNodes, @Nullable final TreeNode targetNode) { if (targetNode instanceof DefaultMutableTreeNode) { final Object userObject = ((DefaultMutableTreeNode)targetNode).getUserObject(); @@ -293,6 +296,7 @@ class ProjectViewDropTarget implements DnDNativeTarget { MoveHandler.canMove(sourceElements, targetElement)); } + @Override public void doDrop(@NotNull final TreeNode[] sourceNodes, @NotNull final TreeNode targetNode) { if (targetNode instanceof DefaultMutableTreeNode) { final Object userObject = ((DefaultMutableTreeNode)targetNode).getUserObject(); @@ -311,6 +315,7 @@ class ProjectViewDropTarget implements DnDNativeTarget { final Module module = getModule(targetNode); final DataContext dataContext = DataManager.getInstance().getDataContext(myTree); getActionHandler().invoke(myProject, sourceElements, new DataContext() { + @Override @Nullable public Object getData(@NonNls String dataId) { if (LangDataKeys.TARGET_MODULE.is(dataId)) { @@ -330,15 +335,18 @@ class ProjectViewDropTarget implements DnDNativeTarget { return RefactoringActionHandlerFactory.getInstance().createMoveHandler(); } + @Override public boolean isDropRedundant(@NotNull TreeNode sourceNode, @NotNull TreeNode targetNode) { return sourceNode.getParent() == targetNode || MoveHandler.isMoveRedundant(getPsiElement(sourceNode), getPsiElement(targetNode)); } + @Override public boolean shouldDelegateToParent(TreeNode[] sourceNodes, @NotNull final TreeNode targetNode) { final PsiElement psiElement = getPsiElement(targetNode); return !MoveHandler.isValidTarget(psiElement, getPsiElements(sourceNodes)); } + @Override public void doDropFiles(List fileList, TreeNode targetNode) { final PsiFileSystemItem[] sourceFileArray = getPsiFiles(fileList); @@ -355,6 +363,7 @@ class ProjectViewDropTarget implements DnDNativeTarget { } private class CopyDropHandler extends MoveCopyDropHandler { + @Override protected boolean canDrop(@NotNull final TreeNode[] sourceNodes, @Nullable final TreeNode targetNode) { final PsiElement[] sourceElements = getPsiElements(sourceNodes); final PsiElement targetElement = getPsiElement(targetNode); @@ -365,6 +374,7 @@ class ProjectViewDropTarget implements DnDNativeTarget { return isTargetAcceptable && CopyHandler.canCopy(sourceElements); } + @Override public void doDrop(@NotNull final TreeNode[] sourceNodes, @NotNull final TreeNode targetNode) { final PsiElement[] sourceElements = getPsiElements(sourceNodes); doDrop(targetNode, sourceElements); @@ -389,15 +399,18 @@ class ProjectViewDropTarget implements DnDNativeTarget { CopyHandler.doCopy(sourceElements, psiDirectory); } + @Override public boolean isDropRedundant(@NotNull TreeNode sourceNode, @NotNull TreeNode targetNode) { return false; } + @Override public boolean shouldDelegateToParent(TreeNode[] sourceNodes, @NotNull final TreeNode targetNode) { final PsiElement psiElement = getPsiElement(targetNode); return psiElement == null || (!(psiElement instanceof PsiDirectoryContainer) && !(psiElement instanceof PsiDirectory)); } + @Override public void doDropFiles(List fileList, TreeNode targetNode) { final PsiFileSystemItem[] sourceFileArray = getPsiFiles(fileList); doDrop(targetNode, sourceFileArray); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewImpl.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewImpl.java index b53dc99b3bef..d1a3d7727bed 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewImpl.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewImpl.java @@ -178,6 +178,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo private static final String ATTRIBUTE_ID = "id"; private JPanel myViewContentPanel; private static final Comparator PANE_WEIGHT_COMPARATOR = new Comparator() { + @Override public int compare(final AbstractProjectViewPane o1, final AbstractProjectViewPane o2) { return o1.getWeight() - o2.getWeight(); } @@ -201,6 +202,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo myConnection = project.getMessageBus().connect(); myConnection.subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootAdapter() { + @Override public void rootsChanged(ModuleRootEvent event) { refresh(); } @@ -211,6 +213,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo myDataProvider = new MyPanel(); myDataProvider.add(myPanel, BorderLayout.CENTER); myCopyPasteDelegator = new CopyPasteDelegator(myProject, myPanel) { + @Override @NotNull protected PsiElement[] getSelectedElements() { final AbstractProjectViewPane viewPane = getCurrentProjectViewPane(); @@ -218,10 +221,12 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo } }; myAutoScrollToSourceHandler = new AutoScrollToSourceHandler() { + @Override protected boolean isAutoScrollMode() { return isAutoscrollToSource(myCurrentViewId); } + @Override protected void setAutoScrollMode(boolean state) { setAutoscrollToSource(state, myCurrentViewId); } @@ -229,6 +234,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo toolWindowManager.addToolWindowManagerListener(new ToolWindowManagerAdapter(){ private boolean toolWindowVisible; + @Override public void stateChanged() { ToolWindow window = toolWindowManager.getToolWindow(ToolWindowId.PROJECT_VIEW); if (window == null) return; @@ -252,10 +258,12 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo myPanel.setContent(myViewContentPanel); } + @Override public String getName() { return "Project"; } + @Override public List getActions(boolean originalProvider) { ArrayList result = new ArrayList(); @@ -330,10 +338,12 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo } } + @Override public boolean isCycleRoot() { return false; } + @Override public synchronized void addProjectPane(final AbstractProjectViewPane pane) { myUninitializedPanes.add(pane); SelectInTarget selectInTarget = pane.createSelectInTarget(); @@ -345,6 +355,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo } } + @Override public synchronized void removeProjectPane(AbstractProjectViewPane pane) { myUninitializedPanes.remove(pane); //assume we are completely initialized here @@ -423,6 +434,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo content.setIcon(newPane.getIcon()); content.setPopupIcon(subId != null ? AllIcons.General.Bullet : newPane.getIcon()); content.setPreferredFocusedComponent(new Computable() { + @Override public JComponent compute() { final AbstractProjectViewPane current = getCurrentProjectViewPane(); return current != null ? current.getComponentToFocus() : null; @@ -470,20 +482,24 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo if (selectedPsiElement != null) { final VirtualFile virtualFile = PsiUtilCore.getVirtualFile(selectedPsiElement); if (virtualFile != null && ((ProjectViewSelectInTarget)newPane.createSelectInTarget()).isSubIdSelectable(newSubId, new SelectInContext() { + @Override @NotNull public Project getProject() { return myProject; } + @Override @NotNull public VirtualFile getVirtualFile() { return virtualFile; } + @Override public Object getSelectorInFile() { return null; } + @Override public FileEditorProvider getFileEditorProvider() { return null; } @@ -539,6 +555,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo GuiUtils.replaceJSplitPaneWithIDEASplitter(myPanel); SwingUtilities.invokeLater(new Runnable() { + @Override public void run() { splitterProportions.restoreSplitterProportions(myPanel); } @@ -602,6 +619,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo myActionGroup.addAction(new PaneOptionAction(myFlattenPackages, IdeBundle.message("action.flatten.packages"), IdeBundle.message("action.flatten.packages"), PlatformIcons.FLATTEN_PACKAGES_ICON, ourFlattenPackagesDefaults) { + @Override public void setSelected(AnActionEvent event, boolean flag) { final AbstractProjectViewPane viewPane = getCurrentProjectViewPane(); final SelectionInfo selectionInfo = SelectionInfo.create(viewPane); @@ -622,6 +640,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo super(optionsMap, text, description, icon, optionDefaultValue); } + @Override public void update(AnActionEvent e) { super.update(e); final Presentation presentation = e.getPresentation(); @@ -637,11 +656,13 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo IdeBundle.message("action.abbreviate.qualified.package.names"), AllIcons.ObjectBrowser.AbbreviatePackageNames, ourAbbreviatePackagesDefaults) { + @Override public boolean isSelected(AnActionEvent event) { return super.isSelected(event) && isAbbreviatePackageNames(myCurrentViewId); } + @Override public void update(AnActionEvent e) { super.update(e); if (ScopeViewPane.ID.equals(myCurrentViewId)) { @@ -665,14 +686,17 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo myActionGroup.addAction(new ScrollFromSourceAction()); } AnAction collapseAllAction = CommonActionsManager.getInstance().createCollapseAllAction(new TreeExpander() { + @Override public void expandAll() { } + @Override public boolean canExpand() { return false; } + @Override public void collapseAll() { AbstractProjectViewPane pane = getCurrentProjectViewPane(); JTree tree = pane.myTree; @@ -681,6 +705,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo } } + @Override public boolean canCollapse() { return true; } @@ -689,6 +714,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo getCurrentProjectViewPane().addToolbarActions(myActionGroup); } + @Override public AbstractProjectViewPane getProjectViewPaneById(String id) { if (!ApplicationManager.getApplication().isUnitTestMode()) { // most tests don't need all panes to be loaded ensurePanesLoaded(); @@ -706,10 +732,12 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo return null; } + @Override public AbstractProjectViewPane getCurrentProjectViewPane() { return getProjectViewPaneById(myCurrentViewId); } + @Override public void refresh() { AbstractProjectViewPane currentProjectViewPane = getCurrentProjectViewPane(); if (currentProjectViewPane != null) { @@ -718,6 +746,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo } } + @Override public void select(final Object element, VirtualFile file, boolean requestFocus) { final AbstractProjectViewPane viewPane = getCurrentProjectViewPane(); if (viewPane != null) { @@ -725,6 +754,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo } } + @Override public ActionCallback selectCB(Object element, VirtualFile file, boolean requestFocus) { final AbstractProjectViewPane viewPane = getCurrentProjectViewPane(); if (viewPane != null && viewPane instanceof AbstractProjectViewPSIPane) { @@ -735,18 +765,22 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo } } + @Override public void dispose() { myConnection.disconnect(); } + @Override public JComponent getComponent() { return myDataProvider; } + @Override public String getCurrentViewId() { return myCurrentViewId; } + @Override public PsiElement getParentOfCurrentSelection() { final AbstractProjectViewPane viewPane = getCurrentProjectViewPane(); if (viewPane == null) { @@ -792,15 +826,18 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo myOptionDefaultValue = optionDefaultValue; } + @Override public boolean isSelected(AnActionEvent event) { return getPaneOptionValue(myOptionsMap, myCurrentViewId, myOptionDefaultValue); } + @Override public void setSelected(AnActionEvent event, boolean flag) { setPaneOption(myOptionsMap, flag, myCurrentViewId, true); } } + @Override public void changeView() { final List views = new ArrayList(myId2Pane.values()); views.remove(getCurrentProjectViewPane()); @@ -808,6 +845,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo final JList list = new JBList(ArrayUtil.toObjectArray(views)); list.setCellRenderer(new DefaultListCellRenderer() { + @Override public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) { super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus); AbstractProjectViewPane pane = (AbstractProjectViewPane)value; @@ -820,6 +858,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo list.setSelectedValue(views.get(0), true); } Runnable runnable = new Runnable() { + @Override public void run() { if (list.getSelectedIndex() < 0) return; AbstractProjectViewPane pane = (AbstractProjectViewPane)list.getSelectedValue(); @@ -833,10 +872,12 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo createPopup().showInCenterOf(getComponent()); } + @Override public void changeView(@NotNull String viewId) { changeView(viewId, null); } + @Override public void changeView(@NotNull String viewId, @Nullable String subId) { AbstractProjectViewPane pane = getProjectViewPaneById(viewId); LOG.assertTrue(pane != null, "Project view pane not found: " + viewId + "; subId:" + subId); @@ -853,11 +894,13 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo } private final class MyDeletePSIElementProvider implements DeleteProvider { + @Override public boolean canDeleteElement(@NotNull DataContext dataContext) { final PsiElement[] elements = getElementsToDelete(); return DeleteHandler.shouldEnableDeleteAction(elements); } + @Override public void deleteElement(@NotNull DataContext dataContext) { List allElements = Arrays.asList(getElementsToDelete()); List validElements = new ArrayList(); @@ -942,6 +985,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo return ((NodeDescriptor)userObject).getElement(); } + @Override public Object getData(String dataId) { final AbstractProjectViewPane currentProjectViewPane = getCurrentProjectViewPane(); if (currentProjectViewPane != null) { @@ -1005,10 +1049,12 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo final LibraryOrderEntry orderEntry = getSelectedLibrary(); if (orderEntry != null) { return new DeleteProvider() { + @Override public void deleteElement(@NotNull DataContext dataContext) { detachLibrary(orderEntry, myProject); } + @Override public boolean canDeleteElement(@NotNull DataContext dataContext) { return true; } @@ -1102,8 +1148,10 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo int ret = Messages.showOkCancelDialog(project, message, title, Messages.getQuestionIcon()); if (ret != 0) return; CommandProcessor.getInstance().executeCommand(module.getProject(), new Runnable() { + @Override public void run() { final Runnable action = new Runnable() { + @Override public void run() { ModuleRootManager rootManager = ModuleRootManager.getInstance(module); OrderEntry[] orderEntries = rootManager.getOrderEntries(); @@ -1186,6 +1234,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo } private final class MyIdeView implements IdeView { + @Override public void selectElement(PsiElement element) { selectPsiElement(element, false); boolean requestFocus = true; @@ -1205,6 +1254,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo } } + @Override public PsiDirectory[] getDirectories() { final AbstractProjectViewPane viewPane = getCurrentProjectViewPane(); if (viewPane != null) { @@ -1214,11 +1264,13 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo return PsiDirectory.EMPTY_ARRAY; } + @Override public PsiDirectory getOrChooseDirectory() { return DirectoryChooserUtil.getOrChooseDirectory(this); } } + @Override public void selectPsiElement(PsiElement element, boolean requestFocus) { if (element == null) return; VirtualFile virtualFile = PsiUtilBase.getVirtualFile(element); @@ -1247,6 +1299,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo parentNode.addContent(e); } + @Override public void loadState(Element parentNode) { Element navigatorElement = parentNode.getChild(ELEMENT_NAVIGATOR); if (navigatorElement != null) { @@ -1300,6 +1353,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo } } + @Override public Element getState() { Element parentNode = new Element("projectView"); Element navigatorElement = new Element(ELEMENT_NAVIGATOR); @@ -1357,6 +1411,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo } } + @Override public boolean isAutoscrollToSource(String paneId) { return getPaneOptionValue(myAutoscrollToSource, paneId, ourAutoscrollToSourceDefaults); } @@ -1365,6 +1420,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo myAutoscrollToSource.put(paneId, autoscrollMode ? Boolean.TRUE : Boolean.FALSE); } + @Override public boolean isAutoscrollFromSource(String paneId) { return getPaneOptionValue(myAutoscrollFromSource, paneId, ourAutoscrollFromSourceDefaults); } @@ -1373,6 +1429,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo setPaneOption(myAutoscrollFromSource, autoscrollMode, paneId, false); } + @Override public boolean isFlattenPackages(String paneId) { return getPaneOptionValue(myFlattenPackages, paneId, ourFlattenPackagesDefaults); } @@ -1381,6 +1438,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo setPaneOption(myFlattenPackages, flattenPackages, paneId, true); } + @Override public boolean isShowMembers(String paneId) { return getPaneOptionValue(myShowMembers, paneId, ourShowMembersDefaults); } @@ -1389,18 +1447,22 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo setPaneOption(myShowMembers, showMembers, paneId, true); } + @Override public boolean isHideEmptyMiddlePackages(String paneId) { return getPaneOptionValue(myHideEmptyPackages, paneId, ourHideEmptyPackagesDefaults); } + @Override public boolean isAbbreviatePackageNames(String paneId) { return getPaneOptionValue(myAbbreviatePackageNames, paneId, ourAbbreviatePackagesDefaults); } + @Override public boolean isShowLibraryContents(String paneId) { return getPaneOptionValue(myShowLibraryContents, paneId, ourShowLibraryContentsDefaults); } + @Override public void setShowLibraryContents(boolean showLibraryContents, String paneId) { setPaneOption(myShowLibraryContents, showLibraryContents, paneId, true); } @@ -1409,18 +1471,22 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo return setPaneOption(myShowLibraryContents, showLibraryContents, paneId, true); } + @Override public boolean isShowModules(String paneId) { return getPaneOptionValue(myShowModules, paneId, ourShowModulesDefaults); } + @Override public void setShowModules(boolean showModules, String paneId) { setPaneOption(myShowModules, showModules, paneId, true); } + @Override public void setHideEmptyPackages(boolean hideEmptyPackages, String paneId) { setPaneOption(myHideEmptyPackages, hideEmptyPackages, paneId, true); } + @Override public void setAbbreviatePackageNames(boolean abbreviatePackageNames, String paneId) { setPaneOption(myAbbreviatePackageNames, abbreviatePackageNames, paneId, true); } @@ -1446,6 +1512,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo super(myHideEmptyPackages, "", "", null, ourHideEmptyPackagesDefaults); } + @Override public void setSelected(AnActionEvent event, boolean flag) { final AbstractProjectViewPane viewPane = getCurrentProjectViewPane(); final SelectionInfo selectionInfo = SelectionInfo.create(viewPane); @@ -1455,6 +1522,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo selectionInfo.apply(viewPane); } + @Override public void update(AnActionEvent e) { super.update(e); final Presentation presentation = e.getPresentation(); @@ -1599,10 +1667,12 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo } } + @Override protected boolean isAutoScrollEnabled() { return isAutoscrollFromSource(myCurrentViewId); } + @Override protected void setAutoScrollEnabled(boolean state) { setAutoscrollFromSource(state, myCurrentViewId); if (state) { @@ -1624,6 +1694,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo myEditor = editor; } + @Override @NotNull public Project getProject() { return myProject; @@ -1633,9 +1704,11 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo return myPsiFile; } + @Override public FileEditorProvider getFileEditorProvider() { if (myPsiFile == null) return null; return new FileEditorProvider() { + @Override public FileEditor openFileEditor() { return myFileEditorManager.openFile(myPsiFile.getContainingFile().getVirtualFile(), false)[0]; } @@ -1655,21 +1728,25 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo return e; } + @Override @NotNull public VirtualFile getVirtualFile() { return getPsiFile().getVirtualFile(); } + @Override public Object getSelectorInFile() { return getPsiElement(); } } } + @Override public boolean isSortByType(String paneId) { return getPaneOptionValue(mySortByType, paneId, ourSortByTypeDefaults); } + @Override public void setSortByType(String paneId, final boolean sortByType) { setPaneOption(mySortByType, sortByType, paneId, false); final AbstractProjectViewPane pane = getProjectViewPaneById(paneId); @@ -1682,14 +1759,17 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo AllIcons.ObjectBrowser.SortByType); } + @Override public boolean isSelected(AnActionEvent event) { return isSortByType(getCurrentViewId()); } + @Override public void setSelected(AnActionEvent event, boolean flag) { setSortByType(getCurrentViewId(), flag); } + @Override public void update(final AnActionEvent e) { super.update(e); final Presentation presentation = e.getPresentation(); @@ -1709,6 +1789,7 @@ public class ProjectViewImpl extends ProjectView implements PersistentStateCompo } } + @Override public Collection getPaneIds() { return myId2Pane.keySet(); } diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewPane.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewPane.java index 27990f69210b..8203be718b44 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewPane.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewPane.java @@ -45,42 +45,51 @@ public class ProjectViewPane extends AbstractProjectViewPSIPane { super(project); } + @Override public String getTitle() { return IdeBundle.message("title.project"); } + @Override @NotNull public String getId() { return ID; } + @Override public Icon getIcon() { return AllIcons.General.ProjectTab; } + @Override public SelectInTarget createSelectInTarget() { return new ProjectPaneSelectInTarget(myProject); } + @Override protected AbstractTreeUpdater createTreeUpdater(AbstractTreeBuilder treeBuilder) { return new ProjectViewTreeUpdater(treeBuilder); } + @Override protected ProjectAbstractTreeStructureBase createStructure() { return new ProjectTreeStructure(myProject, ID){ + @Override protected AbstractTreeNode createRoot(final Project project, ViewSettings settings) { return new ProjectViewProjectNode(project, settings); } }; } + @Override protected ProjectViewTree createTree(DefaultTreeModel treeModel) { return new ProjectViewTree(myProject, treeModel) { public String toString() { return getTitle() + " " + super.toString(); } + @Override public DefaultMutableTreeNode getSelectedNode() { return ProjectViewPane.this.getSelectedNode(); } @@ -94,6 +103,7 @@ public class ProjectViewPane extends AbstractProjectViewPSIPane { // should be first + @Override public int getWeight() { return 0; } @@ -103,6 +113,7 @@ public class ProjectViewPane extends AbstractProjectViewPSIPane { super(treeBuilder); } + @Override public boolean addSubtreeToUpdateByElement(Object element) { if (element instanceof PsiDirectory) { final PsiDirectory dir = (PsiDirectory)element; diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewToolWindowFactory.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewToolWindowFactory.java index 898d75208dc5..192f5966c489 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewToolWindowFactory.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewToolWindowFactory.java @@ -28,6 +28,7 @@ import com.intellij.openapi.wm.ToolWindowFactoryEx; * @author yole */ public class ProjectViewToolWindowFactory implements ToolWindowFactoryEx, DumbAware { + @Override public void createToolWindowContent(Project project, ToolWindow toolWindow) { ((ProjectViewImpl) ProjectView.getInstance(project)).setupImpl(toolWindow); } diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewTree.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewTree.java index ca3b75628bdb..0f5f9e74ea9e 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewTree.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ProjectViewTree.java @@ -67,6 +67,7 @@ public abstract class ProjectViewTree extends JBTreeWithHintProvider { return myProject; } + @Override public final int getToggleClickCount() { final DefaultMutableTreeNode selectedNode = getSelectedNode(); if (selectedNode != null) { diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/PsiFileUrl.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/PsiFileUrl.java index 118ea0435e04..75e62f0f3160 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/PsiFileUrl.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/PsiFileUrl.java @@ -36,6 +36,7 @@ public class PsiFileUrl extends AbstractUrl { super(url, null, ELEMENT_TYPE); } + @Override public Object[] createPath(final Project project) { final VirtualFile file = VirtualFileManager.getInstance().findFileByUrl(url); if (file == null || !file.isValid()){ @@ -44,10 +45,12 @@ public class PsiFileUrl extends AbstractUrl { return new Object[]{PsiManager.getInstance(project).findFile(file)}; } + @Override protected AbstractUrl createUrl(String moduleName, String url) { return new PsiFileUrl(url); } + @Override public AbstractUrl createUrlByElement(Object element) { if (element instanceof PsiFile) { VirtualFile file = ((PsiFile)element).getVirtualFile(); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/RenameModuleHandler.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/RenameModuleHandler.java index f38dedb29047..6028841e6a02 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/RenameModuleHandler.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/RenameModuleHandler.java @@ -50,19 +50,23 @@ import org.jetbrains.annotations.Nullable; public class RenameModuleHandler implements RenameHandler, TitledHandler { private static final Logger LOG = Logger.getInstance("#com.intellij.ide.projectView.actions.RenameModuleHandler"); + @Override public boolean isAvailableOnDataContext(DataContext dataContext) { Module module = LangDataKeys.MODULE_CONTEXT.getData(dataContext); return module != null; } + @Override public boolean isRenaming(DataContext dataContext) { return isAvailableOnDataContext(dataContext); } + @Override public void invoke(@NotNull Project project, Editor editor, PsiFile file, DataContext dataContext) { LOG.assertTrue(false); } + @Override public void invoke(@NotNull final Project project, @NotNull PsiElement[] elements, @NotNull DataContext dataContext) { final Module module = LangDataKeys.MODULE_CONTEXT.getData(dataContext); LOG.assertTrue(module != null); @@ -74,6 +78,7 @@ public class RenameModuleHandler implements RenameHandler, TitledHandler { new MyInputValidator(project, module)); } + @Override public String getActionTitle() { return RefactoringBundle.message("rename.module.title"); } @@ -86,18 +91,22 @@ public class RenameModuleHandler implements RenameHandler, TitledHandler { myModule = module; } + @Override public boolean checkInput(String inputString) { return inputString != null && inputString.length() > 0; } + @Override public boolean canClose(final String inputString) { final String oldName = myModule.getName(); final ModifiableModuleModel modifiableModel = renameModule(inputString); if (modifiableModel == null) return false; final Ref success = Ref.create(Boolean.TRUE); CommandProcessor.getInstance().executeCommand(myProject, new Runnable() { + @Override public void run() { UndoableAction action = new BasicUndoableAction() { + @Override public void undo() throws UnexpectedUndoException { final ModifiableModuleModel modifiableModel = renameModule(oldName); if (modifiableModel != null) { @@ -115,6 +124,7 @@ public class RenameModuleHandler implements RenameHandler, TitledHandler { }; UndoManager.getInstance(myProject).undoableActionPerformed(action); ApplicationManager.getApplication().runWriteAction(new Runnable() { + @Override public void run() { modifiableModel.commit(); } diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ShowModulesAction.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ShowModulesAction.java index 16c7c1d06add..6bbe5873e521 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/ShowModulesAction.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/ShowModulesAction.java @@ -26,17 +26,20 @@ public abstract class ShowModulesAction extends ToggleAction { myProject = project; } + @Override public boolean isSelected(AnActionEvent event) { return ProjectView.getInstance(myProject).isShowModules(getId()); } protected abstract String getId(); + @Override public void setSelected(AnActionEvent event, boolean flag) { final ProjectViewImpl projectView = (ProjectViewImpl)ProjectView.getInstance(myProject); projectView.setShowModules(flag, getId()); } + @Override public void update(AnActionEvent e) { super.update(e); final Presentation presentation = e.getPresentation(); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/AbstractModuleNode.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/AbstractModuleNode.java index 96eb7ea6bf45..376ccde44920 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/AbstractModuleNode.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/AbstractModuleNode.java @@ -38,6 +38,7 @@ public abstract class AbstractModuleNode extends ProjectViewNode impleme super(project, module, viewSettings); } + @Override public void update(PresentationData presentation) { if (getValue().isDisposed()) { setValue(null); @@ -56,6 +57,7 @@ public abstract class AbstractModuleNode extends ProjectViewNode impleme } + @Override public String getTestPresentation() { return "Module"; } @@ -84,11 +86,13 @@ public abstract class AbstractModuleNode extends ProjectViewNode impleme return false; } + @Override public String getToolTip() { final Module module = getValue(); return ModuleType.get(module).getName(); } + @Override public void navigate(final boolean requestFocus) { ProjectSettingsService.getInstance(myProject).openModuleSettings(getValue()); } @@ -98,6 +102,7 @@ public abstract class AbstractModuleNode extends ProjectViewNode impleme return "Open Module Settings"; } + @Override public boolean canNavigate() { return ProjectSettingsService.getInstance(myProject).canOpenModuleSettings(); } diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/AbstractProjectNode.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/AbstractProjectNode.java index f2ffd6cfe9ed..9c41def08fa9 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/AbstractProjectNode.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/AbstractProjectNode.java @@ -77,15 +77,18 @@ public abstract class AbstractProjectNode extends ProjectViewNode { protected abstract AbstractTreeNode createModuleGroupNode(final ModuleGroup moduleGroup) throws InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException; + @Override public void update(PresentationData presentation) { presentation.setIcon(PlatformIcons.PROJECT_ICON); presentation.setPresentableText(getProject().getName()); } + @Override public String getTestPresentation() { return "Project"; } + @Override public boolean contains(@NotNull VirtualFile file) { ProjectFileIndex index = ProjectRootManager.getInstance(getProject()).getFileIndex(); final VirtualFile baseDir = getProject().getBaseDir(); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/AbstractPsiBasedNode.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/AbstractPsiBasedNode.java index b111de43cea3..b61212df543f 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/AbstractPsiBasedNode.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/AbstractPsiBasedNode.java @@ -68,6 +68,7 @@ public abstract class AbstractPsiBasedNode extends ProjectViewNode protected abstract Collection getChildrenImpl(); protected abstract void updateImpl(final PresentationData data); + @Override @NotNull public final Collection getChildren() { final PsiElement psiElement = extractPsiFromValue(); @@ -83,6 +84,7 @@ public abstract class AbstractPsiBasedNode extends ProjectViewNode return children != null ? children : Collections.emptyList(); } + @Override public boolean isValid() { final PsiElement psiElement = extractPsiFromValue(); return psiElement != null && psiElement.isValid(); @@ -103,6 +105,7 @@ public abstract class AbstractPsiBasedNode extends ProjectViewNode } + @Override public FileStatus getFileStatus() { VirtualFile file = getVirtualFileForValue(); if (file == null) { @@ -124,6 +127,7 @@ public abstract class AbstractPsiBasedNode extends ProjectViewNode // Should be called in atomic action + @Override public void update(final PresentationData data) { AccessToken token = ReadAction.start(); try { @@ -176,6 +180,7 @@ public abstract class AbstractPsiBasedNode extends ProjectViewNode return false; } + @Override public boolean contains(@NotNull final VirtualFile file) { final PsiElement psiElement = extractPsiFromValue(); if (psiElement == null || !psiElement.isValid()) { @@ -196,6 +201,7 @@ public abstract class AbstractPsiBasedNode extends ProjectViewNode return (psiElement instanceof NavigationItem) ? (NavigationItem) psiElement : null; } + @Override public void navigate(boolean requestFocus) { if (canNavigate()) { if (requestFocus) { @@ -207,11 +213,13 @@ public abstract class AbstractPsiBasedNode extends ProjectViewNode } } + @Override public boolean canNavigate() { final NavigationItem item = getNavigationItem(); return item != null && item.canNavigate(); } + @Override public boolean canNavigateToSource() { final NavigationItem item = getNavigationItem(); return item != null && item.canNavigateToSource(); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/BasePsiNode.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/BasePsiNode.java index ce62f5952289..84e2b68d7dd0 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/BasePsiNode.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/BasePsiNode.java @@ -27,6 +27,7 @@ public abstract class BasePsiNode extends AbstractPsiBase super(project, value, viewSettings); } + @Override @Nullable protected PsiElement extractPsiFromValue() { return getValue(); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/LibraryGroupNode.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/LibraryGroupNode.java index 3ebe085514e8..f6bce09e4808 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/LibraryGroupNode.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/LibraryGroupNode.java @@ -53,6 +53,7 @@ public class LibraryGroupNode extends ProjectViewNode { this(project, (LibraryGroupElement)value, viewSettings); } + @Override @NotNull public Collection getChildren() { Module module = getValue().getModule(); @@ -107,10 +108,12 @@ public class LibraryGroupNode extends ProjectViewNode { } + @Override public String getTestPresentation() { return "Libraries"; } + @Override public boolean contains(@NotNull VirtualFile file) { final ProjectFileIndex index = ProjectRootManager.getInstance(getProject()).getFileIndex(); if (!index.isInLibrarySource(file) && !index.isInLibraryClasses(file)) { @@ -120,15 +123,18 @@ public class LibraryGroupNode extends ProjectViewNode { return someChildContainsFile(file, false); } + @Override public void update(PresentationData presentation) { presentation.setPresentableText(IdeBundle.message("node.projectview.libraries")); presentation.setIcon(PlatformIcons.LIBRARY_ICON); } + @Override public boolean canNavigate() { return ProjectSettingsService.getInstance(myProject).canOpenModuleLibrarySettings(); } + @Override public void navigate(final boolean requestFocus) { Module module = getValue().getModule(); ProjectSettingsService.getInstance(myProject).openModuleLibrarySettings(module); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/ModuleGroupNode.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/ModuleGroupNode.java index e9a3e499a369..1c3dca9dbb3a 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/ModuleGroupNode.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/ModuleGroupNode.java @@ -49,6 +49,7 @@ public abstract class ModuleGroupNode extends ProjectViewNode imple InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException; protected abstract ModuleGroupNode createModuleGroupNode(ModuleGroup moduleGroup); + @Override @NotNull public Collection getChildren() { final Collection childGroups = getValue().childGroups(getProject()); @@ -82,37 +83,45 @@ public abstract class ModuleGroupNode extends ProjectViewNode imple return result; } + @Override public boolean contains(@NotNull VirtualFile file) { return someChildContainsFile(file, false); } + @Override public void update(PresentationData presentation) { final String[] groupPath = getValue().getGroupPath(); presentation.setPresentableText(groupPath[groupPath.length-1]); presentation.setIcon(PlatformIcons.CLOSED_MODULE_GROUP_ICON); } + @Override public String getTestPresentation() { return "Group: " + getValue(); } + @Override public String getToolTip() { return IdeBundle.message("tooltip.module.group"); } + @Override public int getWeight() { return 0; } + @Override public int getTypeSortWeight(final boolean sortByType) { return 1; } + @Override public boolean canDrop(TreeNode[] sourceNodes) { final List modules = extractModules(sourceNodes); return !modules.isEmpty(); } + @Override public void drop(TreeNode[] sourceNodes, DataContext dataContext) { final List modules = extractModules(sourceNodes); MoveModulesToGroupAction.doMove(modules.toArray(new Module[modules.size()]), getValue(), null); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/ModuleListNode.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/ModuleListNode.java index 4c01dc186229..31acf3fc98a1 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/ModuleListNode.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/ModuleListNode.java @@ -41,6 +41,7 @@ public class ModuleListNode extends ProjectViewNode { this(project, (Module)value, viewSettings); } + @Override @NotNull public Collection getChildren() { Module module = getValue(); @@ -60,14 +61,17 @@ public class ModuleListNode extends ProjectViewNode { } + @Override public String getTestPresentation() { return "Modules"; } + @Override public boolean contains(@NotNull VirtualFile file) { return someChildContainsFile(file); } + @Override public void update(PresentationData presentation) { presentation.setPresentableText("Module Dependencies"); presentation.setIcon(PlatformIcons.CLOSED_MODULE_GROUP_ICON); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/NamedLibraryElementNode.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/NamedLibraryElementNode.java index bc60e5a0fcd3..001159faca81 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/NamedLibraryElementNode.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/NamedLibraryElementNode.java @@ -44,6 +44,7 @@ public class NamedLibraryElementNode extends ProjectViewNode getChildren() { final List children = new ArrayList(); @@ -51,6 +52,7 @@ public class NamedLibraryElementNode extends ProjectViewNode getChildren() { Module module = getValue(); @@ -76,10 +77,12 @@ public class ProjectViewModuleNode extends AbstractModuleNode { return children; } + @Override public int getWeight() { return 10; } + @Override public int getTypeSortWeight(final boolean sortByType) { return 2; } diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/ProjectViewProjectNode.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/ProjectViewProjectNode.java index e08d4902cb5a..eba28dfc4b00 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/ProjectViewProjectNode.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/ProjectViewProjectNode.java @@ -43,6 +43,7 @@ public class ProjectViewProjectNode extends AbstractProjectNode { super(project, project, viewSettings); } + @Override @NotNull public Collection getChildren() { List topLevelContentRoots = ProjectViewDirectoryHelper.getInstance(myProject).getTopLevelRoots(); @@ -98,6 +99,7 @@ public class ProjectViewProjectNode extends AbstractProjectNode { } Collections.sort(roots, new java.util.Comparator() { + @Override public int compare(VirtualFile o1, VirtualFile o2) { return o1.getPath().compareTo(o2.getPath()); } @@ -124,6 +126,7 @@ public class ProjectViewProjectNode extends AbstractProjectNode { return reducedRoots; } + @Override protected AbstractTreeNode createModuleGroup(final Module module) throws InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException { final VirtualFile[] roots = ModuleRootManager.getInstance(module).getContentRoots(); @@ -137,6 +140,7 @@ public class ProjectViewProjectNode extends AbstractProjectNode { return createTreeNode(ProjectViewModuleNode.class, getProject(), module, getSettings()); } + @Override protected AbstractTreeNode createModuleGroupNode(final ModuleGroup moduleGroup) throws InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException { return createTreeNode(ProjectViewModuleGroupNode.class, getProject(), moduleGroup, getSettings()); diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/PsiDirectoryNode.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/PsiDirectoryNode.java index ebab8c629ea9..acc3efd1bb10 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/PsiDirectoryNode.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/PsiDirectoryNode.java @@ -62,6 +62,7 @@ public class PsiDirectoryNode extends BasePsiNode implements Navig return !PlatformUtils.isCidr(); } + @Override protected void updateImpl(PresentationData data) { final Project project = getProject(); final PsiDirectory psiDirectory = getValue(); @@ -151,10 +152,12 @@ public class PsiDirectoryNode extends BasePsiNode implements Navig } } + @Override public Collection getChildrenImpl() { return ProjectViewDirectoryHelper.getInstance(myProject).getDirectoryChildren(getValue(), getSettings(), true); } + @Override @SuppressWarnings("deprecation") public String getTestPresentation() { return "PsiDirectory: " + getValue().getName(); @@ -164,6 +167,7 @@ public class PsiDirectoryNode extends BasePsiNode implements Navig return ProjectViewDirectoryHelper.getInstance(getProject()).isShowFQName(getSettings(), getParentValue(), getValue()); } + @Override public boolean contains(@NotNull VirtualFile file) { final PsiDirectory value = getValue(); if (value == null) { @@ -184,12 +188,14 @@ public class PsiDirectoryNode extends BasePsiNode implements Navig return !fileIndex.isIgnored(file); } + @Override public VirtualFile getVirtualFile() { PsiDirectory directory = getValue(); if (directory == null) return null; return directory.getVirtualFile(); } + @Override public boolean canRepresent(final Object element) { if (super.canRepresent(element)) return true; PsiDirectory directory = getValue(); @@ -197,6 +203,7 @@ public class PsiDirectoryNode extends BasePsiNode implements Navig return ProjectViewDirectoryHelper.getInstance(getProject()).canRepresent(element, directory); } + @Override public boolean canNavigate() { VirtualFile file = getVirtualFile(); Project project = getProject(); @@ -207,10 +214,12 @@ public class PsiDirectoryNode extends BasePsiNode implements Navig (ProjectRootsUtil.isLibraryRoot(file, project) && service.canOpenModuleLibrarySettings())); } + @Override public boolean canNavigateToSource() { return false; } + @Override public void navigate(final boolean requestFocus) { Module module = ModuleUtil.findModuleForPsiElement(getValue()); if (module != null) { @@ -250,10 +259,12 @@ public class PsiDirectoryNode extends BasePsiNode implements Navig return null; } + @Override public int getWeight() { return isFQNameShown() ? 70 : 0; } + @Override public String getTitle() { final PsiDirectory directory = getValue(); if (directory != null) { @@ -297,11 +308,13 @@ public class PsiDirectoryNode extends BasePsiNode implements Navig return null; } + @Override public String getQualifiedNameSortKey() { final PsiDirectoryFactory factory = PsiDirectoryFactory.getInstance(getProject()); return factory.getQualifiedName(getValue(), true); } + @Override public int getTypeSortWeight(final boolean sortByType) { return 3; } diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/PsiFileNode.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/PsiFileNode.java index f8af64c9a133..a1508471a227 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/PsiFileNode.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/PsiFileNode.java @@ -48,6 +48,7 @@ public class PsiFileNode extends BasePsiNode implements NavigatableWith super(project, value, viewSettings); } + @Override public Collection getChildrenImpl() { VirtualFile jarRoot = getJarRoot(); if (jarRoot != null) { @@ -65,12 +66,14 @@ public class PsiFileNode extends BasePsiNode implements NavigatableWith return file != null && file.isValid() && file.getFileType() instanceof ArchiveFileType; } + @Override protected void updateImpl(PresentationData data) { final PsiFile value = getValue(); data.setPresentableText(value.getName()); data.setIcon(value.getIcon(Iconable.ICON_FLAG_READ_STATUS)); } + @Override public VirtualFile getVirtualFile() { PsiFile value = getValue(); return value != null ? value.getVirtualFile() : null; @@ -122,6 +125,7 @@ public class PsiFileNode extends BasePsiNode implements NavigatableWith return null; } + @Override public int getWeight() { return 20; } @@ -140,6 +144,7 @@ public class PsiFileNode extends BasePsiNode implements NavigatableWith return true; } + @Override public Comparable getTypeSortKey() { String extension = extension(getValue()); return extension == null ? null : new ExtensionSortKey(extension); @@ -157,6 +162,7 @@ public class PsiFileNode extends BasePsiNode implements NavigatableWith myExtension = extension; } + @Override public int compareTo(final Object o) { if (!(o instanceof ExtensionSortKey)) return 0; ExtensionSortKey rhs = (ExtensionSortKey) o; @@ -170,6 +176,7 @@ public class PsiFileNode extends BasePsiNode implements NavigatableWith return file != null && file.getFileType() == StdFileTypes.JAVA; } + @Override public boolean canRepresent(final Object element) { return super.canRepresent(element) || getValue() != null && getValue().getVirtualFile() == element; } diff --git a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/StructureViewModuleNode.java b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/StructureViewModuleNode.java index c9d8ac8b2fff..0805605a9d04 100644 --- a/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/StructureViewModuleNode.java +++ b/platform/lang-impl/src/com/intellij/ide/projectView/impl/nodes/StructureViewModuleNode.java @@ -33,6 +33,7 @@ public class StructureViewModuleNode extends AbstractModuleNode { super(project, value, viewSettings); } + @Override @NotNull public Collection getChildren() { final Module module = getValue(); @@ -52,10 +53,12 @@ public class StructureViewModuleNode extends AbstractModuleNode { return children; } + @Override public int getWeight() { return 10; } + @Override public int getTypeSortWeight(final boolean sortByType) { return 2; } diff --git a/platform/lang-impl/src/com/intellij/ide/structureView/newStructureView/StructureTreeBuilder.java b/platform/lang-impl/src/com/intellij/ide/structureView/newStructureView/StructureTreeBuilder.java index 072037cd97d2..b2f6cdd57783 100644 --- a/platform/lang-impl/src/com/intellij/ide/structureView/newStructureView/StructureTreeBuilder.java +++ b/platform/lang-impl/src/com/intellij/ide/structureView/newStructureView/StructureTreeBuilder.java @@ -189,8 +189,11 @@ public class StructureTreeBuilder extends AbstractTreeBuilder { } final void addRootToUpdate() { - getTreeStructure().commit(); - ((SmartTreeStructure)getTreeStructure()).rebuildTree(); + AbstractTreeStructure structure = getTreeStructure(); + if (structure.hasSomethingToCommit()) { + structure.commit(); + } + ((SmartTreeStructure)structure).rebuildTree(); getUpdater().addSubtreeToUpdate(getRootNode()); } diff --git a/platform/lang-impl/src/com/intellij/ide/todo/ScopeBasedTodosPanel.java b/platform/lang-impl/src/com/intellij/ide/todo/ScopeBasedTodosPanel.java index c39a7dc732e2..14bb7d60290a 100644 --- a/platform/lang-impl/src/com/intellij/ide/todo/ScopeBasedTodosPanel.java +++ b/platform/lang-impl/src/com/intellij/ide/todo/ScopeBasedTodosPanel.java @@ -21,13 +21,13 @@ package com.intellij.ide.todo; import com.intellij.ide.util.PropertiesComponent; -import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Comparing; import com.intellij.packageDependencies.DependencyValidationManager; import com.intellij.psi.search.scope.NonProjectFilesScope; import com.intellij.psi.search.scope.packageSet.NamedScope; import com.intellij.psi.search.scope.packageSet.NamedScopeManager; +import com.intellij.psi.search.scope.packageSet.NamedScopesHolder; import com.intellij.ui.ListCellRendererWrapper; import com.intellij.ui.content.Content; import com.intellij.util.Alarm; @@ -43,23 +43,30 @@ public class ScopeBasedTodosPanel extends TodoPanel { private static final String SELECTED_SCOPE = "TODO_SCOPE"; private final Alarm myAlarm; private JComboBox myScopes; + private final NamedScopesHolder.ScopeListener myScopeListener; + private final NamedScopeManager myNamedScopeManager; + private final DependencyValidationManager myValidationManager; - public ScopeBasedTodosPanel(Project project, TodoPanelSettings settings, Content content){ + public ScopeBasedTodosPanel(final Project project, TodoPanelSettings settings, Content content){ super(project,settings,false,content); myAlarm = new Alarm(Alarm.ThreadToUse.SHARED_THREAD, project); - NamedScope[] scopes = DependencyValidationManager.getInstance(project).getScopes(); - scopes = ArrayUtil.mergeArrays(scopes, NamedScopeManager.getInstance(project).getScopes()); - scopes = NonProjectFilesScope.removeFromList(scopes); - myScopes.setModel(new DefaultComboBoxModel(scopes)); final String scopeName = PropertiesComponent.getInstance(project).getValue(SELECTED_SCOPE); - if (scopeName != null) { - for (NamedScope scope : scopes) { - if (Comparing.strEqual(scopeName, scope.getName())) { - myScopes.setSelectedItem(scope); - break; - } + rebuildModel(project, scopeName); + + myScopeListener = new NamedScopesHolder.ScopeListener() { + @Override + public void scopesChanged() { + final NamedScope scope = (NamedScope)myScopes.getSelectedItem(); + rebuildModel(project, scope != null ? scope.getName() : null); } - } + }; + + myNamedScopeManager = NamedScopeManager.getInstance(project); + myNamedScopeManager.addScopeListener(myScopeListener); + + myValidationManager = DependencyValidationManager.getInstance(project); + myValidationManager.addScopeListener(myScopeListener); + myScopes.setRenderer(new ListCellRendererWrapper(myScopes){ @Override public void customize(JList list, NamedScope value, int index, boolean selected, boolean hasFocus) { @@ -79,6 +86,28 @@ public class ScopeBasedTodosPanel extends TodoPanel { rebuildWithAlarm(myAlarm); } + @Override + public void dispose() { + myNamedScopeManager.removeScopeListener(myScopeListener); + myValidationManager.removeScopeListener(myScopeListener); + super.dispose(); + } + + private void rebuildModel(Project project, String scopeName) { + NamedScope[] scopes = DependencyValidationManager.getInstance(project).getScopes(); + scopes = ArrayUtil.mergeArrays(scopes, NamedScopeManager.getInstance(project).getScopes()); + scopes = NonProjectFilesScope.removeFromList(scopes); + myScopes.setModel(new DefaultComboBoxModel(scopes)); + if (scopeName != null) { + for (NamedScope scope : scopes) { + if (Comparing.strEqual(scopeName, scope.getName())) { + myScopes.setSelectedItem(scope); + break; + } + } + } + } + @Override protected JComponent createCenterComponent() { JPanel panel = new JPanel(new BorderLayout()); diff --git a/platform/lang-impl/src/com/intellij/ide/util/treeView/AbstractTreeStructureBase.java b/platform/lang-impl/src/com/intellij/ide/util/treeView/AbstractTreeStructureBase.java index c1bef72d1519..3d04bd08eba3 100644 --- a/platform/lang-impl/src/com/intellij/ide/util/treeView/AbstractTreeStructureBase.java +++ b/platform/lang-impl/src/com/intellij/ide/util/treeView/AbstractTreeStructureBase.java @@ -41,6 +41,7 @@ public abstract class AbstractTreeStructureBase extends AbstractTreeStructure { myProject = project; } + @Override public Object[] getChildElements(Object element) { LOG.assertTrue(element instanceof AbstractTreeNode, element != null ? element.getClass().getName() : null); AbstractTreeNode treeNode = (AbstractTreeNode)element; @@ -69,6 +70,7 @@ public abstract class AbstractTreeStructureBase extends AbstractTreeStructure { return element instanceof AbstractTreeNode; } + @Override public Object getParentElement(Object element) { if (element instanceof AbstractTreeNode){ return ((AbstractTreeNode)element).getParent(); @@ -76,6 +78,7 @@ public abstract class AbstractTreeStructureBase extends AbstractTreeStructure { return null; } + @Override @NotNull public NodeDescriptor createDescriptor(final Object element, final NodeDescriptor parentDescriptor) { return (NodeDescriptor)element; @@ -89,7 +92,8 @@ public abstract class AbstractTreeStructureBase extends AbstractTreeStructure { @Nullable public abstract List getProviders(); - public Object getDataFromProviders(final List selectedNodes, final String dataId) { + @Nullable + public Object getDataFromProviders(@NotNull List selectedNodes, final String dataId) { final List providers = getProvidersDumbAware(); if (providers != null) { for (TreeStructureProvider treeStructureProvider : providers) { diff --git a/platform/lang-impl/src/com/intellij/ide/util/treeView/SmartElementDescriptor.java b/platform/lang-impl/src/com/intellij/ide/util/treeView/SmartElementDescriptor.java index 8700a1421c8d..7ed8f9337926 100644 --- a/platform/lang-impl/src/com/intellij/ide/util/treeView/SmartElementDescriptor.java +++ b/platform/lang-impl/src/com/intellij/ide/util/treeView/SmartElementDescriptor.java @@ -42,6 +42,7 @@ public class SmartElementDescriptor extends NodeDescriptor{ mySmartPointer = SmartPointerManager.getInstance(myProject).createSmartPsiElementPointer(element); } + @Override public Object getElement() { return myElement; } @@ -55,6 +56,7 @@ public class SmartElementDescriptor extends NodeDescriptor{ } // Should be called in atomic action + @Override public boolean update() { myElement = mySmartPointer.getElement(); if (myElement == null) return true; @@ -80,8 +82,8 @@ public class SmartElementDescriptor extends NodeDescriptor{ color = CopyPasteManager.CUT_COLOR; } - boolean changes = !Comparing.equal(icon, myIcon) || !Comparing.equal(color, myColor); - myIcon = icon; + boolean changes = !Comparing.equal(icon, getIcon()) || !Comparing.equal(color, myColor); + setIcon(icon); myColor = color; return changes; } diff --git a/platform/lang-impl/src/com/intellij/ide/util/treeView/smartTree/CachingChildrenTreeNode.java b/platform/lang-impl/src/com/intellij/ide/util/treeView/smartTree/CachingChildrenTreeNode.java index 6cfd68b2228f..a81d18f13792 100644 --- a/platform/lang-impl/src/com/intellij/ide/util/treeView/smartTree/CachingChildrenTreeNode.java +++ b/platform/lang-impl/src/com/intellij/ide/util/treeView/smartTree/CachingChildrenTreeNode.java @@ -36,6 +36,7 @@ public abstract class CachingChildrenTreeNode extends AbstractTreeNode getChildren() { ensureChildrenAreInitialized(); @@ -70,6 +71,7 @@ public abstract class CachingChildrenTreeNode extends AbstractTreeNode extends AbstractTreeNode { clearChildren(); } + @Override public void copyFromNewInstance(final CachingChildrenTreeNode newInstance) { clearChildren(); setChildren(newInstance.getChildren()); synchronizeChildren(); } + @Override public void update(PresentationData presentation) { presentation.updateFrom(getValue().getPresentation()); } + @Override public void initChildren() { clearChildren(); Collection children = getValue().getChildren(); @@ -46,6 +49,7 @@ public class GroupWrapper extends CachingChildrenTreeNode { } } + @Override protected void performTreeActions() { filterChildren(myTreeModel.getFilters()); groupChildren(myTreeModel.getGroupers()); diff --git a/platform/lang-impl/src/com/intellij/ide/util/treeView/smartTree/SmartTreeStructure.java b/platform/lang-impl/src/com/intellij/ide/util/treeView/smartTree/SmartTreeStructure.java index 7db150821b82..e2a10b4d421b 100644 --- a/platform/lang-impl/src/com/intellij/ide/util/treeView/smartTree/SmartTreeStructure.java +++ b/platform/lang-impl/src/com/intellij/ide/util/treeView/smartTree/SmartTreeStructure.java @@ -34,22 +34,27 @@ public class SmartTreeStructure extends AbstractTreeStructure { myProject = project; } + @Override public void commit() { } + @Override @NotNull public NodeDescriptor createDescriptor(Object element, NodeDescriptor parentDescriptor) { return (AbstractTreeNode)element; } + @Override public Object[] getChildElements(Object element) { return ((AbstractTreeNode)element).getChildren().toArray(); } + @Override public Object getParentElement(Object element) { return ((AbstractTreeNode)element).getParent(); } + @Override public Object getRootElement() { if (myRootElementWrapper == null){ myRootElementWrapper = createTree(); @@ -66,6 +71,7 @@ public class SmartTreeStructure extends AbstractTreeStructure { return ((AbstractTreeNode)element).isAlwaysLeaf(); } + @Override public boolean hasSomethingToCommit() { return PsiDocumentManager.getInstance(myProject).hasUncommitedDocuments(); } diff --git a/platform/lang-impl/src/com/intellij/ide/util/treeView/smartTree/TreeElementWrapper.java b/platform/lang-impl/src/com/intellij/ide/util/treeView/smartTree/TreeElementWrapper.java index 2a4d99239a1c..a0dafb0ed58f 100644 --- a/platform/lang-impl/src/com/intellij/ide/util/treeView/smartTree/TreeElementWrapper.java +++ b/platform/lang-impl/src/com/intellij/ide/util/treeView/smartTree/TreeElementWrapper.java @@ -27,15 +27,18 @@ public class TreeElementWrapper extends CachingChildrenTreeNode { super(project, value, treeModel); } + @Override public void copyFromNewInstance(final CachingChildrenTreeNode oldInstance) { } + @Override public void update(PresentationData presentation) { if (((StructureViewTreeElement)getValue()).getValue() != null) { presentation.updateFrom(getValue().getPresentation()); } } + @Override public void initChildren() { clearChildren(); TreeElement[] children = getValue().getChildren(); @@ -55,6 +58,7 @@ public class TreeElementWrapper extends CachingChildrenTreeNode { } } + @Override protected void performTreeActions() { filterChildren(myTreeModel.getFilters()); groupChildren(myTreeModel.getGroupers()); diff --git a/platform/lang-impl/src/com/intellij/psi/impl/PsiDocumentManagerImpl.java b/platform/lang-impl/src/com/intellij/psi/impl/PsiDocumentManagerImpl.java index 9e3734e9de52..594088b83af1 100644 --- a/platform/lang-impl/src/com/intellij/psi/impl/PsiDocumentManagerImpl.java +++ b/platform/lang-impl/src/com/intellij/psi/impl/PsiDocumentManagerImpl.java @@ -85,46 +85,44 @@ public class PsiDocumentManagerImpl extends PsiDocumentManager implements Projec @NotNull SmartPointerManager smartPointerManager, @NotNull EditorFactory editorFactory, @NotNull MessageBus bus, - @NotNull final DocumentCommitThread documentCommitThread) { + @NonNls @NotNull final DocumentCommitThread documentCommitThread) { myProject = project; myPsiManager = psiManager; myDocumentCommitThread = documentCommitThread; mySmartPointerManager = (SmartPointerManagerImpl)smartPointerManager; mySynchronizer = new PsiToDocumentSynchronizer(this, bus); - if (true || !project.isDefault()) { - myPsiManager.addPsiTreeChangeListener(mySynchronizer); - editorFactory.getEventMulticaster().addDocumentListener(this, myProject); - bus.connect().subscribe(AppTopics.FILE_DOCUMENT_SYNC, new FileDocumentManagerAdapter() { - @Override - public void fileContentLoaded(@NotNull final VirtualFile virtualFile, @NotNull Document document) { - PsiFile psiFile = ApplicationManager.getApplication().runReadAction(new Computable() { - @Override - public PsiFile compute() { - return getCachedPsiFile(virtualFile); - } - }); - fireDocumentCreated(document, psiFile); - } - }); - bus.connect().subscribe(DocumentBulkUpdateListener.TOPIC, new DocumentBulkUpdateListener.Adapter() { - @Override - public void updateFinished(@NotNull Document doc) { - documentCommitThread.queueCommit(project, doc, "Bulk update finished"); - } - }); - ApplicationManager.getApplication().addApplicationListener(new ApplicationAdapter() { - @Override - public void beforeWriteActionStart(Object action) { - documentCommitThread.disable("Write action started: "+ action); - } + myPsiManager.addPsiTreeChangeListener(mySynchronizer); + editorFactory.getEventMulticaster().addDocumentListener(this, myProject); + bus.connect().subscribe(AppTopics.FILE_DOCUMENT_SYNC, new FileDocumentManagerAdapter() { + @Override + public void fileContentLoaded(@NotNull final VirtualFile virtualFile, @NotNull Document document) { + PsiFile psiFile = ApplicationManager.getApplication().runReadAction(new Computable() { + @Override + public PsiFile compute() { + return getCachedPsiFile(virtualFile); + } + }); + fireDocumentCreated(document, psiFile); + } + }); + bus.connect().subscribe(DocumentBulkUpdateListener.TOPIC, new DocumentBulkUpdateListener.Adapter() { + @Override + public void updateFinished(@NotNull Document doc) { + documentCommitThread.queueCommit(project, doc, "Bulk update finished"); + } + }); + ApplicationManager.getApplication().addApplicationListener(new ApplicationAdapter() { + @Override + public void beforeWriteActionStart(Object action) { + documentCommitThread.disable("Write action started: "+ action); + } - @Override - public void writeActionFinished(Object action) { - documentCommitThread.enable("Write action finished: "+action); - } - }, myProject); - documentCommitThread.enable("project open"); - } + @Override + public void writeActionFinished(Object action) { + documentCommitThread.enable("Write action finished: "+action); + } + }, myProject); + documentCommitThread.enable("project open"); } @Override @@ -267,6 +265,7 @@ public class PsiDocumentManagerImpl extends PsiDocumentManager implements Projec private final Map actionsWhenAllDocumentsAreCommitted = new LinkedHashMap(); //accessed from EDT only private static final Object PERFORM_ALWAYS_KEY = new Object(){ @Override + @NonNls public String toString() { return "PERFORM_ALWAYS"; } @@ -304,7 +303,10 @@ public class PsiDocumentManagerImpl extends PsiDocumentManager implements Projec /** * Cancel previously registered action and schedules (new) action to be executed when all documents are committed. - * @param key the (unique) name of the action. This action will overwrite any action which was registered under this key earlier. + * @param key the (unique) id of the action. + * @param action The action to be executed after automatic commit. + * This action will overwrite any action which was registered under this key earlier. + * The action will be executed in EDT. * @return true if action has been run immediately, or false if action was scheduled for execution later. */ public boolean cancelAndRunWhenAllCommitted(@NonNls @NotNull Object key, @NotNull final Runnable action) { diff --git a/platform/lang-impl/src/com/intellij/psi/stubs/SerializedStubTree.java b/platform/lang-impl/src/com/intellij/psi/stubs/SerializedStubTree.java index 8be417f457e8..e389a452780a 100644 --- a/platform/lang-impl/src/com/intellij/psi/stubs/SerializedStubTree.java +++ b/platform/lang-impl/src/com/intellij/psi/stubs/SerializedStubTree.java @@ -19,7 +19,7 @@ */ package com.intellij.psi.stubs; -import com.intellij.util.indexing.IOUtils; +import com.intellij.util.CompressionUtil; import com.intellij.util.io.UnsyncByteArrayInputStream; import org.jetbrains.annotations.Nullable; @@ -39,12 +39,12 @@ public class SerializedStubTree { } public SerializedStubTree(DataInput in) throws IOException { - myBytes = IOUtils.readCompressed(in); + myBytes = CompressionUtil.readCompressed(in); myLength = myBytes.length; } public void write(DataOutput out) throws IOException { - IOUtils.writeCompressed(out, myBytes, myLength); + CompressionUtil.writeCompressed(out, myBytes, myLength); } // willIndexStub is one time optimization hint, once can safely pass false diff --git a/platform/platform-api/src/com/intellij/ide/BrowserUtil.java b/platform/platform-api/src/com/intellij/ide/BrowserUtil.java index e9ed6ce2e31c..143736b1788b 100644 --- a/platform/platform-api/src/com/intellij/ide/BrowserUtil.java +++ b/platform/platform-api/src/com/intellij/ide/BrowserUtil.java @@ -227,9 +227,25 @@ public class BrowserUtil { return command; } + public static void addLaunchArgs(List command, String[] launchArgs) { + if (launchArgs.length == 0) { + return; + } + + if (SystemInfo.isMac && ExecUtil.getOpenCommandPath().equals(command.get(0))) { + if (isOpenCommandSupportArgs()) { + command.add("--args"); + } + else { + LOG.warn("'open' command doesn't allow to pass command line arguments so they will be ignored: " + Arrays.toString(launchArgs)); + return; + } + } + + Collections.addAll(command, launchArgs); + } + public static List getOpenBrowserCommand(final @NonNls @NotNull String browserPath) { - // versions before 10.6 don't allow to pass command line arguments to browser via 'open' command - // so we use full path to browser executable in such case if (SystemInfo.isMac && !new File(browserPath).isFile()) { ArrayList command = new ArrayList(); command.add(ExecUtil.getOpenCommandPath()); diff --git a/platform/platform-api/src/com/intellij/ide/util/treeView/AbstractTreeBuilder.java b/platform/platform-api/src/com/intellij/ide/util/treeView/AbstractTreeBuilder.java index 9b1f49b22521..3d2678e4c621 100644 --- a/platform/platform-api/src/com/intellij/ide/util/treeView/AbstractTreeBuilder.java +++ b/platform/platform-api/src/com/intellij/ide/util/treeView/AbstractTreeBuilder.java @@ -27,6 +27,7 @@ import com.intellij.openapi.util.AsyncResult; import com.intellij.util.containers.HashSet; import com.intellij.util.ui.UIUtil; import com.intellij.util.ui.update.MergingUpdateQueue; +import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -40,7 +41,7 @@ import java.util.*; public class AbstractTreeBuilder implements Disposable { private AbstractTreeUi myUi; - private static final String TREE_BUILDER = "TreeBuilder"; + @NonNls private static final String TREE_BUILDER = "TreeBuilder"; public static final boolean DEFAULT_UPDATE_INACTIVE = true; public AbstractTreeBuilder(JTree tree, @@ -66,10 +67,10 @@ public class AbstractTreeBuilder implements Disposable { protected void init(final JTree tree, final DefaultTreeModel treeModel, final AbstractTreeStructure treeStructure, - final @Nullable Comparator comparator, + @Nullable final Comparator comparator, final boolean updateIfInactive) { - tree.putClientProperty(TREE_BUILDER, new WeakReference(this)); + tree.putClientProperty(TREE_BUILDER, new WeakReference(this)); myUi = createUi(); getUi().init(this, tree, treeModel, treeStructure, comparator, updateIfInactive); @@ -208,9 +209,7 @@ public class AbstractTreeBuilder implements Disposable { } protected boolean validateNode(final Object child) { - if (isDisposed()) return false; - - return getUi().getTreeStructure().isValid(child); + return !isDisposed() && getUi().getTreeStructure().isValid(child); } protected boolean isDisposeOnCollapsing(NodeDescriptor nodeDescriptor) { @@ -347,9 +346,7 @@ public class AbstractTreeBuilder implements Disposable { } protected boolean isAutoExpandNode(final NodeDescriptor nodeDescriptor) { - if (isDisposed()) return false; - - return getRootElement() == getTreeStructureElement(nodeDescriptor); + return !isDisposed() && getRootElement() == getTreeStructureElement(nodeDescriptor); } protected boolean isAlwaysShowPlus(final NodeDescriptor descriptor) { @@ -376,15 +373,11 @@ public class AbstractTreeBuilder implements Disposable { } public final boolean wasRootNodeInitialized() { - if (isDisposed()) return false; - - return getUi().wasRootNodeInitialized(); + return !isDisposed() && getUi().wasRootNodeInitialized(); } public final boolean isNodeBeingBuilt(final TreePath path) { - if (isDisposed()) return false; - - return getUi().isNodeBeingBuilt(path); + return !isDisposed() && getUi().isNodeBeingBuilt(path); } /** @@ -458,6 +451,7 @@ public class AbstractTreeBuilder implements Disposable { final Application app = ApplicationManager.getApplication(); if (app != null) { app.runReadAction(new Runnable() { + @Override public void run() { runnable.run(); } @@ -533,11 +527,13 @@ public class AbstractTreeBuilder implements Disposable { super(null, null); } + @Override @NotNull public Collection getChildren() { return Collections.emptyList(); } + @Override public void update(PresentationData presentation) { } } @@ -546,6 +542,7 @@ public class AbstractTreeBuilder implements Disposable { return myUi; } + @Override public void dispose() { if (isDisposed()) return; @@ -560,7 +557,7 @@ public class AbstractTreeBuilder implements Disposable { if (isDisposed()) return false; AbstractTreeUi ui = getUi(); - return ui != null && ui.doUpdateNodeDescriptor(descriptor); + return ui != null && descriptor.update(); } @Nullable @@ -645,14 +642,14 @@ public class AbstractTreeBuilder implements Disposable { myUi.scrollSelectionToVisible(onDone, shouldBeCentered); } - protected boolean isUnitTestingMode() { + private static boolean isUnitTestingMode() { Application app = ApplicationManager.getApplication(); return app != null && app.isUnitTestMode(); } public static boolean isToPaintSelection(JTree tree) { AbstractTreeBuilder builder = getBuilderFor(tree); - return builder != null && builder.getUi() != null ? builder.getUi().isToPaintSelection() : true; + return builder == null || builder.getUi() == null || builder.getUi().isToPaintSelection(); } class UserRunnable implements Runnable { @@ -681,8 +678,4 @@ public class AbstractTreeBuilder implements Disposable { AbstractTreeUi ui = getUi(); return ui != null && ui.isSelectionBeingAdjusted(); } - - private void assertDisposed() { - assert !isDisposed(); - } } diff --git a/platform/platform-api/src/com/intellij/ide/util/treeView/AbstractTreeNode.java b/platform/platform-api/src/com/intellij/ide/util/treeView/AbstractTreeNode.java index d38c34d6e7a5..f34a409f3fa4 100644 --- a/platform/platform-api/src/com/intellij/ide/util/treeView/AbstractTreeNode.java +++ b/platform/platform-api/src/com/intellij/ide/util/treeView/AbstractTreeNode.java @@ -54,6 +54,7 @@ public abstract class AbstractTreeNode extends PresentableNodeDescriptor impl return CopyPasteManager.getInstance().isCutElement(getValue()); } + @Override public PresentableNodeDescriptor getChildToHighlightAt(int index) { final Collection kids = getChildren(); int i = 0; @@ -86,6 +87,7 @@ public abstract class AbstractTreeNode extends PresentableNodeDescriptor impl } } + @Override protected boolean shouldUpdateData() { return !myProject.isDisposed() && getValue() != null; } @@ -103,6 +105,7 @@ public abstract class AbstractTreeNode extends PresentableNodeDescriptor impl return false; } + @Override @Nullable public final Object getElement() { return getValue() != null ? this : null; @@ -131,6 +134,7 @@ public abstract class AbstractTreeNode extends PresentableNodeDescriptor impl return this; } + @Override public final NodeDescriptor getParentDescriptor() { return myParentDescriptor; } @@ -153,6 +157,7 @@ public abstract class AbstractTreeNode extends PresentableNodeDescriptor impl return getTestPresentation(); } + @Override public void apply(@NotNull Map info) { } @@ -164,11 +169,11 @@ public abstract class AbstractTreeNode extends PresentableNodeDescriptor impl @NonNls public String getTestPresentation() { if (myName != null) { return myName; - } else if (getValue() != null){ - return getValue().toString(); - } else { - return null; } + if (getValue() != null){ + return getValue().toString(); + } + return null; } @@ -176,17 +181,21 @@ public abstract class AbstractTreeNode extends PresentableNodeDescriptor impl return FileStatus.NOT_CHANGED; } + @Override public String getName() { return myName; } + @Override public void navigate(boolean requestFocus) { } + @Override public boolean canNavigate() { return false; } + @Override public boolean canNavigateToSource() { return false; } diff --git a/platform/platform-api/src/com/intellij/ide/util/treeView/AbstractTreeUi.java b/platform/platform-api/src/com/intellij/ide/util/treeView/AbstractTreeUi.java index ec0f5893c8f9..be73361dec88 100644 --- a/platform/platform-api/src/com/intellij/ide/util/treeView/AbstractTreeUi.java +++ b/platform/platform-api/src/com/intellij/ide/util/treeView/AbstractTreeUi.java @@ -31,7 +31,6 @@ import com.intellij.ui.treeStructure.AlwaysExpandedTree; import com.intellij.ui.treeStructure.Tree; import com.intellij.util.Alarm; import com.intellij.util.ArrayUtil; -import com.intellij.util.Time; import com.intellij.util.concurrency.WorkerThread; import com.intellij.util.containers.ContainerUtil; import com.intellij.util.containers.HashSet; @@ -40,6 +39,7 @@ import com.intellij.util.ui.UIUtil; import com.intellij.util.ui.tree.TreeUtil; import com.intellij.util.ui.update.Activatable; import com.intellij.util.ui.update.UiNotifyConnector; +import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -64,13 +64,14 @@ public class AbstractTreeUi { private Comparator myNodeDescriptorComparator; private final Comparator myNodeComparator = new Comparator() { + @Override public int compare(TreeNode n1, TreeNode n2) { if (isLoadingNode(n1) || isLoadingNode(n2)) return 0; //todo kirillk hard to undertstand why nodes may be null, just avoid NPEs if (n1 == null || n2 == null) return 0; - NodeDescriptor nodeDescriptor1 = getDescriptorFrom((DefaultMutableTreeNode)n1); - NodeDescriptor nodeDescriptor2 = getDescriptorFrom((DefaultMutableTreeNode)n2); + NodeDescriptor nodeDescriptor1 = getDescriptorFrom(n1); + NodeDescriptor nodeDescriptor2 = getDescriptorFrom(n2); if (nodeDescriptor1 == null || nodeDescriptor2 == null) return 0; @@ -92,7 +93,6 @@ public class AbstractTreeUi { private final Set myActiveWorkerTasks = new HashSet(); private ProgressIndicator myProgress; - private static final int WAIT_CURSOR_DELAY = 100; private AbstractTreeNode TREE_NODE_WRAPPER; private boolean myRootNodeWasQueuedToInitialize = false; @@ -118,7 +118,6 @@ public class AbstractTreeUi { private AbstractTreeBuilder myBuilder; private final Set myUpdatingChildren = new HashSet(); - private long myJanitorPollPeriod = Time.SECOND * 10; private boolean myCanYield = false; @@ -131,6 +130,7 @@ public class AbstractTreeUi { private final Alarm myBusyAlarm = new Alarm(); private final Runnable myWaiterForReady = new Runnable() { + @Override public void run() { maybeSetBusyAndScheduleWaiterForReady(false, null); } @@ -202,11 +202,11 @@ public class AbstractTreeUi { } }; private UiActivityMonitor myActivityMonitor; - private UiActivity myActivityId; + @NonNls private UiActivity myActivityId; protected void init(AbstractTreeBuilder builder, - JTree tree, - DefaultTreeModel treeModel, + @NotNull JTree tree, + @NotNull DefaultTreeModel treeModel, AbstractTreeStructure treeStructure, @Nullable Comparator comparator, boolean updateIfInactive) { @@ -224,6 +224,7 @@ public class AbstractTreeUi { myUpdateIfInactive = updateIfInactive; UIUtil.invokeLaterIfNeeded(new Runnable() { + @Override public void run() { if (!wasRootNodeInitialized()) { if (myRootNode.getChildCount() == 0) { @@ -244,6 +245,7 @@ public class AbstractTreeUi { Disposer.register(getBuilder(), getUpdater()); final UiNotifyConnector uiNotify = new UiNotifyConnector(tree, new Activatable() { + @Override public void showNotify() { myShowing = true; myWasEverShown = true; @@ -252,6 +254,7 @@ public class AbstractTreeUi { } } + @Override public void hideNotify() { myShowing = false; if (canInitiateNewActivity()) { @@ -320,6 +323,7 @@ public class AbstractTreeUi { if (now >= timeToCleanup.longValue()) { ourUi2Countdown.remove(eachUi); Runnable runnable = new Runnable() { + @Override public void run() { if (!canInitiateNewActivity()) return; @@ -339,6 +343,7 @@ public class AbstractTreeUi { protected void doCleanUp() { Runnable cleanup = new Runnable() { + @Override public void run() { if (canInitiateNewActivity()) { cleanUpNow(); @@ -354,10 +359,12 @@ public class AbstractTreeUi { } } + @NotNull public ActionCallback invokeLaterIfNeeded(@NotNull final Runnable runnable, boolean forceEdt) { final ActionCallback result = new ActionCallback(); Runnable actual = new Runnable() { + @Override public void run() { if (isReleased()) { result.setRejected(); @@ -417,14 +424,15 @@ public class AbstractTreeUi { if (getClearOnHideDelay() >= 0) { ourUi2Countdown.put(this, System.currentTimeMillis() + getClearOnHideDelay()); - sheduleCleanUpAll(); + scheduleCleanUpAll(); } } - private void sheduleCleanUpAll() { + private void scheduleCleanUpAll() { cancelCurrentCleanupTask(); myCleanupTask = SimpleTimer.getInstance().setUp(new Runnable() { + @Override public void run() { cleanUpAll(); } @@ -434,6 +442,7 @@ public class AbstractTreeUi { public void requestRelease() { myReleaseRequested = true; cancelUpdate().doWhenDone(new Runnable() { + @Override public void run() { releaseNow(); } @@ -488,11 +497,12 @@ public class AbstractTreeUi { return myBuilder == null; } - protected void doExpandNodeChildren(final DefaultMutableTreeNode node) { + protected void doExpandNodeChildren(@NotNull final DefaultMutableTreeNode node) { if (!myUnbuiltNodes.contains(node)) return; if (isLoadedInBackground(getElementFor(node))) return; - getTreeStructure().commit(); + AbstractTreeStructure structure = getTreeStructure(); + if (structure.hasSomethingToCommit()) structure.commit(); addSubtreeToUpdate(node); getUpdater().performUpdate(); } @@ -551,11 +561,11 @@ public class AbstractTreeUi { return TreeUtil.isAncestor(getRootNode(), node) && getRootNode() == myTreeModel.getRoot(); } - private boolean isNodeValidForElement(final Object element, final DefaultMutableTreeNode node) { + private boolean isNodeValidForElement(@NotNull final Object element, @NotNull final DefaultMutableTreeNode node) { return isSameHierarchy(element, node) || isValidChildOfParent(element, node); } - private boolean isValidChildOfParent(final Object element, final DefaultMutableTreeNode node) { + private boolean isValidChildOfParent(@NotNull final Object element, @NotNull final DefaultMutableTreeNode node) { final DefaultMutableTreeNode parent = (DefaultMutableTreeNode)node.getParent(); final Object parentElement = getElementFor(parent); if (!isInStructure(parentElement)) return false; @@ -572,7 +582,7 @@ public class AbstractTreeUi { return false; } - private boolean isSameHierarchy(Object eachParent, DefaultMutableTreeNode eachParentNode) { + private boolean isSameHierarchy(@Nullable Object eachParent, @Nullable DefaultMutableTreeNode eachParentNode) { boolean valid; while (true) { if (eachParent == null) { @@ -591,7 +601,8 @@ public class AbstractTreeUi { return valid; } - public final DefaultMutableTreeNode getNodeForPath(Object[] path) { + @Nullable + public final DefaultMutableTreeNode getNodeForPath(@NotNull Object[] path) { DefaultMutableTreeNode node = null; for (final Object pathElement : path) { node = node == null ? getFirstNode(pathElement) : findNodeForChildElement(node, pathElement); @@ -624,7 +635,7 @@ public class AbstractTreeUi { } } - public final void buildNodeForPath(Object[] path) { + public final void buildNodeForPath(@NotNull Object[] path) { getUpdater().performUpdate(); DefaultMutableTreeNode node = null; for (final Object pathElement : path) { @@ -654,7 +665,7 @@ public class AbstractTreeUi { } } - private boolean initRootNodeNowIfNeeded(final TreeUpdatePass pass) { + private boolean initRootNodeNowIfNeeded(@NotNull final TreeUpdatePass pass) { boolean wasCleanedUp = false; if (myRootNodeWasQueuedToInitialize) { Object root = getTreeStructure().getRootElement(); @@ -679,6 +690,7 @@ public class AbstractTreeUi { final Object rootElement = getTreeStructure().getRootElement(); addNodeAction(rootElement, new NodeAction() { + @Override public void onReady(final DefaultMutableTreeNode node) { processDeferredActions(); } @@ -689,6 +701,7 @@ public class AbstractTreeUi { final boolean bgLoading = getTreeStructure().isToBuildChildrenInBackground(rootElement); Runnable build = new Runnable() { + @Override public void run() { rootDescriptor.set(getTreeStructure().createDescriptor(rootElement, null)); getRootNode().setUserObject(rootDescriptor.get()); @@ -699,6 +712,7 @@ public class AbstractTreeUi { Runnable update = new Runnable() { + @Override public void run() { if (getElementFromDescriptor(rootDescriptor.get()) != null) { createMapping(getElementFromDescriptor(rootDescriptor.get()), getRootNode()); @@ -722,7 +736,7 @@ public class AbstractTreeUi { }; if (bgLoading) { - queueToBackground(build, update, rootDescriptor).doWhenProcessed(new Runnable() { + queueToBackground(build, update).doWhenProcessed(new Runnable() { @Override public void run() { invokeLaterIfNeeded(new Runnable() { @@ -749,7 +763,7 @@ public class AbstractTreeUi { return isAutoExpand(descriptor, true); } - private boolean isAutoExpand(NodeDescriptor descriptor, boolean validate) { + private boolean isAutoExpand(@Nullable NodeDescriptor descriptor, boolean validate) { if (descriptor == null || isAlwaysExpandedTree()) return false; boolean autoExpand = getBuilder().isAutoExpandNode(descriptor); @@ -792,7 +806,7 @@ public class AbstractTreeUi { if (myRootNode == eachParent) return true; - NodeDescriptor eachDescriptor = getDescriptorFrom((DefaultMutableTreeNode)eachParent); + NodeDescriptor eachDescriptor = getDescriptorFrom(eachParent); if (!isAutoExpand(eachDescriptor, false)) { TreePath path = getPathFor(eachParent); return myWillBeExpanded.contains(path.getLastPathComponent()) || myTree.isExpanded(path) && myTree.isVisible(path); @@ -816,7 +830,7 @@ public class AbstractTreeUi { return eachParent != null ? distance : -1; } - private boolean isAutoExpand(DefaultMutableTreeNode node) { + private boolean isAutoExpand(@NotNull DefaultMutableTreeNode node) { return isAutoExpand(getDescriptorFrom(node)); } @@ -824,7 +838,8 @@ public class AbstractTreeUi { return myTree instanceof AlwaysExpandedTree && ((AlwaysExpandedTree)myTree).isAlwaysExpanded(); } - private AsyncResult update(final NodeDescriptor nodeDescriptor, boolean now) { + @NotNull + private AsyncResult update(@NotNull final NodeDescriptor nodeDescriptor, boolean now) { final AsyncResult result = new AsyncResult(); if (now || isPassthroughMode()) { @@ -838,14 +853,17 @@ public class AbstractTreeUi { if (edt) { final Ref changes = new Ref(false); queueToBackground(new Runnable() { + @Override public void run() { changes.set(_update(nodeDescriptor)); } }, new Runnable() { + @Override public void run() { result.setDone(changes.get()); } - }, nodeDescriptor); + } + ); } else { result.setDone(_update(nodeDescriptor)); @@ -857,8 +875,10 @@ public class AbstractTreeUi { } else { invokeLaterIfNeeded(new Runnable() { + @Override public void run() { execute(new Runnable() { + @Override public void run() { result.setDone(_update(nodeDescriptor)); } @@ -870,16 +890,17 @@ public class AbstractTreeUi { } result.doWhenDone(new AsyncResult.Handler() { + @Override public void run(final Boolean changes) { if (changes) { - final long updateStamp = nodeDescriptor.getUpdateCount(); invokeLaterIfNeeded(new Runnable() { + @Override public void run() { Object element = nodeDescriptor.getElement(); DefaultMutableTreeNode node = getNodeForElement(element, false); if (node != null) { TreePath path = getPathFor(node); - if (path != null && myTree.isVisible(path)) { + if (myTree.isVisible(path)) { updateNodeImageAndPosition(node, false, changes); } } @@ -893,12 +914,13 @@ public class AbstractTreeUi { return result; } - private boolean _update(final NodeDescriptor nodeDescriptor) { + private boolean _update(@NotNull final NodeDescriptor nodeDescriptor) { try { final Ref update = new Ref(); try { acquireLock(); execute(new Runnable() { + @Override public void run() { nodeDescriptor.setUpdateCount(nodeDescriptor.getUpdateCount() + 1); update.set(getBuilder().updateNodeDescriptor(nodeDescriptor)); @@ -945,7 +967,7 @@ public class AbstractTreeUi { processDeferredActions(myDeferredExpansions); } - private static void processDeferredActions(Set actions) { + private static void processDeferredActions(@NotNull Set actions) { final Runnable[] runnables = actions.toArray(new Runnable[actions.size()]); actions.clear(); for (Runnable runnable : runnables) { @@ -954,10 +976,12 @@ public class AbstractTreeUi { } //todo: to make real callback + @NotNull public ActionCallback queueUpdate(Object element) { return queueUpdate(element, true); } + @NotNull public ActionCallback queueUpdate(Object element, boolean updateStructure) { assertIsDispatchThread(); @@ -984,6 +1008,7 @@ public class AbstractTreeUi { } updater.runAfterUpdate(new Runnable() { + @Override public void run() { result.setDone(); } @@ -999,9 +1024,11 @@ public class AbstractTreeUi { updateSubtree(getRootNode(), false); } + @NotNull public ActionCallback doUpdateFromRootCB() { final ActionCallback cb = new ActionCallback(); getUpdater().runAfterUpdate(new Runnable() { + @Override public void run() { cb.setDone(); } @@ -1010,11 +1037,11 @@ public class AbstractTreeUi { return cb; } - public final void updateSubtree(DefaultMutableTreeNode node, boolean canSmartExpand) { + public final void updateSubtree(@NotNull DefaultMutableTreeNode node, boolean canSmartExpand) { updateSubtree(new TreeUpdatePass(node), canSmartExpand); } - public final void updateSubtree(TreeUpdatePass pass, boolean canSmartExpand) { + public final void updateSubtree(@NotNull TreeUpdatePass pass, boolean canSmartExpand) { if (getUpdater() != null) { getUpdater().addSubtreeToUpdate(pass); } @@ -1023,7 +1050,7 @@ public class AbstractTreeUi { } } - final void updateSubtreeNow(TreeUpdatePass pass, boolean canSmartExpand) { + final void updateSubtreeNow(@NotNull TreeUpdatePass pass, boolean canSmartExpand) { maybeSetBusyAndScheduleWaiterForReady(true, getElementFor(pass.getNode())); setHoldSize(true); @@ -1051,7 +1078,7 @@ public class AbstractTreeUi { } } - private void updateRow(final int row, final TreeUpdatePass pass) { + private void updateRow(final int row, @NotNull final TreeUpdatePass pass) { invokeLaterIfNeeded(new Runnable() { @Override public void run() { @@ -1063,6 +1090,7 @@ public class AbstractTreeUi { if (descriptor != null) { DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent(); maybeYeild(new ActiveRunnable() { + @NotNull @Override public ActionCallback run() { ActionCallback result = new ActionCallback(); @@ -1086,7 +1114,7 @@ public class AbstractTreeUi { } @NotNull - UpdaterTreeState setUpdaterState(UpdaterTreeState state) { + private UpdaterTreeState setUpdaterState(@NotNull UpdaterTreeState state) { if (myUpdaterState != null && myUpdaterState.equals(state)) return state; final UpdaterTreeState oldState = myUpdaterState; @@ -1100,12 +1128,13 @@ public class AbstractTreeUi { } } - protected void doUpdateNode(final DefaultMutableTreeNode node) { + protected void doUpdateNode(@NotNull final DefaultMutableTreeNode node) { if (!(node.getUserObject() instanceof NodeDescriptor)) return; final NodeDescriptor descriptor = getDescriptorFrom(node); final Object prevElement = getElementFromDescriptor(descriptor); if (prevElement == null) return; update(descriptor, false).doWhenDone(new AsyncResult.Handler() { + @Override public void run(Boolean changes) { if (!isValid(descriptor)) { if (isInStructure(prevElement)) { @@ -1124,8 +1153,8 @@ public class AbstractTreeUi { return getBuilder().getTreeStructureElement(descriptor); } - private void updateNodeChildren(final DefaultMutableTreeNode node, - final TreeUpdatePass pass, + private void updateNodeChildren(@NotNull final DefaultMutableTreeNode node, + @NotNull final TreeUpdatePass pass, @Nullable final LoadedChildren loadedChildren, final boolean forcedNow, final boolean toSmartExpand, @@ -1135,6 +1164,7 @@ public class AbstractTreeUi { removeFromCancelled(node); execute(new Runnable() { + @Override public void run() { try { @@ -1210,21 +1240,21 @@ public class AbstractTreeUi { queueBackgroundUpdate( new UpdateInfo(descriptor, pass, canSmartExpand(node, toSmartExpand), wasExpanded, childForceUpdate, descriptorIsReady, !alwaysLeaf && updateChildren), node); - return; } else { if (!descriptorIsReady) { update(descriptor, false).doWhenDone(new Runnable() { + @Override public void run() { if (processAlwaysLeaf(node) || !updateChildren) return; - updateNodeChildrenNow(node, pass, preloaded.get(), toSmartExpand, wasExpanded, wasLeaf, childForceUpdate); + updateNodeChildrenNow(node, pass, preloaded.get(), toSmartExpand, wasExpanded, childForceUpdate); } }); } else { if (processAlwaysLeaf(node) || !updateChildren) return; - updateNodeChildrenNow(node, pass, preloaded.get(), toSmartExpand, wasExpanded, wasLeaf, childForceUpdate); + updateNodeChildrenNow(node, pass, preloaded.get(), toSmartExpand, wasExpanded, childForceUpdate); } } } @@ -1237,7 +1267,7 @@ public class AbstractTreeUi { }, node); } - private boolean processAlwaysLeaf(DefaultMutableTreeNode node) { + private boolean processAlwaysLeaf(@NotNull DefaultMutableTreeNode node) { Object element = getElementFor(node); NodeDescriptor desc = getDescriptorFrom(node); @@ -1258,6 +1288,7 @@ public class AbstractTreeUi { } processInnerChange(new Runnable() { + @Override public void run() { for (TreeNode each : children) { removeNodeFromParent((MutableTreeNode)each, true); @@ -1284,17 +1315,16 @@ public class AbstractTreeUi { } } - private boolean isChildNodeForceUpdate(DefaultMutableTreeNode node, boolean parentForceUpdate, boolean parentExpanded) { + private boolean isChildNodeForceUpdate(@NotNull DefaultMutableTreeNode node, boolean parentForceUpdate, boolean parentExpanded) { TreePath path = getPathFor(node); return parentForceUpdate && (parentExpanded || myTree.isExpanded(path)); } - private void updateNodeChildrenNow(final DefaultMutableTreeNode node, - final TreeUpdatePass pass, - final LoadedChildren preloadedChildren, + private void updateNodeChildrenNow(@NotNull final DefaultMutableTreeNode node, + @NotNull final TreeUpdatePass pass, + @Nullable final LoadedChildren preloadedChildren, final boolean toSmartExpand, final boolean wasExpanded, - final boolean wasLeaf, final boolean forceUpdate) { if (isUpdatingChildrenNow(node)) return; @@ -1318,6 +1348,7 @@ public class AbstractTreeUi { processExistingNodes(node, elementToIndexMap, pass, canSmartExpand(node, toSmartExpand), forceUpdate, wasExpanded, preloadedChildren) .doWhenDone(new Runnable() { + @Override public void run() { if (isDisposed(node)) { removeFromUpdatingChildren(node); @@ -1337,7 +1368,8 @@ public class AbstractTreeUi { collectNodesToInsert(descriptor, elementToIndexMap, node, expanded, loadedChildren) .doWhenDone(new AsyncResult.Handler>() { - public void run(ArrayList nodesToInsert) { + @Override + public void run(@NotNull ArrayList nodesToInsert) { insertNodesInto(nodesToInsert, node); updateNodesToInsert(nodesToInsert, pass, canSmartExpand, isChildNodeForceUpdate(node, forceUpdate, expanded)); removeLoading(node, false); @@ -1355,7 +1387,8 @@ public class AbstractTreeUi { final Object element = getElementFor(node); addNodeAction(element, new NodeAction() { - public void onReady(final DefaultMutableTreeNode node) { + @Override + public void onReady(@NotNull final DefaultMutableTreeNode node) { removeLoading(node, false); } }, false); @@ -1363,6 +1396,7 @@ public class AbstractTreeUi { processNodeActionsIfReady(node); } }).doWhenProcessed(new Runnable() { + @Override public void run() { myWillBeExpanded.remove(node); removeFromUpdatingChildren(node); @@ -1371,6 +1405,7 @@ public class AbstractTreeUi { }); } }).doWhenRejected(new Runnable() { + @Override public void run() { removeFromUpdatingChildren(node); processNodeActionsIfReady(node); @@ -1378,7 +1413,7 @@ public class AbstractTreeUi { }); } - private boolean isDisposed(DefaultMutableTreeNode node) { + private boolean isDisposed(@NotNull DefaultMutableTreeNode node) { return !node.isNodeAncestor((DefaultMutableTreeNode)myTree.getModel().getRoot()); } @@ -1406,14 +1441,11 @@ public class AbstractTreeUi { } } - private void expand(DefaultMutableTreeNode node, boolean canSmartExpand) { + private void expand(@NotNull DefaultMutableTreeNode node, boolean canSmartExpand) { expand(new TreePath(node.getPath()), canSmartExpand); } - private void expand(final TreePath path, boolean canSmartExpand) { - if (path == null) return; - - + private void expand(@NotNull final TreePath path, boolean canSmartExpand) { final Object last = path.getLastPathComponent(); boolean isLeaf = myTree.getModel().isLeaf(path.getLastPathComponent()); final boolean isRoot = last == myTree.getModel().getRoot(); @@ -1456,14 +1488,15 @@ public class AbstractTreeUi { myUnbuiltNodes.remove(node); } - private Pair processUnbuilt(final DefaultMutableTreeNode node, + private Pair processUnbuilt(@NotNull final DefaultMutableTreeNode node, final NodeDescriptor descriptor, - final TreeUpdatePass pass, + @NotNull final TreeUpdatePass pass, final boolean isExpanded, - final LoadedChildren loadedChildren) { + @Nullable final LoadedChildren loadedChildren) { final Ref> result = new Ref>(); execute(new Runnable() { + @Override public void run() { if (!isExpanded && getBuilder().isAlwaysShowPlus(descriptor)) { result.set(new Pair(true, null)); @@ -1487,13 +1520,16 @@ public class AbstractTreeUi { else { if (isAutoExpand(node)) { addNodeAction(getElementFor(node), new NodeAction() { - public void onReady(final DefaultMutableTreeNode node) { + @Override + public void onReady(@NotNull final DefaultMutableTreeNode node) { final TreePath path = new TreePath(node.getPath()); if (getTree().isExpanded(path) || children.getElements().isEmpty()) { removeLoading(node, false); } else { maybeYeild(new ActiveRunnable() { + @NotNull + @Override public ActionCallback run() { expand(element, null); return new ActionCallback.Done(); @@ -1521,7 +1557,7 @@ public class AbstractTreeUi { return result.get(); } - private boolean removeIfLoading(TreeNode node) { + private boolean removeIfLoading(@NotNull TreeNode node) { if (isLoadingNode(node)) { moveSelectionToParentIfNeeded(node); removeNodeFromParent((MutableTreeNode)node, false); @@ -1531,7 +1567,7 @@ public class AbstractTreeUi { return false; } - private void moveSelectionToParentIfNeeded(TreeNode node) { + private void moveSelectionToParentIfNeeded(@NotNull TreeNode node) { TreePath path = getPathFor(node); if (myTree.getSelectionModel().isPathSelected(path)) { TreePath parentPath = path.getParentPath(); @@ -1548,6 +1584,7 @@ public class AbstractTreeUi { try { acquireLock(); execute(new Runnable() { + @Override public void run() { passOne.set(getTreeStructure().getChildElements(element)); } @@ -1593,8 +1630,8 @@ public class AbstractTreeUi { } } - private void updateNodesToInsert(final ArrayList nodesToInsert, - TreeUpdatePass pass, + private void updateNodesToInsert(@NotNull final ArrayList nodesToInsert, + @NotNull TreeUpdatePass pass, boolean canSmartExpand, boolean forceUpdate) { for (TreeNode aNodesToInsert : nodesToInsert) { @@ -1603,16 +1640,19 @@ public class AbstractTreeUi { } } - private ActionCallback processExistingNodes(final DefaultMutableTreeNode node, - final MutualMap elementToIndexMap, - final TreeUpdatePass pass, + @NotNull + private ActionCallback processExistingNodes(@NotNull final DefaultMutableTreeNode node, + @NotNull final MutualMap elementToIndexMap, + @NotNull final TreeUpdatePass pass, final boolean canSmartExpand, final boolean forceUpdate, final boolean wasExpaned, - final LoadedChildren preloaded) { + @Nullable final LoadedChildren preloaded) { final ArrayList childNodes = TreeUtil.childrenToArray(node); return maybeYeild(new ActiveRunnable() { + @NotNull + @Override public ActionCallback run() { if (pass.isExpired()) return new ActionCallback.Rejected(); if (childNodes.isEmpty()) return new ActionCallback.Done(); @@ -1630,6 +1670,7 @@ public class AbstractTreeUi { final boolean childForceUpdate = isChildNodeForceUpdate(eachChild, forceUpdate, wasExpaned); maybeYeild(new ActiveRunnable() { + @NotNull @Override public ActionCallback run() { NodeDescriptor descriptor = preloaded != null ? preloaded.getDescriptor(getElementFor(eachChild)) : null; @@ -1658,7 +1699,7 @@ public class AbstractTreeUi { }, pass, node); } - private boolean isRerunNeeded(TreeUpdatePass pass) { + private boolean isRerunNeeded(@NotNull TreeUpdatePass pass) { if (pass.isExpired() || !canInitiateNewActivity()) return false; final boolean rerunBecauseTreeIsHidden = !pass.isExpired() && !isTreeShowing() && getUpdater().isInPostponeMode(); @@ -1666,7 +1707,8 @@ public class AbstractTreeUi { return rerunBecauseTreeIsHidden || getUpdater().isRerunNeededFor(pass); } - private ActionCallback maybeYeild(final ActiveRunnable processRunnable, final TreeUpdatePass pass, final DefaultMutableTreeNode node) { + @NotNull + private ActionCallback maybeYeild(@NotNull final ActiveRunnable processRunnable, @NotNull final TreeUpdatePass pass, final DefaultMutableTreeNode node) { final ActionCallback result = new ActionCallback(); if (isRerunNeeded(pass)) { @@ -1677,6 +1719,7 @@ public class AbstractTreeUi { if (isToYieldUpdateFor(node)) { pass.setCurrentNode(node); boolean wasRun = yieldAndRun(new Runnable() { + @Override public void run() { if (pass.isExpired()) { result.setRejected(); @@ -1685,6 +1728,7 @@ public class AbstractTreeUi { if (isRerunNeeded(pass)) { runDone(new Runnable() { + @Override public void run() { if (!pass.isExpired()) { getUpdater().requeue(pass); @@ -1724,9 +1768,11 @@ public class AbstractTreeUi { return result; } - private ActionCallback execute(final ActiveRunnable runnable) throws ProcessCanceledException { + @NotNull + private ActionCallback execute(@NotNull final ActiveRunnable runnable) throws ProcessCanceledException { final ActionCallback result = new ActionCallback(); execute(new Runnable() { + @Override public void run() { runnable.run().notify(result); } @@ -1734,11 +1780,11 @@ public class AbstractTreeUi { return result; } - private void execute(Runnable runnable) { + private void execute(@NotNull Runnable runnable) { execute(runnable, null); } - private void execute(Runnable runnable, @Nullable DefaultMutableTreeNode node) throws ProcessCanceledException { + private void execute(@NotNull Runnable runnable, @Nullable DefaultMutableTreeNode node) throws ProcessCanceledException { try { if (!canInitiateNewActivity()) { throw new ProcessCanceledException(); @@ -1766,6 +1812,7 @@ public class AbstractTreeUi { return !isCancelProcessed() && !myReleaseRequested && !isReleased(); } + @NotNull private ActionCallback resetToReady() { final ActionCallback result = new ActionCallback(); @@ -1782,6 +1829,7 @@ public class AbstractTreeUi { myResettingToReadyNow.set(true); invokeLaterIfNeeded(new Runnable() { + @Override public void run() { if (!myResettingToReadyNow.get()) { result.setDone(); @@ -1838,6 +1886,7 @@ public class AbstractTreeUi { ActionCallback result = _getReady(); result.doWhenDone(new Runnable() { + @Override public void run() { myResettingToReadyNow.set(false); setCancelRequested(false); @@ -1878,14 +1927,16 @@ public class AbstractTreeUi { } } - private boolean yieldAndRun(final Runnable runnable, final TreeUpdatePass pass) { + private boolean yieldAndRun(@NotNull final Runnable runnable, @NotNull final TreeUpdatePass pass) { myYieldingPasses.add(pass); myYieldingNow = true; yield(new Runnable() { + @Override public void run() { if (isReleased()) return; runOnYieldingDone(new Runnable() { + @Override public void run() { if (isReleased()) return; @@ -1933,7 +1984,8 @@ public class AbstractTreeUi { return ready != null && ready.booleanValue(); } - private Boolean checkValue(Computable computable, boolean attempt, Boolean defaultValue) { + @Nullable + private Boolean checkValue(@NotNull Computable computable, boolean attempt, @Nullable Boolean defaultValue) { boolean toRelease = true; try { if (attempt) { @@ -1956,6 +2008,8 @@ public class AbstractTreeUi { } } + @NotNull + @NonNls public String getStatus() { return "isReady=" + isReady() + "\n" + " isIdle=" + isIdle() + "\n" + @@ -1989,7 +2043,7 @@ public class AbstractTreeUi { return !isYeildingNow() && !isWorkerBusy() && !hasUpdatingChildrenNow() && !isLoadingInBackgroundNow(); } - private void executeYieldingRequest(Runnable runnable, TreeUpdatePass pass) { + private void executeYieldingRequest(@NotNull Runnable runnable, @NotNull TreeUpdatePass pass) { try { try { myYieldingPasses.remove(pass); @@ -2055,7 +2109,7 @@ public class AbstractTreeUi { if (myInitialized.isDone()) { if (isReleaseRequested() || isCancelProcessed()) { - myBusyObject.onReady(AbstractTreeUi.this); + myBusyObject.onReady(this); } else { myBusyObject.onReady(); } @@ -2114,6 +2168,7 @@ public class AbstractTreeUi { return canYield() && getBuilder().isToYieldUpdateFor(node); } + @NotNull private MutualMap loadElementsFromStructure(final NodeDescriptor descriptor, @Nullable LoadedChildren preloadedChildren) { MutualMap elementToIndexMap = new MutualMap(true); @@ -2133,48 +2188,13 @@ public class AbstractTreeUi { return elementToIndexMap; } - private void expand(final DefaultMutableTreeNode node, - final NodeDescriptor descriptor, - final boolean wasLeaf, - final boolean canSmartExpand) { - final Alarm alarm = new Alarm(Alarm.ThreadToUse.SHARED_THREAD); - alarm.addRequest(new Runnable() { - public void run() { - myTree.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR)); - } - }, WAIT_CURSOR_DELAY); - - if (wasLeaf && isAutoExpand(descriptor)) { - expand(node, canSmartExpand); - } - - ArrayList nodes = TreeUtil.childrenToArray(node); - for (TreeNode node1 : nodes) { - final DefaultMutableTreeNode childNode = (DefaultMutableTreeNode)node1; - if (isLoadingNode(childNode)) continue; - NodeDescriptor childDescr = getDescriptorFrom(childNode); - if (isAutoExpand(childDescr)) { - addNodeAction(getElementFor(childNode), new NodeAction() { - public void onReady(DefaultMutableTreeNode node) { - expand(childNode, canSmartExpand); - } - }, false); - addSubtreeToUpdate(childNode); - } - } - - int n = alarm.cancelAllRequests(); - if (n == 0) { - myTree.setCursor(Cursor.getDefaultCursor()); - } - } - public static boolean isLoadingNode(final Object node) { return node instanceof LoadingNode; } + @NotNull private AsyncResult> collectNodesToInsert(final NodeDescriptor descriptor, - final MutualMap elementToIndexMap, + @NotNull final MutualMap elementToIndexMap, final DefaultMutableTreeNode parent, final boolean addLoadingNode, @NotNull final LoadedChildren loadedChildren) { @@ -2209,6 +2229,7 @@ public class AbstractTreeUi { final ActionCallback update = new ActionCallback(); if (needToUpdate) { update(childDescr.get(), false).doWhenDone(new AsyncResult.Handler() { + @Override public void run(Boolean changes) { loadedChildren.putDescriptor(child, childDescr.get(), changes); update.setDone(); @@ -2220,6 +2241,7 @@ public class AbstractTreeUi { } update.doWhenDone(new Runnable() { + @Override public void run() { Object element = getElementFromDescriptor(childDescr.get()); if (element == null) { @@ -2245,6 +2267,7 @@ public class AbstractTreeUi { } processingDone.doWhenDone(new Runnable() { + @Override public void run() { result.setDone(nodesToInsert); } @@ -2265,11 +2288,12 @@ public class AbstractTreeUi { return myClearOnHideDelay > 0 ? myClearOnHideDelay : Registry.intValue("ide.tree.clearOnHideTime"); } + @NotNull public ActionCallback getInitialized() { return myInitialized; } - public ActionCallback getReady(Object requestor) { + public ActionCallback getReady(@NotNull Object requestor) { return myBusyObject.getReady(requestor); } @@ -2295,7 +2319,7 @@ public class AbstractTreeUi { } } - public boolean isParentUpdatingChildrenNow(DefaultMutableTreeNode node) { + public boolean isParentUpdatingChildrenNow(@NotNull DefaultMutableTreeNode node) { synchronized (myUpdatingChildren) { DefaultMutableTreeNode eachParent = (DefaultMutableTreeNode)node.getParent(); while (eachParent != null) { @@ -2314,10 +2338,12 @@ public class AbstractTreeUi { } } + @NotNull public Map> getNodeActions() { return myNodeActions; } + @NotNull public List getLoadedChildrenFor(Object element) { List result = new ArrayList(); @@ -2338,6 +2364,7 @@ public class AbstractTreeUi { return getUpdater().hasNodesToUpdate(); } + @NotNull public List getExpandedElements() { final List result = new ArrayList(); if (isReleased()) return result; @@ -2356,6 +2383,7 @@ public class AbstractTreeUi { return result; } + @NotNull public ActionCallback cancelUpdate() { if (isReleased()) return new ActionCallback.Rejected(); @@ -2364,6 +2392,7 @@ public class AbstractTreeUi { final ActionCallback done = new ActionCallback(); invokeLaterIfNeeded(new Runnable() { + @Override public void run() { if (isReleased()) { done.setRejected(); @@ -2423,7 +2452,8 @@ public class AbstractTreeUi { myStateLock.unlock(); } - public ActionCallback batch(final Progressive progressive) { + @NotNull + public ActionCallback batch(@NotNull final Progressive progressive) { assertIsDispatchThread(); EmptyProgressIndicator indicator = new EmptyProgressIndicator(); @@ -2437,6 +2467,7 @@ public class AbstractTreeUi { } catch (ProcessCanceledException e) { resetToReadyNow().doWhenProcessed(new Runnable() { + @Override public void run() { callback.setRejected(); } @@ -2447,6 +2478,7 @@ public class AbstractTreeUi { if (isReleased()) return new ActionCallback.Rejected(); _getReady().doWhenDone(new Runnable() { + @Override public void run() { if (myBatchIndicators.containsKey(progressive)) { ProgressIndicator indicator = myBatchIndicators.remove(progressive); @@ -2490,7 +2522,7 @@ public class AbstractTreeUi { return myReleaseRequested; } - public void executeUserRunnable(Runnable runnable) { + public void executeUserRunnable(@NotNull Runnable runnable) { try { myUserRunnables.add(runnable); runnable.run(); @@ -2543,6 +2575,7 @@ public class AbstractTreeUi { return getUpdatingParent(kid) != null; } + @Nullable private DefaultMutableTreeNode getUpdatingParent(DefaultMutableTreeNode kid) { DefaultMutableTreeNode eachParent = kid; while (eachParent != null) { @@ -2581,7 +2614,7 @@ public class AbstractTreeUi { } } - private boolean queueBackgroundUpdate(final UpdateInfo updateInfo, final DefaultMutableTreeNode node) { + private boolean queueBackgroundUpdate(@NotNull final UpdateInfo updateInfo, @NotNull final DefaultMutableTreeNode node) { assertIsDispatchThread(); final Object oldElementFromDescriptor = getElementFromDescriptor(updateInfo.getDescriptor()); @@ -2609,8 +2642,10 @@ public class AbstractTreeUi { final DefaultMutableTreeNode[] nodeToProcessActions = new DefaultMutableTreeNode[1]; final Runnable finalizeRunnable = new Runnable() { + @Override public void run() { invokeLaterIfNeeded(new Runnable() { + @Override public void run() { if (isReleased()) return; @@ -2628,6 +2663,7 @@ public class AbstractTreeUi { Runnable buildRunnable = new Runnable() { + @Override public void run() { if (updateInfo.getPass().isExpired()) { finalizeRunnable.run(); @@ -2656,6 +2692,7 @@ public class AbstractTreeUi { NodeDescriptor existingDesc = getDescriptorFrom(getNodeForElement(each, true)); final NodeDescriptor eachChildDescriptor = existingDesc != null ? existingDesc : getTreeStructure().createDescriptor(each, updateInfo.getDescriptor()); execute(new Runnable() { + @Override public void run() { loaded.putDescriptor(each, eachChildDescriptor, update(eachChildDescriptor, true).getResult()); } @@ -2666,6 +2703,8 @@ public class AbstractTreeUi { } + @NotNull + @NonNls @Override public String toString() { return "runnable=" + oldElementFromDescriptor; @@ -2673,6 +2712,7 @@ public class AbstractTreeUi { }; Runnable updateRunnable = new Runnable() { + @Override public void run() { if (updateInfo.getPass().isExpired()) { finalizeRunnable.run(); @@ -2719,7 +2759,8 @@ public class AbstractTreeUi { } } }; - queueToBackground(buildRunnable, updateRunnable, node).doWhenProcessed(finalizeRunnable).doWhenRejected(new Runnable() { + queueToBackground(buildRunnable, updateRunnable).doWhenProcessed(finalizeRunnable).doWhenRejected(new Runnable() { + @Override public void run() { updateInfo.getPass().expire(); } @@ -2732,7 +2773,7 @@ public class AbstractTreeUi { return isExpanded || myTree.isExpanded(getPathFor(node)); } - private void removeLoading(DefaultMutableTreeNode parent, boolean forced) { + private void removeLoading(@NotNull DefaultMutableTreeNode parent, boolean forced) { if (!forced && myUnbuiltNodes.contains(parent) && !myCancelledBuild.containsKey(parent)) { return; } @@ -2757,7 +2798,7 @@ public class AbstractTreeUi { } } - private void processNodeActionsIfReady(final DefaultMutableTreeNode node) { + private void processNodeActionsIfReady(@NotNull final DefaultMutableTreeNode node) { assertIsDispatchThread(); if (isNodeBeingBuilt(node)) return; @@ -2797,7 +2838,7 @@ public class AbstractTreeUi { private static void processActions(DefaultMutableTreeNode node, Object element, - final Map> nodeActions, + @NotNull final Map> nodeActions, @Nullable final Map> secondaryNodeAction) { final List actions = nodeActions.get(element); if (actions != null) { @@ -2822,7 +2863,7 @@ public class AbstractTreeUi { return smartExpand && validateAutoExpand(smartExpand, getElementFor(node)); } - private void processSmartExpand(final DefaultMutableTreeNode node, final boolean canSmartExpand, boolean forced) { + private void processSmartExpand(@NotNull final DefaultMutableTreeNode node, final boolean canSmartExpand, boolean forced) { if (!canInitiateNewActivity()) return; if (!getBuilder().isSmartExpand()) return; @@ -2832,7 +2873,8 @@ public class AbstractTreeUi { if (isNodeBeingBuilt(node) && !forced) { addNodeAction(getElementFor(node), new NodeAction() { - public void onReady(DefaultMutableTreeNode node) { + @Override + public void onReady(@NotNull DefaultMutableTreeNode node) { processSmartExpand(node, canSmartExpand, true); } }, true); @@ -2842,6 +2884,7 @@ public class AbstractTreeUi { if (child != null) { final TreePath childPath = new TreePath(node.getPath()).pathByAddingChild(child); processInnerChange(new Runnable() { + @Override public void run() { myTree.expandPath(childPath); } @@ -2851,7 +2894,7 @@ public class AbstractTreeUi { } @Nullable - private static TreeNode getChildForSmartExpand(DefaultMutableTreeNode node) { + private static TreeNode getChildForSmartExpand(@NotNull DefaultMutableTreeNode node) { int realChildCount = 0; TreeNode nodeToExpand = null; @@ -2893,6 +2936,7 @@ public class AbstractTreeUi { return getParentLoadingInBackground(nodeObject) != null; } + @Nullable private DefaultMutableTreeNode getParentLoadingInBackground(Object nodeObject) { if (!(nodeObject instanceof DefaultMutableTreeNode)) return null; @@ -2915,14 +2959,15 @@ public class AbstractTreeUi { return IdeBundle.message("progress.searching"); } - private ActionCallback processExistingNode(final DefaultMutableTreeNode childNode, + @NotNull + private ActionCallback processExistingNode(@NotNull final DefaultMutableTreeNode childNode, final NodeDescriptor childDescriptor, - final DefaultMutableTreeNode parentNode, - final MutualMap elementToIndexMap, - final TreeUpdatePass pass, + @NotNull final DefaultMutableTreeNode parentNode, + @NotNull final MutualMap elementToIndexMap, + @NotNull final TreeUpdatePass pass, final boolean canSmartExpand, final boolean forceUpdate, - LoadedChildren parentPreloadedChildren) { + @Nullable LoadedChildren parentPreloadedChildren) { final ActionCallback result = new ActionCallback(); @@ -2951,6 +2996,7 @@ public class AbstractTreeUi { } update.doWhenDone(new AsyncResult.Handler() { + @Override public void run(Boolean isChanged) { final Ref changes = new Ref(isChanged); @@ -2977,6 +3023,7 @@ public class AbstractTreeUi { newElement.set(elementFromMap); forceRemapping.set(true); update(childDesc.get(), false).doWhenDone(new AsyncResult.Handler() { + @Override public void run(Boolean isChanged) { changes.set(isChanged); updateIndexDone.setDone(isChanged); @@ -2993,6 +3040,7 @@ public class AbstractTreeUi { } updateIndexDone.doWhenDone(new Runnable() { + @Override public void run() { if (childDesc.get().getIndex() != index.intValue()) { changes.set(true); @@ -3007,6 +3055,7 @@ public class AbstractTreeUi { } updateIndexDone.doWhenDone(new Runnable() { + @Override public void run() { //if (index != null && changes.get()) { // updateNodeImageAndPosition(childNode, false, changes.get()); @@ -3063,8 +3112,8 @@ public class AbstractTreeUi { return result; } - private void adjustSelectionOnChildRemove(DefaultMutableTreeNode parentNode, int selectedIndex, Object disposedElement) { - if (selectedIndex >= 0 && getSelectedElements().size() > 0) return; + private void adjustSelectionOnChildRemove(@NotNull DefaultMutableTreeNode parentNode, int selectedIndex, Object disposedElement) { + if (selectedIndex >= 0 && !getSelectedElements().isEmpty()) return; DefaultMutableTreeNode node = getNodeForElement(disposedElement, false); if (node != null && isValidForSelectionAdjusting(node)) { @@ -3098,7 +3147,7 @@ public class AbstractTreeUi { } } - private boolean isValidForSelectionAdjusting(TreeNode node) { + private boolean isValidForSelectionAdjusting(@NotNull TreeNode node) { if (!myTree.isRootVisible() && getRootNode() == node) return false; if (isLoadingNode(node)) return true; @@ -3115,19 +3164,22 @@ public class AbstractTreeUi { return parentElementInTree.equals(parentElement); } + @NotNull public Condition getExpiredElementCondition(final Object element) { return new Condition() { + @Override public boolean value(final Object o) { return isInStructure(element); } }; } - private void addSelectionPath(final TreePath path, + private void addSelectionPath(@NotNull final TreePath path, final boolean isAdjustedSelection, final Condition isExpiredAdjustement, @Nullable final Object adjustmentCause) { processInnerChange(new Runnable() { + @Override public void run() { TreePath toSelect = null; @@ -3160,6 +3212,7 @@ public class AbstractTreeUi { }); } + @NotNull private static TreePath getPathFor(@NotNull TreeNode node) { if (node instanceof DefaultMutableTreeNode) { return new TreePath(((DefaultMutableTreeNode)node).getPath()); @@ -3177,8 +3230,9 @@ public class AbstractTreeUi { } - private void removeNodeFromParent(final MutableTreeNode node, final boolean willAdjustSelection) { + private void removeNodeFromParent(@NotNull final MutableTreeNode node, final boolean willAdjustSelection) { processInnerChange(new Runnable() { + @Override public void run() { if (willAdjustSelection) { final TreePath path = getPathFor(node); @@ -3194,8 +3248,9 @@ public class AbstractTreeUi { }); } - private void expandPath(final TreePath path, final boolean canSmartExpand) { + private void expandPath(@NotNull final TreePath path, final boolean canSmartExpand) { processInnerChange(new Runnable() { + @Override public void run() { if (path.getLastPathComponent() instanceof DefaultMutableTreeNode) { DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent(); @@ -3233,14 +3288,8 @@ public class AbstractTreeUi { return myUpdaterState != null && myUpdaterState.isProcessingNow() && myUserRunnables.isEmpty(); } - protected static boolean doUpdateNodeDescriptor(final NodeDescriptor descriptor) { - boolean update = descriptor.update(); - return update; - } - - private void makeLoadingOrLeafIfNoChildren(final DefaultMutableTreeNode node) { + private void makeLoadingOrLeafIfNoChildren(@NotNull final DefaultMutableTreeNode node) { TreePath path = getPathFor(node); - if (path == null) return; insertLoadingNode(node, true); @@ -3264,7 +3313,7 @@ public class AbstractTreeUi { } - private boolean isValid(NodeDescriptor descriptor) { + private boolean isValid(@Nullable NodeDescriptor descriptor) { return descriptor != null && isValid(getElementFromDescriptor(descriptor)); } @@ -3286,13 +3335,15 @@ public class AbstractTreeUi { } - protected ActionCallback queueToBackground(@NotNull final Runnable bgBuildAction, @Nullable final Runnable edtPostRunnable, final Object id) { + @NotNull + private ActionCallback queueToBackground(@NotNull final Runnable bgBuildAction, @Nullable final Runnable edtPostRunnable) { if (!canInitiateNewActivity()) return new ActionCallback.Rejected(); final ActionCallback result = new ActionCallback(); final Ref fail = new Ref(false); final Runnable finalizer = new Runnable() { + @Override public void run() { if (fail.get()) { result.setRejected(); @@ -3303,9 +3354,10 @@ public class AbstractTreeUi { } }; - registerWorkerTask(bgBuildAction, id); + registerWorkerTask(bgBuildAction); final Runnable pooledThreadWithProgressRunnable = new Runnable() { + @Override public void run() { try { final AbstractTreeBuilder builder = getBuilder(); @@ -3315,6 +3367,7 @@ public class AbstractTreeUi { } builder.runBackgroundLoading(new Runnable() { + @Override public void run() { assertNotDispatchThread(); @@ -3328,6 +3381,7 @@ public class AbstractTreeUi { if (edtPostRunnable != null) { builder.updateAfterLoadedInBackground(new Runnable() { + @Override public void run() { try { assertIsDispatchThread(); @@ -3343,35 +3397,36 @@ public class AbstractTreeUi { cancelUpdate(); } finally { - unregisterWorkerTask(bgBuildAction, finalizer, id); + unregisterWorkerTask(bgBuildAction, finalizer); } } }); } else { - unregisterWorkerTask(bgBuildAction, finalizer, id); + unregisterWorkerTask(bgBuildAction, finalizer); } } catch (ProcessCanceledException e) { fail.set(true); - unregisterWorkerTask(bgBuildAction, finalizer, id); + unregisterWorkerTask(bgBuildAction, finalizer); cancelUpdate(); } catch (Throwable t) { - unregisterWorkerTask(bgBuildAction, finalizer, id); + unregisterWorkerTask(bgBuildAction, finalizer); throw new RuntimeException(t); } } }); } catch (ProcessCanceledException e) { - unregisterWorkerTask(bgBuildAction, finalizer, id); + unregisterWorkerTask(bgBuildAction, finalizer); cancelUpdate(); } } }; Runnable pooledThreadRunnable = new Runnable() { + @Override public void run() { try { if (myProgress != null) { @@ -3383,7 +3438,7 @@ public class AbstractTreeUi { } catch (ProcessCanceledException e) { fail.set(true); - unregisterWorkerTask(bgBuildAction, finalizer, id); + unregisterWorkerTask(bgBuildAction, finalizer); cancelUpdate(); } } @@ -3407,13 +3462,13 @@ public class AbstractTreeUi { return result; } - private void registerWorkerTask(Runnable runnable, Object id) { + private void registerWorkerTask(@NotNull Runnable runnable) { synchronized (myActiveWorkerTasks) { myActiveWorkerTasks.add(runnable); } } - private void unregisterWorkerTask(Runnable runnable, @Nullable Runnable finalizeRunnable, Object id) { + private void unregisterWorkerTask(@NotNull Runnable runnable, @Nullable Runnable finalizeRunnable) { boolean wasRemoved; synchronized (myActiveWorkerTasks) { @@ -3425,6 +3480,7 @@ public class AbstractTreeUi { } invokeLaterIfNeeded(new Runnable() { + @Override public void run() { maybeReady(); } @@ -3443,7 +3499,7 @@ public class AbstractTreeUi { } } - private void updateNodeImageAndPosition(final DefaultMutableTreeNode node, boolean updatePosition, boolean nodeChanged) { + private void updateNodeImageAndPosition(@NotNull final DefaultMutableTreeNode node, boolean updatePosition, boolean nodeChanged) { if (!(node.getUserObject() instanceof NodeDescriptor)) return; NodeDescriptor descriptor = getDescriptorFrom(node); if (getElementFromDescriptor(descriptor) == null) return; @@ -3495,7 +3551,7 @@ public class AbstractTreeUi { return myTreeModel; } - private void insertNodesInto(final ArrayList toInsert, final DefaultMutableTreeNode parentNode) { + private void insertNodesInto(@NotNull final ArrayList toInsert, @NotNull final DefaultMutableTreeNode parentNode) { sortChildren(parentNode, toInsert, false, true); final ArrayList all = new ArrayList(toInsert.size() + parentNode.getChildCount()); all.addAll(toInsert); @@ -3530,6 +3586,7 @@ public class AbstractTreeUi { sortChildren(parentNode, all, true, false); if (!before.equals(all)) { processInnerChange(new Runnable() { + @Override public void run() { Enumeration expanded = getTree().getExpandedDescendants(getPathFor(parentNode)); TreePath[] selected = getTree().getSelectionModel().getSelectionPaths(); @@ -3559,7 +3616,7 @@ public class AbstractTreeUi { } } - private void sortChildren(DefaultMutableTreeNode node, ArrayList children, boolean updateStamp, boolean forceSort) { + private void sortChildren(@NotNull DefaultMutableTreeNode node, @NotNull ArrayList children, boolean updateStamp, boolean forceSort) { NodeDescriptor descriptor = getDescriptorFrom(node); assert descriptor != null; @@ -3577,7 +3634,7 @@ public class AbstractTreeUi { return myNodeDescriptorComparator; } - private void disposeNode(DefaultMutableTreeNode node) { + private void disposeNode(@NotNull DefaultMutableTreeNode node) { TreeNode parent = node.getParent(); if (parent instanceof DefaultMutableTreeNode) { addToUnbuilt((DefaultMutableTreeNode)parent); @@ -3603,19 +3660,19 @@ public class AbstractTreeUi { node.removeAllChildren(); } - public boolean addSubtreeToUpdate(final DefaultMutableTreeNode root) { + public boolean addSubtreeToUpdate(@NotNull final DefaultMutableTreeNode root) { return addSubtreeToUpdate(root, true); } - public boolean addSubtreeToUpdate(final DefaultMutableTreeNode root, boolean updateStructure) { + public boolean addSubtreeToUpdate(@NotNull final DefaultMutableTreeNode root, boolean updateStructure) { return addSubtreeToUpdate(root, null, updateStructure); } - public boolean addSubtreeToUpdate(final DefaultMutableTreeNode root, final Runnable runAfterUpdate) { + public boolean addSubtreeToUpdate(@NotNull final DefaultMutableTreeNode root, final Runnable runAfterUpdate) { return addSubtreeToUpdate(root, runAfterUpdate, true); } - public boolean addSubtreeToUpdate(final DefaultMutableTreeNode root, final Runnable runAfterUpdate, final boolean updateStructure) { + public boolean addSubtreeToUpdate(@NotNull final DefaultMutableTreeNode root, @Nullable final Runnable runAfterUpdate, final boolean updateStructure) { Object element = getElementFor(root); if (element != null && getTreeStructure().isAlwaysLeaf(element)) { removeFromUnbuilt(root); @@ -3624,23 +3681,18 @@ public class AbstractTreeUi { execute(new Runnable() { @Override public void run() { - getUpdater().addSubtreeToUpdate(new TreeUpdatePass(root, null, new ActiveRunnable() { - @Override - public ActionCallback run() { - if (runAfterUpdate != null) { - runAfterUpdate.run(); - } - return new ActionCallback.Done(); - } - }).setUpdateChildren(false)); + getUpdater().runAfterUpdate(runAfterUpdate); + getUpdater().addSubtreeToUpdate(new TreeUpdatePass(root).setUpdateChildren(false)); } }); return false; - } else { + } + else { execute(new Runnable() { + @Override public void run() { getUpdater().runAfterUpdate(runAfterUpdate); - getUpdater().addSubtreeToUpdate(new TreeUpdatePass(root, null, null).setUpdateStructure(updateStructure).setUpdateStamp(-1)); + getUpdater().addSubtreeToUpdate(new TreeUpdatePass(root).setUpdateStructure(updateStructure).setUpdateStamp(-1)); } }); @@ -3651,19 +3703,19 @@ public class AbstractTreeUi { return myRootNodeWasQueuedToInitialize && myRootNodeInitialized; } - public void select(final Object[] elements, @Nullable final Runnable onDone) { + public void select(@NotNull final Object[] elements, @Nullable final Runnable onDone) { select(elements, onDone, false); } - public void select(final Object[] elements, @Nullable final Runnable onDone, boolean addToSelection) { + public void select(@NotNull final Object[] elements, @Nullable final Runnable onDone, boolean addToSelection) { select(elements, onDone, addToSelection, false); } - public void select(final Object[] elements, @Nullable final Runnable onDone, boolean addToSelection, boolean deferred) { + public void select(@NotNull final Object[] elements, @Nullable final Runnable onDone, boolean addToSelection, boolean deferred) { _select(elements, onDone, addToSelection, true, false, true, deferred, false, false); } - void _select(final Object[] elements, + void _select(@NotNull final Object[] elements, final Runnable onDone, final boolean addToSelection, final boolean checkCurrentSelection, @@ -3672,7 +3724,7 @@ public class AbstractTreeUi { _select(elements, onDone, addToSelection, checkCurrentSelection, checkIfInStructure, true, false, false, false); } - void _select(final Object[] elements, + void _select(@NotNull final Object[] elements, final Runnable onDone, final boolean addToSelection, final boolean checkCurrentSelection, @@ -3682,11 +3734,11 @@ public class AbstractTreeUi { _select(elements, onDone, addToSelection, checkCurrentSelection, checkIfInStructure, scrollToVisible, false, false, false); } - public void userSelect(final Object[] elements, final Runnable onDone, final boolean addToSelection, boolean scroll) { + public void userSelect(@NotNull final Object[] elements, final Runnable onDone, final boolean addToSelection, boolean scroll) { _select(elements, onDone, addToSelection, true, false, scroll, false, true, true); } - void _select(final Object[] elements, + void _select(@NotNull final Object[] elements, final Runnable onDone, final boolean addToSelection, final boolean checkCurrentSelection, @@ -3735,6 +3787,7 @@ public class AbstractTreeUi { runDone(new Runnable() { + @Override public void run() { try { if (!checkDeferred(deferred, onDone)) return; @@ -3783,9 +3836,11 @@ public class AbstractTreeUi { clearSelection(); } addNext(elementsToSelect, 0, new Runnable() { + @Override public void run() { if (getTree().isSelectionEmpty()) { processInnerChange(new Runnable() { + @Override public void run() { restoreSelection(currentElements); } @@ -3820,7 +3875,7 @@ public class AbstractTreeUi { return mySelectionIsBeingAdjusted; } - private void restoreSelection(Set selection) { + private void restoreSelection(@NotNull Set selection) { for (Object each : selection) { DefaultMutableTreeNode node = getNodeForElement(each, false); if (node != null && isValidForSelectionAdjusting(node)) { @@ -3830,11 +3885,12 @@ public class AbstractTreeUi { } - private void addToDeferred(final Object[] elementsToSelect, final Runnable onDone, final boolean addToSelection) { + private void addToDeferred(@NotNull final Object[] elementsToSelect, final Runnable onDone, final boolean addToSelection) { if (!addToSelection) { myDeferredSelections.clear(); } myDeferredSelections.add(new Runnable() { + @Override public void run() { select(elementsToSelect, onDone, addToSelection, true); } @@ -3871,7 +3927,7 @@ public class AbstractTreeUi { } - private void addNext(final Object[] elements, + private void addNext(@NotNull final Object[] elements, final int i, @Nullable final Runnable onDone, final int[] originalRows, @@ -3890,6 +3946,7 @@ public class AbstractTreeUi { } doSelect(elements[i], new Runnable() { + @Override public void run() { if (!checkDeferred(deferred, onDone)) return; @@ -3907,7 +3964,7 @@ public class AbstractTreeUi { _select(new Object[]{element}, onDone, addToSelection, true, false); } - private void doSelect(final Object element, + private void doSelect(@NotNull final Object element, final Runnable onDone, final boolean addToSelection, final boolean deferred, @@ -3915,10 +3972,12 @@ public class AbstractTreeUi { final boolean scrollToVisible, final boolean canSmartExpand) { final Runnable _onDone = new Runnable() { + @Override public void run() { if (!checkDeferred(deferred, onDone)) return; checkPathAndMaybeRevalidate(element, new Runnable() { + @Override public void run() { selectVisible(element, onDone, addToSelection, canBeCentered, scrollToVisible); } @@ -3928,7 +3987,7 @@ public class AbstractTreeUi { _expand(element, _onDone, true, false, canSmartExpand); } - private void checkPathAndMaybeRevalidate(Object element, final Runnable onDone, final boolean parentsOnly, final boolean checkIfInStructure, final boolean canSmartExpand) { + private void checkPathAndMaybeRevalidate(@NotNull Object element, @NotNull final Runnable onDone, final boolean parentsOnly, final boolean checkIfInStructure, final boolean canSmartExpand) { boolean toRevalidate = isValid(element) && !myRevalidatedObjects.contains(element) && getNodeForElement(element, false) == null && isInStructure(element); if (!toRevalidate) { runDone(onDone); @@ -3943,14 +4002,17 @@ public class AbstractTreeUi { } revalidated.doWhenDone(new AsyncResult.Handler() { + @Override public void run(final Object o) { invokeLaterIfNeeded(new Runnable() { + @Override public void run() { _expand(o, onDone, parentsOnly, checkIfInStructure, canSmartExpand); } }, false); } }).doWhenRejected(new Runnable() { + @Override public void run() { runDone(onDone); } @@ -3984,7 +4046,7 @@ public class AbstractTreeUi { }); } - private void selectVisible(Object element, final Runnable onDone, boolean addToSelection, boolean canBeCentered, final boolean scroll) { + private void selectVisible(@NotNull Object element, final Runnable onDone, boolean addToSelection, boolean canBeCentered, final boolean scroll) { final DefaultMutableTreeNode toSelect = getNodeForElement(element, false); if (toSelect == null) { @@ -4008,8 +4070,10 @@ public class AbstractTreeUi { if (Registry.is("ide.tree.autoscrollToVCenter") && canBeCentered) { setHoldSize(false); runDone(new Runnable() { + @Override public void run() { TreeUtil.showRowCentered(myTree, row, false, scroll).doWhenDone(new Runnable() { + @Override public void run() { runDone(onDone); } @@ -4020,6 +4084,7 @@ public class AbstractTreeUi { else { setHoldSize(false); TreeUtil.showAndSelect(myTree, row - 2, row + 2, row, -1, addToSelection, scroll).doWhenDone(new Runnable() { + @Override public void run() { runDone(onDone); } @@ -4027,7 +4092,7 @@ public class AbstractTreeUi { } } - private int getRowIfUnderSelection(Object element) { + private int getRowIfUnderSelection(@NotNull Object element) { int preselectedRow = -1; final Set selection = getSelectedElements(); @@ -4074,8 +4139,8 @@ public class AbstractTreeUi { public void expandAllWithoutRecursion(@Nullable final Runnable onDone) { final JTree tree = getTree(); - int myCurrentRow = 0; if (tree.getRowCount() > 0) { + int myCurrentRow = 0; while (myCurrentRow < tree.getRowCount()) { final TreePath path = tree.getPathForRow(myCurrentRow); final Object last = path.getLastPathComponent(); @@ -4095,6 +4160,7 @@ public class AbstractTreeUi { private int myCurrentRow = 0; private int myInvocationCount = 0; + @Override public void run() { if (++myInvocationCount > expandRecursionDepth) { myInvocationCount = 0; @@ -4130,20 +4196,16 @@ public class AbstractTreeUi { expand(new Object[]{element}, onDone); } - public void expand(final Object[] element, @Nullable final Runnable onDone) { + public void expand(@NotNull final Object[] element, @Nullable final Runnable onDone) { expand(element, onDone, false); } - void expand(final Object element, @Nullable final Runnable onDone, boolean checkIfInStructure) { - _expand(new Object[]{element}, onDone == null ? new EmptyRunnable() : onDone, false, checkIfInStructure, false); - } - - void expand(final Object[] element, @Nullable final Runnable onDone, boolean checkIfInStructure) { + void expand(@NotNull final Object[] element, @Nullable final Runnable onDone, boolean checkIfInStructure) { _expand(element, onDone == null ? new EmptyRunnable() : onDone, false, checkIfInStructure, false); } - void _expand(final Object[] element, + void _expand(@NotNull final Object[] element, @NotNull final Runnable onDone, final boolean parentsOnly, final boolean checkIfInStructure, @@ -4151,6 +4213,7 @@ public class AbstractTreeUi { try { runDone(new Runnable() { + @Override public void run() { if (element.length == 0) { runDone(onDone); @@ -4164,10 +4227,12 @@ public class AbstractTreeUi { final ActionCallback done = new ActionCallback(element.length); done.doWhenDone(new Runnable() { + @Override public void run() { runDone(onDone); } }).doWhenRejected(new Runnable() { + @Override public void run() { runDone(onDone); } @@ -4187,12 +4252,12 @@ public class AbstractTreeUi { } } - private void expandNext(final Object[] elements, + private void expandNext(@NotNull final Object[] elements, final int index, final boolean parentsOnly, final boolean checkIfInStricture, final boolean canSmartExpand, - final ActionCallback done, + @NotNull final ActionCallback done, final int currentDepth) { if (elements.length <= 0) { done.setDone(); @@ -4211,8 +4276,10 @@ public class AbstractTreeUi { } Runnable expandRunnable = new Runnable() { + @Override public void run() { _expand(elements[index], new Runnable() { + @Override public void run() { done.setDone(); expandNext(elements, index + 1, parentsOnly, checkIfInStricture, canSmartExpand, done, actualDepth[0] + 1); @@ -4229,8 +4296,9 @@ public class AbstractTreeUi { } } - public void collapseChildren(final Object element, @Nullable final Runnable onDone) { + public void collapseChildren(@NotNull final Object element, @Nullable final Runnable onDone) { runDone(new Runnable() { + @Override public void run() { final DefaultMutableTreeNode node = getNodeForElement(element, false); if (node != null) { @@ -4259,8 +4327,7 @@ public class AbstractTreeUi { try { execute(done); } - catch (ProcessCanceledException e) { - return; + catch (ProcessCanceledException ignored) { } } } @@ -4305,7 +4372,7 @@ public class AbstractTreeUi { try { LOG.error("Tree path contains equal elements at different levels: element=" + eachElement + " class=" + eachElement.getClass() + " path=" + kidsToExpand + " tree structure=" + myTreeStructure); } - catch (AssertionError e) { + catch (AssertionError ignored) { } runDone(onDone); throw new ProcessCanceledException(); @@ -4335,8 +4402,9 @@ public class AbstractTreeUi { } } - private void deferExpansion(final Object element, final Runnable onDone, final boolean parentsOnly, final boolean canSmartExpand) { + private void deferExpansion(final Object element, @NotNull final Runnable onDone, final boolean parentsOnly, final boolean canSmartExpand) { myDeferredExpansions.add(new Runnable() { + @Override public void run() { _expand(element, onDone, parentsOnly, false, canSmartExpand); } @@ -4344,7 +4412,7 @@ public class AbstractTreeUi { } private void processExpand(final DefaultMutableTreeNode toExpand, - final List kidsToExpand, + @NotNull final List kidsToExpand, final int expandIndex, @NotNull final Runnable onDone, final boolean canSmartExpand) { @@ -4356,7 +4424,8 @@ public class AbstractTreeUi { } addNodeAction(element, new NodeAction() { - public void onReady(final DefaultMutableTreeNode node) { + @Override + public void onReady(@NotNull final DefaultMutableTreeNode node) { if (node.getChildCount() > 0 && !myTree.isExpanded(new TreePath(node.getPath()))) { if (!isAutoExpand(node)) { expand(node, canSmartExpand); @@ -4369,6 +4438,7 @@ public class AbstractTreeUi { } checkPathAndMaybeRevalidate(kidsToExpand.get(expandIndex - 1), new Runnable() { + @Override public void run() { final DefaultMutableTreeNode nextNode = getNodeForElement(kidsToExpand.get(expandIndex - 1), false); processExpand(nextNode, kidsToExpand, expandIndex - 1, onDone, canSmartExpand); @@ -4400,22 +4470,6 @@ public class AbstractTreeUi { return getUpdater().isEnqueuedToUpdate(node) || isUpdatingParent(node) || myCancelledBuild.containsKey(node); } - private static String asString(DefaultMutableTreeNode node) { - if (node == null) return null; - - StringBuffer children = new StringBuffer(node.toString()); - children.append(" ["); - for (int i = 0; i < node.getChildCount(); i++) { - children.append(node.getChildAt(i)); - if (i < node.getChildCount() - 1) { - children.append(","); - } - } - children.append("]"); - - return children.toString(); - } - @Nullable public Object getElementFor(Object node) { if (!(node instanceof DefaultMutableTreeNode)) return null; @@ -4423,7 +4477,7 @@ public class AbstractTreeUi { } @Nullable - Object getElementFor(DefaultMutableTreeNode node) { + Object getElementFor(@Nullable DefaultMutableTreeNode node) { if (node != null) { final Object o = node.getUserObject(); if (o instanceof NodeDescriptor) { @@ -4434,15 +4488,16 @@ public class AbstractTreeUi { return null; } - public final boolean isNodeBeingBuilt(final TreePath path) { + public final boolean isNodeBeingBuilt(@NotNull final TreePath path) { return isNodeBeingBuilt(path.getLastPathComponent()); } - public final boolean isNodeBeingBuilt(Object node) { + public final boolean isNodeBeingBuilt(@NotNull Object node) { return getParentBuiltNode(node) != null || myRootNode == node && !wasRootNodeInitialized(); } - public final DefaultMutableTreeNode getParentBuiltNode(Object node) { + @Nullable + public final DefaultMutableTreeNode getParentBuiltNode(@NotNull Object node) { DefaultMutableTreeNode parent = getParentLoadingInBackground(node); if (parent != null) return parent; @@ -4452,10 +4507,8 @@ public class AbstractTreeUi { final boolean childrenAreNoLoadedYet = myUnbuiltNodes.contains(treeNode) || isUpdatingChildrenNow(treeNode); if (childrenAreNoLoadedYet) { - if (node instanceof DefaultMutableTreeNode) { - final TreePath nodePath = new TreePath(((DefaultMutableTreeNode)node).getPath()); - if (!myTree.isExpanded(nodePath)) return null; - } + final TreePath nodePath = new TreePath(treeNode.getPath()); + if (!myTree.isExpanded(nodePath)) return null; return (DefaultMutableTreeNode)node; } @@ -4477,7 +4530,7 @@ public class AbstractTreeUi { return myUpdater; } - public void setUpdater(final AbstractTreeUpdater updater) { + public void setUpdater(@Nullable final AbstractTreeUpdater updater) { myUpdater = updater; if (updater != null && myUpdateIfInactive) { updater.showNotify(); @@ -4554,7 +4607,7 @@ public class AbstractTreeUi { _remapNodeActions(element, elementToPutNodeActionsFor, myNodeChildrenActions); } - private static void _remapNodeActions(Object element, Object elementToPutNodeActionsFor, final Map> nodeActions) { + private static void _remapNodeActions(Object element, @Nullable Object elementToPutNodeActionsFor, @NotNull final Map> nodeActions) { final List actions = nodeActions.get(element); nodeActions.remove(element); @@ -4563,10 +4616,12 @@ public class AbstractTreeUi { } } + @Nullable private DefaultMutableTreeNode getFirstNode(Object element) { return findNode(element, 0); } + @Nullable private DefaultMutableTreeNode findNode(final Object element, int startIndex) { final Object value = getBuilder().findNodeByElement(element); if (value == null) { @@ -4593,7 +4648,8 @@ public class AbstractTreeUi { } } - private DefaultMutableTreeNode findNodeForChildElement(DefaultMutableTreeNode parentNode, Object element) { + @Nullable + private DefaultMutableTreeNode findNodeForChildElement(@NotNull DefaultMutableTreeNode parentNode, Object element) { final Object value = myElementToNodeMap.get(element); if (value == null) { return null; @@ -4634,7 +4690,7 @@ public class AbstractTreeUi { } } - private void _addNodeAction(Object element, NodeAction action, Map> map) { + private void _addNodeAction(Object element, NodeAction action, @NotNull Map> map) { maybeSetBusyAndScheduleWaiterForReady(true, element); List list = map.get(element); if (list == null) { @@ -4677,17 +4733,15 @@ public class AbstractTreeUi { state.restore(null); } + @NotNull public AbstractTreeUi setClearOnHideDelay(final long clearOnHideDelay) { myClearOnHideDelay = clearOnHideDelay; return this; } - public void setJantorPollPeriod(final long time) { - myJanitorPollPeriod = time; - } - private class MySelectionListener implements TreeSelectionListener { - public void valueChanged(final TreeSelectionEvent e) { + @Override + public void valueChanged(@NotNull final TreeSelectionEvent e) { if (mySilentSelect != null && mySilentSelect.equals(e.getNewLeadSelectionPath())) return; dropUpdaterStateIfExternalChange(); @@ -4696,7 +4750,8 @@ public class AbstractTreeUi { private class MyExpansionListener implements TreeExpansionListener { - public void treeExpanded(TreeExpansionEvent event) { + @Override + public void treeExpanded(@NotNull TreeExpansionEvent event) { final TreePath path = event.getPath(); if (mySilentExpand != null && mySilentExpand.equals(path)) return; @@ -4705,6 +4760,7 @@ public class AbstractTreeUi { if (myRequestedExpand != null && !myRequestedExpand.equals(path)) { _getReady().doWhenDone(new Runnable() { + @Override public void run() { Object element = getElementFor(path.getLastPathComponent()); expand(element, null); @@ -4742,7 +4798,8 @@ public class AbstractTreeUi { processNodeActionsIfReady(node); } - public void treeCollapsed(TreeExpansionEvent e) { + @Override + public void treeCollapsed(@NotNull TreeExpansionEvent e) { dropUpdaterStateIfExternalChange(); final TreePath path = e.getPath(); @@ -4759,6 +4816,7 @@ public class AbstractTreeUi { NodeDescriptor descriptor = getDescriptorFrom(node); if (getBuilder().isDisposeOnCollapsing(descriptor)) { runDone(new Runnable() { + @Override public void run() { if (isDisposed(node)) return; @@ -4784,10 +4842,9 @@ public class AbstractTreeUi { addSelectionPath(pathToSelect, true, Condition.FALSE, null); } } - } - private void removeChildren(DefaultMutableTreeNode node) { + private void removeChildren(@NotNull DefaultMutableTreeNode node) { EnumerationCopy copy = new EnumerationCopy(node.children()); while (copy.hasMoreElements()) { disposeNode((DefaultMutableTreeNode)copy.nextElement()); @@ -4796,7 +4853,7 @@ public class AbstractTreeUi { myTreeModel.nodeStructureChanged(node); } - private void maybeUpdateSubtreeToUpdate(final DefaultMutableTreeNode subtreeRoot) { + private void maybeUpdateSubtreeToUpdate(@NotNull final DefaultMutableTreeNode subtreeRoot) { if (!myUnbuiltNodes.contains(subtreeRoot)) return; TreePath path = getPathFor(subtreeRoot); @@ -4810,6 +4867,7 @@ public class AbstractTreeUi { } else if (parent != subtreeRoot) { addNodeAction(getElementFor(subtreeRoot), new NodeAction() { + @Override public void onReady(DefaultMutableTreeNode parent) { maybeUpdateSubtreeToUpdate(subtreeRoot); } @@ -4849,6 +4907,7 @@ public class AbstractTreeUi { myCanYield = canYield; } + @NotNull public Collection getYeildingPasses() { return myYieldingPasses; } @@ -4859,12 +4918,12 @@ public class AbstractTreeUi { return !myUnbuiltNodes.contains(node); } - static class LoadedChildren { - private final List myElements; + private static class LoadedChildren { + @NotNull private final List myElements; private final Map myDescriptors = new HashMap(); private final Map myChanges = new HashMap(); - LoadedChildren(Object[] elements) { + LoadedChildren(@Nullable Object[] elements) { myElements = Arrays.asList(elements != null ? elements : ArrayUtil.EMPTY_OBJECT_ARRAY); } @@ -4876,6 +4935,7 @@ public class AbstractTreeUi { myChanges.put(descriptor, isChanged); } + @NotNull List getElements() { return myElements; } @@ -4884,9 +4944,10 @@ public class AbstractTreeUi { return myDescriptors.get(element); } + @NotNull @Override public String toString() { - return Arrays.asList(myElements) + "->" + myChanges; + return myElements + "->" + myChanges; } public boolean isUpdated(Object element) { @@ -4895,10 +4956,6 @@ public class AbstractTreeUi { } } - UpdaterTreeState getUpdaterState() { - return myUpdaterState; - } - private long getComparatorStamp() { if (myNodeDescriptorComparator instanceof NodeDescriptor.NodeComparator) { long currentComparatorStamp = ((NodeDescriptor.NodeComparator)myNodeDescriptorComparator).getStamp(); @@ -4967,7 +5024,7 @@ public class AbstractTreeUi { return myDescriptorIsUpToDate; } - public synchronized void apply(UpdateInfo updateInfo) { + public synchronized void apply(@NotNull UpdateInfo updateInfo) { myDescriptor = updateInfo.myDescriptor; myPass = updateInfo.myPass; myCanSmartExpand = updateInfo.myCanSmartExpand; @@ -4980,7 +5037,9 @@ public class AbstractTreeUi { return myUpdateChildren; } - public String toString() { + @NotNull + @NonNls + public synchronized String toString() { return "UpdateInfo: desc=" + myDescriptor + " pass=" + @@ -5022,18 +5081,22 @@ public class AbstractTreeUi { private void addModelListenerToDianoseAccessOutsideEdt() { myTreeModel.addTreeModelListener(new TreeModelListener() { + @Override public void treeNodesChanged(TreeModelEvent e) { assertIsDispatchThread(); } + @Override public void treeNodesInserted(TreeModelEvent e) { assertIsDispatchThread(); } + @Override public void treeNodesRemoved(TreeModelEvent e) { assertIsDispatchThread(); } + @Override public void treeStructureChanged(TreeModelEvent e) { assertIsDispatchThread(); } diff --git a/platform/platform-api/src/com/intellij/ide/util/treeView/AbstractTreeUpdater.java b/platform/platform-api/src/com/intellij/ide/util/treeView/AbstractTreeUpdater.java index a0560c550047..260659d0d293 100644 --- a/platform/platform-api/src/com/intellij/ide/util/treeView/AbstractTreeUpdater.java +++ b/platform/platform-api/src/com/intellij/ide/util/treeView/AbstractTreeUpdater.java @@ -50,13 +50,13 @@ public class AbstractTreeUpdater implements Disposable, Activatable { private long myUpdateCount; private boolean myReleaseRequested; - public AbstractTreeUpdater(AbstractTreeBuilder treeBuilder) { + public AbstractTreeUpdater(@NotNull AbstractTreeBuilder treeBuilder) { myTreeBuilder = treeBuilder; final JTree tree = myTreeBuilder.getTree(); final JComponent component = tree instanceof TreeTableTree ? ((TreeTableTree)tree).getTreeTable() : tree; myUpdateQueue = new MergingUpdateQueue("UpdateQueue", 300, component.isShowing(), component) { @Override - protected Alarm createAlarm(Alarm.ThreadToUse thread, Disposable parent) { + protected Alarm createAlarm(@NotNull Alarm.ThreadToUse thread, Disposable parent) { return new Alarm(thread, parent) { @Override protected boolean isEdt() { @@ -175,7 +175,7 @@ public class AbstractTreeUpdater implements Disposable, Activatable { if (toAdd.isExpired()) { - requeueViewUpdateIfNeeded(); + reQueueViewUpdateIfNeeded(); return; } @@ -186,18 +186,16 @@ public class AbstractTreeUpdater implements Disposable, Activatable { myUpdateCount = newUpdateCount; toAdd.setUpdateStamp(myUpdateCount); - requeueViewUpdate(); + reQueueViewUpdate(); } - private void requeueViewUpdateIfNeeded() { - //if (myTreeBuilder.getUi().isPassthroughMode()) return; - + private void reQueueViewUpdateIfNeeded() { if (myUpdateQueue.isEmpty() && !myNodeQueue.isEmpty()) { - requeueViewUpdate(); + reQueueViewUpdate(); } } - private void requeueViewUpdate() { + private void reQueueViewUpdate() { queue(new Update("ViewUpdate") { @Override public boolean isExpired() { @@ -208,7 +206,7 @@ public class AbstractTreeUpdater implements Disposable, Activatable { public void run() { if (myTreeBuilder.getTreeStructure().hasSomethingToCommit()) { myTreeBuilder.getTreeStructure().commit(); - requeueViewUpdateIfNeeded(); + reQueueViewUpdateIfNeeded(); return; } try { @@ -354,7 +352,7 @@ public class AbstractTreeUpdater implements Disposable, Activatable { myRunBeforeUpdate = runnable; } - public long getUpdateCount() { + public synchronized long getUpdateCount() { return myUpdateCount; } @@ -382,7 +380,7 @@ public class AbstractTreeUpdater implements Disposable, Activatable { @NonNls @Override - public String toString() { + public synchronized String toString() { return "AbstractTreeUpdater updateCount=" + myUpdateCount + " queue=[" + myUpdateQueue.toString() + "] " + " nodeQueue=" + myNodeQueue; } @@ -416,7 +414,7 @@ public class AbstractTreeUpdater implements Disposable, Activatable { }); } - public void requestRelease() { + public synchronized void requestRelease() { myReleaseRequested = true; reset(); diff --git a/platform/platform-api/src/com/intellij/ide/util/treeView/AlphaComparator.java b/platform/platform-api/src/com/intellij/ide/util/treeView/AlphaComparator.java index 41c940d716fc..88a8a3b7a704 100644 --- a/platform/platform-api/src/com/intellij/ide/util/treeView/AlphaComparator.java +++ b/platform/platform-api/src/com/intellij/ide/util/treeView/AlphaComparator.java @@ -25,6 +25,7 @@ public class AlphaComparator implements Comparator{ protected AlphaComparator() { } + @Override public int compare(NodeDescriptor nodeDescriptor1, NodeDescriptor nodeDescriptor2) { int weight1 = nodeDescriptor1.getWeight(); int weight2 = nodeDescriptor2.getWeight(); diff --git a/platform/platform-api/src/com/intellij/ide/util/treeView/IndexComparator.java b/platform/platform-api/src/com/intellij/ide/util/treeView/IndexComparator.java index afa0047135e6..07d38c9662a8 100644 --- a/platform/platform-api/src/com/intellij/ide/util/treeView/IndexComparator.java +++ b/platform/platform-api/src/com/intellij/ide/util/treeView/IndexComparator.java @@ -28,6 +28,7 @@ public class IndexComparator implements Comparator { private IndexComparator() {} + @Override public int compare(NodeDescriptor nodeDescriptor1, NodeDescriptor nodeDescriptor2) { return nodeDescriptor1.getIndex() - nodeDescriptor2.getIndex(); } diff --git a/platform/platform-api/src/com/intellij/ide/util/treeView/NodeDescriptor.java b/platform/platform-api/src/com/intellij/ide/util/treeView/NodeDescriptor.java index d410bc0dd484..dc5e236f6717 100644 --- a/platform/platform-api/src/com/intellij/ide/util/treeView/NodeDescriptor.java +++ b/platform/platform-api/src/com/intellij/ide/util/treeView/NodeDescriptor.java @@ -27,7 +27,13 @@ public abstract class NodeDescriptor { private final NodeDescriptor myParentDescriptor; protected String myName; - protected Icon myIcon; + protected Icon myClosedIcon; + + /** + * Unused. It's there only for API compatibility. + */ + @Deprecated + protected Icon myOpenIcon; protected Color myColor; private int myIndex = -1; @@ -63,8 +69,24 @@ public abstract class NodeDescriptor { return myName; } + /** + Use #getIcon() instead + */ + @Deprecated + public final Icon getOpenIcon() { + return getIcon(); + } + + /** + Use #getIcon() instead + */ + @Deprecated + public final Icon getClosedIcon() { + return getIcon(); + } + public final Icon getIcon() { - return myIcon; + return myClosedIcon; } public final Color getColor() { @@ -114,11 +136,15 @@ public abstract class NodeDescriptor { } public void applyFrom(NodeDescriptor desc) { - myIcon = desc.myIcon; + setIcon(desc.getIcon()); myName = desc.myName; myColor = desc.myColor; } + public void setIcon(Icon closedIcon) { + myClosedIcon = closedIcon; + } + public abstract static class NodeComparator implements Comparator { private long myStamp; @@ -157,6 +183,7 @@ public abstract class NodeDescriptor { myDelegate.incStamp(); } + @Override public int compare(T o1, T o2) { return myDelegate.compare(o1, o2); } diff --git a/platform/platform-api/src/com/intellij/ide/util/treeView/NodeOptions.java b/platform/platform-api/src/com/intellij/ide/util/treeView/NodeOptions.java index b6c0730898c9..376a25b554b1 100644 --- a/platform/platform-api/src/com/intellij/ide/util/treeView/NodeOptions.java +++ b/platform/platform-api/src/com/intellij/ide/util/treeView/NodeOptions.java @@ -54,18 +54,22 @@ public interface NodeOptions { * The default tree view settings. */ NodeOptions DEFAULT_OPTIONS = new NodeOptions() { + @Override public boolean isFlattenPackages() { return false; } + @Override public boolean isAbbreviatePackageNames() { return false; } + @Override public boolean isHideEmptyMiddlePackages() { return false; } + @Override public boolean isShowLibraryContents() { return false; } diff --git a/platform/platform-api/src/com/intellij/ide/util/treeView/NodeRenderer.java b/platform/platform-api/src/com/intellij/ide/util/treeView/NodeRenderer.java index bc484bcb4163..c507836e3156 100644 --- a/platform/platform-api/src/com/intellij/ide/util/treeView/NodeRenderer.java +++ b/platform/platform-api/src/com/intellij/ide/util/treeView/NodeRenderer.java @@ -34,7 +34,7 @@ import java.awt.*; import java.util.List; public class NodeRenderer extends ColoredTreeCellRenderer { - + @Override public void customizeCellRenderer(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) { Color color = null; NodeDescriptor descriptor = null; @@ -54,7 +54,7 @@ public class NodeRenderer extends ColoredTreeCellRenderer { final PresentationData presentation = node.getPresentation(); final List coloredText = presentation.getColoredText(); - if (coloredText.size() == 0) { + if (coloredText.isEmpty()) { String text = tree.convertValueToText(value.toString(), selected, expanded, leaf, row, hasFocus); SimpleTextAttributes simpleTextAttributes = getSimpleTextAttributes(node, presentation.getForcedTextForeground() != null ? presentation.getForcedTextForeground() : color); doAppend(text, simpleTextAttributes, selected); @@ -66,7 +66,7 @@ public class NodeRenderer extends ColoredTreeCellRenderer { } final String location = presentation.getLocationString(); - if (location != null && location.length() > 0) { + if (location != null && !location.isEmpty()) { doAppend(" (" + location + ")", SimpleTextAttributes.GRAY_ATTRIBUTES, selected); } @@ -130,4 +130,4 @@ public class NodeRenderer extends ColoredTreeCellRenderer { return SimpleTextAttributes.REGULAR_ATTRIBUTES; } -} +} \ No newline at end of file diff --git a/platform/platform-api/src/com/intellij/ide/util/treeView/PresentableNodeDescriptor.java b/platform/platform-api/src/com/intellij/ide/util/treeView/PresentableNodeDescriptor.java index 84cc67c80abf..c4add9f856f1 100644 --- a/platform/platform-api/src/com/intellij/ide/util/treeView/PresentableNodeDescriptor.java +++ b/platform/platform-api/src/com/intellij/ide/util/treeView/PresentableNodeDescriptor.java @@ -33,14 +33,14 @@ public abstract class PresentableNodeDescriptor extends NodeDescriptor { super(project, parentDescriptor); } + @Override public final boolean update() { if (shouldUpdateData()) { PresentationData before = getPresentation().clone(); PresentationData updated = getUpdatedPresentation(); - return shouldApply() ? apply(updated, before) : false; - } else { - return false; + return shouldApply() && apply(updated, before); } + return false; } protected final boolean apply(PresentationData presentation) { @@ -52,16 +52,17 @@ public abstract class PresentableNodeDescriptor extends NodeDescriptor { if (desc instanceof PresentableNodeDescriptor) { PresentableNodeDescriptor pnd = (PresentableNodeDescriptor)desc; apply(pnd.getPresentation()); - } else { + } + else { super.applyFrom(desc); } } protected final boolean apply(PresentationData presentation, @Nullable PresentationData before) { - myIcon = presentation.getIcon(false); + setIcon(presentation.getIcon(false)); myName = presentation.getPresentableText(); myColor = presentation.getForcedTextForeground(); - boolean updated = before != null ? !presentation.equals(before) : true; + boolean updated = before == null || !presentation.equals(before); if (myUpdatedPresentation == null) { myUpdatedPresentation = createPresentation(); @@ -120,7 +121,8 @@ public abstract class PresentableNodeDescriptor extends NodeDescriptor { PresentationData result; if (myUpdatedPresentation == null) { result = getTemplatePresentation(); - } else { + } + else { result = myUpdatedPresentation; } return result; @@ -219,15 +221,14 @@ public abstract class PresentableNodeDescriptor extends NodeDescriptor { } public String getName() { - if (getPresentation().getColoredText().size() > 0) { + if (!getPresentation().getColoredText().isEmpty()) { StringBuilder result = new StringBuilder(""); for (ColoredFragment each : getPresentation().getColoredText()) { result.append(each.getText()); } return result.toString(); - } else { - return myName; } + return myName; } } diff --git a/platform/platform-api/src/com/intellij/ide/util/treeView/TreeState.java b/platform/platform-api/src/com/intellij/ide/util/treeView/TreeState.java index a58b29fe429e..18630d18b3f5 100644 --- a/platform/platform-api/src/com/intellij/ide/util/treeView/TreeState.java +++ b/platform/platform-api/src/com/intellij/ide/util/treeView/TreeState.java @@ -37,7 +37,7 @@ public class TreeState implements JDOMExternalizable { @NonNls private static final String PATH = "PATH"; @NonNls private static final String PATH_ELEMENT = "PATH_ELEMENT"; @NonNls private static final String USER_OBJECT = "USER_OBJECT"; - public static final String CALLBACK = "Callback"; + @NonNls public static final String CALLBACK = "Callback"; static class PathElement implements JDOMExternalizable { public String myItemId; @@ -73,11 +73,13 @@ public class TreeState implements JDOMExternalizable { return myUserObject != null && myUserObject.equals(object); } + @Override public void readExternal(Element element) throws InvalidDataException { DefaultJDOMExternalizer.readExternal(this, element); myUserObject = element.getAttributeValue(USER_OBJECT); } + @Override public void writeExternal(Element element) throws WriteExternalException { DefaultJDOMExternalizer.writeExternal(this, element); if (myUserObject instanceof String){ @@ -100,6 +102,7 @@ public class TreeState implements JDOMExternalizable { this(new ArrayList>(), new ArrayList>()); } + @Override public void readExternal(Element element) throws InvalidDataException { myExpandedPaths.clear(); final List paths = element.getChildren(PATH); @@ -125,6 +128,7 @@ public class TreeState implements JDOMExternalizable { return new TreeState(createExpandedPaths(tree, treeNode), createSelectedPaths(tree, treeNode)); } + @Override public void writeExternal(Element element) throws WriteExternalException { for (List path : myExpandedPaths) { final Element pathElement = new Element(PATH); @@ -242,8 +246,10 @@ public class TreeState implements JDOMExternalizable { private void applyExpanded(final TreeFacade tree, final Object root) { tree.getIntialized().doWhenDone(new Runnable() { + @Override public void run() { tree.batch(new Progressive() { + @Override public void run(@NotNull ProgressIndicator indicator) { _applyExpanded(tree, root, indicator); } @@ -325,9 +331,11 @@ public class TreeState implements JDOMExternalizable { } - private TreeNode requestedExpand; - - private boolean applyTo(final int positionInPath, final List path, final Object root, final TreeFacade tree, final ProgressIndicator indicator) { + private static boolean applyTo(final int positionInPath, + final List path, + final Object root, + final TreeFacade tree, + final ProgressIndicator indicator) { if (!(root instanceof DefaultMutableTreeNode)) return false; final DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode)root; @@ -343,6 +351,7 @@ public class TreeState implements JDOMExternalizable { } tree.expand(treeNode).doWhenDone(new Runnable() { + @Override public void run() { indicator.checkCanceled(); @@ -406,11 +415,13 @@ public class TreeState implements JDOMExternalizable { myTree = tree; } + @Override public ActionCallback expand(DefaultMutableTreeNode node) { myTree.expandPath(new TreePath(node.getPath())); return new ActionCallback.Done(); } + @Override public ActionCallback getIntialized() { final WeakReference ref = (WeakReference)myTree.getClientProperty(CALLBACK); if (ref != null) { @@ -420,6 +431,7 @@ public class TreeState implements JDOMExternalizable { return new ActionCallback.Done(); } + @Override public void batch(Progressive progressive) { progressive.run(new EmptyProgressIndicator()); } @@ -433,14 +445,17 @@ public class TreeState implements JDOMExternalizable { myBuilder = builder; } + @Override public ActionCallback getIntialized() { return myBuilder.getReady(this); } + @Override public void batch(Progressive progressive) { myBuilder.batch(progressive); } + @Override public ActionCallback expand(DefaultMutableTreeNode node) { final Object userObject = node.getUserObject(); if (!(userObject instanceof NodeDescriptor)) return new ActionCallback.Rejected(); @@ -452,6 +467,7 @@ public class TreeState implements JDOMExternalizable { final ActionCallback result = new ActionCallback(); myBuilder.expand(element, new Runnable() { + @Override public void run() { result.setDone(); } diff --git a/platform/platform-api/src/com/intellij/ide/util/treeView/TreeUpdatePass.java b/platform/platform-api/src/com/intellij/ide/util/treeView/TreeUpdatePass.java index 43f8b34585d0..836011218515 100644 --- a/platform/platform-api/src/com/intellij/ide/util/treeView/TreeUpdatePass.java +++ b/platform/platform-api/src/com/intellij/ide/util/treeView/TreeUpdatePass.java @@ -15,41 +15,30 @@ */ package com.intellij.ide.util.treeView; -import com.intellij.openapi.util.ActiveRunnable; +import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import javax.swing.tree.DefaultMutableTreeNode; import java.util.HashSet; import java.util.Set; public class TreeUpdatePass { - - private DefaultMutableTreeNode myNode; - - private ActiveRunnable myBefore; - private ActiveRunnable myAfter; + private final DefaultMutableTreeNode myNode; private long myUpdateStamp; private boolean myExpired; private DefaultMutableTreeNode myCurrentNode; - private long myAllocation; + private final long myAllocation; private boolean myUpdateChildren = true; private boolean myUpdateStructure = true; - private Set myUpdatedDescriptors = new HashSet(); - - public TreeUpdatePass(@NotNull final DefaultMutableTreeNode node, @Nullable final ActiveRunnable before, @Nullable final ActiveRunnable after) { - myNode = node; - myBefore = before; - myAfter = after; - myAllocation = System.currentTimeMillis(); - } + private final Set myUpdatedDescriptors = new HashSet(); public TreeUpdatePass(@NotNull final DefaultMutableTreeNode node) { - this(node, null, null); + myNode = node; + myAllocation = System.currentTimeMillis(); } public TreeUpdatePass setUpdateChildren(boolean updateChildren) { @@ -90,6 +79,7 @@ public class TreeUpdatePass { myCurrentNode = currentNode; } + @NonNls @Override public String toString() { return "TreUpdatePass node=" + myNode + " structure=" + myUpdateStructure + " stamp=" + myUpdateStamp + " expired=" + myExpired + " currentNode=" + myCurrentNode + " allocation=" + myAllocation; diff --git a/platform/platform-api/src/com/intellij/ide/util/treeView/TreeVisitor.java b/platform/platform-api/src/com/intellij/ide/util/treeView/TreeVisitor.java index ef6d0851c119..2744537e60e4 100644 --- a/platform/platform-api/src/com/intellij/ide/util/treeView/TreeVisitor.java +++ b/platform/platform-api/src/com/intellij/ide/util/treeView/TreeVisitor.java @@ -15,8 +15,8 @@ */ package com.intellij.ide.util.treeView; -public interface TreeVisitor { +import org.jetbrains.annotations.NotNull; - boolean visit(T node); - +public interface TreeVisitor { + boolean visit(@NotNull T node); } \ No newline at end of file diff --git a/platform/platform-api/src/com/intellij/ide/util/treeView/UpdaterTreeState.java b/platform/platform-api/src/com/intellij/ide/util/treeView/UpdaterTreeState.java index 111931a84348..4a6fe05317e3 100644 --- a/platform/platform-api/src/com/intellij/ide/util/treeView/UpdaterTreeState.java +++ b/platform/platform-api/src/com/intellij/ide/util/treeView/UpdaterTreeState.java @@ -20,6 +20,7 @@ import com.intellij.openapi.util.Condition; import com.intellij.util.ArrayUtil; import com.intellij.util.Function; import com.intellij.util.containers.ContainerUtil; +import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.Nullable; import javax.swing.*; @@ -32,7 +33,6 @@ public class UpdaterTreeState { private final AbstractTreeUi myUi; protected WeakHashMap myToSelect = new WeakHashMap(); protected WeakHashMap myAdjustedSelection = new WeakHashMap(); - protected WeakHashMap myDisposedElements = new WeakHashMap(); protected WeakHashMap myToExpand = new WeakHashMap(); private int myProcessingCount; @@ -169,8 +169,10 @@ public class UpdaterTreeState { final Set originallySelected = myUi.getSelectedElements(); myUi._select(toSelect, new Runnable() { + @Override public void run() { processUnsuccessfulSelections(toSelect, new Function() { + @Override public Object fun(final Object o) { if (myUi.getTree().isRootVisible() || !myUi.getTreeStructure().getRootElement().equals(o)) { addSelection(o); @@ -180,8 +182,10 @@ public class UpdaterTreeState { }, originallySelected); processAjusted(adjusted, originallySelected).doWhenDone(new Runnable() { + @Override public void run() { myUi.expand(toExpand, new Runnable() { + @Override public void run() { myUi.clearUpdaterState(); setProcessingNow(false); @@ -224,17 +228,17 @@ public class UpdaterTreeState { final Set selected = myUi.getSelectedElements(); boolean wasFullyRejected = false; - if (toSelect.length > 0 && selected.size() > 0 && !originallySelected.containsAll(selected)) { + if (toSelect.length > 0 && !selected.isEmpty() && !originallySelected.containsAll(selected)) { final Set successfulSelections = new HashSet(); ContainerUtil.addAll(successfulSelections, toSelect); successfulSelections.retainAll(selected); - wasFullyRejected = successfulSelections.size() == 0; - } else if (selected.size() == 0 && originallySelected.size() == 0) { + wasFullyRejected = successfulSelections.isEmpty(); + } else if (selected.isEmpty() && originallySelected.isEmpty()) { wasFullyRejected = true; } - if (wasFullyRejected && selected.size() > 0) return; + if (wasFullyRejected && !selected.isEmpty()) return; for (Object eachToSelect : toSelect) { if (!selected.contains(eachToSelect)) { @@ -249,15 +253,15 @@ public class UpdaterTreeState { final Set allSelected = myUi.getSelectedElements(); Set toSelect = new HashSet(); - for (Object each : adjusted.keySet()) { - if (adjusted.get(each).value(each)) continue; + for (Map.Entry entry : adjusted.entrySet()) { + if (entry.getValue().value(entry.getKey())) continue; for (final Object eachSelected : allSelected) { - if (isParentOrSame(each, eachSelected)) continue; - toSelect.add(each); + if (isParentOrSame(entry.getKey(), eachSelected)) continue; + toSelect.add(entry.getKey()); } - if (allSelected.size() == 0) { - toSelect.add(each); + if (allSelected.isEmpty()) { + toSelect.add(entry.getKey()); } } @@ -265,9 +269,11 @@ public class UpdaterTreeState { if (newSelection.length > 0) { myUi._select(newSelection, new Runnable() { + @Override public void run() { final Set hangByParent = new HashSet (); processUnsuccessfulSelections(newSelection, new Function() { + @Override public Object fun(final Object o) { if (myUi.isInStructure(o) && !adjusted.get(o).value(o)) { hangByParent.add(o); @@ -289,14 +295,14 @@ public class UpdaterTreeState { } private ActionCallback processHangByParent(Set elements) { - if (elements.size() == 0) return new ActionCallback.Done(); + if (elements.isEmpty()) return new ActionCallback.Done(); ActionCallback result = new ActionCallback(elements.size()); - for (Iterator iterator = elements.iterator(); iterator.hasNext();) { - Object hangElement = iterator.next(); + for (Object hangElement : elements) { if (!myAdjustmentCause2Adjustment.containsKey(hangElement)) { processHangByParent(hangElement).notify(result); - } else { + } + else { result.setDone(); } } @@ -318,6 +324,7 @@ public class UpdaterTreeState { callback.setDone(); } else { myUi.select(nextElement, new Runnable() { + @Override public void run() { processNextHang(nextElement, callback); } @@ -356,9 +363,12 @@ public class UpdaterTreeState { } } + @NonNls @Override public String toString() { - return "UpdaterState toSelect" + Arrays.asList(myToSelect) + " toExpand=" + Arrays.asList(myToExpand) + " processingNow=" + isProcessingNow() + " canRun=" + myCanRunRestore; + return "UpdaterState toSelect" + + myToSelect + " toExpand=" + + myToExpand + " processingNow=" + isProcessingNow() + " canRun=" + myCanRunRestore; } public void setProcessingNow(boolean processingNow) { diff --git a/platform/platform-api/src/com/intellij/ide/util/treeView/smartTree/ActionPresentationData.java b/platform/platform-api/src/com/intellij/ide/util/treeView/smartTree/ActionPresentationData.java index 2d5d095950b4..d5194afe675d 100644 --- a/platform/platform-api/src/com/intellij/ide/util/treeView/smartTree/ActionPresentationData.java +++ b/platform/platform-api/src/com/intellij/ide/util/treeView/smartTree/ActionPresentationData.java @@ -41,14 +41,17 @@ public class ActionPresentationData implements ActionPresentation { myIcon = icon; } + @Override public String getText() { return myText; } + @Override public String getDescription() { return myDescription; } + @Override public Icon getIcon() { return myIcon; } diff --git a/platform/platform-api/src/com/intellij/ide/util/treeView/smartTree/Sorter.java b/platform/platform-api/src/com/intellij/ide/util/treeView/smartTree/Sorter.java index 5a2992799433..1b0728de37de 100644 --- a/platform/platform-api/src/com/intellij/ide/util/treeView/smartTree/Sorter.java +++ b/platform/platform-api/src/com/intellij/ide/util/treeView/smartTree/Sorter.java @@ -45,8 +45,10 @@ public interface Sorter extends TreeAction { * The default sorter which sorts the tree nodes alphabetically. */ Sorter ALPHA_SORTER = new Sorter() { + @Override public Comparator getComparator() { return new Comparator() { + @Override public int compare(Object o1, Object o2) { String s1 = SorterUtil.getStringPresentation(o1); String s2 = SorterUtil.getStringPresentation(o2); @@ -55,6 +57,7 @@ public interface Sorter extends TreeAction { }; } + @Override public boolean isVisible() { return true; } @@ -63,6 +66,7 @@ public interface Sorter extends TreeAction { return getName(); } + @Override @NotNull public ActionPresentation getPresentation() { return new ActionPresentationData(IdeBundle.message("action.sort.alphabetically"), @@ -70,6 +74,7 @@ public interface Sorter extends TreeAction { AllIcons.ObjectBrowser.Sorted); } + @Override @NotNull public String getName() { return ALPHA_SORTER_ID; diff --git a/platform/platform-api/src/com/intellij/openapi/util/BusyObject.java b/platform/platform-api/src/com/intellij/openapi/util/BusyObject.java index 977a353eccb0..66a11097fa8c 100644 --- a/platform/platform-api/src/com/intellij/openapi/util/BusyObject.java +++ b/platform/platform-api/src/com/intellij/openapi/util/BusyObject.java @@ -60,6 +60,8 @@ public interface BusyObject { protected void onReadyWasSent() { } + @Override + @NotNull public final ActionCallback getReady(@NotNull Object requestor) { if (isReady()) { return new ActionCallback.Done(); @@ -69,6 +71,7 @@ public interface BusyObject { } } + @NotNull private ActionCallback addReadyCallback(Object requestor) { synchronized (myReadyCallbacks) { ActionCallback cb = myReadyCallbacks.get(requestor); @@ -117,6 +120,7 @@ public interface BusyObject { myBusyCount.addAndGet(1); ActionCallback cb = runnable.run(); cb.doWhenProcessed(new Runnable() { + @Override public void run() { myBusyCount.addAndGet(-1); if (isReady()) { diff --git a/platform/platform-api/src/com/intellij/ui/tabs/impl/DragHelper.java b/platform/platform-api/src/com/intellij/ui/tabs/impl/DragHelper.java index fda9ee1622d0..523683496154 100644 --- a/platform/platform-api/src/com/intellij/ui/tabs/impl/DragHelper.java +++ b/platform/platform-api/src/com/intellij/ui/tabs/impl/DragHelper.java @@ -15,6 +15,9 @@ */ package com.intellij.ui.tabs.impl; +import com.intellij.ide.IdeBundle; +import com.intellij.ide.ui.UISettings; +import com.intellij.openapi.ui.Messages; import com.intellij.ui.InplaceButton; import com.intellij.ui.MouseDragHelper; import com.intellij.ui.ScreenUtil; @@ -224,6 +227,24 @@ class DragHelper extends MouseDragHelper { super.processDragFinish(event, willDragOutStart); endDrag(willDragOutStart); + + final int place = UISettings.getInstance().EDITOR_TAB_PLACEMENT; + + if (!willDragOutStart && JBEditorTabs.isAlphabeticalMode() && place != SwingConstants.TOP && place != SwingConstants.BOTTOM) { + final Point p = new Point(event.getPoint()); + SwingUtilities.convertPoint(event.getComponent(), p, myTabs); + if (myTabs.getVisibleRect().contains(p)) { + final int answer = Messages.showOkCancelDialog(myTabs, + IdeBundle.message("alphabetical.mode.is.on.warning"), + IdeBundle.message("title.warning"), + Messages.getQuestionIcon()); + if (answer == Messages.OK) { + JBEditorTabs.setAlphabeticalMode(false); + myTabs.relayout(true, false); + myTabs.revalidate(); + } + } + } } private void endDrag(boolean willDragOutStart) { diff --git a/platform/platform-api/src/com/intellij/ui/treeStructure/SimpleNode.java b/platform/platform-api/src/com/intellij/ui/treeStructure/SimpleNode.java index 2b3aa4e9e1e2..19e127fc3efc 100644 --- a/platform/platform-api/src/com/intellij/ui/treeStructure/SimpleNode.java +++ b/platform/platform-api/src/com/intellij/ui/treeStructure/SimpleNode.java @@ -93,7 +93,7 @@ public abstract class SimpleNode extends PresentableNodeDescriptor implements Co Color oldColor = myColor; String oldName = myName; - Icon oldIcon = myIcon; + Icon oldIcon = getIcon(); List oldFragments = new ArrayList(presentation.getColoredText()); myColor = UIUtil.getTreeTextForeground(); @@ -104,11 +104,11 @@ public abstract class SimpleNode extends PresentableNodeDescriptor implements Co myName = getName(); presentation.setPresentableText(myName); - presentation.setChanged(!Comparing.equal(new Object[]{myIcon, myName, oldFragments, myColor}, + presentation.setChanged(!Comparing.equal(new Object[]{getIcon(), myName, oldFragments, myColor}, new Object[]{oldIcon, oldName, oldFragments, oldColor})); presentation.setForcedTextForeground(myColor); - presentation.setIcon(myIcon); + presentation.setIcon(getIcon()); } protected void updateFileStatus() { @@ -241,7 +241,7 @@ public abstract class SimpleNode extends PresentableNodeDescriptor implements Co * or update presentation dynamically by defining {@link #update(com.intellij.ide.projectView.PresentationData)} */ public void setUniformIcon(Icon aIcon) { - myIcon = aIcon; + setIcon(aIcon); } /** diff --git a/platform/platform-api/src/com/intellij/ui/treeStructure/SimpleTree.java b/platform/platform-api/src/com/intellij/ui/treeStructure/SimpleTree.java index 859bb8429a6c..889f17e511aa 100644 --- a/platform/platform-api/src/com/intellij/ui/treeStructure/SimpleTree.java +++ b/platform/platform-api/src/com/intellij/ui/treeStructure/SimpleTree.java @@ -28,6 +28,7 @@ import com.intellij.ui.TreeUIHelper; import com.intellij.util.ui.EmptyIcon; import com.intellij.util.ui.UIUtil; import com.intellij.util.ui.tree.TreeUtil; +import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import javax.swing.*; @@ -118,7 +119,7 @@ public class SimpleTree extends Tree implements CellEditorListener { public boolean accept(AbstractTreeBuilder builder, final SimpleNodeVisitor visitor) { return builder.accept(SimpleNode.class, new TreeVisitor() { - public boolean visit(SimpleNode node) { + public boolean visit(@NotNull SimpleNode node) { return visitor.accept(node); } }) != null; @@ -479,7 +480,7 @@ public class SimpleTree extends Tree implements CellEditorListener { public boolean select(AbstractTreeBuilder aBuilder, final SimpleNodeVisitor aVisitor, boolean shouldExpand) { return aBuilder.select(SimpleNode.class, new TreeVisitor() { - public boolean visit(SimpleNode node) { + public boolean visit(@NotNull SimpleNode node) { return aVisitor.accept(node); } }, null, false); diff --git a/platform/platform-api/src/com/intellij/util/ui/update/MergingUpdateQueue.java b/platform/platform-api/src/com/intellij/util/ui/update/MergingUpdateQueue.java index 5f566400c3d6..20bcd4907d14 100644 --- a/platform/platform-api/src/com/intellij/util/ui/update/MergingUpdateQueue.java +++ b/platform/platform-api/src/com/intellij/util/ui/update/MergingUpdateQueue.java @@ -111,7 +111,7 @@ public class MergingUpdateQueue implements Runnable, Disposable, Activatable { } - protected Alarm createAlarm(Alarm.ThreadToUse thread, Disposable parent) { + protected Alarm createAlarm(@NotNull Alarm.ThreadToUse thread, Disposable parent) { return new Alarm(thread, parent); } diff --git a/platform/platform-impl/src/com/intellij/openapi/command/impl/EditorChangeAction.java b/platform/platform-impl/src/com/intellij/openapi/command/impl/EditorChangeAction.java index 32efab447f23..8141659ae5dd 100644 --- a/platform/platform-impl/src/com/intellij/openapi/command/impl/EditorChangeAction.java +++ b/platform/platform-impl/src/com/intellij/openapi/command/impl/EditorChangeAction.java @@ -26,10 +26,13 @@ import com.intellij.openapi.vfs.VirtualFile; import com.intellij.testFramework.LightVirtualFile; import org.jetbrains.annotations.NonNls; +import static com.intellij.util.CompressionUtil.compressCharSequence; +import static com.intellij.util.CompressionUtil.uncompressCharSequence; + public class EditorChangeAction extends BasicUndoableAction { private final int myOffset; - private final CharSequence myOldString; - private final CharSequence myNewString; + private final Object myOldString; + private final Object myNewString; private final long myOldTimeStamp; private final long myNewTimeStamp; @@ -45,8 +48,8 @@ public class EditorChangeAction extends BasicUndoableAction { super(document); myOffset = offset; - myOldString = oldString == null ? "" : oldString; - myNewString = newString == null ? "" : newString; + myOldString = oldString == null ? "" : compressCharSequence(oldString); + myNewString = newString == null ? "" : compressCharSequence(newString); myOldTimeStamp = oldTimeStamp; myNewTimeStamp = document.getModificationStamp(); } @@ -65,13 +68,13 @@ public class EditorChangeAction extends BasicUndoableAction { } public void performUndo() { - exchangeStrings(myNewString, myOldString); + exchangeStrings(uncompressCharSequence(myNewString), uncompressCharSequence(myOldString)); } public void redo() { DocumentUndoProvider.startDocumentUndo(getDocument()); try { - exchangeStrings(myOldString, myNewString); + exchangeStrings(uncompressCharSequence(myOldString), uncompressCharSequence(myNewString)); } finally { DocumentUndoProvider.finishDocumentUndo(getDocument()); diff --git a/platform/platform-impl/src/com/intellij/openapi/fileChooser/ex/FileNodeDescriptor.java b/platform/platform-impl/src/com/intellij/openapi/fileChooser/ex/FileNodeDescriptor.java index b299a6801869..1368a2703bf3 100644 --- a/platform/platform-impl/src/com/intellij/openapi/fileChooser/ex/FileNodeDescriptor.java +++ b/platform/platform-impl/src/com/intellij/openapi/fileChooser/ex/FileNodeDescriptor.java @@ -58,9 +58,9 @@ public class FileNodeDescriptor extends NodeDescriptor { if (file == null) return true; - myIcon = myOriginalIcon; + setIcon(myOriginalIcon); if (myFileElement.isHidden()) { - myIcon = IconLoader.getTransparentIcon(myIcon); + setIcon(IconLoader.getTransparentIcon(getIcon())); } myColor = myFileElement.isHidden() ? SimpleTextAttributes.DARK_TEXT.getFgColor() : null; return changed; diff --git a/platform/platform-impl/src/com/intellij/openapi/keymap/impl/ui/KeymapPanel.java b/platform/platform-impl/src/com/intellij/openapi/keymap/impl/ui/KeymapPanel.java index 0959ed2d2bcf..d5cb01779f0c 100644 --- a/platform/platform-impl/src/com/intellij/openapi/keymap/impl/ui/KeymapPanel.java +++ b/platform/platform-impl/src/com/intellij/openapi/keymap/impl/ui/KeymapPanel.java @@ -438,6 +438,7 @@ public class KeymapPanel extends JPanel implements SearchableConfigurable, Confi myPopup = JBPopupFactory.getInstance().createComponentPopupBuilder(createFilteringPanel(), null) .setRequestFocus(true) .setTitle(KeyMapBundle.message("filter.settings.popup.title")) + .setCancelKeyEnabled(false) .setMovable(true) .createPopup(); } diff --git a/platform/lang-impl/src/com/intellij/util/indexing/IOUtils.java b/platform/platform-impl/src/com/intellij/util/CompressionUtil.java similarity index 71% rename from platform/lang-impl/src/com/intellij/util/indexing/IOUtils.java rename to platform/platform-impl/src/com/intellij/util/CompressionUtil.java index 4041dbe6237d..a06bf7b8c9d4 100644 --- a/platform/lang-impl/src/com/intellij/util/indexing/IOUtils.java +++ b/platform/platform-impl/src/com/intellij/util/CompressionUtil.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.intellij.util.indexing; +package com.intellij.util; import com.intellij.idea.StartupUtil; import com.intellij.util.io.DataInputOutputUtil; @@ -24,11 +24,13 @@ import java.io.DataOutput; import java.io.IOException; import java.lang.ref.SoftReference; import java.lang.reflect.Field; +import java.nio.CharBuffer; +import java.nio.charset.Charset; /** * @author Maxim.Mossienko */ -public class IOUtils { +public class CompressionUtil { private static final boolean ourCanUseSnappy; static { @@ -79,4 +81,31 @@ public class IOUtils { return Snappy.uncompress(bytes); } } + + private static final int STRING_COMPRESSION_THRESHOLD = 1024; + + public static CharSequence uncompressCharSequence(Object string) { + if (string instanceof CharSequence) return (CharSequence)string; + byte[] b = (byte[])string; + try { + return Snappy.uncompressString(b, Charset.defaultCharset()); + } catch (Exception ex) { + throw new RuntimeException(ex); + } + } + + public static Object compressCharSequence(CharSequence string) { + if (!ourCanUseSnappy || string.length() < STRING_COMPRESSION_THRESHOLD) { + if (string instanceof CharBuffer && ((CharBuffer)string).capacity() > STRING_COMPRESSION_THRESHOLD) { + string = string.toString(); // shrink to size + } + return string; + } + try { + return Snappy.compress(string.toString(), Charset.defaultCharset()); + } catch (IOException ex) { + ex.printStackTrace(); + return string; + } + } } diff --git a/platform/platform-impl/src/org/jetbrains/io/WebServer.java b/platform/platform-impl/src/org/jetbrains/io/WebServer.java index 524ca88acade..c5c7f37ec608 100644 --- a/platform/platform-impl/src/org/jetbrains/io/WebServer.java +++ b/platform/platform-impl/src/org/jetbrains/io/WebServer.java @@ -137,7 +137,12 @@ public class WebServer { public ChannelPipeline getPipeline() throws Exception { ChannelPipeline pipeline = pipeline(new HttpRequestDecoder(), new HttpChunkAggregator(1048576), new HttpResponseEncoder()); for (Consumer consumer : pipelineConsumers.compute()) { - consumer.consume(pipeline); + try { + consumer.consume(pipeline); + } + catch (Throwable e) { + LOG.error(e); + } } pipeline.addLast("defaultHandler", defaultHandler); return pipeline; diff --git a/platform/platform-resources-en/src/messages/ApplicationBundle.properties b/platform/platform-resources-en/src/messages/ApplicationBundle.properties index 2d0ee4ea5971..53c1c55ecc12 100644 --- a/platform/platform-resources-en/src/messages/ApplicationBundle.properties +++ b/platform/platform-resources-en/src/messages/ApplicationBundle.properties @@ -335,7 +335,7 @@ checkbox.caret.blinking.ms=Caret blinking (ms): checkbox.mark.modified.tabs.with.asterisk=Mark modified tabs with asterisk group.code.folding=Code Folding checkbox.collapse.xml.tags=XML tags -checkbox.collapse.xml.attributes=XML 'style' attribute +checkbox.collapse.html.style.attribute=HTML 'style' attribute checkbox.collapse.anonymous.classes=Anonymous classes checkbox.collapse.closures="Closures" (anonymous classes implementing one method) checkbox.collapse.generic.constructor.parameters=Generic constructor and method parameters diff --git a/platform/platform-resources-en/src/messages/IdeBundle.properties b/platform/platform-resources-en/src/messages/IdeBundle.properties index ddc8b0a6b28d..8e70e76ae95f 100644 --- a/platform/platform-resources-en/src/messages/IdeBundle.properties +++ b/platform/platform-resources-en/src/messages/IdeBundle.properties @@ -1091,4 +1091,5 @@ diff.dialog.title=Diff Between ''{0}'' and ''{1}'' goto.custom.region.command=Go to Custom Region goto.custom.region.message.dumb.mode=Go to Custom Region action is not available until indices are built. -goto.custom.region.message.unavailable=There are no custom folding regions in the current file. \ No newline at end of file +goto.custom.region.message.unavailable=There are no custom folding regions in the current file. +alphabetical.mode.is.on.warning=Alphabetical order for tabs is ON. Switch it OFF? \ No newline at end of file diff --git a/platform/platform-tests/testSrc/com/intellij/ide/util/treeView/AbstractTreeBuilderTest.java b/platform/platform-tests/testSrc/com/intellij/ide/util/treeView/AbstractTreeBuilderTest.java index 1695a3d9ab7b..05b791c078e2 100644 --- a/platform/platform-tests/testSrc/com/intellij/ide/util/treeView/AbstractTreeBuilderTest.java +++ b/platform/platform-tests/testSrc/com/intellij/ide/util/treeView/AbstractTreeBuilderTest.java @@ -21,7 +21,6 @@ import com.intellij.openapi.util.Condition; import com.intellij.testFramework.PlatformTestUtil; import com.intellij.ui.SimpleTextAttributes; import com.intellij.ui.treeStructure.Tree; -import com.intellij.util.Time; import com.intellij.util.WaitFor; import com.intellij.util.containers.HashMap; import junit.framework.Assert; @@ -542,7 +541,6 @@ abstract class AbstractTreeBuilderTest extends BaseTreeTestCase extends FlyIdeaTestCase { Throwable myCancelRequest; boolean myReadyRequest; - private boolean myYieldingUiBuild; - private boolean myBgStructureBuilding; + private final boolean myYieldingUiBuild; + private final boolean myBgStructureBuilding; protected Set myForegroundLoadingNodes = new HashSet(); private boolean myPassThroughMode; @@ -97,7 +97,7 @@ abstract class BaseTreeTestCase extends FlyIdeaTestCase { boolean success = new WaitFor(60000) { @Override protected boolean condition() { - final boolean[] ready = new boolean[]{false}; + final boolean[] ready = {false}; invokeAndWaitIfNeeded(new Runnable() { @Override public void run() { @@ -107,7 +107,7 @@ abstract class BaseTreeTestCase extends FlyIdeaTestCase { return; } - ready[0] = (myCancelRequest != null || myReadyRequest) || (condition.value(null) && (ui.isReady())); + ready[0] = myCancelRequest != null || myReadyRequest || condition.value(null) && ui.isReady(); } }); @@ -177,10 +177,6 @@ abstract class BaseTreeTestCase extends FlyIdeaTestCase { super(tree, treeModel, treeStructure, comparator, updateIfInactive); } - public BaseTreeBuilder() { - } - - @Override protected final boolean updateNodeDescriptor(NodeDescriptor descriptor) { checkThread(descriptor.getElement()); @@ -188,16 +184,14 @@ abstract class BaseTreeTestCase extends FlyIdeaTestCase { int delay = getNodeDescriptorUpdateDelay(); if (delay > 0) { try { - Thread.currentThread().sleep(delay); + Thread.sleep(delay); } catch (InterruptedException e) { e.printStackTrace(); } } - if (getUi() == null) return false; - - return super.updateNodeDescriptor(descriptor); + return getUi() != null && super.updateNodeDescriptor(descriptor); } @Override @@ -446,7 +440,7 @@ abstract class BaseTreeTestCase extends FlyIdeaTestCase { }, new Condition() { @Override public boolean value(Object o) { - return done.get() || (canBeInterrupted && getBuilder().getUi().isCancelledReady()); + return done.get() || canBeInterrupted && getBuilder().getUi().isCancelledReady(); } }); } diff --git a/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/DirectoryIndexImpl.java b/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/DirectoryIndexImpl.java index 6909760dc09d..3687605a8341 100644 --- a/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/DirectoryIndexImpl.java +++ b/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/DirectoryIndexImpl.java @@ -431,7 +431,7 @@ public class DirectoryIndexImpl extends DirectoryIndex { @Override public boolean visitFile(@NotNull VirtualFile file) { if (progress != null) progress.checkCanceled(); - if (!file.isDirectory() || isIgnored(file)) return false; + if (!file.isDirectory() && file != dir || isIgnored(file)) return false; DirectoryInfo info = getOrCreateDirInfo(file); @@ -477,7 +477,7 @@ public class DirectoryIndexImpl extends DirectoryIndex { @Override public boolean visitFile(@NotNull VirtualFile file) { if (progress != null) progress.checkCanceled(); - if (!file.isDirectory() || isIgnored(file)) return false; + if (!file.isDirectory() && file != dir || isIgnored(file)) return false; DirectoryInfo info = getOrCreateDirInfo(file); diff --git a/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/LibraryOrderEntryBaseImpl.java b/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/LibraryOrderEntryBaseImpl.java index b5a7136497c4..fc913bc2ea82 100644 --- a/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/LibraryOrderEntryBaseImpl.java +++ b/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/LibraryOrderEntryBaseImpl.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2012 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. @@ -65,9 +65,11 @@ abstract class LibraryOrderEntryBaseImpl extends OrderEntryBaseImpl implements L public VirtualFile[] getRootFiles(@NotNull OrderRootType type) { RootProvider rootProvider = getRootProvider(); - return rootProvider == null ? VirtualFile.EMPTY_ARRAY : filterDirectories(rootProvider.getFiles(type)); + return rootProvider != null ? rootProvider.getFiles(type) : VirtualFile.EMPTY_ARRAY; } + /** @deprecated has no sense (to remove in IDEA 13) */ + @SuppressWarnings({"MethodMayBeStatic", "UnusedDeclaration"}) protected VirtualFile[] filterDirectories(@NotNull VirtualFile[] files) { List filtered = ContainerUtil.mapNotNull(files, new NullableFunction() { @Override diff --git a/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/LibraryOrderEntryImpl.java b/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/LibraryOrderEntryImpl.java index 665071c5c5cc..3c3e38cdc046 100644 --- a/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/LibraryOrderEntryImpl.java +++ b/platform/projectModel-impl/src/com/intellij/openapi/roots/impl/LibraryOrderEntryImpl.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2009 JetBrains s.r.o. + * Copyright 2000-2012 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. @@ -19,11 +19,12 @@ package com.intellij.openapi.roots.impl; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.roots.*; import com.intellij.openapi.roots.impl.libraries.LibraryEx; -import com.intellij.openapi.roots.libraries.*; +import com.intellij.openapi.roots.libraries.Library; +import com.intellij.openapi.roots.libraries.LibraryTable; +import com.intellij.openapi.roots.libraries.LibraryTablesRegistrar; import com.intellij.openapi.util.Comparing; import com.intellij.openapi.util.InvalidDataException; import com.intellij.openapi.util.WriteExternalException; -import com.intellij.openapi.vfs.VirtualFile; import com.intellij.openapi.vfs.pointers.VirtualFilePointerManager; import org.jdom.Element; import org.jetbrains.annotations.NonNls; @@ -44,15 +45,11 @@ class LibraryOrderEntryImpl extends LibraryOrderEntryBaseImpl implements Library @NonNls private static final String LEVEL_ATTR = "level"; private final MyOrderEntryLibraryTableListener myLibraryListener = new MyOrderEntryLibraryTableListener(); @NonNls private static final String EXPORTED_ATTR = "exported"; - private PersistentLibraryKind myLibraryKind; LibraryOrderEntryImpl(@NotNull Library library, @NotNull RootModelImpl rootModel, @NotNull ProjectRootManagerImpl projectRootManager) { super(rootModel, projectRootManager); LOG.assertTrue(library.getTable() != null); myLibrary = library; - if (myLibrary instanceof LibraryEx) { - myLibraryKind = ((LibraryEx)myLibrary).getKind(); - } addListeners(); init(); } @@ -79,7 +76,6 @@ class LibraryOrderEntryImpl extends LibraryOrderEntryBaseImpl implements Library } else { myLibrary = that.myLibrary; - myLibraryKind = that.myLibraryKind; } myExported = that.myExported; myScope = that.myScope; @@ -109,9 +105,6 @@ class LibraryOrderEntryImpl extends LibraryOrderEntryBaseImpl implements Library myLibraryName = null; myLibraryLevel = null; myLibrary = library; - if (library instanceof LibraryEx) { - myLibraryKind = ((LibraryEx)library).getKind(); - } } } @@ -251,9 +244,6 @@ class LibraryOrderEntryImpl extends LibraryOrderEntryBaseImpl implements Library myLibrary = newLibrary; myLibraryName = null; myLibraryLevel = null; - if (newLibrary instanceof LibraryEx && myLibraryKind == null) { - myLibraryKind = ((LibraryEx)newLibrary).getKind(); - } updateFromRootProviderAndSubscribe(); } } @@ -291,12 +281,4 @@ class LibraryOrderEntryImpl extends LibraryOrderEntryBaseImpl implements Library public void afterLibraryRemoved(Library library) { } } - - @Override - protected VirtualFile[] filterDirectories(@NotNull VirtualFile[] files) { - if (myLibraryKind != null && myLibraryKind.isFileBased()) { - return files; - } - return super.filterDirectories(files); - } } diff --git a/platform/projectModel-impl/src/com/intellij/openapi/roots/libraries/PersistentLibraryKind.java b/platform/projectModel-impl/src/com/intellij/openapi/roots/libraries/PersistentLibraryKind.java index 23654c87a5df..636061956091 100644 --- a/platform/projectModel-impl/src/com/intellij/openapi/roots/libraries/PersistentLibraryKind.java +++ b/platform/projectModel-impl/src/com/intellij/openapi/roots/libraries/PersistentLibraryKind.java @@ -23,23 +23,27 @@ import org.jetbrains.annotations.NotNull; * @author yole */ public abstract class PersistentLibraryKind

extends LibraryKind { - private final boolean myFileBased; - /** - * @param kindId must be unique among all {@link com.intellij.openapi.roots.libraries.LibraryType} and {@link com.intellij.openapi.roots.libraries.LibraryPresentationProvider} implementations - * @param based + * @param kindId must be unique among all {@link com.intellij.openapi.roots.libraries.LibraryType} and + * {@link com.intellij.openapi.roots.libraries.LibraryPresentationProvider} implementations. */ + public PersistentLibraryKind(@NotNull @NonNls String kindId) { + super(kindId); + } + + /** @deprecated 'fileBased' has no sense, use {@linkplain #PersistentLibraryKind(String)} (to remove in IDEA 13) */ + @SuppressWarnings("UnusedParameters") public PersistentLibraryKind(@NotNull @NonNls String kindId, boolean fileBased) { super(kindId); - myFileBased = fileBased; } @NotNull public abstract P createDefaultProperties(); - + /** @deprecated has no sense (to remove in IDEA 13) */ + @SuppressWarnings({"UnusedDeclaration", "MethodMayBeStatic"}) public boolean isFileBased() { - return myFileBased; + return false; } public OrderRootType[] getAdditionalRootTypes() { diff --git a/platform/testFramework/testSrc/com/intellij/psi/codeStyle/arrangement/AbstractRearrangerTest.groovy b/platform/testFramework/testSrc/com/intellij/psi/codeStyle/arrangement/AbstractRearrangerTest.groovy index a78c03c4822d..f39aaf3ed8e7 100644 --- a/platform/testFramework/testSrc/com/intellij/psi/codeStyle/arrangement/AbstractRearrangerTest.groovy +++ b/platform/testFramework/testSrc/com/intellij/psi/codeStyle/arrangement/AbstractRearrangerTest.groovy @@ -24,7 +24,9 @@ import com.intellij.psi.codeStyle.CodeStyleSettingsManager import com.intellij.psi.codeStyle.arrangement.engine.ArrangementEngine import com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryType import com.intellij.psi.codeStyle.arrangement.match.ArrangementModifier +import com.intellij.psi.codeStyle.arrangement.match.StdArrangementEntryMatcher import com.intellij.psi.codeStyle.arrangement.model.ArrangementAtomMatchCondition +import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingType import com.intellij.testFramework.fixtures.LightPlatformCodeInsightFixtureTestCase import org.jetbrains.annotations.NotNull @@ -48,6 +50,10 @@ abstract class AbstractRearrangerTest extends LightPlatformCodeInsightFixtureTes CodeStyleSettingsManager.getInstance(myFixture.project).dropTemporarySettings() super.tearDown() } + + protected StdArrangementRule rule(@NotNull ArrangementMatchCondition condition) { + new StdArrangementRule(new StdArrangementEntryMatcher(condition)) + } @NotNull protected ArrangementAtomMatchCondition atom(@NotNull Object condition) { diff --git a/platform/util/src/com/intellij/openapi/util/io/win32/IdeaWin32.java b/platform/util/src/com/intellij/openapi/util/io/win32/IdeaWin32.java index 0763490ad9c0..6ac6deaf17c6 100644 --- a/platform/util/src/com/intellij/openapi/util/io/win32/IdeaWin32.java +++ b/platform/util/src/com/intellij/openapi/util/io/win32/IdeaWin32.java @@ -16,6 +16,7 @@ package com.intellij.openapi.util.io.win32; import com.intellij.openapi.application.PathManager; +import com.intellij.openapi.diagnostic.LogUtil; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.util.SystemInfo; import org.jetbrains.annotations.NotNull; @@ -31,7 +32,7 @@ import java.io.FileNotFoundException; * @since 12.0 */ public class IdeaWin32 { - private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.util.io.win32.Win32LocalFileSystem"); + private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.util.io.win32.IdeaWin32"); private static final String PATH_PREFIX = "\\\\?\\"; private static final int PREFIX_SIZE = PATH_PREFIX.length(); @@ -97,6 +98,7 @@ public class IdeaWin32 { @Nullable public FileInfo getInfo(@NotNull final String path) { + LogUtil.debug(LOG, "getInfo(%s)", path); return getInfo0(path(path)); } @@ -108,6 +110,7 @@ public class IdeaWin32 { @Nullable public FileInfo[] listChildren(@NotNull final String path) { + LogUtil.debug(LOG, "list(%s)", path); return listChildren0(path(path) + PATH_SUFFIX); } diff --git a/platform/util/src/com/intellij/util/containers/ContainerUtil.java b/platform/util/src/com/intellij/util/containers/ContainerUtil.java index 618a56767b37..009746a0bfcc 100644 --- a/platform/util/src/com/intellij/util/containers/ContainerUtil.java +++ b/platform/util/src/com/intellij/util/containers/ContainerUtil.java @@ -897,7 +897,7 @@ public class ContainerUtil extends ContainerUtilRt { @NotNull public static Collection subtract(@NotNull Collection from, @NotNull Collection what) { - final Set set = newHashSet(); + final Set set = newHashSet(from); set.removeAll(what); return set; } diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/junit/AssertsWithoutMessagesInspection.java b/plugins/InspectionGadgets/src/com/siyeh/ig/junit/AssertsWithoutMessagesInspection.java index 2b05a972e67e..69561f1e7e1c 100644 --- a/plugins/InspectionGadgets/src/com/siyeh/ig/junit/AssertsWithoutMessagesInspection.java +++ b/plugins/InspectionGadgets/src/com/siyeh/ig/junit/AssertsWithoutMessagesInspection.java @@ -58,13 +58,15 @@ public class AssertsWithoutMessagesInspection extends BaseInspection { @NonNls private static final Set s_assertMethods = new HashSet(8); static { - s_assertMethods.add("assertTrue"); - s_assertMethods.add("assertFalse"); + s_assertMethods.add("assertArrayEquals"); s_assertMethods.add("assertEquals"); - s_assertMethods.add("assertNull"); + s_assertMethods.add("assertFalse"); s_assertMethods.add("assertNotNull"); - s_assertMethods.add("assertSame"); s_assertMethods.add("assertNotSame"); + s_assertMethods.add("assertNull"); + s_assertMethods.add("assertSame"); + s_assertMethods.add("assertThat"); + s_assertMethods.add("assertTrue"); s_assertMethods.add("fail"); } diff --git a/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/inferLambdaParameterType/SimpleWildcard_after.java b/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/inferLambdaParameterType/SimpleWildcard_after.java index 33dcda3ba94a..0baede4b98be 100644 --- a/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/inferLambdaParameterType/SimpleWildcard_after.java +++ b/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/inferLambdaParameterType/SimpleWildcard_after.java @@ -1,7 +1,7 @@ class Test1 { public static void main(String[] args) { - Comparable c = (Integer o)->{ + Comparable c = (Integer o) ->{ return 0; }; } diff --git a/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/inferLambdaParameterType/Simple_after.java b/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/inferLambdaParameterType/Simple_after.java index 5835eda2f6fb..cfece6d6467d 100644 --- a/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/inferLambdaParameterType/Simple_after.java +++ b/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/inferLambdaParameterType/Simple_after.java @@ -1,5 +1,5 @@ class X { { - Comparable c = (String o)-> 1; + Comparable c = (String o) -> 1; } } \ No newline at end of file diff --git a/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/inferLambdaParameterType/TwoParams_after.java b/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/inferLambdaParameterType/TwoParams_after.java index 7f9733d47279..1a76f46a9a31 100644 --- a/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/inferLambdaParameterType/TwoParams_after.java +++ b/plugins/IntentionPowerPak/test/com/siyeh/ipp/types/inferLambdaParameterType/TwoParams_after.java @@ -4,6 +4,6 @@ class X { } { - I c = (String o1, String o2)-> {}; + I c = (String o1, String o2) -> {}; } } \ No newline at end of file diff --git a/plugins/android/common/src/org/jetbrains/android/util/AndroidCommonUtils.java b/plugins/android/common/src/org/jetbrains/android/util/AndroidCommonUtils.java index 3be8392b3e29..f169fa963bdf 100644 --- a/plugins/android/common/src/org/jetbrains/android/util/AndroidCommonUtils.java +++ b/plugins/android/common/src/org/jetbrains/android/util/AndroidCommonUtils.java @@ -435,8 +435,14 @@ public class AndroidCommonUtils { if (propFile.exists() && propFile.isFile()) { final Map map = ProjectProperties.parsePropertyFile(new BufferingFileWrapper(propFile), new MessageBuildingSdkLog()); - final String revision = map.get("Pkg.Revision"); + String revision = map.get("Pkg.Revision"); + if (revision != null) { + final int dot = revision.indexOf('.'); + if (dot > 0) { + revision = revision.substring(0, dot); + } + try { revisionNumber = Integer.parseInt(revision); } diff --git a/plugins/android/jps-plugin/src/org/jetbrains/jps/android/AndroidJpsUtil.java b/plugins/android/jps-plugin/src/org/jetbrains/jps/android/AndroidJpsUtil.java index 18257452326b..4fb5d94ac8f3 100644 --- a/plugins/android/jps-plugin/src/org/jetbrains/jps/android/AndroidJpsUtil.java +++ b/plugins/android/jps-plugin/src/org/jetbrains/jps/android/AndroidJpsUtil.java @@ -217,14 +217,19 @@ class AndroidJpsUtil { public static void processClasspath(@NotNull CompileContext context, @NotNull JpsModule module, @NotNull AndroidDependencyProcessor processor) { - processClasspath(context, module, processor, new HashSet(), false); + // In a module imported from Maven dependencies are transitive, so we don't need to traverse all dependency tree + // and compute all jars referred by library modules. Moreover it would be incorrect, + // because Maven has dependency resolving algorithm based on versioning + final boolean recursive = isMavenizedModule(module); + processClasspath(context, module, processor, new HashSet(), false, recursive); } private static void processClasspath(@NotNull CompileContext context, @NotNull final JpsModule module, @NotNull final AndroidDependencyProcessor processor, @NotNull final Set visitedModules, - final boolean exportedLibrariesOnly) { + final boolean exportedLibrariesOnly, + final boolean recursive) { if (!visitedModules.add(module.getName())) { return; } @@ -283,7 +288,9 @@ class AndroidJpsUtil { // do not support android-app->android-app compile dependencies processor.processJavaModuleOutputDirectory(depClassDir); } - processClasspath(context, depModule, processor, visitedModules, !depLibrary || exportedLibrariesOnly); + if (recursive) { + processClasspath(context, depModule, processor, visitedModules, !depLibrary || exportedLibrariesOnly, recursive); + } } } } diff --git a/plugins/android/src/org/jetbrains/android/facet/AndroidRootUtil.java b/plugins/android/src/org/jetbrains/android/facet/AndroidRootUtil.java index 9d922833e4f7..ad8cf6f640e0 100644 --- a/plugins/android/src/org/jetbrains/android/facet/AndroidRootUtil.java +++ b/plugins/android/src/org/jetbrains/android/facet/AndroidRootUtil.java @@ -34,6 +34,8 @@ import com.intellij.psi.PsiFile; import com.intellij.psi.PsiManager; import com.intellij.util.containers.OrderedSet; import org.jetbrains.android.compiler.AndroidCompileUtil; +import org.jetbrains.android.compiler.AndroidDexCompiler; +import org.jetbrains.android.maven.AndroidMavenUtil; import org.jetbrains.android.sdk.AndroidPlatform; import org.jetbrains.android.sdk.AndroidSdkAdditionalData; import org.jetbrains.android.sdk.AndroidSdkType; @@ -226,7 +228,8 @@ public class AndroidRootUtil { final Set outputDirs, @Nullable final Set libraries, final Set visited, - final boolean exportedLibrariesOnly) { + final boolean exportedLibrariesOnly, + final boolean recursive) { if (!visited.add(module)) { return; } @@ -276,8 +279,10 @@ public class AndroidRootUtil { VirtualFile classDir = extension.getCompilerOutputPath(); if (libraryProject) { - if (classDir != null) { - final VirtualFile packedClassesJar = classDir.findChild(AndroidCommonUtils.CLASSES_JAR_FILE_NAME); + final VirtualFile tmpArtifactsDir = AndroidDexCompiler.getOutputDirectoryForDex(depModule); + + if (tmpArtifactsDir != null) { + final VirtualFile packedClassesJar = tmpArtifactsDir.findChild(AndroidCommonUtils.CLASSES_JAR_FILE_NAME); if (packedClassesJar != null) { outputDirs.add(packedClassesJar); } @@ -288,7 +293,10 @@ public class AndroidRootUtil { outputDirs.add(classDir); } } - fillExternalLibrariesAndModules(depModule, outputDirs, libraries, visited, !libraryProject || exportedLibrariesOnly); + if (recursive) { + fillExternalLibrariesAndModules(depModule, outputDirs, libraries, visited, + !libraryProject || exportedLibrariesOnly, recursive); + } } } } @@ -299,7 +307,11 @@ public class AndroidRootUtil { public static List getExternalLibraries(Module module) { Set files = new HashSet(); OrderedSet libs = new OrderedSet(); - fillExternalLibrariesAndModules(module, files, libs, new HashSet(), false); + // In a module imported from Maven dependencies are transitive, so we don't need to traverse all dependency tree + // and compute all jars referred by library modules. Moreover it would be incorrect, + // because Maven has dependency resolving algorithm based on versioning + final boolean recursive = !AndroidMavenUtil.isMavenizedModule(module); + fillExternalLibrariesAndModules(module, files, libs, new HashSet(), false, recursive); addAnnotationsJar(module, libs); return libs; @@ -336,7 +348,7 @@ public class AndroidRootUtil { public static Set getDependentModules(Module module, VirtualFile moduleOutputDir) { Set files = new HashSet(); - fillExternalLibrariesAndModules(module, files, null, new HashSet(), false); + fillExternalLibrariesAndModules(module, files, null, new HashSet(), false, true); files.remove(moduleOutputDir); return files; } diff --git a/plugins/android/src/org/jetbrains/android/maven/AndroidExternalApklibDependenciesManager.java b/plugins/android/src/org/jetbrains/android/maven/AndroidExternalApklibDependenciesManager.java index c371d29a185a..6d619bc8fde1 100644 --- a/plugins/android/src/org/jetbrains/android/maven/AndroidExternalApklibDependenciesManager.java +++ b/plugins/android/src/org/jetbrains/android/maven/AndroidExternalApklibDependenciesManager.java @@ -151,18 +151,16 @@ public class AndroidExternalApklibDependenciesManager implements PersistentState private String myArtifactId; private String myVersion; private String myType; - private String myLibraryName; private String myScope; public MavenDependencyInfo() { } - public MavenDependencyInfo(@NotNull MavenId mavenId, @NotNull String type, @NotNull String scope, @NotNull String libraryName) { + public MavenDependencyInfo(@NotNull MavenId mavenId, @NotNull String type, @NotNull String scope) { myGroupId = mavenId.getGroupId(); myArtifactId = mavenId.getArtifactId(); myVersion = mavenId.getVersion(); myType = type; - myLibraryName = libraryName; myScope = scope; } @@ -182,10 +180,6 @@ public class AndroidExternalApklibDependenciesManager implements PersistentState return myType; } - public String getLibraryName() { - return myLibraryName; - } - public String getScope() { return myScope; } @@ -206,10 +200,6 @@ public class AndroidExternalApklibDependenciesManager implements PersistentState myType = type; } - public void setLibraryName(String libraryName) { - myLibraryName = libraryName; - } - public void setScope(String scope) { myScope = scope; } diff --git a/plugins/android/src/org/jetbrains/android/maven/AndroidFacetImporterBase.java b/plugins/android/src/org/jetbrains/android/maven/AndroidFacetImporterBase.java index f2cfb83c2867..8e6f844f644e 100644 --- a/plugins/android/src/org/jetbrains/android/maven/AndroidFacetImporterBase.java +++ b/plugins/android/src/org/jetbrains/android/maven/AndroidFacetImporterBase.java @@ -31,6 +31,7 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.roots.*; import com.intellij.openapi.roots.libraries.Library; +import com.intellij.openapi.util.Comparing; import com.intellij.openapi.util.Key; import com.intellij.openapi.util.Ref; import com.intellij.openapi.util.io.FileUtil; @@ -409,13 +410,13 @@ public abstract class AndroidFacetImporterBase extends FacetImporter result = Ref.create(null); @@ -588,10 +627,8 @@ public abstract class AndroidFacetImporterBase extends FacetImporter(); for (MavenArtifact depArtifact : projectForExternalApklib.getDependencies()) { - final String depArtifactLibraryName = depArtifact.getLibraryName(); - dependencies.add(new AndroidExternalApklibDependenciesManager.MavenDependencyInfo( - depArtifact.getMavenId(), depArtifact.getType(), depArtifact.getScope(), depArtifactLibraryName)); + depArtifact.getMavenId(), depArtifact.getType(), depArtifact.getScope())); } final AndroidExternalApklibDependenciesManager apklibDependenciesManager = diff --git a/plugins/ant/src/com/intellij/lang/ant/config/explorer/AntBuildFileNodeDescriptor.java b/plugins/ant/src/com/intellij/lang/ant/config/explorer/AntBuildFileNodeDescriptor.java index 90542c63b995..045841f81e11 100644 --- a/plugins/ant/src/com/intellij/lang/ant/config/explorer/AntBuildFileNodeDescriptor.java +++ b/plugins/ant/src/com/intellij/lang/ant/config/explorer/AntBuildFileNodeDescriptor.java @@ -54,7 +54,7 @@ final class AntBuildFileNodeDescriptor extends AntNodeDescriptor { if (buildModel != null) { AntTargetNodeDescriptor.addShortcutText(buildModel.getDefaultTargetActionId(), myAppearance); } - myIcon = AllIcons.Ant.Build; + setIcon(AllIcons.Ant.Build); myName = myBuildFile.getPresentableName(); return !Comparing.equal(myAppearance, oldAppearence); } diff --git a/plugins/ant/src/com/intellij/lang/ant/config/explorer/AntTargetNodeDescriptor.java b/plugins/ant/src/com/intellij/lang/ant/config/explorer/AntTargetNodeDescriptor.java index 044bd0f6028e..2b6671130582 100644 --- a/plugins/ant/src/com/intellij/lang/ant/config/explorer/AntTargetNodeDescriptor.java +++ b/plugins/ant/src/com/intellij/lang/ant/config/explorer/AntTargetNodeDescriptor.java @@ -66,7 +66,7 @@ final class AntTargetNodeDescriptor extends AntNodeDescriptor { final CompositeAppearance oldText = myHighlightedText; final boolean isMeta = myTarget instanceof MetaTarget; - myIcon = isMeta ? AllIcons.Ant.MetaTarget : AllIcons.Ant.Target; + setIcon(isMeta ? AllIcons.Ant.MetaTarget : AllIcons.Ant.Target); myHighlightedText = new CompositeAppearance(); diff --git a/plugins/commander/src/com/intellij/ide/commander/Commander.java b/plugins/commander/src/com/intellij/ide/commander/Commander.java index e512eb5fe4ac..5ecc9d0b9a57 100644 --- a/plugins/commander/src/com/intellij/ide/commander/Commander.java +++ b/plugins/commander/src/com/intellij/ide/commander/Commander.java @@ -44,7 +44,7 @@ import com.intellij.openapi.wm.ex.IdeFocusTraversalPolicy; import com.intellij.psi.*; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.util.PsiTreeUtil; -import com.intellij.psi.util.PsiUtilBase; +import com.intellij.psi.util.PsiUtilCore; import com.intellij.ui.AutoScrollToSourceHandler; import org.jdom.Element; import org.jetbrains.annotations.NonNls; @@ -108,11 +108,13 @@ public class Commander extends JPanel implements PersistentStateComponent= 0 && proportion <= 1) { mySplitter.setProportion(proportion); } - } catch (NumberFormatException e) { + } + catch (NumberFormatException ignored) { } } } @@ -211,19 +212,23 @@ public class Commander extends JPanel implements PersistentStateComponent exte public GradleProjectStructureNodeDescriptor(@NotNull T id, @NotNull String text, @Nullable Icon icon) { super(null, null); myId = id; - myIcon = icon; + setIcon(icon); myName = text; } @@ -38,7 +38,7 @@ public class GradleProjectStructureNodeDescriptor exte protected void update(@NotNull PresentationData presentation) { presentation.setAttributesKey(myAttributes); presentation.setPresentableText(myName); - presentation.setIcon(myIcon); + presentation.setIcon(getIcon()); } @NotNull diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/completion/GroovyCompletionData.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/completion/GroovyCompletionData.java index 04c217cf6515..5b03d15b232f 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/completion/GroovyCompletionData.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/lang/completion/GroovyCompletionData.java @@ -21,6 +21,7 @@ import com.intellij.codeInsight.TailType; import com.intellij.codeInsight.TailTypes; import com.intellij.codeInsight.completion.CompletionParameters; import com.intellij.codeInsight.completion.CompletionResultSet; +import com.intellij.codeInsight.completion.JavaCompletionData; import com.intellij.codeInsight.completion.ModifierChooser; import com.intellij.codeInsight.lookup.LookupElement; import com.intellij.codeInsight.lookup.LookupElementBuilder; @@ -226,7 +227,7 @@ public class GroovyCompletionData { private static LookupElement keyword(final String keyword, @NotNull TailType tail) { LookupElementBuilder element = LookupElementBuilder.create(keyword).bold(); - return tail != TailType.NONE ? TailTypeDecorator.withTail(element, tail) : element; + return tail != TailType.NONE ? new JavaCompletionData.OverrideableSpace(element, tail) : element; } private static void registerControlCompletion(PsiElement context, CompletionResultSet result) { diff --git a/plugins/groovy/test/org/jetbrains/plugins/groovy/completion/GroovyCompletionTest.groovy b/plugins/groovy/test/org/jetbrains/plugins/groovy/completion/GroovyCompletionTest.groovy index 60e26d908003..4aecd0291632 100644 --- a/plugins/groovy/test/org/jetbrains/plugins/groovy/completion/GroovyCompletionTest.groovy +++ b/plugins/groovy/test/org/jetbrains/plugins/groovy/completion/GroovyCompletionTest.groovy @@ -1266,6 +1266,13 @@ def foo(Integer a) { ''') } + public void testForSpace() { + configure('f') + myFixture.completeBasic() + myFixture.type 'or ' + myFixture.checkResult "for " + } + void testInferArgumentTypeFromMethod3() { doBasicTest('''\ def bar(String s) {} diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/utils/library/RepositoryLibraryType.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/utils/library/RepositoryLibraryType.java index 0eff8e964288..7a1ba738d1d2 100644 --- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/utils/library/RepositoryLibraryType.java +++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/utils/library/RepositoryLibraryType.java @@ -32,7 +32,7 @@ import javax.swing.*; * @author nik */ public class RepositoryLibraryType extends LibraryType { - private static final PersistentLibraryKind LIBRARY_KIND = new PersistentLibraryKind("repository", false) { + private static final PersistentLibraryKind LIBRARY_KIND = new PersistentLibraryKind("repository") { @NotNull @Override public RepositoryLibraryProperties createDefaultProperties() { diff --git a/plugins/testng/src/com/theoryinpractice/testng/inspection/AssertsWithoutMessagesTestNGInspection.java b/plugins/testng/src/com/theoryinpractice/testng/inspection/AssertsWithoutMessagesTestNGInspection.java index c0fac924c781..3c8534511ab9 100644 --- a/plugins/testng/src/com/theoryinpractice/testng/inspection/AssertsWithoutMessagesTestNGInspection.java +++ b/plugins/testng/src/com/theoryinpractice/testng/inspection/AssertsWithoutMessagesTestNGInspection.java @@ -27,6 +27,9 @@ import org.jetbrains.annotations.NotNull; import java.util.HashSet; import java.util.Set; +/** + * @author Bas Leijdekkers + */ public class AssertsWithoutMessagesTestNGInspection extends BaseJavaLocalInspectionTool { @NotNull @@ -45,15 +48,16 @@ public class AssertsWithoutMessagesTestNGInspection extends BaseJavaLocalInspect } static { - ourAssertMethods.add("assertTrue"); - ourAssertMethods.add("assertFalse"); + ourAssertMethods.add("assertArrayEquals"); ourAssertMethods.add("assertEquals"); ourAssertMethods.add("assertEqualsNoOrder"); - ourAssertMethods.add("assertNull"); + ourAssertMethods.add("assertFalse"); ourAssertMethods.add("assertNotEquals"); ourAssertMethods.add("assertNotNull"); - ourAssertMethods.add("assertSame"); ourAssertMethods.add("assertNotSame"); + ourAssertMethods.add("assertNull"); + ourAssertMethods.add("assertSame"); + ourAssertMethods.add("assertTrue"); ourAssertMethods.add("fail"); } diff --git a/plugins/ui-designer/ui-designer-new/src/com/intellij/designer/componentTree/TreeNodeDescriptor.java b/plugins/ui-designer/ui-designer-new/src/com/intellij/designer/componentTree/TreeNodeDescriptor.java index ec3cb7b9579d..28900e5806b1 100644 --- a/plugins/ui-designer/ui-designer-new/src/com/intellij/designer/componentTree/TreeNodeDescriptor.java +++ b/plugins/ui-designer/ui-designer-new/src/com/intellij/designer/componentTree/TreeNodeDescriptor.java @@ -18,8 +18,6 @@ package com.intellij.designer.componentTree; import com.intellij.ide.util.treeView.NodeDescriptor; import org.jetbrains.annotations.Nullable; -import javax.swing.*; - /** * @author Alexander Lobas */ @@ -45,8 +43,4 @@ public final class TreeNodeDescriptor extends NodeDescriptor { public Object getElement() { return myElement; } - - public void setIcon(Icon icon) { - myIcon = icon; - } } diff --git a/plugins/xpath/xpath-lang/src/org/intellij/lang/xpath/xslt/associations/impl/AssociationsEditor.java b/plugins/xpath/xpath-lang/src/org/intellij/lang/xpath/xslt/associations/impl/AssociationsEditor.java index 64b483f2afb9..170e78d8719f 100644 --- a/plugins/xpath/xpath-lang/src/org/intellij/lang/xpath/xslt/associations/impl/AssociationsEditor.java +++ b/plugins/xpath/xpath-lang/src/org/intellij/lang/xpath/xslt/associations/impl/AssociationsEditor.java @@ -387,7 +387,7 @@ class AssociationsEditor { public MyNodeDescriptor(NodeDescriptor nodeDescriptor) { super(nodeDescriptor.getProject(), null); myName = nodeDescriptor.toString(); - myIcon = LayeredIcon.create(nodeDescriptor.getIcon(), LINK_OVERLAY); + setIcon(LayeredIcon.create(nodeDescriptor.getIcon(), LINK_OVERLAY)); myColor = nodeDescriptor.getColor(); myNode = nodeDescriptor.getElement(); } diff --git a/xml/impl/src/com/intellij/application/options/editor/XmlCodeFoldingOptionsProvider.java b/xml/impl/src/com/intellij/application/options/editor/XmlCodeFoldingOptionsProvider.java index 5cc77a906d40..2c685dfa2faa 100644 --- a/xml/impl/src/com/intellij/application/options/editor/XmlCodeFoldingOptionsProvider.java +++ b/xml/impl/src/com/intellij/application/options/editor/XmlCodeFoldingOptionsProvider.java @@ -27,6 +27,6 @@ public class XmlCodeFoldingOptionsProvider extends BeanConfigurable> + +> \ No newline at end of file