*/
package com.intellij.compiler.impl;
-import com.intellij.CommonBundle;
-import com.intellij.analysis.AnalysisScope;
+import com.intellij.*;
+import com.intellij.analysis.*;
import com.intellij.compiler.*;
-import com.intellij.compiler.make.CacheCorruptedException;
-import com.intellij.compiler.make.CacheUtils;
-import com.intellij.compiler.make.DependencyCache;
-import com.intellij.compiler.progress.CompilerTask;
-import com.intellij.diagnostic.IdeErrorsDialog;
-import com.intellij.diagnostic.PluginException;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.application.ModalityState;
+import com.intellij.compiler.make.*;
+import com.intellij.compiler.progress.*;
+import com.intellij.diagnostic.*;
+import com.intellij.openapi.application.*;
import com.intellij.openapi.compiler.*;
import com.intellij.openapi.compiler.Compiler;
-import com.intellij.openapi.compiler.ex.CompileContextEx;
-import com.intellij.openapi.compiler.ex.CompilerPathsEx;
-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.extensions.Extensions;
-import com.intellij.openapi.extensions.PluginId;
-import com.intellij.openapi.fileEditor.FileDocumentManager;
-import com.intellij.openapi.fileTypes.FileType;
-import com.intellij.openapi.fileTypes.FileTypeManager;
-import com.intellij.openapi.fileTypes.StdFileTypes;
-import com.intellij.openapi.module.LanguageLevelUtil;
-import com.intellij.openapi.module.Module;
-import com.intellij.openapi.module.ModuleManager;
-import com.intellij.openapi.progress.ProcessCanceledException;
-import com.intellij.openapi.progress.ProgressIndicator;
-import com.intellij.openapi.progress.ProgressManager;
-import com.intellij.openapi.project.DumbService;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.project.ProjectBundle;
-import com.intellij.openapi.projectRoots.Sdk;
+import com.intellij.openapi.compiler.ex.*;
+import com.intellij.openapi.diagnostic.*;
+import com.intellij.openapi.extensions.*;
+import com.intellij.openapi.fileEditor.*;
+import com.intellij.openapi.fileTypes.*;
+import com.intellij.openapi.module.*;
+import com.intellij.openapi.progress.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.projectRoots.*;
import com.intellij.openapi.roots.*;
-import com.intellij.openapi.roots.ex.ProjectRootManagerEx;
-import com.intellij.openapi.roots.ui.configuration.CommonContentEntriesEditor;
-import com.intellij.openapi.roots.ui.configuration.ProjectSettingsService;
-import com.intellij.openapi.ui.MessageType;
-import com.intellij.openapi.ui.Messages;
+import com.intellij.openapi.roots.ex.*;
+import com.intellij.openapi.roots.ui.configuration.*;
+import com.intellij.openapi.ui.*;
import com.intellij.openapi.util.*;
-import com.intellij.openapi.util.io.FileUtil;
-import com.intellij.openapi.util.registry.Registry;
-import com.intellij.openapi.vfs.LocalFileSystem;
-import com.intellij.openapi.vfs.VfsUtil;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.openapi.vfs.VirtualFileManager;
-import com.intellij.openapi.wm.StatusBar;
-import com.intellij.openapi.wm.ToolWindowId;
-import com.intellij.openapi.wm.ToolWindowManager;
-import com.intellij.openapi.wm.WindowManager;
-import com.intellij.packageDependencies.DependenciesBuilder;
-import com.intellij.packageDependencies.ForwardDependenciesBuilder;
-import com.intellij.pom.java.LanguageLevel;
-import com.intellij.psi.PsiCompiledElement;
-import com.intellij.psi.PsiDocumentManager;
-import com.intellij.psi.PsiFile;
-import com.intellij.psi.PsiManager;
-import com.intellij.util.Chunk;
-import com.intellij.util.LocalTimeCounter;
-import com.intellij.util.StringBuilderSpinAllocator;
-import com.intellij.util.ThrowableRunnable;
+import com.intellij.openapi.util.io.*;
+import com.intellij.openapi.util.registry.*;
+import com.intellij.openapi.vfs.*;
+import com.intellij.openapi.wm.*;
+import com.intellij.packageDependencies.*;
+import com.intellij.pom.java.*;
+import com.intellij.psi.*;
+import com.intellij.util.*;
import com.intellij.util.concurrency.Semaphore;
-import com.intellij.util.containers.ContainerUtil;
+import com.intellij.util.containers.*;
import com.intellij.util.containers.HashMap;
-import com.intellij.util.containers.MultiMap;
-import com.intellij.util.containers.OrderedSet;
-import gnu.trove.TObjectHashingStrategy;
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
+import gnu.trove.*;
+import org.jetbrains.annotations.*;
import java.io.*;
import java.util.*;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
+import java.util.HashSet;
+import java.util.concurrent.*;
public class CompileDriver {
private static final Logger LOG = Logger.getInstance("#com.intellij.compiler.impl.CompileDriver");
final StatusBar statusBar = WindowManager.getInstance().getStatusBar(myProject);
if (statusBar != null) { // because this code is in invoke later, the code may work for already closed project
// in case another project was opened in the frame while the compiler was working (See SCR# 28591)
- statusBar.setInfo(statusMessage);
+ StatusBar.Info.set(statusMessage, myProject);
if (duration > ONE_MINUTE_MS) {
final MessageType messageType = errorCount > 0 ? MessageType.ERROR : warningCount > 0 ? MessageType.WARNING : MessageType.INFO;
ToolWindowManager.getInstance(myProject).notifyByBalloon(ToolWindowId.MESSAGES_WINDOW, messageType, statusMessage);
*/
package com.intellij.compiler.impl;
-import com.intellij.codeInsight.daemon.impl.actions.SuppressFix;
-import com.intellij.codeInsight.daemon.impl.actions.SuppressForClassFix;
-import com.intellij.compiler.CompilerConfiguration;
-import com.intellij.compiler.CompilerConfigurationImpl;
-import com.intellij.compiler.CompilerWorkspaceConfiguration;
-import com.intellij.compiler.HelpID;
-import com.intellij.compiler.options.CompilerConfigurable;
+import com.intellij.codeInsight.daemon.impl.actions.*;
+import com.intellij.compiler.*;
+import com.intellij.compiler.options.*;
import com.intellij.ide.errorTreeView.*;
-import com.intellij.ide.util.treeView.NodeDescriptor;
+import com.intellij.ide.util.treeView.*;
import com.intellij.openapi.actionSystem.*;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.command.CommandProcessor;
-import com.intellij.openapi.compiler.CompilerBundle;
-import com.intellij.openapi.compiler.options.ExcludeEntryDescription;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.fileEditor.OpenFileDescriptor;
-import com.intellij.openapi.module.LanguageLevelUtil;
-import com.intellij.openapi.module.Module;
-import com.intellij.openapi.module.ModuleUtil;
-import com.intellij.openapi.options.ShowSettingsUtil;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.projectRoots.JavaSdk;
-import com.intellij.openapi.projectRoots.Sdk;
-import com.intellij.openapi.roots.ModuleRootManager;
-import com.intellij.openapi.util.IconLoader;
-import com.intellij.openapi.vcs.FileStatusManager;
-import com.intellij.openapi.vfs.LocalFileSystem;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.pom.Navigatable;
-import com.intellij.pom.java.LanguageLevel;
+import com.intellij.openapi.application.*;
+import com.intellij.openapi.command.*;
+import com.intellij.openapi.compiler.*;
+import com.intellij.openapi.compiler.options.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.fileEditor.*;
+import com.intellij.openapi.module.*;
+import com.intellij.openapi.options.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.projectRoots.*;
+import com.intellij.openapi.roots.*;
+import com.intellij.openapi.util.*;
+import com.intellij.openapi.vcs.*;
+import com.intellij.openapi.vfs.*;
+import com.intellij.pom.*;
+import com.intellij.pom.java.*;
import com.intellij.psi.*;
-import com.intellij.util.IncorrectOperationException;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
import javax.swing.*;
return new SuppressFix(id) {
@Override
@SuppressWarnings({"SimplifiableIfStatement"})
- public boolean isAvailable(@NotNull final Project project, final Editor editor, @Nullable final PsiElement context) {
+ public boolean isAvailable(@NotNull final Project project, final Editor editor, @NotNull final PsiElement context) {
if (getContainer(context) instanceof PsiClass) return false;
return super.isAvailable(project, editor, context);
}
package com.intellij.packaging.impl.compiler;
-import com.intellij.compiler.impl.packagingCompiler.DestinationInfo;
-import com.intellij.compiler.impl.FileProcessingCompilerStateCache;
-import com.intellij.openapi.compiler.FileProcessingCompiler;
-import com.intellij.openapi.compiler.ValidityState;
-import com.intellij.openapi.util.Pair;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.util.SmartList;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.compiler.impl.*;
+import com.intellij.compiler.impl.packagingCompiler.*;
+import com.intellij.openapi.compiler.*;
+import com.intellij.openapi.util.*;
+import com.intellij.openapi.vfs.*;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
-import java.util.ArrayList;
-import java.util.List;
-import java.io.IOException;
+import java.io.*;
+import java.util.*;
/**
* @author nik
public List<DestinationInfo> getEnabledDestinations() {
if (myEnabledDestinations == null) {
- myEnabledDestinations = new ArrayList<DestinationInfo>();
+ myEnabledDestinations = new SmartList<DestinationInfo>();
for (Pair<DestinationInfo, Boolean> destination : myDestinations) {
if (destination.getSecond()) {
myEnabledDestinations.add(destination.getFirst());
public ValidityState getValidityState() {
return new ArtifactPackagingItemValidityState(getEnabledDestinations(), mySourceFileModified, myOldState);
}
-}
\ No newline at end of file
+}
*/
package com.intellij.execution.configurations;
-import com.intellij.execution.ExecutionBundle;
-import com.intellij.execution.JavaExecutionUtil;
-import com.intellij.openapi.module.Module;
-import com.intellij.openapi.module.ModuleManager;
-import com.intellij.openapi.module.ModuleUtil;
-import com.intellij.openapi.project.Project;
-import com.intellij.psi.JavaPsiFacade;
-import com.intellij.psi.PsiClass;
-import com.intellij.psi.PsiDocumentManager;
-import com.intellij.psi.search.GlobalSearchScope;
-import gnu.trove.THashSet;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.execution.*;
+import com.intellij.openapi.module.*;
+import com.intellij.openapi.project.*;
+import com.intellij.psi.*;
+import com.intellij.psi.search.*;
+import gnu.trove.*;
+import org.jetbrains.annotations.*;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Set;
+import java.util.*;
/**
* @author spleaner
return Arrays.asList(ModuleManager.getInstance(project).getModules());
}
else {
- return ModuleUtil.collectModulesDependsOn(modules);
+ final Set<Module> result = new HashSet<Module>();
+ for (Module module : modules) {
+ ModuleUtil.collectModulesDependsOn(module, result);
+ }
+ return result;
}
}
public void handleInsert(InsertionContext context, LookupElementDecorator<LookupItem> item) {
@SuppressWarnings({"unchecked"}) final LookupItem<PsiClass> delegate = item.getDelegate();
+ final PsiElement position = SmartCompletionDecorator.getPosition(context, delegate);
+ final PsiExpression enclosing = PsiTreeUtil.getContextOfType(position, PsiExpression.class, true);
+ final PsiAnonymousClass anonymousClass = PsiTreeUtil.getParentOfType(position, PsiAnonymousClass.class);
+ final boolean inAnonymous = anonymousClass != null && anonymousClass.getParent() == enclosing;
+
insertParentheses(context, delegate, delegate.getObject());
DefaultInsertHandler.addImportForItem(context.getFile(), context.getStartOffset(), delegate);
- final PsiElement position = SmartCompletionDecorator.getPosition(context, delegate);
-
- final PsiExpression enclosing = PsiTreeUtil.getContextOfType(position, PsiExpression.class, true);
- if (item.getUserData(LookupItem.BRACKETS_COUNT_ATTR) == null) {
- final PsiAnonymousClass anonymousClass = PsiTreeUtil.getParentOfType(position, PsiAnonymousClass.class);
- if (anonymousClass == null || anonymousClass.getParent() != enclosing) {
-
- final PsiClass psiClass = (PsiClass)item.getObject();
- if (psiClass.hasModifierProperty(PsiModifier.ABSTRACT) || psiClass.isInterface()) {
- FeatureUsageTracker.getInstance().triggerFeatureUsed("editing.completion.smarttype.anonymous");
+ if (item.getUserData(LookupItem.BRACKETS_COUNT_ATTR) == null && !inAnonymous) {
+ if (((PsiClass)item.getObject()).hasModifierProperty(PsiModifier.ABSTRACT)) {
+ FeatureUsageTracker.getInstance().triggerFeatureUsed("editing.completion.smarttype.anonymous");
- PostprocessReformattingAspect.getInstance(context.getProject()).doPostponedFormatting(context.getFile().getViewProvider());
+ PostprocessReformattingAspect.getInstance(context.getProject()).doPostponedFormatting(context.getFile().getViewProvider());
- final Editor editor = context.getEditor();
- final int offset = context.getTailOffset();
- editor.getDocument().insertString(offset, " {}");
- editor.getCaretModel().moveToOffset(offset + 2);
- context.setLaterRunnable(generateAnonymousBody(editor, context.getFile()));
- }
- else {
- FeatureUsageTracker.getInstance().triggerFeatureUsed("editing.completion.smarttype.afternew");
- }
+ final Editor editor = context.getEditor();
+ final int offset = context.getTailOffset();
+ editor.getDocument().insertString(offset, " {}");
+ editor.getCaretModel().moveToOffset(offset + 2);
+ context.setLaterRunnable(generateAnonymousBody(editor, context.getFile()));
+ }
+ else {
+ FeatureUsageTracker.getInstance().triggerFeatureUsed("editing.completion.smarttype.afternew");
}
}
}
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.util.IncorrectOperationException;
import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
public class DefaultInsertHandler extends TemplateInsertHandler implements Cloneable {
private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.completion.DefaultInsertHandler");
- protected InsertionContext myContext;
- private LookupItem<?> myLookupItem;
-
- private Project myProject;
- private PsiFile myFile;
- private Editor myEditor;
- protected Document myDocument;
- private InsertHandlerState myState;
public static final DefaultInsertHandler NO_TAIL_HANDLER = new DefaultInsertHandler(){
@Override
- protected TailType getTailType(char completionChar) {
+ protected TailType getTailType(char completionChar, LookupItem item) {
return TailType.NONE;
}
};
private void handleInsertInner(InsertionContext context, LookupItem item, final char completionChar) {
LOG.assertTrue(CommandProcessor.getInstance().getCurrentCommand() != null);
- PsiDocumentManager.getInstance(context.getProject()).commitDocument(context.getEditor().getDocument());
- myContext = context;
- myLookupItem = item;
+ final Project project = context.getProject();
+ final Editor editor = context.getEditor();
+ final Document document = editor.getDocument();
+ PsiDocumentManager.getInstance(project).commitDocument(document);
- myProject = myContext.getProject();
- myFile = myContext.getFile();
- myEditor = myContext.getEditor();
- myDocument = myEditor.getDocument();
+ final PsiFile file = context.getFile();
- TailType tailType = getTailType(completionChar);
+ TailType tailType = getTailType(completionChar, item);
- myState = new InsertHandlerState(myContext.getSelectionEndOffset(), myContext.getSelectionEndOffset());
+ InsertHandlerState state = new InsertHandlerState(context.getSelectionEndOffset(), context.getSelectionEndOffset());
- final boolean needLeftParenth = isToInsertParenth();
- final boolean hasParams = needLeftParenth && hasParams();
+ final boolean needLeftParenth = isToInsertParenth(context, item);
+ final boolean hasParams = needLeftParenth && hasParams(context, item);
if (CompletionUtil.isOverwrite(item, completionChar)) {
- removeEndOfIdentifier(needLeftParenth && hasParams);
+ removeEndOfIdentifier(needLeftParenth && hasParams, context);
}
- else if(myContext.getOffsetMap().getOffset(CompletionInitializationContext.IDENTIFIER_END_OFFSET) != myContext.getSelectionEndOffset()) {
+ else if(context.getOffsetMap().getOffset(CompletionInitializationContext.IDENTIFIER_END_OFFSET) != context.getSelectionEndOffset()) {
JavaCompletionUtil.resetParensInfo(context.getOffsetMap());
}
- handleParenses(hasParams, needLeftParenth, tailType);
- handleBrackets();
+ handleParentheses(hasParams, needLeftParenth, tailType, context, state);
+ handleBrackets(item, document, state);
- if (myLookupItem.getObject() instanceof PsiVariable) {
- if (completionChar == '!' && PsiType.BOOLEAN.isAssignableFrom(((PsiVariable) myLookupItem.getObject()).getType())) {
- PsiDocumentManager.getInstance(myProject).commitDocument(myDocument);
+ if (item.getObject() instanceof PsiVariable) {
+ if (completionChar == '!' && PsiType.BOOLEAN.isAssignableFrom(((PsiVariable) item.getObject()).getType())) {
+ PsiDocumentManager.getInstance(project).commitDocument(document);
final PsiReferenceExpression ref =
- PsiTreeUtil.findElementOfClassAtOffset(myFile, myState.tailOffset - 1, PsiReferenceExpression.class, false);
+ PsiTreeUtil.findElementOfClassAtOffset(file, state.tailOffset - 1, PsiReferenceExpression.class, false);
if (ref != null) {
FeatureUsageTracker.getInstance().triggerFeatureUsed(CodeCompletionFeatures.EXCLAMATION_FINISH);
- myDocument.insertString(ref.getTextRange().getStartOffset(), "!");
- myState.caretOffset++;
- myState.tailOffset++;
+ document.insertString(ref.getTextRange().getStartOffset(), "!");
+ state.caretOffset++;
+ state.tailOffset++;
}
}
}
- myContext.setTailOffset(myState.tailOffset);
- myState.caretOffset = processTail(tailType, myState.caretOffset, myState.tailOffset);
- myEditor.getSelectionModel().removeSelection();
+ context.setTailOffset(state.tailOffset);
+ state.caretOffset = processTail(tailType, state.caretOffset, state.tailOffset, editor);
+ editor.getSelectionModel().removeSelection();
- qualifyIfNeeded();
+ qualifyIfNeeded(context, item);
if (needLeftParenth && hasParams){
// Invoke parameters popup
- AutoPopupController.getInstance(myProject).autoPopupParameterInfo(myEditor, null);
+ AutoPopupController.getInstance(project).autoPopupParameterInfo(editor, null);
}
if (tailType == TailType.DOT){
- AutoPopupController.getInstance(myProject).autoPopupMemberLookup(myEditor, null);
+ AutoPopupController.getInstance(project).autoPopupMemberLookup(editor, null);
}
if (completionChar == '#') {
context.setLaterRunnable(new Runnable() {
public void run() {
- new CodeCompletionHandlerBase(CompletionType.BASIC) {
- }.invoke(myProject, myEditor, myFile);
+ new CodeCompletionHandlerBase(CompletionType.BASIC).invoke(project, editor, file);
}
});
}
- if (insertingAnnotation()) {
+ if (insertingAnnotation(context, item)) {
// Check if someone inserts annotation class that require @
- PsiElement elementAt = myFile.findElementAt(myContext.getStartOffset());
+ PsiElement elementAt = file.findElementAt(context.getStartOffset());
final PsiElement parentElement = elementAt != null ? elementAt.getParent():null;
if (elementAt instanceof PsiIdentifier &&
(PsiTreeUtil.getParentOfType(elementAt, PsiAnnotationParameterList.class) != null ||
parentElement instanceof PsiErrorElement && parentElement.getParent() instanceof PsiJavaFile // top level annotation without @
)
- && isAtTokenNeeded()) {
+ && isAtTokenNeeded(context)) {
int expectedOffsetForAtToken = elementAt.getTextRange().getStartOffset();
- myDocument.insertString(expectedOffsetForAtToken, "@");
+ document.insertString(expectedOffsetForAtToken, "@");
}
}
}
- private void qualifyIfNeeded() {
+ private static void qualifyIfNeeded(InsertionContext context, LookupElement item) {
try{
- if (myLookupItem.getObject() instanceof PsiField) {
- PsiDocumentManager.getInstance(myFile.getProject()).commitAllDocuments();
- PsiReference reference = myFile.findReferenceAt(myContext.getStartOffset());
+ final PsiFile file = context.getFile();
+ if (item.getObject() instanceof PsiField) {
+ PsiDocumentManager.getInstance(file.getProject()).commitAllDocuments();
+ PsiReference reference = file.findReferenceAt(context.getStartOffset());
if (reference instanceof PsiReferenceExpression && !((PsiReferenceExpression) reference).isQualified()) {
- final PsiField member = (PsiField)myLookupItem.getObject();
+ final PsiField member = (PsiField)item.getObject();
final PsiVariable target =
- JavaPsiFacade.getInstance(myProject).getResolveHelper().resolveReferencedVariable(member.getName(), (PsiElement)reference);
+ JavaPsiFacade.getInstance(context.getProject()).getResolveHelper().resolveReferencedVariable(member.getName(), (PsiElement)reference);
if (member.getManager().areElementsEquivalent(target, JavaCompletionUtil.getOriginalElement(member))) return;
final PsiClass psiClass = member.getContainingClass();
if (psiClass != null && StringUtil.isNotEmpty(psiClass.getName())) {
- myDocument.insertString(myContext.getStartOffset(), psiClass.getName() + ".");
+ context.getEditor().getDocument().insertString(context.getStartOffset(), psiClass.getName() + ".");
}
}
}
- addImportForItem(myFile, myContext.getStartOffset(), myLookupItem);
- if (myContext.getTailOffset() < 0) { //hack, hack, hack. ideally the tail offset just should survive after the importing stuff
- myContext.setTailOffset(myEditor.getCaretModel().getOffset());
+ addImportForItem(file, context.getStartOffset(), item);
+ if (context.getTailOffset() < 0) { //hack, hack, hack. ideally the tail offset just should survive after the importing stuff
+ context.setTailOffset(context.getEditor().getCaretModel().getOffset());
}
}
catch(IncorrectOperationException e){
}
}
- private boolean isAtTokenNeeded() {
+ private static boolean isAtTokenNeeded(InsertionContext myContext) {
HighlighterIterator iterator = ((EditorEx)myContext.getEditor()).getHighlighter().createIterator(myContext.getStartOffset());
LOG.assertTrue(iterator.getTokenType() == JavaTokenType.IDENTIFIER);
iterator.retreat();
return iterator.getTokenType() != JavaTokenType.AT && iterator.getTokenType() != JavaTokenType.DOT;
}
- private void handleBrackets(){
+ private static void handleBrackets(LookupElement item, Document document, InsertHandlerState myState){
// brackets
- final Integer bracketsAttr = (Integer)myLookupItem.getUserData(LookupItem.BRACKETS_COUNT_ATTR);
+ final Integer bracketsAttr = (Integer)item.getUserData(LookupItem.BRACKETS_COUNT_ATTR);
if (bracketsAttr != null){
int count = bracketsAttr.intValue();
if(count > 0)
myState.caretOffset = myState.tailOffset + 1;
for(int i = 0; i < count; i++){
- myDocument.insertString(myState.tailOffset, "[]");
+ document.insertString(myState.tailOffset, "[]");
myState.tailOffset += 2;
}
}
}
- private void handleParenses(final boolean hasParams, final boolean needParenth, TailType tailType){
+ private static void handleParentheses(final boolean hasParams, final boolean needParenth, TailType tailType, InsertionContext context, InsertHandlerState myState){
+ final Document document = context.getEditor().getDocument();
boolean insertRightParenth = tailType != TailType.SMART_COMPLETION;
if (needParenth){
- if (myContext.getOffsetMap().getOffset(JavaCompletionUtil.LPAREN_OFFSET) >= 0 && myContext.getOffsetMap().getOffset(JavaCompletionUtil.ARG_LIST_END_OFFSET) >= 0){
- myState.tailOffset = myContext.getOffsetMap().getOffset(JavaCompletionUtil.ARG_LIST_END_OFFSET);
- if (myContext.getOffsetMap().getOffset(JavaCompletionUtil.RPAREN_OFFSET) < 0 && insertRightParenth){
- myDocument.insertString(myState.tailOffset, ")");
+ if (context.getOffsetMap().getOffset(JavaCompletionUtil.LPAREN_OFFSET) >= 0 && context.getOffsetMap().getOffset(JavaCompletionUtil.ARG_LIST_END_OFFSET) >= 0){
+ myState.tailOffset = context.getOffsetMap().getOffset(JavaCompletionUtil.ARG_LIST_END_OFFSET);
+ if (context.getOffsetMap().getOffset(JavaCompletionUtil.RPAREN_OFFSET) < 0 && insertRightParenth){
+ document.insertString(myState.tailOffset, ")");
myState.tailOffset += 1;
}
if (hasParams){
- myState.caretOffset = myContext.getOffsetMap().getOffset(JavaCompletionUtil.LPAREN_OFFSET) + 1;
+ myState.caretOffset = context.getOffsetMap().getOffset(JavaCompletionUtil.LPAREN_OFFSET) + 1;
}
else{
- myState.caretOffset = myContext.getOffsetMap().getOffset(JavaCompletionUtil.ARG_LIST_END_OFFSET);
+ myState.caretOffset = context.getOffsetMap().getOffset(JavaCompletionUtil.ARG_LIST_END_OFFSET);
}
}
else{
- final CodeStyleSettings styleSettings = CodeStyleSettingsManager.getSettings(myProject);
- myState.tailOffset = myContext.getSelectionEndOffset();
- myState.caretOffset = myContext.getSelectionEndOffset();
+ final CodeStyleSettings styleSettings = CodeStyleSettingsManager.getSettings(context.getProject());
+ myState.tailOffset = context.getSelectionEndOffset();
+ myState.caretOffset = context.getSelectionEndOffset();
if(styleSettings.SPACE_BEFORE_METHOD_CALL_PARENTHESES){
- myDocument.insertString(myState.tailOffset++, " ");
+ document.insertString(myState.tailOffset++, " ");
myState.caretOffset ++;
}
if (insertRightParenth) {
- final CharSequence charsSequence = myDocument.getCharsSequence();
+ final CharSequence charsSequence = document.getCharsSequence();
if (charsSequence.length() <= myState.tailOffset || charsSequence.charAt(myState.tailOffset) != '(') {
- myDocument.insertString(myState.tailOffset, "(");
+ document.insertString(myState.tailOffset, "(");
}
- myDocument.insertString(myState.tailOffset + 1, ")");
+ document.insertString(myState.tailOffset + 1, ")");
if (hasParams){
myState.tailOffset += 2;
myState.caretOffset++;
}
}
else{
- myDocument.insertString(myState.tailOffset++, "(");
+ document.insertString(myState.tailOffset++, "(");
myState.caretOffset ++;
}
if(hasParams && styleSettings.SPACE_WITHIN_METHOD_CALL_PARENTHESES){
- myDocument.insertString(myState.caretOffset++, " ");
+ document.insertString(myState.caretOffset++, " ");
myState.tailOffset++;
}
}
}
}
- protected boolean isToInsertParenth(){
- return insertingAnnotationWithParameters();
+ protected static boolean isToInsertParenth(InsertionContext context, LookupElement item){
+ return insertingAnnotationWithParameters(context, item);
}
- private boolean hasParams(){
- final String lookupString = myLookupItem.getLookupString();
+ private static boolean hasParams(InsertionContext context, LookupElement item){
+ final String lookupString = item.getLookupString();
if (PsiKeyword.SYNCHRONIZED.equals(lookupString)) {
- final PsiElement place = myFile.findElementAt(myContext.getStartOffset());
+ final PsiElement place = context.getFile().findElementAt(context.getStartOffset());
return PsiTreeUtil.getParentOfType(place, PsiMember.class, PsiCodeBlock.class) instanceof PsiCodeBlock;
}
else if(PsiKeyword.CATCH.equals(lookupString) ||
PsiKeyword.WHILE.equals(lookupString) ||
PsiKeyword.FOR.equals(lookupString))
return true;
- else if (insertingAnnotationWithParameters()) {
+ else if (insertingAnnotationWithParameters(context, item)) {
return true;
}
return false;
}
- private boolean insertingAnnotationWithParameters() {
- if(insertingAnnotation()) {
- final Document document = myContext.getEditor().getDocument();
- PsiDocumentManager.getInstance(myContext.getProject()).commitDocument(document);
- PsiElement elementAt = myFile.findElementAt(myContext.getStartOffset());
+ private static boolean insertingAnnotationWithParameters(InsertionContext context, LookupElement item) {
+ if(insertingAnnotation(context, item)) {
+ final Document document = context.getEditor().getDocument();
+ PsiDocumentManager.getInstance(context.getProject()).commitDocument(document);
+ PsiElement elementAt = context.getFile().findElementAt(context.getStartOffset());
if (elementAt instanceof PsiIdentifier) {
final PsiModifierListOwner parent = PsiTreeUtil.getParentOfType(elementAt, PsiModifierListOwner.class, false, PsiCodeBlock.class);
if (parent != null) {
- for (PsiMethod m : ((PsiClass)myLookupItem.getObject()).getMethods()) {
+ for (PsiMethod m : ((PsiClass)item.getObject()).getMethods()) {
if (!(m instanceof PsiAnnotationMethod)) continue;
final PsiAnnotationMemberValue defaultValue = ((PsiAnnotationMethod)m).getDefaultValue();
if (defaultValue == null) return true;
return false;
}
- private boolean insertingAnnotation() {
- final Object obj = myLookupItem.getObject();
+ private static boolean insertingAnnotation(InsertionContext context, LookupElement item) {
+ final Object obj = item.getObject();
if (!(obj instanceof PsiClass) || !((PsiClass)obj).isAnnotationType()) return false;
- final Document document = myEditor.getDocument();
- PsiDocumentManager.getInstance(myFile.getProject()).commitDocument(document);
- final int offset = myContext.getStartOffset();
+ final Document document = context.getEditor().getDocument();
+ PsiDocumentManager.getInstance(context.getProject()).commitDocument(document);
+ final int offset = context.getStartOffset();
- if (PsiTreeUtil.findElementOfClassAtOffset(myFile, offset, PsiImportStatement.class, false) != null) return false;
+ final PsiFile file = context.getFile();
+
+ if (PsiTreeUtil.findElementOfClassAtOffset(file, offset, PsiImportStatement.class, false) != null) return false;
//outside of any class: we are surely inserting an annotation
- if (PsiTreeUtil.findElementOfClassAtOffset(myFile, offset, PsiClass.class, false) == null) return true;
+ if (PsiTreeUtil.findElementOfClassAtOffset(file, offset, PsiClass.class, false) == null) return true;
//the easiest check that there's a @ before the identifier
- return PsiTreeUtil.findElementOfClassAtOffset(myFile, offset, PsiAnnotation.class, false) != null;
+ return PsiTreeUtil.findElementOfClassAtOffset(file, offset, PsiAnnotation.class, false) != null;
}
- protected void removeEndOfIdentifier(boolean needParenth){
- JavaCompletionUtil.initOffsets(myContext.getFile(), myContext.getProject(), myContext.getOffsetMap());
- myDocument.deleteString(myContext.getSelectionEndOffset(), myContext.getOffsetMap().getOffset(CompletionInitializationContext.IDENTIFIER_END_OFFSET));
- if(myContext.getOffsetMap().getOffset(JavaCompletionUtil.LPAREN_OFFSET) > 0 && !needParenth){
- myDocument.deleteString(myContext.getOffsetMap().getOffset(JavaCompletionUtil.LPAREN_OFFSET),
- myContext.getOffsetMap().getOffset(JavaCompletionUtil.ARG_LIST_END_OFFSET));
- JavaCompletionUtil.resetParensInfo(myContext.getOffsetMap());
+ protected static void removeEndOfIdentifier(boolean needParenth, InsertionContext context){
+ final Document document = context.getEditor().getDocument();
+ JavaCompletionUtil.initOffsets(context.getFile(), context.getProject(), context.getOffsetMap());
+ document.deleteString(context.getSelectionEndOffset(), context.getOffsetMap().getOffset(CompletionInitializationContext.IDENTIFIER_END_OFFSET));
+ if(context.getOffsetMap().getOffset(JavaCompletionUtil.LPAREN_OFFSET) > 0 && !needParenth){
+ document.deleteString(context.getOffsetMap().getOffset(JavaCompletionUtil.LPAREN_OFFSET),
+ context.getOffsetMap().getOffset(JavaCompletionUtil.ARG_LIST_END_OFFSET));
+ JavaCompletionUtil.resetParensInfo(context.getOffsetMap());
}
}
- protected TailType getTailType(final char completionChar){
+ protected TailType getTailType(final char completionChar, LookupItem item){
switch(completionChar){
case '.': return TailType.DOT;
case ',': return TailType.COMMA;
case '\"':
case '[': return TailType.createSimpleTailType(completionChar);
}
- final TailType attr = myLookupItem.getTailType();
+ final TailType attr = item.getTailType();
return attr == TailType.UNKNOWN ? TailType.NONE : attr;
}
- private int processTail(TailType tailType, int caretOffset, int tailOffset) {
- myEditor.getCaretModel().moveToOffset(caretOffset);
- tailType.processTail(myEditor, tailOffset);
- return myEditor.getCaretModel().getOffset();
+ private static int processTail(TailType tailType, int caretOffset, int tailOffset, Editor editor) {
+ editor.getCaretModel().moveToOffset(caretOffset);
+ tailType.processTail(editor, tailOffset);
+ return editor.getCaretModel().getOffset();
}
@Override
private static void shortenReference(final PsiFile file, final int offset) throws IncorrectOperationException {
final PsiDocumentManager manager = PsiDocumentManager.getInstance(file.getProject());
final Document document = manager.getDocument(file);
+ assert document != null;
manager.commitDocument(document);
final PsiReference ref = file.findReferenceAt(offset);
if (ref instanceof PsiJavaCodeReferenceElement) {
return toDelete;
}
+ @Nullable
static PsiElement resolveReference(final PsiReference psiReference) {
if (psiReference instanceof PsiPolyVariantReference) {
final ResolveResult[] results = ((PsiPolyVariantReference)psiReference).multiResolve(true);
*/
package com.intellij.codeInsight.daemon.impl.actions;
-import com.intellij.codeInsight.CodeInsightUtilBase;
-import com.intellij.codeInsight.daemon.DaemonCodeAnalyzer;
-import com.intellij.codeInsight.daemon.HighlightDisplayKey;
+import com.intellij.codeInsight.*;
+import com.intellij.codeInsight.daemon.*;
import com.intellij.codeInspection.*;
-import com.intellij.lang.java.JavaLanguage;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.module.Module;
-import com.intellij.openapi.module.ModuleUtil;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.impl.storage.ClasspathStorage;
-import com.intellij.openapi.ui.Messages;
+import com.intellij.lang.java.*;
+import com.intellij.openapi.application.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.module.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.roots.impl.storage.*;
+import com.intellij.openapi.ui.*;
import com.intellij.psi.*;
-import com.intellij.psi.codeStyle.JavaCodeStyleManager;
-import com.intellij.psi.impl.source.jsp.jspJava.JspHolderMethod;
-import com.intellij.psi.javadoc.PsiDocComment;
-import com.intellij.psi.javadoc.PsiDocTag;
-import com.intellij.psi.javadoc.PsiDocTagValue;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.util.IncorrectOperationException;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.psi.codeStyle.*;
+import com.intellij.psi.impl.source.jsp.jspJava.*;
+import com.intellij.psi.javadoc.*;
+import com.intellij.psi.util.*;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
/**
* @author ven
return InspectionsBundle.message("suppress.inspection.family");
}
- public boolean isAvailable(@NotNull final Project project, final Editor editor, @Nullable final PsiElement context) {
+ public boolean isAvailable(@NotNull final Project project, final Editor editor, @NotNull final PsiElement context) {
PsiDocCommentOwner container = getContainer(context);
boolean isValid = container != null && !(container instanceof JspHolderMethod);
if (!isValid) {
*/
package com.intellij.codeInsight.daemon.impl.quickfix;
-import com.intellij.codeInsight.CodeInsightUtilBase;
-import com.intellij.codeInsight.daemon.QuickFixBundle;
-import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction;
-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.project.Project;
+import com.intellij.codeInsight.*;
+import com.intellij.codeInsight.daemon.*;
+import com.intellij.codeInsight.intention.*;
+import com.intellij.openapi.diagnostic.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.project.*;
import com.intellij.psi.*;
import com.intellij.psi.controlFlow.*;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.util.IncorrectOperationException;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.annotations.NotNull;
+import com.intellij.psi.util.*;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
/**
* @author ven
return QuickFixBundle.message("remove.redundant.else.fix");
}
- public boolean isAvailable(@NotNull Project project, Editor editor, @Nullable PsiElement element) {
+ public boolean isAvailable(@NotNull Project project, Editor editor, @NotNull PsiElement element) {
if (element instanceof PsiKeyword &&
element.getParent() instanceof PsiIfStatement &&
PsiKeyword.ELSE.equals(element.getText())) {
*/
package com.intellij.codeInsight.daemon.impl.quickfix;
-import com.intellij.codeInsight.CodeInsightUtilBase;
-import com.intellij.codeInsight.TargetElementUtil;
-import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.project.Project;
+import com.intellij.codeInsight.*;
+import com.intellij.codeInsight.intention.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.project.*;
import com.intellij.psi.*;
-import com.intellij.psi.codeStyle.JavaCodeStyleManager;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.psi.util.PsiUtil;
-import com.intellij.psi.util.TypeConversionUtil;
-import com.intellij.util.ArrayUtil;
-import com.intellij.util.IncorrectOperationException;
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.psi.codeStyle.*;
+import com.intellij.psi.util.*;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
-import java.util.Collection;
+import java.util.*;
public class SurroundWithArrayFix extends PsiElementBaseIntentionAction {
private final PsiCall myMethodCall;
return getText();
}
- public boolean isAvailable(@NotNull final Project project, final Editor editor, @Nullable final PsiElement element) {
+ public boolean isAvailable(@NotNull final Project project, final Editor editor, @NotNull final PsiElement element) {
return getExpression(element) != null;
}
*/
package com.intellij.codeInsight.intention.impl;
-import com.intellij.codeInsight.intention.AddAnnotationFix;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.project.Project;
+import com.intellij.codeInsight.intention.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.project.*;
import com.intellij.psi.*;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.*;
public class AddDeprecationAnnotationFix extends AddAnnotationFix {
public AddDeprecationAnnotationFix() {
@Override
- public boolean isAvailable(@NotNull final Project project, final Editor editor, @Nullable final PsiElement element) {
+ public boolean isAvailable(@NotNull final Project project, final Editor editor, @NotNull final PsiElement element) {
if (!super.isAvailable(project, editor, element)) {
return false;
}
*/
package com.intellij.codeInsight.intention.impl;
-import com.intellij.codeInsight.AnnotationUtil;
-import com.intellij.codeInsight.intention.AddAnnotationFix;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.project.Project;
+import com.intellij.codeInsight.*;
+import com.intellij.codeInsight.intention.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.project.*;
import com.intellij.psi.*;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.*;
public class AddNullableNotNullAnnotationFix extends AddAnnotationFix {
public AddNullableNotNullAnnotationFix(final String annotation, final String annotationToRemove) {
}
@Override
- public boolean isAvailable(@NotNull final Project project, final Editor editor, @Nullable final PsiElement element) {
+ public boolean isAvailable(@NotNull final Project project, final Editor editor, @NotNull final PsiElement element) {
if (!super.isAvailable(project, editor, element)) {
return false;
}
*/
package com.intellij.codeInsight.intention.impl;
-import com.intellij.codeInsight.CodeInsightBundle;
-import com.intellij.codeInsight.CodeInsightUtilBase;
-import com.intellij.codeInsight.highlighting.HighlightManager;
-import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction;
-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.editor.colors.EditorColors;
-import com.intellij.openapi.editor.colors.EditorColorsManager;
-import com.intellij.openapi.project.Project;
+import com.intellij.codeInsight.*;
+import com.intellij.codeInsight.highlighting.*;
+import com.intellij.codeInsight.intention.*;
+import com.intellij.openapi.diagnostic.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.editor.colors.*;
+import com.intellij.openapi.project.*;
import com.intellij.psi.*;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.psi.util.PsiUtil;
-import com.intellij.util.IncorrectOperationException;
-import gnu.trove.TIntArrayList;
-import gnu.trove.TIntProcedure;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.psi.util.*;
+import com.intellij.util.*;
+import gnu.trove.*;
+import org.jetbrains.annotations.*;
/**
* @author ven
return CodeInsightBundle.message("intention.add.on.demand.static.import.family");
}
- public boolean isAvailable(@NotNull Project project, Editor editor, @Nullable PsiElement element) {
- if (element == null || !PsiUtil.isLanguageLevel5OrHigher(element)) return false;
+ public boolean isAvailable(@NotNull Project project, Editor editor, @NotNull PsiElement element) {
+ if (!PsiUtil.isLanguageLevel5OrHigher(element)) return false;
if (!(element instanceof PsiIdentifier) || !(element.getParent() instanceof PsiReferenceExpression)) {
return false;
}
*/
package com.intellij.codeInsight.intention.impl;
-import com.intellij.codeInsight.CodeInsightBundle;
-import com.intellij.codeInsight.CodeInsightUtilBase;
-import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction;
-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Key;
+import com.intellij.codeInsight.*;
+import com.intellij.codeInsight.intention.*;
+import com.intellij.openapi.diagnostic.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.util.*;
import com.intellij.psi.*;
-import com.intellij.psi.impl.source.tree.java.PsiReferenceExpressionImpl;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.psi.util.PsiUtil;
-import com.intellij.util.IncorrectOperationException;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.psi.impl.source.tree.java.*;
+import com.intellij.psi.util.*;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
public class AddSingleMemberStaticImportAction extends PsiElementBaseIntentionAction {
private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.intention.impl.AddSingleMemberStaticImportAction");
return CodeInsightBundle.message("intention.add.single.member.static.import.family");
}
- public boolean isAvailable(@NotNull Project project, Editor editor, @Nullable PsiElement element) {
- if (element == null || !PsiUtil.isLanguageLevel5OrHigher(element)) return false;
+ public boolean isAvailable(@NotNull Project project, Editor editor, @NotNull PsiElement element) {
+ if (!PsiUtil.isLanguageLevel5OrHigher(element)) return false;
PsiFile file = element.getContainingFile();
if (element instanceof PsiIdentifier && element.getParent() instanceof PsiReferenceExpression &&
((PsiReferenceExpression)element.getParent()).getQualifierExpression() != null) {
*/
package com.intellij.codeInsight.intention.impl;
-import com.intellij.codeInsight.CodeInsightBundle;
-import com.intellij.codeInsight.CodeInsightUtilBase;
-import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.project.Project;
-import com.intellij.patterns.PlatformPatterns;
+import com.intellij.codeInsight.*;
+import com.intellij.codeInsight.intention.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.project.*;
+import com.intellij.patterns.*;
import com.intellij.psi.*;
-import com.intellij.psi.codeStyle.CodeStyleManager;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.ui.ColorChooser;
-import com.intellij.util.IncorrectOperationException;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.psi.codeStyle.*;
+import com.intellij.psi.util.*;
+import com.intellij.ui.*;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
import java.awt.*;
public class ColorChooserIntentionAction extends PsiElementBaseIntentionAction {
- public boolean isAvailable(@NotNull final Project project, final Editor editor, @Nullable final PsiElement element) {
+ public boolean isAvailable(@NotNull final Project project, final Editor editor, @NotNull final PsiElement element) {
if (PlatformPatterns.psiElement().inside(PlatformPatterns.psiElement(PsiNewExpression.class)).accepts(element)) {
final PsiNewExpression expression = PsiTreeUtil.getParentOfType(element, PsiNewExpression.class, false);
if (expression != null) {
*/
package com.intellij.codeInsight.intention.impl;
-import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.project.Project;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiFile;
-import com.intellij.psi.PsiReference;
-import com.intellij.psi.impl.source.resolve.reference.impl.PsiMultiReference;
-import com.intellij.psi.impl.source.resolve.reference.impl.providers.FileReference;
-import com.intellij.psi.impl.source.resolve.reference.impl.providers.FileReferenceOwner;
-import com.intellij.psi.impl.source.resolve.reference.impl.providers.FileReferenceSet;
-import com.intellij.util.IncorrectOperationException;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.codeInsight.intention.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.project.*;
+import com.intellij.psi.*;
+import com.intellij.psi.impl.source.resolve.reference.impl.*;
+import com.intellij.psi.impl.source.resolve.reference.impl.providers.*;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
/**
* @author spleaner
}
@Override
- public boolean isAvailable(@NotNull Project project, Editor editor, @Nullable PsiElement element) {
- if (element == null) return false;
+ public boolean isAvailable(@NotNull Project project, Editor editor, @NotNull PsiElement element) {
final PsiFile containingFile = element.getContainingFile();
if (containingFile == null) return false;
*/
package com.intellij.codeInsight.intention.impl;
-import com.intellij.codeInsight.CodeInsightBundle;
-import com.intellij.codeInsight.CodeInsightUtil;
-import com.intellij.codeInsight.daemon.impl.analysis.HighlightNamesUtil;
-import com.intellij.codeInsight.daemon.impl.quickfix.CreateClassKind;
-import com.intellij.codeInsight.generation.OverrideImplementUtil;
-import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.fileEditor.ex.IdeDocumentHistory;
-import com.intellij.openapi.module.ModuleUtil;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.ui.Messages;
-import com.intellij.openapi.util.TextRange;
+import com.intellij.codeInsight.*;
+import com.intellij.codeInsight.daemon.impl.analysis.*;
+import com.intellij.codeInsight.daemon.impl.quickfix.*;
+import com.intellij.codeInsight.generation.*;
+import com.intellij.codeInsight.intention.*;
+import com.intellij.openapi.application.*;
+import com.intellij.openapi.diagnostic.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.fileEditor.ex.*;
+import com.intellij.openapi.module.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.ui.*;
+import com.intellij.openapi.util.*;
import com.intellij.psi.*;
-import com.intellij.psi.impl.source.PostprocessReformattingAspect;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.util.IncorrectOperationException;
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.psi.impl.source.*;
+import com.intellij.psi.util.*;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
public class CreateSubclassAction extends PsiElementBaseIntentionAction {
private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.intention.impl.ImplementAbstractClassAction");
return CodeInsightBundle.message("intention.implement.abstract.class.family");
}
- public boolean isAvailable(@NotNull Project project, Editor editor, @Nullable PsiElement element) {
- if (element == null) return false;
+ public boolean isAvailable(@NotNull Project project, Editor editor, @NotNull PsiElement element) {
PsiClass psiClass = PsiTreeUtil.getParentOfType(element, PsiClass.class);
if (psiClass == null || psiClass.isAnnotationType() || psiClass.isEnum() || psiClass instanceof PsiAnonymousClass ||
psiClass.hasModifierProperty(PsiModifier.FINAL)) {
*/
package com.intellij.codeInsight.intention.impl;
-import com.intellij.codeInsight.CodeInsightBundle;
-import com.intellij.codeInsight.CodeInsightServicesUtil;
-import com.intellij.codeInsight.CodeInsightUtilBase;
-import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction;
-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.TextRange;
+import com.intellij.codeInsight.*;
+import com.intellij.codeInsight.intention.*;
+import com.intellij.openapi.diagnostic.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.util.*;
import com.intellij.psi.*;
-import com.intellij.psi.codeStyle.CodeStyleManager;
+import com.intellij.psi.codeStyle.*;
import com.intellij.psi.controlFlow.*;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.util.IncorrectOperationException;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.psi.util.*;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
-import java.util.List;
+import java.util.*;
public class InvertIfConditionAction extends PsiElementBaseIntentionAction {
private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.intention.impl.InvertIfConditionAction");
- public boolean isAvailable(@NotNull Project project, Editor editor, @Nullable PsiElement element) {
- if (element == null) return false;
+ public boolean isAvailable(@NotNull Project project, Editor editor, @NotNull PsiElement element) {
int offset = editor.getCaretModel().getOffset();
final PsiIfStatement ifStatement = PsiTreeUtil.getParentOfType(element, PsiIfStatement.class);
*/
package com.intellij.codeInsight.intention.impl;
-import com.intellij.codeInsight.CodeInsightBundle;
-import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction;
-import com.intellij.openapi.editor.CaretModel;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Pair;
-import com.intellij.pom.java.LanguageLevel;
+import com.intellij.codeInsight.*;
+import com.intellij.codeInsight.intention.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.util.*;
import com.intellij.psi.*;
-import com.intellij.psi.util.PsiUtil;
-import com.intellij.psi.util.TypeConversionUtil;
-import com.intellij.util.IncorrectOperationException;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.psi.util.*;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
/**
* @author dsl
return CodeInsightBundle.message("intention.make.type.generic.text", variableName, newTypeName);
}
- public boolean isAvailable(@NotNull Project project, Editor editor, @Nullable PsiElement element) {
- if (element == null) return false;
+ public boolean isAvailable(@NotNull Project project, Editor editor, @NotNull PsiElement element) {
if (!PsiUtil.isLanguageLevel5OrHigher(element)) return false;
if (!element.isWritable()) return false;
return findVariable(element) != null;
*/
package com.intellij.codeInsight.intention.impl;
-import com.intellij.codeInsight.CodeInsightBundle;
-import com.intellij.codeInsight.CodeInsightUtilBase;
-import com.intellij.codeInsight.daemon.impl.analysis.HighlightControlFlowUtil;
-import com.intellij.codeInsight.daemon.impl.analysis.HighlightUtil;
-import com.intellij.codeInsight.daemon.impl.quickfix.CreateFromUsageUtils;
-import com.intellij.codeInsight.highlighting.HighlightManager;
-import com.intellij.codeInsight.intention.IntentionAction;
-import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction;
-import com.intellij.codeInsight.intention.QuickFixFactory;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.editor.colors.EditorColors;
-import com.intellij.openapi.editor.colors.EditorColorsManager;
-import com.intellij.openapi.editor.markup.TextAttributes;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Ref;
+import com.intellij.codeInsight.*;
+import com.intellij.codeInsight.daemon.impl.analysis.*;
+import com.intellij.codeInsight.daemon.impl.quickfix.*;
+import com.intellij.codeInsight.highlighting.*;
+import com.intellij.codeInsight.intention.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.editor.colors.*;
+import com.intellij.openapi.editor.markup.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.util.*;
import com.intellij.psi.*;
-import com.intellij.psi.impl.source.jsp.jspJava.JspClass;
-import com.intellij.psi.javadoc.PsiDocComment;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.util.IncorrectOperationException;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.psi.impl.source.jsp.jspJava.*;
+import com.intellij.psi.javadoc.*;
+import com.intellij.psi.util.*;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
import java.util.*;
return CodeInsightBundle.message("intention.move.initializer.to.constructor");
}
- public boolean isAvailable(@NotNull Project project, Editor editor, @Nullable PsiElement element) {
- if (element == null) return false;
+ public boolean isAvailable(@NotNull Project project, Editor editor, @NotNull PsiElement element) {
if (element instanceof PsiCompiledElement) return false;
final PsiField field = PsiTreeUtil.getParentOfType(element, PsiField.class, false, PsiMember.class, PsiCodeBlock.class, PsiDocComment.class);
if (field == null || field.hasModifierProperty(PsiModifier.STATIC)) return false;
*/
package com.intellij.codeInsight.intention.impl;
-import com.intellij.codeInsight.CodeInsightBundle;
-import com.intellij.codeInsight.CodeInsightUtilBase;
-import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.project.Project;
+import com.intellij.codeInsight.*;
+import com.intellij.codeInsight.intention.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.project.*;
import com.intellij.psi.*;
-import com.intellij.psi.codeStyle.CodeStyleManager;
-import com.intellij.psi.javadoc.PsiDocComment;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.util.IncorrectOperationException;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.psi.codeStyle.*;
+import com.intellij.psi.javadoc.*;
+import com.intellij.psi.util.*;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
/**
* @author max
return CodeInsightBundle.message("intention.split.declaration.family");
}
- public boolean isAvailable(@NotNull Project project, Editor editor, @Nullable PsiElement element) {
- if (element == null) return false;
+ public boolean isAvailable(@NotNull Project project, Editor editor, @NotNull PsiElement element) {
int offset = editor.getCaretModel().getOffset();
if (!(element instanceof PsiJavaToken)) return false;
*/
package com.intellij.codeInsight.intention.impl;
-import com.intellij.codeInsight.CodeInsightBundle;
-import com.intellij.codeInsight.CodeInsightUtilBase;
-import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction;
-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.editor.ScrollType;
-import com.intellij.openapi.project.Project;
+import com.intellij.codeInsight.*;
+import com.intellij.codeInsight.intention.*;
+import com.intellij.openapi.diagnostic.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.project.*;
import com.intellij.psi.*;
-import com.intellij.psi.codeStyle.CodeStyleManager;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.util.IncorrectOperationException;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.psi.codeStyle.*;
+import com.intellij.psi.util.*;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
/**
* @author mike
public class SplitIfAction extends PsiElementBaseIntentionAction {
private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.intention.impl.SplitIfAction");
- public boolean isAvailable(@NotNull Project project, Editor editor, @Nullable PsiElement element) {
- if (element == null) return false;
+ public boolean isAvailable(@NotNull Project project, Editor editor, @NotNull PsiElement element) {
if (!(element instanceof PsiJavaToken)) {
return false;
--- /dev/null
+/*
+ * Copyright 2000-2010 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * User: anna
+ * Date: 28-May-2010
+ */
+package com.intellij.psi.impl;
+
+import com.intellij.openapi.extensions.*;
+import com.intellij.psi.*;
+import org.jetbrains.annotations.*;
+
+public abstract class AllowedApiFilterExtension {
+ public static final ExtensionPointName<AllowedApiFilterExtension> EP_NAME = ExtensionPointName.create("com.intellij.allowedApiFilter");
+
+ public abstract boolean isClassForbidden(@NotNull String fqn, @NotNull PsiElement place);
+
+ public static boolean isClassAllowed(@NotNull String fqn, @NotNull PsiElement place) {
+ for (AllowedApiFilterExtension extension : Extensions.getExtensions(EP_NAME)) {
+ if (extension.isClassForbidden(fqn, place)) return false;
+ }
+ return true;
+ }
+}
CachedValue<Map<MethodSignature, HierarchicalMethodSignature>> value = aClass.getUserData(SIGNATURES_KEY);
if (value == null) {
BySignaturesCachedValueProvider provider = new BySignaturesCachedValueProvider(aClass);
- value = CachedValuesManager.getManager(aClass.getProject()).createCachedValue(provider, false);
- //Do not cache for nonphysical elements
- if (aClass.isPhysical()) {
- UserDataHolderEx dataHolder = (UserDataHolderEx)aClass;
- value = dataHolder.putUserDataIfAbsent(SIGNATURES_KEY, value);
- }
+ UserDataHolderEx dataHolder = (UserDataHolderEx)aClass;
+ value = dataHolder.putUserDataIfAbsent(SIGNATURES_KEY,
+ CachedValuesManager.getManager(aClass.getProject()).createCachedValue(provider, false));
}
return value.getValue();
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclaractionKind.CLASS)) {
NameHint nameHint = processor.getHint(NameHint.KEY);
if (nameHint != null) {
- if (processClassesByName(processor, state, place, scope, nameHint.getName(state))) return false;
+ final String shortName = nameHint.getName(state);
+ if (containsClassNamed(shortName) && processClassesByName(processor, state, place, scope, shortName)) return false;
}
else if (prefixMatcher != null && migration == null) {
for (String className : getClassNamesCache()) {
*/
package com.intellij.refactoring.extractInterface;
-import com.intellij.openapi.project.Project;
+import com.intellij.openapi.project.*;
import com.intellij.psi.*;
-import com.intellij.refactoring.HelpID;
-import com.intellij.refactoring.JavaRefactoringSettings;
-import com.intellij.refactoring.RefactoringBundle;
-import com.intellij.refactoring.classMembers.DelegatingMemberInfoModel;
-import com.intellij.refactoring.classMembers.MemberInfoBase;
-import com.intellij.refactoring.extractSuperclass.ExtractSuperBaseDialog;
-import com.intellij.refactoring.extractSuperclass.ExtractSuperBaseProcessor;
-import com.intellij.refactoring.ui.MemberSelectionPanel;
-import com.intellij.refactoring.util.DocCommentPolicy;
-import com.intellij.refactoring.util.classMembers.MemberInfo;
+import com.intellij.refactoring.*;
+import com.intellij.refactoring.classMembers.*;
+import com.intellij.refactoring.extractSuperclass.*;
+import com.intellij.refactoring.ui.*;
+import com.intellij.refactoring.util.*;
+import com.intellij.refactoring.util.classMembers.*;
import javax.swing.*;
import java.awt.*;
_panel = new JPanel(new BorderLayout());
myPackageLabel = new JLabel();
- myPackageLabel.setText(RefactoringBundle.message("package.for.new.interface"));
+ myPackageLabel.setText(getPackageNameLabelText());
_panel.add(myPackageLabel, BorderLayout.NORTH);
_panel.add(myPackageNameField, BorderLayout.CENTER);
return myInterfaceNameLabel;
}
+ @Override
+ protected String getPackageNameLabelText() {
+ return isExtractSuperclass() ? RefactoringBundle.message("package.for.new.interface") : "Package name for original class";
+ }
+
protected JLabel getPackageNameLabel() {
return myPackageLabel;
}
/*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2010 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*/
package com.intellij.refactoring.extractInterface;
-import com.intellij.openapi.project.Project;
+import com.intellij.openapi.project.*;
import com.intellij.psi.*;
-import com.intellij.refactoring.extractSuperclass.ExtractSuperBaseProcessor;
-import com.intellij.refactoring.util.DocCommentPolicy;
-import com.intellij.refactoring.util.classMembers.MemberInfo;
-import com.intellij.util.IncorrectOperationException;
+import com.intellij.refactoring.extractSuperclass.*;
+import com.intellij.refactoring.util.*;
+import com.intellij.refactoring.util.classMembers.*;
+import com.intellij.util.*;
/**
* @author dsl
}
protected PsiClass extractSuper(String superClassName) throws IncorrectOperationException {
- return ExtractInterfaceHandler.extractInterface(myTargetDirectory, myClass, superClassName, myMemberInfos, myJavaDocPolicy);
+ return ExtractInterfaceHandler.extractInterface(myClass.getContainingFile().getContainingDirectory(), myClass, superClassName, myMemberInfos, myJavaDocPolicy);
}
protected boolean isSuperInheritor(PsiClass aClass) {
*/
package com.intellij.refactoring.extractSuperclass;
-import com.intellij.ide.util.PackageUtil;
-import com.intellij.openapi.command.CommandProcessor;
-import com.intellij.openapi.help.HelpManager;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.ProjectFileIndex;
-import com.intellij.openapi.roots.ProjectRootManager;
-import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.ide.util.*;
+import com.intellij.openapi.command.*;
+import com.intellij.openapi.help.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.roots.*;
+import com.intellij.openapi.util.text.*;
+import com.intellij.openapi.vfs.*;
import com.intellij.psi.*;
-import com.intellij.refactoring.RefactoringBundle;
-import com.intellij.refactoring.ui.DocCommentPanel;
-import com.intellij.refactoring.ui.PackageNameReferenceEditorCombo;
-import com.intellij.refactoring.ui.RefactoringDialog;
-import com.intellij.refactoring.util.CommonRefactoringUtil;
-import com.intellij.refactoring.util.RefactoringMessageUtil;
-import com.intellij.refactoring.util.classMembers.MemberInfo;
-import com.intellij.ui.RecentsManager;
-import com.intellij.util.IncorrectOperationException;
+import com.intellij.refactoring.*;
+import com.intellij.refactoring.ui.*;
+import com.intellij.refactoring.util.*;
+import com.intellij.refactoring.util.classMembers.*;
+import com.intellij.ui.*;
+import com.intellij.util.*;
import javax.swing.*;
-import java.awt.event.ItemEvent;
-import java.awt.event.ItemListener;
-import java.util.List;
+import java.awt.event.*;
+import java.util.*;
/**
* @author dsl
protected void updateDialogForExtractSubclass() {
getClassNameLabel().setText(RefactoringBundle.message("extractSuper.rename.original.class.to"));
+ getPackageNameLabel().setText(getPackageNameLabelText());
getPreviewAction().setEnabled(true);
}
protected void updateDialogForExtractSuperclass() {
getClassNameLabel().setText(getClassNameLabelText());
+ getPackageNameLabel().setText(getPackageNameLabelText());
getPreviewAction().setEnabled(false);
}
protected abstract JLabel getPackageNameLabel();
+ protected abstract String getPackageNameLabelText();
+
protected abstract String getEntityName();
public int getJavaDocPolicy() {
/*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2010 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*/
package com.intellij.refactoring.extractSuperclass;
-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Comparing;
+import com.intellij.openapi.diagnostic.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.util.*;
import com.intellij.psi.*;
-import com.intellij.psi.codeStyle.JavaCodeStyleManager;
-import com.intellij.psi.search.GlobalSearchScope;
-import com.intellij.psi.search.searches.ReferencesSearch;
-import com.intellij.psi.util.InheritanceUtil;
-import com.intellij.psi.util.MethodSignatureUtil;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.refactoring.RefactoringBundle;
-import com.intellij.refactoring.turnRefsToSuper.TurnRefsToSuperProcessorBase;
-import com.intellij.refactoring.util.DocCommentPolicy;
-import com.intellij.refactoring.util.classMembers.MemberInfo;
-import com.intellij.usageView.UsageInfo;
-import com.intellij.usageView.UsageViewDescriptor;
-import com.intellij.usageView.UsageViewUtil;
-import com.intellij.util.IncorrectOperationException;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.ArrayList;
-import java.util.Collection;
+import com.intellij.psi.codeStyle.*;
+import com.intellij.psi.search.*;
+import com.intellij.psi.search.searches.*;
+import com.intellij.psi.util.*;
+import com.intellij.refactoring.*;
+import com.intellij.refactoring.turnRefsToSuper.*;
+import com.intellij.refactoring.util.*;
+import com.intellij.refactoring.util.classMembers.*;
+import com.intellij.usageView.*;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
/**
* @author dsl
final String oldQualifiedName = myClass.getQualifiedName();
myClass.setName(myNewClassName);
PsiClass superClass = extractSuper(superClassName);
+ final PsiDirectory initialDirectory = myClass.getContainingFile().getContainingDirectory();
+ if (myTargetDirectory != initialDirectory) {
+ myTargetDirectory.add(myClass.getContainingFile().copy());
+ myClass.getContainingFile().delete();
+ }
for (final UsageInfo usage : usages) {
if (usage instanceof BindToOldUsageInfo) {
final PsiReference reference = usage.getReference();
/*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2010 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*/
package com.intellij.refactoring.extractSuperclass;
-import com.intellij.openapi.project.Project;
+import com.intellij.openapi.project.*;
import com.intellij.psi.*;
-import com.intellij.refactoring.util.DocCommentPolicy;
-import com.intellij.refactoring.util.classMembers.MemberInfo;
-import com.intellij.util.IncorrectOperationException;
+import com.intellij.refactoring.util.*;
+import com.intellij.refactoring.util.classMembers.*;
+import com.intellij.util.*;
/**
* @author dsl
protected PsiClass extractSuper(final String superClassName) throws IncorrectOperationException {
- return ExtractSuperClassUtil.extractSuperClass(myProject, myTargetDirectory, superClassName, myClass, myMemberInfos, myJavaDocPolicy);
+ return ExtractSuperClassUtil.extractSuperClass(myProject, myClass.getContainingFile().getContainingDirectory(), superClassName, myClass, myMemberInfos, myJavaDocPolicy);
}
protected boolean isSuperInheritor(PsiClass aClass) {
*/
package com.intellij.refactoring.extractSuperclass;
-import com.intellij.openapi.project.Project;
-import com.intellij.psi.PsiClass;
-import com.intellij.psi.PsiMember;
-import com.intellij.psi.PsiMethod;
-import com.intellij.refactoring.HelpID;
-import com.intellij.refactoring.JavaRefactoringSettings;
-import com.intellij.refactoring.RefactoringBundle;
-import com.intellij.refactoring.classMembers.MemberInfoChange;
-import com.intellij.refactoring.classMembers.MemberInfoModel;
-import com.intellij.refactoring.memberPullUp.PullUpHelper;
-import com.intellij.refactoring.ui.MemberSelectionPanel;
-import com.intellij.refactoring.util.DocCommentPolicy;
-import com.intellij.refactoring.util.classMembers.InterfaceContainmentVerifier;
-import com.intellij.refactoring.util.classMembers.MemberInfo;
-import com.intellij.refactoring.util.classMembers.UsesAndInterfacesDependencyMemberInfoModel;
+import com.intellij.openapi.project.*;
+import com.intellij.psi.*;
+import com.intellij.refactoring.*;
+import com.intellij.refactoring.classMembers.*;
+import com.intellij.refactoring.memberPullUp.*;
+import com.intellij.refactoring.ui.*;
+import com.intellij.refactoring.util.*;
+import com.intellij.refactoring.util.classMembers.*;
import javax.swing.*;
import java.awt.*;
-import java.util.ArrayList;
+import java.util.*;
import java.util.List;
class ExtractSuperclassDialog extends ExtractSuperBaseDialog {
_panel = new JPanel(new BorderLayout());
myPackageLabel = new JLabel();
- myPackageLabel.setText(RefactoringBundle.message("package.for.new.superclass"));
+ myPackageLabel.setText(getPackageNameLabelText());
_panel.add(myPackageLabel, BorderLayout.NORTH);
_panel.add(myPackageNameField, BorderLayout.CENTER);
//_panel.add(myBtnPackageChooser, BorderLayout.EAST);
return myPackageLabel;
}
+ @Override
+ protected String getPackageNameLabelText() {
+ return isExtractSuperclass() ? RefactoringBundle.message("package.for.new.superclass") : "Package name for original class";
+ }
+
protected String getEntityName() {
return RefactoringBundle.message("ExtractSuperClass.superclass");
}
*/
package com.intellij.refactoring.rename;
-import com.intellij.codeInsight.ChangeContextUtil;
-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Comparing;
-import com.intellij.openapi.util.Pair;
+import com.intellij.codeInsight.*;
+import com.intellij.openapi.diagnostic.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.util.*;
import com.intellij.psi.*;
-import com.intellij.psi.search.GlobalSearchScope;
-import com.intellij.psi.search.LocalSearchScope;
-import com.intellij.psi.search.searches.ClassInheritorsSearch;
-import com.intellij.psi.search.searches.ReferencesSearch;
+import com.intellij.psi.search.*;
+import com.intellij.psi.search.searches.*;
import com.intellij.psi.util.ClassUtil;
-import com.intellij.refactoring.HelpID;
-import com.intellij.refactoring.JavaRefactoringSettings;
-import com.intellij.refactoring.RefactoringBundle;
-import com.intellij.refactoring.listeners.RefactoringElementListener;
-import com.intellij.refactoring.util.MoveRenameUsageInfo;
-import com.intellij.refactoring.util.RefactoringUtil;
-import com.intellij.usageView.UsageInfo;
-import com.intellij.util.IncorrectOperationException;
-import com.intellij.util.containers.MultiMap;
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.refactoring.*;
+import com.intellij.refactoring.listeners.*;
+import com.intellij.refactoring.util.*;
+import com.intellij.usageView.*;
+import com.intellij.util.*;
+import com.intellij.util.containers.*;
+import org.jetbrains.annotations.*;
import java.util.*;
-import java.util.regex.Pattern;
+import java.util.HashSet;
+import java.util.regex.*;
/**
* @author yole
}
}
}
- else {
+ else if (!(aClass instanceof PsiTypeParameter)) {
final String qualifiedNameAfterRename = RenameUtil.getQualifiedNameAfterRename(aClass.getQualifiedName(), newName);
Project project = element.getProject();
final PsiClass conflictingClass =
}
public static PsiThisExpression createThisExpression(PsiManager manager, PsiClass qualifierClass) throws IncorrectOperationException {
- PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory();
- if (qualifierClass != null) {
- PsiThisExpression qualifiedThis = (PsiThisExpression)factory.createExpressionFromText("q.this", null);
- qualifiedThis = (PsiThisExpression)CodeStyleManager.getInstance(manager.getProject()).reformat(qualifiedThis);
- PsiJavaCodeReferenceElement thisQualifier = qualifiedThis.getQualifier();
- LOG.assertTrue(thisQualifier != null);
- thisQualifier.bindToElement(qualifierClass);
- return qualifiedThis;
- }
- else {
- return (PsiThisExpression)factory.createExpressionFromText("this", null);
- }
- }
+ return RefactoringUtil.<PsiThisExpression>createQualifiedExpression(manager, qualifierClass, "this");
+ }
+
+ public static PsiSuperExpression createSuperExpression(PsiManager manager, PsiClass qualifierClass) throws IncorrectOperationException {
+ return RefactoringUtil.<PsiSuperExpression>createQualifiedExpression(manager, qualifierClass, "super");
+ }
+
+ private static <T extends PsiQualifiedExpression> T createQualifiedExpression(PsiManager manager, PsiClass qualifierClass, String qName) throws IncorrectOperationException {
+ PsiElementFactory factory = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory();
+ if (qualifierClass != null) {
+ T qualifiedThis = (T)factory.createExpressionFromText("q." + qName, null);
+ qualifiedThis = (T)CodeStyleManager.getInstance(manager.getProject()).reformat(qualifiedThis);
+ PsiJavaCodeReferenceElement thisQualifier = qualifiedThis.getQualifier();
+ LOG.assertTrue(thisQualifier != null);
+ thisQualifier.bindToElement(qualifierClass);
+ return qualifiedThis;
+ }
+ else {
+ return (T)factory.createExpressionFromText(qName, null);
+ }
+ }
/**
* removes a reference to the specified class from the reference list given
*/
package com.intellij.refactoring.util.duplicates;
-import com.intellij.codeInsight.PsiEquivalenceUtil;
-import com.intellij.lang.ASTNode;
-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.util.Comparing;
-import com.intellij.openapi.util.Key;
-import com.intellij.openapi.util.Pair;
+import com.intellij.codeInsight.*;
+import com.intellij.lang.*;
+import com.intellij.openapi.diagnostic.*;
+import com.intellij.openapi.util.*;
import com.intellij.psi.*;
import com.intellij.psi.controlFlow.*;
-import com.intellij.psi.impl.source.PsiImmediateClassType;
-import com.intellij.psi.tree.IElementType;
-import com.intellij.psi.util.InheritanceUtil;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.psi.util.PsiUtil;
-import com.intellij.psi.util.TypeConversionUtil;
-import com.intellij.refactoring.extractMethod.InputVariables;
-import com.intellij.refactoring.util.RefactoringUtil;
-import com.intellij.util.ArrayUtil;
-import com.intellij.util.IncorrectOperationException;
-import com.intellij.util.containers.IntArrayList;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.psi.impl.source.*;
+import com.intellij.psi.tree.*;
+import com.intellij.psi.util.*;
+import com.intellij.refactoring.extractMethod.*;
+import com.intellij.refactoring.util.*;
+import com.intellij.util.*;
+import com.intellij.util.containers.*;
+import org.jetbrains.annotations.*;
import java.util.*;
final PsiExpression candidateQualifier = candidateRefExpr.getQualifierExpression();
if (patternQualifier == null) {
PsiClass contextClass = PsiTreeUtil.getParentOfType(pattern, PsiClass.class);
+ if (candidateQualifier instanceof PsiReferenceExpression) {
+ final PsiElement resolved = ((PsiReferenceExpression)candidateQualifier).resolve();
+ if (resolved instanceof PsiClass && contextClass != null && contextClass.isInheritor((PsiClass)resolved, true)) {
+ return true;
+ }
+ }
return contextClass != null && match.registerInstanceExpression(candidateQualifier, contextClass);
} else {
if (candidateQualifier == null) {
if (contextClass != null && InheritanceUtil.isInheritorOrSelf(thisClass, contextClass, true)) {
contextClass = thisClass;
}
+ final PsiClass thisCandidate = RefactoringUtil.getThisClass(candidate);
+ if (thisCandidate != null && InheritanceUtil.isInheritorOrSelf(thisCandidate, contextClass, true)) {
+ contextClass = thisCandidate;
+ }
return contextClass != null && match.putParameter(parameter, RefactoringUtil.createThisExpression(patternQualifier.getManager(), contextClass));
+ } else if (patternQualifier instanceof PsiReferenceExpression) {
+ final PsiElement resolved = ((PsiReferenceExpression)patternQualifier).resolve();
+ if (resolved instanceof PsiClass) {
+ final PsiClass classContext = PsiTreeUtil.getParentOfType(candidate, PsiClass.class);
+ if (classContext != null && classContext.isInheritor((PsiClass)resolved, true)) {
+ return true;
+ }
+ }
}
return false;
final PsiElement candidateContextClass = candidateQualifier == null ? PsiTreeUtil.getParentOfType(candidate, PsiClass.class) : candidateQualifier.resolve();
return contextClass == candidateContextClass;
}
+ } else if (pattern instanceof PsiSuperExpression) {
+ final PsiJavaCodeReferenceElement qualifier = ((PsiSuperExpression)pattern).getQualifier();
+ final PsiElement contextClass = qualifier == null ? PsiTreeUtil.getParentOfType(pattern, PsiClass.class) : qualifier.resolve();
+ if (candidate instanceof PsiSuperExpression) {
+ final PsiJavaCodeReferenceElement candidateQualifier = ((PsiSuperExpression)candidate).getQualifier();
+ return contextClass == (candidateQualifier != null ? candidateQualifier.resolve() : PsiTreeUtil.getParentOfType(candidate, PsiClass.class));
+ }
}
PsiElement[] children1 = getFilteredChildren(pattern);
} else if (needStaticQualifier || myMethod.hasModifierProperty(PsiModifier.STATIC)) {
qualifierExpression.replace(factory.createReferenceExpression(containingClass));
} else {
- qualifierExpression.replace(RefactoringUtil.createThisExpression(containingClass.getManager(), containingClass));
+ final PsiClass psiClass = PsiTreeUtil.getParentOfType(match.getMatchStart(), PsiClass.class);
+ if (psiClass != null && psiClass.isInheritor(containingClass, true)) {
+ qualifierExpression.replace(RefactoringUtil.createSuperExpression(containingClass.getManager(), psiClass));
+ } else {
+ qualifierExpression.replace(RefactoringUtil.createThisExpression(containingClass.getManager(), containingClass));
+ }
}
}
VisibilityUtil.escalateVisibility(myMethod, match.getMatchStart());
*/
package com.intellij.testIntegration.createTest;
-import com.intellij.codeInsight.CodeInsightBundle;
-import com.intellij.codeInsight.CodeInsightUtil;
-import com.intellij.codeInsight.daemon.impl.analysis.HighlightNamesUtil;
-import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.extensions.Extensions;
-import com.intellij.openapi.fileEditor.ex.IdeDocumentHistory;
-import com.intellij.openapi.module.Module;
-import com.intellij.openapi.module.ModuleUtil;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.ProjectRootManager;
-import com.intellij.openapi.ui.Messages;
-import com.intellij.openapi.util.TextRange;
-import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.codeInsight.*;
+import com.intellij.codeInsight.daemon.impl.analysis.*;
+import com.intellij.codeInsight.intention.*;
+import com.intellij.openapi.application.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.extensions.*;
+import com.intellij.openapi.fileEditor.ex.*;
+import com.intellij.openapi.module.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.roots.*;
+import com.intellij.openapi.ui.*;
+import com.intellij.openapi.util.*;
+import com.intellij.openapi.vfs.*;
import com.intellij.psi.*;
-import com.intellij.psi.impl.source.PostprocessReformattingAspect;
-import com.intellij.psi.search.GlobalSearchScope;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.refactoring.util.classMembers.MemberInfo;
-import com.intellij.testIntegration.TestFrameworkDescriptor;
-import com.intellij.testIntegration.TestIntegrationUtils;
-import com.intellij.util.IncorrectOperationException;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.Collection;
+import com.intellij.psi.impl.source.*;
+import com.intellij.psi.search.*;
+import com.intellij.psi.util.*;
+import com.intellij.refactoring.util.classMembers.*;
+import com.intellij.testIntegration.*;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
public class CreateTestAction extends PsiElementBaseIntentionAction {
@NotNull
return getText();
}
- public boolean isAvailable(@NotNull Project project, Editor editor, @Nullable PsiElement element) {
- if (element == null) return false;
+ public boolean isAvailable(@NotNull Project project, Editor editor, @NotNull PsiElement element) {
if (Extensions.getExtensions(TestFrameworkDescriptor.EXTENSION_NAME).length == 0) return false;
if (!isAvailableForElement(element)) return false;
--- /dev/null
+public class Foo {
+
+ public Foo() {
+ Runnable r = new Runnable() {
+ public void run() {
+ Goo<String> g = new Goo<String>() {
+ @Override
+ void foo() {
+ <selection>//To change body of implemented methods use File | Settings | File Templates.</selection>
+ }
+ };
+ }
+ };
+ }
+}
+
+abstract class Goo<T> {
+ abstract void foo();
+}
--- /dev/null
+public class Foo {
+
+ public Foo() {
+ Runnable r = new Runnable() {
+ public void run() {
+ Goo<String> g = new G<caret>
+ }
+ };
+ }
+}
+
+abstract class Goo<T> {
+ abstract void foo();
+}
--- /dev/null
+public class aa {
+ public static boolean isVis<caret>ualUpdate(int update_type) {
+ return update_type <= Iaaa.FULL_QUOTE_VISUAL;
+ }
+}
+
+interface Iaaa {
+ int FULL_QUOTE_VISUAL = 0;
+}
+
+class a implements Iaaa {
+ int update_type = 8;
+
+ public static boolean blabla(int update_type) {
+ return update_type <= FULL_QUOTE_VISUAL;
+ }
+}
\ No newline at end of file
--- /dev/null
+public class aa {
+ public static boolean isVisualUpdate(int update_type) {
+ return update_type <= Iaaa.FULL_QUOTE_VISUAL;
+ }
+}
+
+interface Iaaa {
+ int FULL_QUOTE_VISUAL = 0;
+}
+
+class a implements Iaaa {
+ int update_type = 8;
+
+ public static boolean blabla(int update_type) {
+ return aa.isVisualUpdate(update_type);
+ }
+}
\ No newline at end of file
--- /dev/null
+public class BaseClass extends JComponent {
+}
+
+class SubClass extends BaseClass {
+ void a() {
+ System.out.println(getLocation());
+ }
+}
+
+class Util {
+ public static void met<caret>hod(BaseClass base) {
+ System.out.println(base.getLocation());
+ }
+}
--- /dev/null
+public class BaseClass extends JComponent {
+}
+
+class SubClass extends BaseClass {
+ void a() {
+ Util.method(SubClass.this);
+ }
+}
+
+class Util {
+ public static void method(BaseClass base) {
+ System.out.println(base.getLocation());
+ }
+}
--- /dev/null
+public class a {
+ void f<caret>oo() {
+ System.out.println();
+ }
+}
+
+class b extends a {
+ void foo() {
+ System.out.println();
+ }
+}
\ No newline at end of file
--- /dev/null
+public class a {
+ void foo() {
+ System.out.println();
+ }
+}
+
+class b extends a {
+ void foo() {
+ b.super.foo();
+ }
+}
\ No newline at end of file
--- /dev/null
+public class a {
+ public void login() {
+ System.out.println();
+ }
+}
+
+class b extends a {
+ public void doL<caret>ogin() throws Exception {
+ super.login();
+ }
+}
+
+class c extends a {
+ public void doLogin() throws Exception {
+ super.login();
+ }
+}
\ No newline at end of file
--- /dev/null
+public class a {
+ public void login() {
+ System.out.println();
+ }
+}
+
+class b extends a {
+ public void doL<caret>ogin() throws Exception {
+ super.login();
+ }
+
+ public void foo() throws Exception {
+ new Runnable() {
+ public void run() {
+ b.super.login();
+ }
+ }.run();
+ }
+}
+
--- /dev/null
+public class a {
+ public void login() {
+ System.out.println();
+ }
+}
+
+class b extends a {
+ public void doLogin() throws Exception {
+ super.login();
+ }
+
+ public void foo() throws Exception {
+ new Runnable() {
+ public void run() {
+ doLogin();
+ }
+ }.run();
+ }
+}
+
--- /dev/null
+public class aa {
+ public static boolean isVisualUpdate(int update_type) {
+ return update_type <= Iaaa.FULL_QUOTE_VISUAL;
+ }
+}
+
+interface Iaaa {
+ int FULL_QUOTE_VISUAL = 0;
+}
+
+class a implements Iaaa {
+ int update_type = 8;
+
+ public static boolean blab<caret>la(int update_type) {
+ return update_type <= FULL_QUOTE_VISUAL;
+ }
+}
\ No newline at end of file
--- /dev/null
+public class aa {
+ public static boolean isVisualUpdate(int update_type) {
+ return a.blabla(update_type);
+ }
+}
+
+interface Iaaa {
+ int FULL_QUOTE_VISUAL = 0;
+}
+
+class a implements Iaaa {
+ int update_type = 8;
+
+ public static boolean blabla(int update_type) {
+ return update_type <= FULL_QUOTE_VISUAL;
+ }
+}
\ No newline at end of file
--- /dev/null
+public class Test<T<caret> extends String> {}
+
+class P {}
\ No newline at end of file
--- /dev/null
+public class Test<P extends String> {}
+
+class P {}
\ No newline at end of file
public void testEnumAsDefaultAnnotationParam() throws Throwable { doTest(); }
+ public void testNewAbstractInsideAnonymous() throws Throwable { doTest(); }
+
public void testFilterPrivateConstructors() throws Throwable { doTest(); }
public void testExplicitMethodTypeParametersQualify() throws Throwable { doTest(); }
public void testDetectNameConflictsWithStatic() throws Exception {
doTest();
}
+
+ public void testCorrectThis() throws Exception {
+ doTest();
+ }
+
+ public void testSuperInTheSameContext() throws Exception {
+ doTest(false);
+ }
+
+ public void testSuperInTheSameContextQualified() throws Exception {
+ doTest();
+ }
+
+ public void testInsertSuperQualifierWhenNameConflicts() throws Exception {
+ doTest();
+ }
+
+ public void testUnqualifiedStaticAccess() throws Exception {
+ doTest();
+ }
+
+ public void testCandidateUnqualifiedStaticAccess() throws Exception {
+ doTest();
+ }
+
+
}
\ No newline at end of file
package com.intellij.refactoring;
-import com.intellij.JavaTestUtil;
-import com.intellij.codeInsight.TargetElementUtilBase;
-import com.intellij.openapi.projectRoots.Sdk;
-import com.intellij.openapi.projectRoots.impl.JavaSdkImpl;
-import com.intellij.psi.PsiElement;
-import com.intellij.refactoring.rename.RenameProcessor;
-import com.intellij.refactoring.rename.RenameUtil;
-import com.intellij.refactoring.util.MoveRenameUsageInfo;
-import com.intellij.testFramework.LightCodeInsightTestCase;
-import com.intellij.usageView.UsageInfo;
-import org.junit.Assert;
-
-import java.util.HashMap;
+import com.intellij.*;
+import com.intellij.codeInsight.*;
+import com.intellij.openapi.projectRoots.*;
+import com.intellij.openapi.projectRoots.impl.*;
+import com.intellij.psi.*;
+import com.intellij.refactoring.rename.*;
+import com.intellij.refactoring.util.*;
+import com.intellij.testFramework.*;
+import com.intellij.usageView.*;
+import org.junit.*;
+
+import java.util.*;
/**
* @author sashache
fail("Conflicts were not found");
}
+ public void testRenameTypeParameterToExistingClassName() throws Exception {
+ doTest("P");
+ }
+
private void doTest(final String newName) throws Exception {
configureByFile(BASE_PATH + getTestName(false) + ".java");
PsiElement element = TargetElementUtilBase
package com.intellij.codeInsight.intention;
-import com.intellij.codeInsight.AnnotationUtil;
-import com.intellij.codeInsight.CodeInsightBundle;
-import com.intellij.codeInsight.CodeInsightUtilBase;
-import com.intellij.codeInsight.ExternalAnnotationsManager;
-import com.intellij.codeInspection.LocalQuickFix;
-import com.intellij.codeInspection.ProblemDescriptor;
-import com.intellij.lang.findUsages.FindUsagesProvider;
-import com.intellij.lang.findUsages.LanguageFindUsages;
-import com.intellij.openapi.command.undo.UndoUtil;
-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.editor.CaretModel;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.project.Project;
+import com.intellij.codeInsight.*;
+import com.intellij.codeInspection.*;
+import com.intellij.lang.findUsages.*;
+import com.intellij.openapi.command.undo.*;
+import com.intellij.openapi.diagnostic.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.project.*;
import com.intellij.psi.*;
-import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
-import com.intellij.psi.codeStyle.JavaCodeStyleManager;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.psi.util.PsiUtil;
-import com.intellij.util.IncorrectOperationException;
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.psi.codeStyle.*;
+import com.intellij.psi.util.*;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
/**
* @author ven
return listOwner;
}
- public boolean isAvailable(@NotNull final Project project, final Editor editor, @Nullable final PsiElement element) {
- if (element == null || !element.isValid()) return false;
+ public boolean isAvailable(@NotNull final Project project, final Editor editor, @NotNull final PsiElement element) {
+ if (!element.isValid()) return false;
if (!PsiUtil.isLanguageLevel5OrHigher(element)) return false;
final PsiModifierListOwner owner;
if (myModifierListOwner != null) {
final int position = caretModel.getOffset();
element = file.findElementAt(position);
}
- return isAvailable(project, editor, element);
+ return element != null && isAvailable(project, editor, element);
}
public void invoke(@NotNull final Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
--- /dev/null
+/*
+ * Copyright 2000-2010 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.psi;
+
+import org.jetbrains.annotations.Nullable;
+
+public interface PsiQualifiedExpression extends PsiExpression {
+ @Nullable
+ PsiJavaCodeReferenceElement getQualifier();
+}
\ No newline at end of file
* Represents a Java <code>super</code> expression in a super method call. Note that the qualifier of
* a super constructor call is represented as a {@link PsiKeyword} rather than a <code>PsiSuperExpression</code>.
*/
-public interface PsiSuperExpression extends PsiExpression {
+public interface PsiSuperExpression extends PsiQualifiedExpression {
/**
* Returns the expression representing the class name qualifying the <code>super</code>
* expression.
/**
* Represents a Java <code>this</code> expression.
*/
-public interface PsiThisExpression extends PsiExpression {
+public interface PsiThisExpression extends PsiQualifiedExpression {
/**
* Returns the expression representing the class name qualifying the <code>this</code>
* expression.
*/
package com.intellij.codeInsight.intention;
-import com.intellij.codeInsight.intention.impl.BaseIntentionAction;
-import com.intellij.openapi.editor.CaretModel;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.project.Project;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiFile;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.codeInsight.intention.impl.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.project.*;
+import com.intellij.psi.*;
+import org.jetbrains.annotations.*;
public abstract class PsiElementBaseIntentionAction extends BaseIntentionAction {
* @param element the element under caret.
* @return true if the intention is available, false otherwise.
*/
- public abstract boolean isAvailable(@NotNull Project project, Editor editor, @Nullable PsiElement element);
+ public abstract boolean isAvailable(@NotNull Project project, Editor editor, @NotNull PsiElement element);
public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
if (!file.getManager().isInProject(file)) return false;
final CaretModel caretModel = editor.getCaretModel();
final int position = caretModel.getOffset();
- return isAvailable(project, editor, file.findElementAt(position));
+ final PsiElement element = file.findElementAt(position);
+ if (element == null) return false;
+ return isAvailable(project, editor, element);
}
}
\ No newline at end of file
package com.intellij.execution.configurations;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.module.Module;
-import com.intellij.openapi.module.ModuleManager;
-import com.intellij.openapi.module.ModuleUtil;
-import com.intellij.openapi.util.Computable;
-import com.intellij.openapi.util.InvalidDataException;
-import com.intellij.openapi.util.WriteExternalException;
-import org.jdom.Element;
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Arrays;
-import java.util.Collection;
+import com.intellij.openapi.application.*;
+import com.intellij.openapi.diagnostic.*;
+import com.intellij.openapi.module.*;
+import com.intellij.openapi.util.*;
+import org.jdom.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
public abstract class ModuleBasedConfiguration<ConfigurationModule extends RunConfigurationModule> extends RuntimeConfiguration {
private static final Logger LOG = Logger.getInstance("#com.intellij.execution.configurations.ModuleBasedConfiguration");
public void restoreOriginalModule(final Module originalModule) {
if (originalModule == null) return;
final Module[] classModules = getModules();
- final Collection<Module> modules = ModuleUtil.collectModulesDependsOn(Arrays.asList(classModules));
+ final Set<Module> modules = new HashSet<Module>();
+ for (Module classModule : classModules) {
+ ModuleUtil.collectModulesDependsOn(classModule, modules);
+ }
if (modules.contains(originalModule)) setModule(originalModule);
}
}
*/
package com.intellij.openapi.module;
-import com.intellij.openapi.application.ReadAction;
-import com.intellij.openapi.application.Result;
-import com.intellij.openapi.project.Project;
+import com.intellij.openapi.application.*;
+import com.intellij.openapi.project.*;
import com.intellij.openapi.roots.*;
-import com.intellij.openapi.util.Key;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.psi.PsiDirectory;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiFile;
+import com.intellij.openapi.util.*;
+import com.intellij.openapi.vfs.*;
+import com.intellij.psi.*;
import com.intellij.util.containers.HashSet;
-import com.intellij.util.graph.Graph;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.util.graph.*;
+import org.jetbrains.annotations.*;
import java.util.*;
return element.getUserData(KEY_MODULE);
}
+ //ignores export flag
public static void getDependencies(@NotNull Module module, Set<Module> modules) {
if (modules.contains(module)) return;
modules.add(module);
}
}
- public static Collection<Module> collectModulesDependsOn(@NotNull final Collection<Module> modules) {
- if (modules.isEmpty()) return Collections.emptyList();
- final HashSet<Module> result = new HashSet<Module>();
- final Project project = modules.iterator().next().getProject();
- final ModuleManager moduleManager = ModuleManager.getInstance(project);
- for (final Module module : modules) {
- result.add(module);
- result.addAll(moduleManager.getModuleDependentModules(module));
+ /**
+ * collect transitive module dependants
+ * @param module to find dependencies on
+ * @param result resulted set
+ */
+ public static void collectModulesDependsOn(@NotNull final Module module, final Set<Module> result) {
+ if (result.contains(module)) return;
+ result.add(module);
+ final ModuleManager moduleManager = ModuleManager.getInstance(module.getProject());
+ final List<Module> dependentModules = moduleManager.getModuleDependentModules(module);
+ for (final Module dependentModule : dependentModules) {
+ final OrderEntry[] orderEntries = ModuleRootManager.getInstance(dependentModule).getOrderEntries();
+ for (OrderEntry o : orderEntries) {
+ if (o instanceof ModuleOrderEntry) {
+ final ModuleOrderEntry orderEntry = (ModuleOrderEntry)o;
+ if (orderEntry.getModule() == module) {
+ if (orderEntry.isExported()) {
+ collectModulesDependsOn(dependentModule, result);
+ } else {
+ result.add(dependentModule);
+ }
+ break;
+ }
+ }
+ }
}
- return result;
}
@NotNull
package com.intellij.codeInsight.daemon.impl;
-import com.intellij.codeHighlighting.BackgroundEditorHighlighter;
-import com.intellij.codeHighlighting.HighlightingPass;
+import com.intellij.codeHighlighting.*;
import com.intellij.codeHighlighting.Pass;
-import com.intellij.codeHighlighting.TextEditorHighlightingPass;
-import com.intellij.codeInsight.daemon.DaemonCodeAnalyzer;
-import com.intellij.codeInsight.daemon.DaemonCodeAnalyzerSettings;
-import com.intellij.codeInsight.daemon.LineMarkerInfo;
-import com.intellij.codeInsight.daemon.ReferenceImporter;
-import com.intellij.codeInsight.hint.HintManager;
-import com.intellij.codeInsight.intention.impl.IntentionHintComponent;
-import com.intellij.concurrency.Job;
-import com.intellij.lang.annotation.HighlightSeverity;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.codeInsight.daemon.*;
+import com.intellij.codeInsight.hint.*;
+import com.intellij.codeInsight.intention.impl.*;
+import com.intellij.concurrency.*;
+import com.intellij.lang.annotation.*;
+import com.intellij.openapi.application.*;
+import com.intellij.openapi.diagnostic.*;
import com.intellij.openapi.editor.Document;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.editor.ex.EditorMarkupModel;
-import com.intellij.openapi.editor.markup.MarkupModel;
-import com.intellij.openapi.editor.markup.RangeHighlighter;
-import com.intellij.openapi.extensions.Extensions;
-import com.intellij.openapi.fileEditor.FileEditor;
-import com.intellij.openapi.fileEditor.TextEditor;
-import com.intellij.openapi.fileEditor.impl.text.TextEditorProvider;
-import com.intellij.openapi.fileTypes.FileType;
-import com.intellij.openapi.fileTypes.StdFileTypes;
-import com.intellij.openapi.progress.ProgressIndicator;
-import com.intellij.openapi.project.Project;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.editor.ex.*;
+import com.intellij.openapi.editor.markup.*;
+import com.intellij.openapi.extensions.*;
+import com.intellij.openapi.fileEditor.*;
+import com.intellij.openapi.fileEditor.impl.text.*;
+import com.intellij.openapi.fileTypes.*;
+import com.intellij.openapi.progress.*;
+import com.intellij.openapi.project.*;
import com.intellij.openapi.util.*;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.openapi.vfs.VirtualFileManager;
-import com.intellij.packageDependencies.DependencyValidationManager;
-import com.intellij.psi.PsiCompiledElement;
-import com.intellij.psi.PsiDocumentManager;
-import com.intellij.psi.PsiFile;
-import com.intellij.psi.PsiFileSystemItem;
-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.util.Alarm;
-import com.intellij.util.SmartList;
-import com.intellij.util.containers.ContainerUtil;
-import gnu.trove.THashMap;
-import gnu.trove.THashSet;
-import org.jdom.Element;
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.annotations.TestOnly;
+import com.intellij.openapi.vfs.*;
+import com.intellij.packageDependencies.*;
+import com.intellij.psi.*;
+import com.intellij.psi.search.scope.packageSet.*;
+import com.intellij.util.*;
+import com.intellij.util.containers.*;
+import gnu.trove.*;
+import org.jdom.*;
+import org.jetbrains.annotations.*;
import java.util.*;
@NonNls private static final String FILE_TAG = "file";
@NonNls private static final String URL_ATT = "url";
private DaemonListeners myDaemonListeners;
- private StatusBarUpdater myStatusBarUpdater;
private final PassExecutorService myPassExecutorService;
private static final Key<List<HighlightInfo>> HIGHLIGHTS_TO_REMOVE_KEY = Key.create("HIGHLIGHTS_TO_REMOVE");
private int myModificationCount = 0;
public void projectOpened() {
assert !myInitialized : "Double Initializing";
- myStatusBarUpdater = new StatusBarUpdater(myProject);
- Disposer.register(myProject, myStatusBarUpdater);
-
myDaemonListeners = new DaemonListeners(myProject, this, myEditorTracker);
Disposer.register(myProject, myDaemonListeners);
reloadScopes();
markup.putUserData(HIGHLIGHTS_IN_EDITOR_DOCUMENT_KEY, Collections.unmodifiableList(highlightsToSet));
markup.putUserData(HIGHLIGHTS_TO_REMOVE_KEY, Collections.unmodifiableList(highlightsToRemove));
-
- DaemonCodeAnalyzer codeAnalyzer = DaemonCodeAnalyzer.getInstance(project);
- if (codeAnalyzer instanceof DaemonCodeAnalyzerImpl && ((DaemonCodeAnalyzerImpl)codeAnalyzer).myStatusBarUpdater != null) {
- ((DaemonCodeAnalyzerImpl)codeAnalyzer).myStatusBarUpdater.updateStatus();
- }
}
private static void stripWarningsCoveredByErrors(final Project project, List<HighlightInfo> highlights, MarkupModel markup) {
+++ /dev/null
-
-/*
- * Copyright 2000-2009 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.codeInsight.daemon.impl;
-
-import com.intellij.codeInsight.daemon.DaemonCodeAnalyzer;
-import com.intellij.openapi.Disposable;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.editor.Document;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.editor.EditorFactory;
-import com.intellij.openapi.editor.event.CaretEvent;
-import com.intellij.openapi.editor.event.CaretListener;
-import com.intellij.openapi.editor.ex.DocumentEx;
-import com.intellij.openapi.fileEditor.FileEditorManager;
-import com.intellij.openapi.fileEditor.FileEditorManagerAdapter;
-import com.intellij.openapi.fileEditor.FileEditorManagerEvent;
-import com.intellij.openapi.fileEditor.FileEditorManagerListener;
-import com.intellij.openapi.project.DumbAwareRunnable;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.wm.StatusBar;
-import com.intellij.openapi.wm.WindowManager;
-import com.intellij.openapi.wm.ex.StatusBarEx;
-
-public class StatusBarUpdater implements Disposable {
- private final Project myProject;
- private final UpdateStatusRunnable myUpdateStatusRunnable = new UpdateStatusRunnable();
-
- public StatusBarUpdater(Project project) {
- myProject = project;
-
- CaretListener caretListener = new CaretListener() {
- public void caretPositionChanged(CaretEvent e) {
- ApplicationManager.getApplication().invokeLater(myUpdateStatusRunnable);
- }
- };
- EditorFactory.getInstance().getEventMulticaster().addCaretListener(caretListener, this);
-
- project.getMessageBus().connect().subscribe(FileEditorManagerListener.FILE_EDITOR_MANAGER, new FileEditorManagerAdapter() {
- @Override
- public void selectionChanged(FileEditorManagerEvent event) {
- ApplicationManager.getApplication().invokeLater(myUpdateStatusRunnable);
- }
- });
- }
-
- public void dispose() {
- }
-
- public void updateStatus() {
- Editor editor = FileEditorManager.getInstance(myProject).getSelectedTextEditor();
- if (editor == null || !editor.getContentComponent().hasFocus()){
- return;
- }
-
- final Document document = editor.getDocument();
- if (document instanceof DocumentEx && ((DocumentEx)document).isInBulkUpdate()) return;
-
- int offset = editor.getCaretModel().getOffset();
- DaemonCodeAnalyzer codeAnalyzer = DaemonCodeAnalyzer.getInstance(myProject);
- HighlightInfo info = ((DaemonCodeAnalyzerImpl)codeAnalyzer).findHighlightByOffset(document, offset, false);
- String text = info != null && info.description != null ? info.description : "";
-
- StatusBar statusBar = WindowManager.getInstance().getStatusBar(myProject);
- if (statusBar instanceof StatusBarEx) {
- StatusBarEx barEx = (StatusBarEx)statusBar;
- if (!text.equals(barEx.getInfo())){
- statusBar.setInfo(text);
- }
- barEx.update(editor);
- }
- }
-
- private class UpdateStatusRunnable implements DumbAwareRunnable {
- public void run() {
- if (!myProject.isDisposed()) {
- updateStatus();
- }
- }
- }
-}
\ No newline at end of file
package com.intellij.codeInsight.daemon.impl.actions;
-import com.intellij.codeInsight.CodeInsightUtilBase;
-import com.intellij.codeInspection.InspectionsBundle;
-import com.intellij.codeInspection.SuppressIntentionAction;
-import com.intellij.codeInspection.SuppressionUtil;
-import com.intellij.lang.Commenter;
-import com.intellij.lang.LanguageCommenters;
-import com.intellij.openapi.command.undo.UndoUtil;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.fileTypes.LanguageFileType;
-import com.intellij.openapi.project.Project;
-import com.intellij.psi.PsiComment;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiParserFacade;
-import com.intellij.psi.PsiWhiteSpace;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.util.IncorrectOperationException;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.Collections;
-import java.util.List;
+import com.intellij.codeInsight.*;
+import com.intellij.codeInspection.*;
+import com.intellij.lang.*;
+import com.intellij.openapi.command.undo.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.fileTypes.*;
+import com.intellij.openapi.project.*;
+import com.intellij.psi.*;
+import com.intellij.psi.util.*;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
/**
* @author Roman.Chernyatchik
container.getParent().addBefore(comment, container);
}
- public boolean isAvailable(@NotNull final Project project, final Editor editor, @Nullable final PsiElement context) {
- return context != null && context.getManager().isInProject(context) && getContainer(context) != null;
+ public boolean isAvailable(@NotNull final Project project, final Editor editor, @NotNull final PsiElement context) {
+ return context.getManager().isInProject(context) && getContainer(context) != null;
}
public void invoke(final Project project, @Nullable Editor editor, final PsiElement element) throws IncorrectOperationException {
package com.intellij.codeInsight.hint;
-import com.intellij.lang.parameterInfo.ParameterInfoHandler;
-import com.intellij.lang.parameterInfo.ParameterInfoUIContextEx;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.psi.PsiElement;
-import com.intellij.ui.SideBorder;
-import com.intellij.ui.SplittingUtil;
-import com.intellij.ui.StrikeoutLabel;
-import com.intellij.util.ui.UIUtil;
-import org.jetbrains.annotations.NotNull;
+import com.intellij.lang.parameterInfo.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.psi.*;
+import com.intellij.ui.*;
+import com.intellij.util.ui.*;
+import org.jetbrains.annotations.*;
import javax.swing.*;
-import javax.swing.border.Border;
-import javax.swing.border.LineBorder;
+import javax.swing.border.*;
import java.awt.*;
-import java.util.EnumSet;
+import java.util.*;
class ParameterInfoComponent extends JPanel{
private final Object[] myObjects;
public void setup(String text, int highlightStartOffset, int highlightEndOffset, boolean isDisabled, boolean strikeout, boolean isDisabledBeforeHighlight, Color background) {
removeAll();
- String[] lines = SplittingUtil.splitText(text, getFontMetrics(BOLD_FONT), myWidthLimit, ',');
+ String[] lines = UIUtil.splitText(text, getFontMetrics(BOLD_FONT), myWidthLimit, ',');
myOneLineComponents = new OneLineComponent[lines.length];
package com.intellij.codeInsight.problems;
import com.intellij.codeInsight.daemon.impl.*;
-import com.intellij.codeInsight.daemon.impl.analysis.HighlightInfoHolder;
-import com.intellij.lang.annotation.HighlightSeverity;
-import com.intellij.openapi.Disposable;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.application.impl.LaterInvocator;
-import com.intellij.openapi.editor.Document;
-import com.intellij.openapi.extensions.Extensions;
-import com.intellij.openapi.fileEditor.FileDocumentManager;
-import com.intellij.openapi.fileEditor.FileEditor;
-import com.intellij.openapi.fileEditor.FileEditorManager;
-import com.intellij.openapi.fileEditor.TextEditor;
-import com.intellij.openapi.module.Module;
-import com.intellij.openapi.module.ModuleUtil;
-import com.intellij.openapi.progress.ProcessCanceledException;
-import com.intellij.openapi.progress.ProgressIndicator;
-import com.intellij.openapi.progress.ProgressManager;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Computable;
-import com.intellij.openapi.util.Condition;
-import com.intellij.openapi.util.Disposer;
-import com.intellij.openapi.util.TextRange;
-import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.openapi.vcs.FileStatusListener;
-import com.intellij.openapi.vcs.FileStatusManager;
+import com.intellij.codeInsight.daemon.impl.analysis.*;
+import com.intellij.lang.annotation.*;
+import com.intellij.openapi.*;
+import com.intellij.openapi.application.*;
+import com.intellij.openapi.application.impl.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.extensions.*;
+import com.intellij.openapi.fileEditor.*;
+import com.intellij.openapi.module.*;
+import com.intellij.openapi.progress.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.util.*;
+import com.intellij.openapi.util.text.*;
+import com.intellij.openapi.vcs.*;
import com.intellij.openapi.vfs.*;
-import com.intellij.openapi.wm.StatusBar;
-import com.intellij.openapi.wm.WindowManager;
-import com.intellij.openapi.wm.ex.StatusBarEx;
-import com.intellij.problems.Problem;
-import com.intellij.problems.WolfTheProblemSolver;
+import com.intellij.openapi.wm.*;
+import com.intellij.openapi.wm.ex.*;
+import com.intellij.problems.*;
import com.intellij.psi.*;
-import com.intellij.util.containers.ContainerUtil;
-import gnu.trove.THashMap;
-import gnu.trove.THashSet;
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
+import com.intellij.util.containers.*;
+import gnu.trove.*;
+import org.jetbrains.annotations.*;
import java.util.*;
return true;
}
- private static String saveStatusBarInfo(StatusBar statusBar) {
+ private static String saveStatusBarInfo(final StatusBar statusBar) {
String oldInfo = null;
if (statusBar instanceof StatusBarEx) {
- oldInfo = ((StatusBarEx)statusBar).getInfo();
+ oldInfo = statusBar.getInfo();
}
return oldInfo;
}
package com.intellij.find.findUsages;
-import com.intellij.codeInsight.hint.HintManager;
-import com.intellij.codeInsight.hint.HintManagerImpl;
-import com.intellij.codeInsight.hint.HintUtil;
-import com.intellij.find.FindBundle;
-import com.intellij.lang.findUsages.LanguageFindUsages;
-import com.intellij.navigation.NavigationItem;
-import com.intellij.openapi.actionSystem.ActionManager;
-import com.intellij.openapi.actionSystem.AnAction;
-import com.intellij.openapi.actionSystem.IdeActions;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.codeInsight.hint.*;
+import com.intellij.find.*;
+import com.intellij.lang.findUsages.*;
+import com.intellij.navigation.*;
+import com.intellij.openapi.actionSystem.*;
+import com.intellij.openapi.application.*;
+import com.intellij.openapi.diagnostic.*;
import com.intellij.openapi.editor.Document;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.extensions.Extensions;
-import com.intellij.openapi.fileEditor.FileEditor;
-import com.intellij.openapi.fileEditor.FileEditorLocation;
-import com.intellij.openapi.fileEditor.TextEditor;
-import com.intellij.openapi.keymap.KeymapUtil;
-import com.intellij.openapi.progress.ProgressIndicator;
-import com.intellij.openapi.progress.ProgressManager;
-import com.intellij.openapi.progress.Task;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.ui.Messages;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.extensions.*;
+import com.intellij.openapi.fileEditor.*;
+import com.intellij.openapi.keymap.*;
+import com.intellij.openapi.progress.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.ui.*;
import com.intellij.openapi.util.*;
-import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.openapi.wm.StatusBar;
-import com.intellij.openapi.wm.WindowManager;
+import com.intellij.openapi.util.text.*;
+import com.intellij.openapi.wm.*;
import com.intellij.psi.*;
-import com.intellij.psi.search.LocalSearchScope;
-import com.intellij.psi.search.SearchScope;
-import com.intellij.ui.LightweightHint;
+import com.intellij.psi.search.*;
+import com.intellij.ui.*;
import com.intellij.ui.content.Content;
-import com.intellij.usageView.UsageInfo;
+import com.intellij.usageView.*;
import com.intellij.usageView.UsageViewManager;
-import com.intellij.usageView.UsageViewUtil;
import com.intellij.usages.*;
-import com.intellij.usages.impl.UsageViewManagerImpl;
-import com.intellij.util.Processor;
-import com.intellij.util.containers.ContainerUtil;
-import org.jdom.Element;
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.usages.impl.*;
+import com.intellij.util.*;
+import com.intellij.util.containers.*;
+import org.jdom.*;
+import org.jetbrains.annotations.*;
import javax.swing.*;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.concurrent.atomic.AtomicInteger;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
public class FindUsagesManager implements JDOMExternalizable {
private static final Logger LOG = Logger.getInstance("#com.intellij.find.findParameterUsages.FindUsagesManager");
}
private void clearStatusBar() {
- StatusBar statusBar = WindowManager.getInstance().getStatusBar(myProject);
- statusBar.setInfo("");
+ StatusBar.Info.set("", myProject);
}
private static String getSearchAgainMessage(PsiElement element, final FileSearchScope direction) {
showEditorHint(message, textEditor.getEditor());
}
else {
- StatusBar statusBar = WindowManager.getInstance().getStatusBar(myProject);
- statusBar.setInfo(message);
+ StatusBar.Info.set(message, myProject);
}
}
import com.intellij.ide.fileTemplates.FileTemplateManager;
import com.intellij.ide.fileTemplates.InternalTemplateBean;
import com.intellij.ide.plugins.IdeaPluginDescriptorImpl;
+import com.intellij.ide.plugins.cl.PluginClassLoader;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.application.ApplicationNamesInfo;
import com.intellij.openapi.application.PathManager;
Set<VirtualFile> dirList = new THashSet<VirtualFile>();
- appendDefaultTemplatesDirFromClassloader(FileTemplateManagerImpl.class.getClassLoader(), dirList);
PluginDescriptor[] plugins = ApplicationManager.getApplication().getPlugins();
for (PluginDescriptor plugin : plugins) {
if (plugin instanceof IdeaPluginDescriptorImpl && ((IdeaPluginDescriptorImpl)plugin).isEnabled()) {
- appendDefaultTemplatesDirFromClassloader(plugin.getPluginClassLoader(), dirList);
+ final ClassLoader loader = plugin.getPluginClassLoader();
+ if (loader instanceof PluginClassLoader && ((PluginClassLoader)loader).getUrls().isEmpty()) {
+ continue; // development mode, when IDEA_CORE's loader contains all the classpath
+ }
+ appendDefaultTemplatesDirFromClassloader(loader, dirList);
}
}
package com.intellij.openapi.wm.impl.status;
-import com.intellij.codeInsight.daemon.DaemonCodeAnalyzer;
-import com.intellij.codeInsight.daemon.impl.HectorComponent;
-import com.intellij.codeInsight.daemon.impl.analysis.HighlightLevelUtil;
-import com.intellij.ide.DataManager;
-import com.intellij.openapi.actionSystem.PlatformDataKeys;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.fileEditor.FileEditorManager;
-import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.IconLoader;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.openapi.wm.StatusBar;
-import com.intellij.profile.codeInspection.InspectionProjectProfileManager;
-import com.intellij.psi.PsiFile;
-import com.intellij.psi.PsiManager;
-import com.intellij.ui.UIBundle;
-import com.intellij.ui.awt.RelativePoint;
-import com.intellij.util.ui.EmptyIcon;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.codeInsight.daemon.*;
+import com.intellij.codeInsight.daemon.impl.*;
+import com.intellij.codeInsight.daemon.impl.analysis.*;
+import com.intellij.ide.*;
+import com.intellij.openapi.actionSystem.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.fileEditor.*;
+import com.intellij.openapi.fileEditor.ex.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.util.*;
+import com.intellij.openapi.vfs.*;
+import com.intellij.openapi.wm.*;
+import com.intellij.profile.codeInspection.*;
+import com.intellij.psi.*;
+import com.intellij.ui.*;
+import com.intellij.ui.awt.*;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
import javax.swing.*;
import java.awt.*;
-import java.awt.event.MouseAdapter;
-import java.awt.event.MouseEvent;
+import java.awt.event.*;
+
+public class TogglePopupHintsPanel implements StatusBarWidget, StatusBarWidget.IconPresentation {
+ private static final Icon INSPECTIONS_ICON = IconLoader.getIcon("/ide/hectorOn.png");
+ private static final Icon INSPECTIONS_OFF_ICON = IconLoader.getIcon("/ide/hectorOff.png");
+ private static final Icon EMPTY_ICON = IconLoader.getIcon("/ide/hectorNo.png");
+
+ private Icon myCurrentIcon;
+ private String myToolTipText;
+ private StatusBar myStatusBar;
+
+ public TogglePopupHintsPanel(@NotNull final Project project) {
+ myCurrentIcon = EMPTY_ICON;
+ project.getMessageBus().connect().subscribe(FileEditorManagerListener.FILE_EDITOR_MANAGER, new FileEditorManagerAdapter() {
+ @Override
+ public void selectionChanged(FileEditorManagerEvent event) {
+ updateStatus();
+ }
+
+ @Override
+ public void fileOpened(FileEditorManager source, VirtualFile file) {
+ updateStatus();
+ }
+ });
+ }
-public class TogglePopupHintsPanel extends JPanel implements StatusBarPatch{
- private static final Icon INSPECTIONS_ICON = IconLoader.getIcon("/objectBrowser/showGlobalInspections.png");
- private static final Icon INSPECTIONS_OFF_ICON = IconLoader.getIcon("/general/inspectionsOff.png");
- private static final Icon EMPTY_ICON = new EmptyIcon(INSPECTIONS_ICON.getIconWidth(), INSPECTIONS_ICON.getIconHeight());
+ public void dispose() {
+ }
- private final JLabel myHectorLabel = new JLabel(EMPTY_ICON);
+ @NotNull
+ public Icon getIcon() {
+ return myCurrentIcon;
+ }
- public TogglePopupHintsPanel(final StatusBar statusBar) {
- super(new GridBagLayout());
- myHectorLabel.addMouseListener(new MouseAdapter() {
- public void mouseClicked(MouseEvent e) {
+ public String getTooltipText() {
+ return myToolTipText;
+ }
+
+ public Consumer<MouseEvent> getClickConsumer() {
+ return new Consumer<MouseEvent>() {
+ public void consume(final MouseEvent e) {
Point point = new Point(0, 0);
final PsiFile file = getCurrentFile();
if (file != null) {
final HectorComponent component = new HectorComponent(file);
final Dimension dimension = component.getPreferredSize();
point = new Point(point.x - dimension.width, point.y - dimension.height);
- component.showComponent(new RelativePoint(TogglePopupHintsPanel.this, point));
+ component.showComponent(new RelativePoint(e.getComponent(), point));
}
}
- });
- myHectorLabel.setIconTextGap(0);
-
- add(myHectorLabel, new GridBagConstraints(0, 0, 1, 1, 0, 1, GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(0, 0, 0, 0), 0, 0));
-
- StatusBarTooltipper.install(this, myHectorLabel, statusBar);
+ };
}
+ @NotNull
+ public String ID() {
+ return "InspectionProfile";
+ }
-
- public JComponent getComponent() {
+ public Presentation getPresentation(@NotNull Type type) {
return this;
}
+ public void install(@NotNull final StatusBar statusBar) {
+ myStatusBar = statusBar;
+ }
+
public String updateStatusBar(final Editor selected, final JComponent componentSelected) {
- updateStatus();
- String text = componentSelected == null ? null : componentSelected.getToolTipText();
- setCursor(Cursor.getPredefinedCursor(text == null ? Cursor.DEFAULT_CURSOR : Cursor.HAND_CURSOR));
- return text;
+ //updateStatus();
+ //String text = componentSelected == null ? null : componentSelected.getToolTipText();
+ //setCursor(Cursor.getPredefinedCursor(text == null ? Cursor.DEFAULT_CURSOR : Cursor.HAND_CURSOR));
+ return "";
}
public void clear() {
- myHectorLabel.setIcon(EMPTY_ICON);
- myHectorLabel.setToolTipText(null);
+ myCurrentIcon = EMPTY_ICON;
+ myToolTipText = null;
+ myStatusBar.updateWidget(ID());
}
public void updateStatus() {
private void updateStatus(PsiFile file) {
if (isStateChangeable(file)) {
- String tooltip;
if (HighlightLevelUtil.shouldInspect(file)) {
- myHectorLabel.setIcon(INSPECTIONS_ICON);
- tooltip = "Current inspection profile: " + InspectionProjectProfileManager.getInstance(file.getProject()).getInspectionProfile().getName() + ". ";
+ myCurrentIcon = INSPECTIONS_ICON;
+ myToolTipText = "Current inspection profile: " + InspectionProjectProfileManager.getInstance(file.getProject()).getInspectionProfile().getName() + ". ";
}
else {
- myHectorLabel.setIcon(INSPECTIONS_OFF_ICON);
- tooltip = "Inspections are off. ";
+ myCurrentIcon = INSPECTIONS_OFF_ICON;
+ myToolTipText = "Inspections are off. ";
}
- myHectorLabel.setToolTipText(tooltip + UIBundle.message("popup.hints.panel.click.to.configure.highlighting.tooltip.text"));
+ myToolTipText += UIBundle.message("popup.hints.panel.click.to.configure.highlighting.tooltip.text");
}
else {
- myHectorLabel.setIcon(EMPTY_ICON);
- myHectorLabel.setToolTipText(null);
+ myCurrentIcon = EMPTY_ICON;
+ myToolTipText = null;
}
+
+ myStatusBar.updateWidget(ID());
}
private static boolean isStateChangeable(PsiFile file) {
@Nullable
private Project getCurrentProject() {
- return PlatformDataKeys.PROJECT.getData(DataManager.getInstance().getDataContext(this));
- }
-
- public Point getToolTipLocation(MouseEvent event) {
- return new Point(0, -20);
+ return PlatformDataKeys.PROJECT.getData(DataManager.getInstance().getDataContext((Component) myStatusBar));
}
}
package com.intellij.packageDependencies.ui;
-import com.intellij.CommonBundle;
-import com.intellij.analysis.AnalysisScope;
-import com.intellij.analysis.AnalysisScopeBundle;
-import com.intellij.analysis.PerformAnalysisInBackgroundOption;
-import com.intellij.codeInsight.hint.HintUtil;
-import com.intellij.ide.CommonActionsManager;
-import com.intellij.ide.ExporterToTextFile;
-import com.intellij.openapi.Disposable;
+import com.intellij.*;
+import com.intellij.analysis.*;
+import com.intellij.codeInsight.hint.*;
+import com.intellij.ide.*;
+import com.intellij.openapi.*;
import com.intellij.openapi.actionSystem.*;
-import com.intellij.openapi.actionSystem.ex.ComboBoxAction;
-import com.intellij.openapi.components.PathMacroManager;
-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.extensions.Extensions;
-import com.intellij.openapi.help.HelpManager;
-import com.intellij.openapi.options.ShowSettingsUtil;
-import com.intellij.openapi.progress.ProgressManager;
-import com.intellij.openapi.project.DumbAware;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.ProjectFileIndex;
-import com.intellij.openapi.roots.ProjectRootManager;
-import com.intellij.openapi.ui.Messages;
-import com.intellij.openapi.ui.Splitter;
-import com.intellij.openapi.ui.popup.JBPopupFactory;
-import com.intellij.openapi.util.Disposer;
-import com.intellij.openapi.util.IconLoader;
-import com.intellij.openapi.util.JDOMUtil;
-import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.openapi.wm.StatusBar;
-import com.intellij.openapi.wm.WindowManager;
+import com.intellij.openapi.actionSystem.ex.*;
+import com.intellij.openapi.components.*;
+import com.intellij.openapi.diagnostic.*;
+import com.intellij.openapi.extensions.*;
+import com.intellij.openapi.help.*;
+import com.intellij.openapi.options.*;
+import com.intellij.openapi.progress.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.roots.*;
+import com.intellij.openapi.ui.*;
+import com.intellij.openapi.ui.popup.*;
+import com.intellij.openapi.util.*;
+import com.intellij.openapi.util.text.*;
+import com.intellij.openapi.vfs.*;
+import com.intellij.openapi.wm.*;
import com.intellij.packageDependencies.*;
-import com.intellij.packageDependencies.actions.AnalyzeDependenciesHandler;
-import com.intellij.packageDependencies.actions.BackwardDependenciesHandler;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiFile;
-import com.intellij.psi.PsiManager;
-import com.intellij.psi.search.scope.packageSet.NamedScope;
-import com.intellij.psi.search.scope.packageSet.PackageSet;
+import com.intellij.packageDependencies.actions.*;
+import com.intellij.psi.*;
+import com.intellij.psi.search.scope.packageSet.*;
import com.intellij.ui.*;
import com.intellij.ui.content.Content;
import com.intellij.ui.treeStructure.Tree;
-import com.intellij.usageView.UsageViewBundle;
+import com.intellij.usageView.*;
import com.intellij.util.*;
-import com.intellij.util.ui.UIUtil;
-import com.intellij.util.ui.tree.TreeUtil;
-import org.jdom.Document;
-import org.jdom.Element;
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.util.ui.*;
+import com.intellij.util.ui.tree.*;
+import org.jdom.*;
+import org.jetbrains.annotations.*;
import javax.swing.*;
-import javax.swing.event.ChangeListener;
-import javax.swing.event.TreeSelectionEvent;
-import javax.swing.event.TreeSelectionListener;
-import javax.swing.tree.DefaultTreeModel;
-import javax.swing.tree.TreePath;
+import javax.swing.event.*;
+import javax.swing.tree.*;
import java.awt.*;
import java.util.*;
import java.util.List;
PackageDependenciesNode selectedNode = (PackageDependenciesNode)path.getLastPathComponent();
traverseToLeaves(selectedNode, denyRules, allowRules);
}
- final StatusBar statusBar = WindowManager.getInstance().getStatusBar(myProject);
if (denyRules.length() + allowRules.length() > 0) {
- statusBar.setInfo(AnalysisScopeBundle.message("status.bar.rule.violation.message",
+ StatusBar.Info.set(AnalysisScopeBundle.message("status.bar.rule.violation.message",
((denyRules.length() == 0 || allowRules.length() == 0) ? 1 : 2),
(denyRules.length() > 0 ? denyRules.toString() + (allowRules.length() > 0 ? "; " : "") : " ") +
- (allowRules.length() > 0 ? allowRules.toString() : " ")));
-
+ (allowRules.length() > 0 ? allowRules.toString() : " ")), myProject);
}
else {
- statusBar.setInfo(AnalysisScopeBundle.message("status.bar.no.rule.violation.message"));
+ StatusBar.Info.set(AnalysisScopeBundle.message("status.bar.no.rule.violation.message"), myProject);
}
}
});
*/
package com.intellij.profile.codeInspection;
-import com.intellij.codeInsight.daemon.impl.SeverityRegistrar;
-import com.intellij.codeInsight.daemon.impl.analysis.HighlightingSettingsPerFile;
-import com.intellij.codeInspection.InspectionProfile;
-import com.intellij.codeInspection.ex.InspectionProfileImpl;
-import com.intellij.codeInspection.ex.InspectionProfileWrapper;
-import com.intellij.openapi.application.Application;
-import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.codeInsight.daemon.impl.*;
+import com.intellij.codeInsight.daemon.impl.analysis.*;
+import com.intellij.codeInspection.*;
+import com.intellij.codeInspection.ex.*;
+import com.intellij.openapi.application.*;
import com.intellij.openapi.components.*;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.startup.StartupManager;
-import com.intellij.openapi.util.Disposer;
-import com.intellij.openapi.util.InvalidDataException;
-import com.intellij.openapi.util.WriteExternalException;
-import com.intellij.openapi.wm.WindowManager;
-import com.intellij.openapi.wm.ex.StatusBarEx;
-import com.intellij.openapi.wm.impl.status.TogglePopupHintsPanel;
-import com.intellij.openapi.Disposable;
-import com.intellij.packageDependencies.DependencyValidationManager;
-import com.intellij.profile.DefaultProjectProfileManager;
-import com.intellij.profile.Profile;
-import com.intellij.psi.PsiElement;
-import org.jdom.Element;
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.startup.*;
+import com.intellij.openapi.util.*;
+import com.intellij.openapi.wm.*;
+import com.intellij.openapi.wm.ex.*;
+import com.intellij.openapi.wm.impl.status.*;
+import com.intellij.packageDependencies.*;
+import com.intellij.profile.*;
+import com.intellij.psi.*;
+import org.jdom.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
/**
* User: anna
return getInspectionProfile();
}
-
-
public InspectionProfileWrapper getProfileWrapper(){
final InspectionProfile profile = getInspectionProfile();
final String profileName = profile.getName();
public void projectOpened() {
myStatusBar = (StatusBarEx)WindowManager.getInstance().getStatusBar(myProject);
- myTogglePopupHintsPanel = new TogglePopupHintsPanel(myStatusBar);
- myStatusBar.addFileStatusComponent(myTogglePopupHintsPanel);
- Disposer.register(myProject, new Disposable() {
- public void dispose() {
- myStatusBar.removeFileStatusComponent(myTogglePopupHintsPanel);
- }
- });
+ myTogglePopupHintsPanel = new TogglePopupHintsPanel(myProject);
+ myStatusBar.addWidget(myTogglePopupHintsPanel, myProject);
StartupManager.getInstance(myProject).registerPostStartupActivity(new Runnable() {
public void run() {
final Set<Profile> profiles = new HashSet<Profile>();
*/
package com.intellij.execution.process;
-import com.intellij.ide.IdeBundle;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Key;
-import com.intellij.openapi.wm.WindowManager;
-import org.jetbrains.annotations.NonNls;
+import com.intellij.ide.*;
+import com.intellij.openapi.application.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.util.*;
+import com.intellij.openapi.wm.*;
+import org.jetbrains.annotations.*;
/**
* @author dyoma
if (myProject != null) ApplicationManager.getApplication().invokeLater(new Runnable(){
public void run() {
if (myProject.isDisposed()) return;
- WindowManager.getInstance().getStatusBar(myProject).setInfo(message);
+ StatusBar.Info.set(message, myProject);
}
});
}
*/
package com.intellij.notification;
-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.ui.popup.Balloon;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.openapi.diagnostic.*;
+import com.intellij.openapi.ui.popup.*;
+import org.jetbrains.annotations.*;
import javax.swing.*;
-import java.lang.ref.WeakReference;
+import java.lang.ref.*;
/**
* @author spleaner
public void setBalloon(@Nullable final Balloon balloon) {
if (balloon != null) {
myBalloonRef = new WeakReference<Balloon>(balloon);
+ } else {
+ myBalloonRef = null;
}
}
+
+ @Nullable
+ public Balloon getBalloon() {
+ return myBalloonRef == null ? null : myBalloonRef.get();
+ }
}
package com.intellij.openapi.options;
import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import javax.swing.*;
* Date: 08-Feb-2006
*/
public interface SearchableConfigurable extends Configurable {
+ @NotNull
@NonNls String getId();
@Nullable Runnable enableSearch(String option);
/*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2010 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package com.intellij.openapi.wm.impl.status;
-
-import com.intellij.openapi.editor.Editor;
+package com.intellij.openapi.wm;
import javax.swing.*;
/**
- * @author cdr
+ * User: spLeaner
*/
-public interface StatusBarPatch {
- JComponent getComponent();
+public interface CustomStatusBarWidget extends StatusBarWidget {
- //returns updated tooltip/text
- String updateStatusBar(Editor selected, final JComponent componentSelected);
+ JComponent getComponent();
- void clear();
}
*/
package com.intellij.openapi.wm;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.annotations.NotNull;
+import com.intellij.openapi.*;
+import com.intellij.openapi.application.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.startup.*;
+import com.intellij.util.messages.*;
+import org.jetbrains.annotations.*;
import javax.swing.*;
import java.awt.*;
-public interface StatusBar {
- /**
- * Set status bar text
- * @param s text to be shown in the status bar
- */
- void setInfo(@Nullable String s);
+/**
+ * @author spleaner
+ */
+public interface StatusBar extends StatusBarInfo {
+ @SuppressWarnings({"AbstractClassNeverImplemented"})
+ abstract class Info implements StatusBarInfo {
+ public static final Topic<StatusBarInfo> TOPIC = Topic.create("IdeStatusBar.Text", StatusBarInfo.class);
- /**
- * Add arbitrary component indicating something related to status in the status bar. The component shall be
- * small enough to keep visual status bar appearance metaphor.
- * @param c - custom component to be added to the status bar.
- */
- void addCustomIndicationComponent(@NotNull JComponent c);
+ private Info() {}
+
+ public static void set(@Nullable final String text, @Nullable final Project project) {
+ if (project != null && !project.isInitialized() && !project.isDisposed()) {
+ StartupManager.getInstance(project).runWhenProjectIsInitialized(new Runnable() {
+ public void run() {
+ project.getMessageBus().syncPublisher(TOPIC).setInfo(text);
+ }
+ });
+ return;
+ }
+
+ final MessageBus bus = project == null ? ApplicationManager.getApplication().getMessageBus() : project.getMessageBus();
+ bus.syncPublisher(TOPIC).setInfo(text);
+ }
+ }
+
+ void addWidget(@NotNull StatusBarWidget widget);
+ void addWidget(@NotNull StatusBarWidget widget, @NotNull String anchor);
+
+ void addWidget(@NotNull StatusBarWidget widget, @NotNull Disposable parentDisposable);
+ void addWidget(@NotNull StatusBarWidget widget, @NotNull String anchor, @NotNull Disposable parentDisposable);
/**
- * Shows animated notification popup.
- * @param content Content of the notification
- * @param backgroundColor background color for the notification. Be sure use light colors since bright onces
- * look noisy. See {@link com.intellij.ui.LightColors} for convinient colors
+ * @deprecated use addWidget instead
*/
- void fireNotificationPopup(@NotNull JComponent content, final Color backgroundColor);
-
+ @Deprecated
+ void addCustomIndicationComponent(@NotNull JComponent c);
void removeCustomIndicationComponent(@NotNull JComponent c);
- void startRefreshIndication(String tooltipText);
+ void removeWidget(@NotNull String id);
+ void updateWidget(@NotNull String id);
- void stopRefreshIndication();
+ void fireNotificationPopup(@NotNull JComponent content, Color backgroundColor);
}
*/
package com.intellij.openapi.wm;
-import com.intellij.openapi.extensions.ExtensionPointName;
-import org.jetbrains.annotations.NotNull;
+import com.intellij.openapi.extensions.*;
+import org.jetbrains.annotations.*;
import javax.swing.*;
-import java.util.EventListener;
+import java.util.*;
+/**
+ * @deprecated use StatusBarWidget instead
+ */
+@Deprecated
public abstract class StatusBarCustomComponentFactory<T extends JComponent> implements EventListener {
public static final ExtensionPointName<StatusBarCustomComponentFactory> EP_NAME = ExtensionPointName.create("com.intellij.statusBarComponent");
--- /dev/null
+/*
+ * Copyright 2000-2010 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.openapi.wm;
+
+import org.jetbrains.annotations.*;
+
+/**
+ * User: spLeaner
+ */
+public interface StatusBarInfo {
+
+ /**
+ * Set status bar text
+ * @param s text to be shown in the status bar
+ */
+ void setInfo(@Nullable String s);
+
+ String getInfo();
+}
--- /dev/null
+/*
+ * Copyright 2000-2010 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.openapi.wm;
+
+import com.intellij.openapi.*;
+import com.intellij.openapi.ui.popup.*;
+import com.intellij.openapi.util.*;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
+
+import javax.swing.*;
+import javax.swing.border.*;
+import java.awt.*;
+import java.awt.event.*;
+
+/**
+ * User: spLeaner
+ */
+public interface StatusBarWidget extends Disposable {
+
+ enum Type {
+ DEFAULT, MAC
+ }
+
+ interface Presentation {
+ @Nullable
+ String getTooltipText();
+
+ @Nullable
+ Consumer<MouseEvent> getClickConsumer();
+ }
+
+ interface IconPresentation extends Presentation {
+ @NotNull
+ Icon getIcon();
+ }
+
+ interface TextPresentation extends Presentation {
+ @NotNull
+ String getText();
+
+ @NotNull
+ String getMaxPossibleText();
+ }
+
+ interface MultipleTextValuesPresentation extends Presentation {
+ @NotNull
+ ListPopup getPopupStep();
+
+ @Nullable
+ String getSelectedValue();
+
+ @NotNull
+ String getMaxValue();
+ }
+
+ @NotNull
+ String ID();
+
+ @Nullable
+ Presentation getPresentation(@NotNull Type type);
+
+ void install(@NotNull final StatusBar statusBar);
+
+ class WidgetBorder implements Border {
+ public static final WidgetBorder INSTANCE = new WidgetBorder();
+
+ private static final Color TOP = new Color(227, 227, 227);
+ private static final Color LEFT1_FROM = new Color(161, 161, 161);
+ private static final Color LEFT1_TO = new Color(133, 133, 133);
+ private static final Color LEFT2_FROM = new Color(220, 220, 220);
+ private static final Color LEFT2_TO = new Color(184, 184, 184);
+ private static final Color LEFT1_FROM_INACTIVE = new Color(190, 190, 190);
+ private static final Color PIXEL = LEFT1_FROM_INACTIVE;
+ private static final Color LEFT1_TO_INACTIVE = new Color(180, 180, 180);
+
+ private static final Color SEPARATOR_COLOR = new Color(215, 215, 215);
+
+ public void paintBorder(final Component c, final Graphics g, final int x, final int y, final int width, final int height) {
+ final Graphics2D g2 = (Graphics2D)g.create();
+ if (SystemInfo.isMac) {
+ final Window window = SwingUtilities.getWindowAncestor(c);
+ if (window != null && window.isActive()) {
+ g2.setPaint(new GradientPaint(0, 0, LEFT1_FROM, 0, height, LEFT1_TO));
+ g2.drawLine(x, y, x, y + height);
+
+ g2.setPaint(new GradientPaint(0, 0, LEFT2_FROM, 0, height, LEFT2_TO));
+ g2.drawLine(x + 1, y, x + 1, y + height);
+
+ g2.setColor(PIXEL);
+ g2.drawLine(x, y, x, y);
+
+ g2.setColor(TOP);
+ g2.drawLine(x + 2, y, x + width - 2, y);
+ }
+ else {
+ g2.setPaint(new GradientPaint(0, 0, LEFT1_FROM_INACTIVE, 0, height, LEFT1_TO_INACTIVE));
+ g2.drawLine(x, y, x, y + height);
+ }
+ } else {
+ g2.setColor(SEPARATOR_COLOR);
+ g2.drawLine(x, y, x, y + height);
+ }
+
+ g2.dispose();
+ }
+
+ public Insets getBorderInsets(Component c) {
+ return new Insets(2, SystemInfo.isMac ? 4 : 4, 2, 2);
+ }
+
+ public boolean isBorderOpaque() {
+ return false;
+ }
+ }
+}
+++ /dev/null
-/*
- * Copyright 2000-2009 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.ui;
-
-import com.intellij.openapi.wm.StatusBar;
-import com.intellij.openapi.wm.IdeFrame;
-
-import javax.swing.*;
-import java.awt.event.MouseAdapter;
-import java.awt.event.MouseEvent;
-import java.awt.*;
-
-import org.jetbrains.annotations.Nullable;
-
-public class StatusBarInformer {
-
- private String myText;
- private StatusBar myStatusBar;
- private JComponent myComponent;
-
- public StatusBarInformer(final JComponent component, String text) {
- this(component, text, null);
- }
-
- public StatusBarInformer(final JComponent component, String text, StatusBar statusBar) {
- myText = text;
- myStatusBar = statusBar;
- myComponent = component;
- myComponent.addMouseListener(new MouseAdapter() {
- public void mouseEntered(final MouseEvent e) {
- final StatusBar bar = getStatusBar();
- final String text = getText();
- if (bar != null) {
- bar.setInfo(text);
- }
- myComponent.setToolTipText(text);
- }
-
- public void mouseExited(final MouseEvent e) {
- final StatusBar bar = getStatusBar();
- if (bar != null) {
- bar.setInfo(null);
- }
- myComponent.setToolTipText(null);
- }
- });
- }
-
- @Nullable
- protected String getText() {
- return myText;
- }
-
- @Nullable
- protected StatusBar getStatusBar() {
- if (myStatusBar != null) return myStatusBar;
- final Window window = SwingUtilities.getWindowAncestor(myComponent);
- if (window instanceof IdeFrame) {
- return ((IdeFrame)window).getStatusBar();
- }
- return null;
- }
-}
*/
package com.intellij.ui.components.labels;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.project.ProjectManager;
-import com.intellij.openapi.util.IconLoader;
-import com.intellij.openapi.wm.WindowManager;
-import com.intellij.openapi.wm.StatusBar;
-import com.intellij.ui.UI;
-import com.intellij.util.ui.UIUtil;
+import com.intellij.openapi.application.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.util.*;
+import com.intellij.openapi.wm.*;
+import com.intellij.ui.*;
+import com.intellij.util.ui.*;
import javax.swing.*;
-import javax.swing.border.Border;
+import javax.swing.border.*;
import java.awt.*;
-import java.awt.event.MouseAdapter;
-import java.awt.event.MouseEvent;
-import java.awt.event.MouseMotionListener;
-import java.util.HashSet;
-import java.util.Set;
+import java.awt.event.*;
+import java.util.*;
/**
* @author kir
setActive(false);
}
- private void setStatusBarText(String statusBarText) {
+ private static void setStatusBarText(String statusBarText) {
if (ApplicationManager.getApplication() == null) return; // makes this component work in UIDesigner preview.
final Project[] projects = ProjectManager.getInstance().getOpenProjects();
for (Project project : projects) {
- final StatusBar bar = WindowManager.getInstance().getStatusBar(project);
- if (bar != null) {
- bar.setInfo(statusBarText);
- }
+ StatusBar.Info.set(statusBarText, project);
}
}
package com.intellij.util.ui;
-import com.intellij.openapi.Disposable;
+import com.intellij.openapi.*;
import javax.swing.*;
import java.awt.*;
return myPaintPassive ? myPassiveIcon : myEmptyPassiveIcon;
}
+ public boolean isRunning() {
+ return myAnimator.isRunning();
+ }
public boolean isAnimated() {
return true;
*/
package com.intellij.diagnostic;
-import com.intellij.concurrency.JobScheduler;
-import com.intellij.ide.util.PropertiesComponent;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.util.IconLoader;
-import com.intellij.openapi.wm.impl.status.StatusBarPatch;
-import com.intellij.ui.LightColors;
-import com.intellij.ui.popup.NotificationPopup;
+import com.intellij.concurrency.*;
+import com.intellij.ide.util.*;
+import com.intellij.openapi.util.*;
+import com.intellij.openapi.wm.*;
+import com.intellij.ui.*;
+import com.intellij.ui.popup.*;
+import org.jetbrains.annotations.*;
import javax.swing.*;
import java.awt.*;
-import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
-import java.awt.event.MouseAdapter;
-import java.awt.event.MouseEvent;
-import java.util.concurrent.TimeUnit;
+import java.awt.event.*;
+import java.util.concurrent.*;
-public class IdeMessagePanel extends JPanel implements MessagePoolListener, StatusBarPatch {
+public class IdeMessagePanel extends JPanel implements MessagePoolListener, CustomStatusBarWidget {
private final IconPane myIdeFatal;
private final IconPane[] myIcons;
private boolean myOpeningInProgress;
private final MessagePool myMessagePool;
private boolean myNotificationPopupAlreadyShown = false;
- private final Icon myIcon = IconLoader.getIcon("/general/ideFatalError.png");
+ private final Icon myIcon = IconLoader.getIcon("/ide/fatalError.png");
+ private final Icon myEmptyIcon = IconLoader.getIcon("/ide/emptyFatalError.png");
public IdeMessagePanel(MessagePool messagePool) {
super(new BorderLayout());
- myIdeFatal = new IconPane(myIcon,
+ myIdeFatal = new IconPane(myIcon, myEmptyIcon,
DiagnosticBundle.message("error.notification.empty.text"), new ActionListener() {
public void actionPerformed(ActionEvent e) {
openFatals();
JobScheduler.getScheduler().scheduleAtFixedRate(new Blinker(), (long)1, (long)1, TimeUnit.SECONDS);
updateFatalErrorsIcon();
+
+ setOpaque(false);
}
- public JComponent getComponent() {
- return this;
+ @NotNull
+ public String ID() {
+ return "FatalError";
}
- public String updateStatusBar(final Editor selected, final JComponent componentSelected) {
+ public Presentation getPresentation(@NotNull Type type) {
return null;
}
- public void clear() {
+ public void dispose() {
+ }
+ public void install(@NotNull StatusBar statusBar) {
+ }
+
+ public JComponent getComponent() {
+ return this;
}
private void openFatals() {
private boolean myIsActive;
private final ActionListener myListener;
- public IconPane(Icon aIcon, String aEmptyText, ActionListener aListener) {
- myIcon = new IconWrapper(aIcon);
+ public IconPane(Icon aIcon, Icon offIcon, String aEmptyText, ActionListener aListener) {
+ myIcon = new IconWrapper(aIcon, offIcon);
myEmptyText = aEmptyText;
myListener = aListener;
setIcon(myIcon);
+ setBorder(BorderFactory.createEmptyBorder(0, 1, 0, 1));
+
addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if (myIsActive) {
private final Icon myIcon;
private boolean myEnabled;
private boolean myShouldPaint = true;
+ private Icon myOffIcon;
- public IconWrapper(Icon aIcon) {
+ public IconWrapper(Icon aIcon, Icon offIcon) {
myIcon = aIcon;
+ myOffIcon = offIcon;
}
public void setIconPainted(boolean aPainted) {
public void paintIcon(Component c, Graphics g, int x, int y) {
if (myEnabled && myShouldPaint) {
myIcon.paintIcon(c, g, x, y);
+ } else if (myOffIcon != null) {
+ myOffIcon.paintIcon(c, g, x, y);
}
}
*/
package com.intellij.ide.util;
-import com.intellij.ide.IdeBundle;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.editor.LogicalPosition;
-import com.intellij.openapi.editor.ScrollType;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.ui.DialogWrapper;
+import com.intellij.ide.*;
+import com.intellij.openapi.application.ex.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.ui.*;
import javax.swing.*;
import java.awt.*;
public class GotoLineNumberDialog extends DialogWrapper {
- private JLabel myLabel;
private JTextField myField;
+ private JTextField myOffsetField;
private final Editor myEditor;
public GotoLineNumberDialog(Project project, Editor editor){
protected void doOKAction(){
final LogicalPosition currentPosition = myEditor.getCaretModel().getLogicalPosition();
int lineNumber = getLineNumber(currentPosition.line + 1);
+ if (isInternal() && myOffsetField.getText().length() > 0) {
+ try {
+ final int offset = Integer.parseInt(myOffsetField.getText());
+ if (offset < myEditor.getDocument().getTextLength()) {
+ myEditor.getCaretModel().moveToOffset(offset);
+ myEditor.getScrollingModel().scrollToCaret(ScrollType.CENTER);
+ myEditor.getSelectionModel().removeSelection();
+ super.doOKAction();
+ }
+ return;
+ }
+ catch (NumberFormatException e) {
+ return;
+ }
+ }
+
if (lineNumber <= 0) return;
int columnNumber = getColumnNumber(currentPosition.column);
}
}
+ private static boolean isInternal() {
+ return ApplicationManagerEx.getApplicationEx().isInternal();
+ }
+
public JComponent getPreferredFocusedComponent() {
return myField;
}
gbConstraints.weightx = 0;
gbConstraints.weighty = 1;
gbConstraints.anchor = GridBagConstraints.EAST;
- myLabel = new JLabel(IdeBundle.message("editbox.line.number"));
- panel.add(myLabel, gbConstraints);
+ JLabel label = new JLabel(IdeBundle.message("editbox.line.number"));
+ panel.add(label, gbConstraints);
gbConstraints.fill = GridBagConstraints.BOTH;
gbConstraints.weightx = 1;
panel.add(myField, gbConstraints);
myField.setToolTipText(IdeBundle.message("tooltip.syntax.linenumber.columnnumber"));
+ if (isInternal()) {
+ gbConstraints.gridy = 1;
+ gbConstraints.weightx = 0;
+ gbConstraints.weighty = 1;
+ gbConstraints.anchor = GridBagConstraints.EAST;
+ final JLabel offsetLabel = new JLabel("Offset:");
+ panel.add(offsetLabel, gbConstraints);
+
+ gbConstraints.fill = GridBagConstraints.BOTH;
+ gbConstraints.weightx = 1;
+ myOffsetField = new MyTextField();
+ panel.add(myOffsetField, gbConstraints);
+ }
+
return panel;
}
}
*/
package com.intellij.notification.impl;
-import com.intellij.ide.DataManager;
-import com.intellij.notification.impl.ui.NotificationComponent;
-import com.intellij.openapi.actionSystem.PlatformDataKeys;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.wm.impl.status.StatusBarImpl;
-import com.intellij.openapi.wm.impl.status.StatusBarPatch;
-import com.intellij.openapi.wm.impl.status.StatusBarTooltipper;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.ide.*;
+import com.intellij.notification.*;
+import com.intellij.notification.impl.ui.*;
+import com.intellij.openapi.actionSystem.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.ui.popup.*;
+import com.intellij.openapi.util.*;
+import com.intellij.openapi.wm.*;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.lang.ref.*;
/**
* @author spleaner
*/
-public class IdeNotificationArea implements StatusBarPatch {
- private final NotificationComponent myNotificationComponent;
+public class IdeNotificationArea implements StatusBarWidget, StatusBarWidget.IconPresentation, NotificationModelListener {
+ private static final Icon EMPTY_ICON = IconLoader.getIcon("/ide/notifications.png");
+ private static final Icon ERROR_ICON = IconLoader.getIcon("/ide/error_notifications.png");
+ private static final Icon WARNING_ICON = IconLoader.getIcon("/ide/warning_notifications.png");
+ private static final Icon INFO_ICON = IconLoader.getIcon("/ide/info_notifications.png");
- public IdeNotificationArea(final StatusBarImpl statusBar) {
- myNotificationComponent = new NotificationComponent(this);
+ private WeakReference<JBPopup> myPopupRef;
+ private Icon myCurrentIcon = EMPTY_ICON;
+ private StatusBar myStatusBar;
- StatusBarTooltipper.install(this, statusBar);
+ public IdeNotificationArea() {
}
- public JComponent getComponent() {
- return myNotificationComponent;
+ public Presentation getPresentation(@NotNull Type type) {
+ return this;
+ }
+
+ public void dispose() {
+ getManager().removeListener(this); // clean up
+ cancelPopup();
+ }
+
+ public void install(@NotNull StatusBar statusBar) {
+ myStatusBar = statusBar;
+ getManager().addListener(this);
+ }
+
+ private void cancelPopup() {
+ if (myPopupRef != null) {
+ final JBPopup popup = myPopupRef.get();
+ if (popup != null) {
+ popup.cancel();
+ }
+
+ myPopupRef = null;
+ }
}
@Nullable
- public String updateStatusBar(final Editor selected, final JComponent componentSelected) {
+ private Project getProject() {
+ return PlatformDataKeys.PROJECT.getData(DataManager.getInstance().getDataContext((Component) myStatusBar));
+ }
+
+ public Consumer<MouseEvent> getClickConsumer() {
+ return new Consumer<MouseEvent>() {
+ public void consume(MouseEvent mouseEvent) {
+ toggleList();
+ }
+ };
+ }
+
+ private static NotificationsManagerImpl getManager() {
+ return NotificationsManagerImpl.getNotificationsManagerImpl();
+ }
+
+ private void toggleList() {
+ JBPopup popup = null;
+ if (myPopupRef != null) {
+ popup = myPopupRef.get();
+ myPopupRef = null;
+ }
+
+ if (popup != null && popup.isVisible()) {
+ popup.cancel();
+ } else {
+ myPopupRef = new WeakReference<JBPopup>(NotificationsListPanel.show(getProject(), (JComponent) myStatusBar));
+ }
+ }
+
+ @NotNull
+ public Icon getIcon() {
+ return myCurrentIcon;
+ }
+
+ public String getTooltipText() {
final NotificationsManagerImpl manager = NotificationsManagerImpl.getNotificationsManagerImpl();
if (manager.hasNotifications(getProject())) {
final int count = manager.count(getProject());
return String.format("%s notification%s pending", count, count == 1 ? "" : "s");
}
- return null;
+ return "No new notifications";
}
- public void clear() {
+ @NotNull
+ public String ID() {
+ return "Notifications";
}
- @Nullable
- public Project getProject() {
- return PlatformDataKeys.PROJECT.getData(DataManager.getInstance().getDataContext(myNotificationComponent));
+ public void updateStatus() {
+ final NotificationsManagerImpl manager = getManager();
+
+ Icon icon = EMPTY_ICON;
+ final NotificationType maximumType = manager.getMaximumType(getProject());
+ if (maximumType != null) {
+ switch (maximumType) {
+ case WARNING:
+ icon = WARNING_ICON;
+ break;
+ case ERROR:
+ icon = ERROR_ICON;
+ break;
+ case INFORMATION:
+ default:
+ icon = INFO_ICON;
+ break;
+ }
+ }
+
+ myCurrentIcon = icon;
+ if (manager.count(getProject()) == 0) {
+ cancelPopup();
+ }
+
+ myStatusBar.updateWidget(ID());
+ }
+
+ public void notificationsAdded(@NotNull final Notification... notifications) {
+ SwingUtilities.invokeLater(new Runnable() {
+ public void run() {
+ updateStatus();
+ }
+ });
+ }
+
+ public void notificationsRead(@NotNull Notification... notification) {
+ SwingUtilities.invokeLater(new Runnable() {
+ public void run() {
+ updateStatus();
+ }
+ });
+ }
+
+ @SuppressWarnings({"SSBasedInspection"})
+ public void notificationsRemoved(@NotNull final Notification... notifications) {
+ SwingUtilities.invokeLater(new Runnable() {
+ public void run() {
+ updateStatus();
+ }
+ });
}
}
package com.intellij.notification.impl;
import com.intellij.notification.*;
-import com.intellij.notification.impl.ui.NotificationsUtil;
-import com.intellij.openapi.Disposable;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.components.ApplicationComponent;
-import com.intellij.openapi.components.ServiceManager;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.ui.popup.Balloon;
-import com.intellij.openapi.ui.popup.BalloonBuilder;
-import com.intellij.openapi.ui.popup.JBPopupFactory;
-import com.intellij.openapi.util.Disposer;
-import com.intellij.openapi.wm.WindowManager;
-import com.intellij.openapi.wm.impl.IdeFrameImpl;
-import com.intellij.ui.BalloonLayout;
-import com.intellij.ui.SystemNotifications;
-import com.intellij.ui.components.panels.NonOpaquePanel;
-import com.intellij.util.ArrayUtil;
-import com.intellij.util.PairFunction;
-import com.intellij.util.ui.UIUtil;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.notification.impl.ui.*;
+import com.intellij.openapi.application.*;
+import com.intellij.openapi.components.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.ui.popup.*;
+import com.intellij.openapi.wm.*;
+import com.intellij.openapi.wm.impl.*;
+import com.intellij.ui.*;
+import com.intellij.ui.components.panels.*;
+import com.intellij.util.*;
+import com.intellij.util.ui.*;
+import org.jetbrains.annotations.*;
import javax.swing.*;
-import javax.swing.border.EmptyBorder;
-import javax.swing.event.HyperlinkListener;
+import javax.swing.border.*;
+import javax.swing.event.*;
import java.awt.*;
-import java.util.ArrayList;
-import java.util.Collection;
+import java.util.*;
import java.util.List;
/**
}
final Balloon balloon = builder.createBalloon();
+ balloon.addListener(new JBPopupAdapter() {
+ @Override
+ public void onClosed(LightweightWindowEvent event) {
+ notification.setBalloon(null);
+ }
+ });
+
notification.setBalloon(balloon);
final Runnable show = new Runnable() {
if (window instanceof IdeFrameImpl) {
final BalloonLayout balloonLayout = ((IdeFrameImpl)window).getBalloonLayout();
balloonLayout.add(balloon);
- if (project != null) {
- Disposer.register(project, new Disposable() {
- public void dispose() {
- balloon.hide();
- }
- });
- }
}
}
};
*/
package com.intellij.notification.impl;
-import com.intellij.notification.Notifications;
-import com.intellij.notification.Notification;
-import com.intellij.notification.NotificationDisplayType;
-import com.intellij.openapi.application.Application;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.components.ProjectComponent;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Disposer;
-import com.intellij.openapi.Disposable;
-import org.jetbrains.annotations.NotNull;
+import com.intellij.notification.*;
+import com.intellij.openapi.*;
+import com.intellij.openapi.application.*;
+import com.intellij.openapi.components.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.ui.popup.*;
+import com.intellij.openapi.util.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
/**
* @author spleaner
}
public void projectClosed() {
+ final Collection<Notification> collection = NotificationsManagerImpl.getNotificationsManagerImpl().getByType(null, myProject);
+ for (final Notification notification : collection) {
+ final Balloon balloon = notification.getBalloon();
+ if (balloon != null) balloon.hide();
+ }
}
private static boolean isDummyEnvironment() {
+++ /dev/null
-/*
- * Copyright 2000-2009 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.notification.impl.ui;
-
-import com.intellij.concurrency.JobScheduler;
-import com.intellij.notification.Notification;
-import com.intellij.notification.NotificationType;
-import com.intellij.notification.impl.*;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.ui.popup.JBPopup;
-import com.intellij.openapi.util.IconLoader;
-import com.intellij.util.ui.UIUtil;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import javax.swing.*;
-import java.awt.*;
-import java.awt.event.MouseAdapter;
-import java.awt.event.MouseEvent;
-import java.awt.image.BufferedImage;
-import java.lang.ref.WeakReference;
-import java.util.concurrent.TimeUnit;
-
-/**
- * @author spleaner
- */
-public class NotificationComponent extends JLabel implements NotificationModelListener {
- private static final Icon EMPTY_ICON = IconLoader.getIcon("/ide/notifications.png");
- private static final Icon READ_ICON = IconLoader.getIcon("/ide/read_notifications.png");
- private static final Icon ERROR_ICON = IconLoader.getIcon("/ide/error_notifications.png");
- private static final Icon WARNING_ICON = IconLoader.getIcon("/ide/warning_notifications.png");
- private static final Icon INFO_ICON = IconLoader.getIcon("/ide/info_notifications.png");
-
- private WeakReference<JBPopup> myPopupRef;
-
- private BlinkIconWrapper myCurrentIcon;
- private final boolean myBlinkIcon = true;
- private final IdeNotificationArea myArea;
-
- public NotificationComponent(@NotNull final IdeNotificationArea area) {
- myArea = area;
-
- addMouseListener(new MouseAdapter() {
- @Override
- public void mousePressed(final MouseEvent e) {
- if (UIUtil.isActionClick(e)) {
- toggleList();
- }
- }
- });
-
- myCurrentIcon = new BlinkIconWrapper(EMPTY_ICON, false);
- setIcon(myCurrentIcon);
-
- JobScheduler.getScheduler().scheduleAtFixedRate(new IconBlinker(), (long)1, (long)1, TimeUnit.SECONDS);
- }
-
- private static NotificationsManagerImpl getManager() {
- return NotificationsManagerImpl.getNotificationsManagerImpl();
- }
-
- @Override
- public void removeNotify() {
- getManager().removeListener(this); // clean up
-
- cancelPopup();
- super.removeNotify();
- }
-
- private void cancelPopup() {
- if (myPopupRef != null) {
- final JBPopup popup = myPopupRef.get();
- if (popup != null) {
- popup.cancel();
- }
-
- myPopupRef = null;
- }
- }
-
- public void addNotify() {
- super.addNotify();
-
- getManager().addListener(this);
- }
-
- private void toggleList() {
- JBPopup popup = null;
- if (myPopupRef != null) {
- popup = myPopupRef.get();
- myPopupRef = null;
- }
-
- if (popup != null && popup.isVisible()) {
- popup.cancel();
- } else {
- myPopupRef = new WeakReference<JBPopup>(NotificationsListPanel.show(getProject(), this));
- }
- }
-
- public void updateStatus() {
- final NotificationsManagerImpl manager = getManager();
-
- Icon icon = EMPTY_ICON;
- final NotificationType maximumType = manager.getMaximumType(getProject());
- if (maximumType != null) {
- switch (maximumType) {
- case WARNING:
- icon = WARNING_ICON;
- break;
- case ERROR:
- icon = ERROR_ICON;
- break;
- case INFORMATION:
- default:
- icon = INFO_ICON;
- break;
- }
- }
-
- myCurrentIcon = new BlinkIconWrapper(icon, false);
- setIcon(myCurrentIcon);
-
- if (manager.count(getProject()) == 0) {
- cancelPopup();
- }
-
- repaint();
- }
-
- @Nullable
- public Project getProject() {
- return myArea.getProject();
- }
-
- @SuppressWarnings({"SSBasedInspection"})
- public void notificationsAdded(@NotNull final Notification... notifications) {
- SwingUtilities.invokeLater(new Runnable() {
- public void run() {
- updateStatus();
- }
- });
- }
-
- public void notificationsRead(@NotNull Notification... notification) {
- SwingUtilities.invokeLater(new Runnable() {
- public void run() {
- updateStatus();
- }
- });
- }
-
- @SuppressWarnings({"SSBasedInspection"})
- public void notificationsRemoved(@NotNull final Notification... notifications) {
- SwingUtilities.invokeLater(new Runnable() {
- public void run() {
- updateStatus();
- }
- });
- }
-
- private void blinkIcon(boolean visible) {
- myCurrentIcon.setPaint(visible);
- }
-
- private class IconBlinker implements Runnable {
- private boolean myVisible;
-
- public void run() {
- myVisible = !myVisible;
- blinkIcon(myVisible);
- }
- }
-
- private class BlinkIconWrapper implements Icon {
- private final Icon myOriginal;
- private boolean myPaint;
- private final boolean myBlink;
- private BufferedImage myGrayscaleImage;
-
- private BlinkIconWrapper(@NotNull final Icon original, final boolean blink) {
- myOriginal = original;
- myBlink = blink;
- }
-
- public void setPaint(final boolean paint) {
- if (paint != myPaint) {
- SwingUtilities.invokeLater(new Runnable() {
- public void run() {
- repaint();
- }
- });
- }
-
- myPaint = paint;
- }
-
- public void paintIcon(Component c, Graphics g, int x, int y) {
- if (!myBlinkIcon) {
- if (myGrayscaleImage == null) {
- myGrayscaleImage = new BufferedImage(myOriginal.getIconWidth(), myOriginal.getIconHeight(), BufferedImage.TYPE_BYTE_GRAY);
- final Graphics2D gi = myGrayscaleImage.createGraphics();
-
- gi.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.2f));
-
- myOriginal.paintIcon(c, gi, 0, 0);
- gi.dispose();
- }
-
- g.drawImage(myGrayscaleImage, x, y, null);
- }
- else if (!myBlink || !myPaint) {
- myOriginal.paintIcon(c, g, x, y);
- }
- }
-
- public int getIconWidth() {
- return myOriginal.getIconWidth();
- }
-
- public int getIconHeight() {
- return myOriginal.getIconHeight();
- }
- }
-}
*/
package com.intellij.openapi.fileEditor.impl;
-import com.intellij.AppTopics;
-import com.intellij.ProjectTopics;
-import com.intellij.ide.IdeBundle;
-import com.intellij.ide.plugins.PluginManager;
-import com.intellij.ide.ui.UISettings;
-import com.intellij.ide.ui.UISettingsListener;
-import com.intellij.injected.editor.VirtualFileWindow;
-import com.intellij.openapi.Disposable;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.application.ModalityState;
-import com.intellij.openapi.application.ex.ApplicationManagerEx;
-import com.intellij.openapi.application.impl.LaterInvocator;
+import com.intellij.*;
+import com.intellij.ide.*;
+import com.intellij.ide.plugins.*;
+import com.intellij.ide.ui.*;
+import com.intellij.injected.editor.*;
+import com.intellij.openapi.*;
+import com.intellij.openapi.application.*;
+import com.intellij.openapi.application.ex.*;
+import com.intellij.openapi.application.impl.*;
import com.intellij.openapi.command.CommandProcessor;
-import com.intellij.openapi.components.ProjectComponent;
-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.editor.ex.EditorEx;
-import com.intellij.openapi.extensions.Extensions;
+import com.intellij.openapi.components.*;
+import com.intellij.openapi.diagnostic.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.editor.ex.*;
+import com.intellij.openapi.extensions.*;
import com.intellij.openapi.fileEditor.*;
-import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx;
-import com.intellij.openapi.fileEditor.ex.FileEditorProviderManager;
-import com.intellij.openapi.fileEditor.ex.IdeDocumentHistory;
-import com.intellij.openapi.fileEditor.impl.text.TextEditorImpl;
-import com.intellij.openapi.fileEditor.impl.text.TextEditorProvider;
-import com.intellij.openapi.fileTypes.FileTypeEvent;
-import com.intellij.openapi.fileTypes.FileTypeListener;
-import com.intellij.openapi.project.DumbAware;
-import com.intellij.openapi.project.DumbAwareRunnable;
-import com.intellij.openapi.project.DumbService;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.project.impl.ProjectImpl;
-import com.intellij.openapi.roots.ModuleRootEvent;
-import com.intellij.openapi.roots.ModuleRootListener;
-import com.intellij.openapi.startup.StartupManager;
+import com.intellij.openapi.fileEditor.FileEditorProvider;
+import com.intellij.openapi.fileEditor.ex.*;
+import com.intellij.openapi.fileEditor.impl.text.*;
+import com.intellij.openapi.fileTypes.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.project.impl.*;
+import com.intellij.openapi.roots.*;
+import com.intellij.openapi.startup.*;
import com.intellij.openapi.util.*;
-import com.intellij.openapi.vcs.FileStatus;
-import com.intellij.openapi.vcs.FileStatusListener;
-import com.intellij.openapi.vcs.FileStatusManager;
+import com.intellij.openapi.vcs.*;
import com.intellij.openapi.vfs.*;
-import com.intellij.openapi.wm.ToolWindowManager;
-import com.intellij.openapi.wm.WindowManager;
-import com.intellij.openapi.wm.ex.StatusBarEx;
-import com.intellij.openapi.wm.ex.WindowManagerEx;
-import com.intellij.openapi.wm.impl.FrameTitleBuilder;
-import com.intellij.openapi.wm.impl.IdeFrameImpl;
-import com.intellij.util.containers.ContainerUtil;
-import com.intellij.util.messages.MessageBusConnection;
-import com.intellij.util.messages.impl.MessageListenerList;
-import com.intellij.util.ui.update.MergingUpdateQueue;
-import com.intellij.util.ui.update.Update;
-import org.jdom.Element;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.openapi.wm.*;
+import com.intellij.openapi.wm.ex.*;
+import com.intellij.openapi.wm.impl.*;
+import com.intellij.util.containers.*;
+import com.intellij.util.messages.*;
+import com.intellij.util.messages.impl.*;
+import com.intellij.util.ui.update.*;
+import org.jdom.*;
+import org.jetbrains.annotations.*;
import javax.swing.*;
import java.awt.*;
-import java.beans.PropertyChangeEvent;
-import java.beans.PropertyChangeListener;
-import java.io.File;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
+import java.beans.*;
+import java.io.*;
+import java.util.*;
import java.util.List;
/**
}
}
else if (VirtualFile.PROP_WRITABLE.equals(e.getPropertyName()) || VirtualFile.PROP_ENCODING.equals(e.getPropertyName())) {
+ // TODO: message bus?
updateIconAndStatusbar(e);
}
}
if (file.equals(getSelectedFiles()[0])) { // update "write" status
final StatusBarEx statusBar = (StatusBarEx)WindowManager.getInstance().getStatusBar(myProject);
assert statusBar != null;
- statusBar.update(getSelectedTextEditor());
+ statusBar.updateWidgets();
}
}
}
*/
package com.intellij.openapi.fileEditor.impl.text;
-import com.intellij.AppTopics;
-import com.intellij.ide.ui.customization.CustomActionsSchema;
+import com.intellij.*;
+import com.intellij.ide.ui.customization.*;
import com.intellij.openapi.actionSystem.*;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.editor.Document;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.editor.EditorFactory;
-import com.intellij.openapi.editor.colors.EditorColorsManager;
+import com.intellij.openapi.application.*;
+import com.intellij.openapi.diagnostic.*;
+import com.intellij.openapi.editor.*;
+import com.intellij.openapi.editor.colors.*;
import com.intellij.openapi.editor.event.*;
-import com.intellij.openapi.editor.ex.EditorEx;
-import com.intellij.openapi.editor.ex.EditorMarkupModel;
-import com.intellij.openapi.editor.highlighter.EditorHighlighter;
-import com.intellij.openapi.editor.highlighter.EditorHighlighterFactory;
-import com.intellij.openapi.editor.impl.EditorImpl;
-import com.intellij.openapi.fileEditor.FileDocumentManager;
-import com.intellij.openapi.fileEditor.FileEditor;
-import com.intellij.openapi.fileEditor.FileEditorManager;
-import com.intellij.openapi.fileEditor.impl.FileEditorManagerImpl;
-import com.intellij.openapi.fileTypes.FileTypeEvent;
-import com.intellij.openapi.fileTypes.FileTypeListener;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.openapi.vfs.VirtualFileAdapter;
-import com.intellij.openapi.vfs.VirtualFileEvent;
-import com.intellij.openapi.vfs.VirtualFilePropertyEvent;
-import com.intellij.openapi.wm.WindowManager;
-import com.intellij.openapi.wm.ex.StatusBarEx;
-import com.intellij.util.EditorPopupHandler;
-import com.intellij.util.messages.MessageBusConnection;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.openapi.editor.ex.*;
+import com.intellij.openapi.editor.highlighter.*;
+import com.intellij.openapi.editor.impl.*;
+import com.intellij.openapi.fileEditor.*;
+import com.intellij.openapi.fileEditor.impl.*;
+import com.intellij.openapi.fileTypes.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.vfs.*;
+import com.intellij.openapi.wm.*;
+import com.intellij.openapi.wm.ex.*;
+import com.intellij.util.*;
+import com.intellij.util.messages.*;
+import org.jetbrains.annotations.*;
import javax.swing.*;
import java.awt.*;
-import java.awt.event.MouseEvent;
-import java.beans.PropertyChangeEvent;
-import java.beans.PropertyChangeListener;
+import java.awt.event.*;
+import java.beans.*;
/**
* @author Anton Katilin
void deselectNotify(){
StatusBarEx statusBar = (StatusBarEx)WindowManager.getInstance().getStatusBar(myProject);
if (statusBar == null) return;
- statusBar.clear();
+ //statusBar.clear();
}
private static void assertThread(){
private void updateStatusBar(){
final StatusBarEx statusBar = (StatusBarEx)WindowManager.getInstance().getStatusBar(myProject);
if (statusBar == null) return;
- statusBar.update(getEditor());
+ statusBar.updateWidgets(); // TODO: do we need this?!
}
@Nullable
*/
package com.intellij.openapi.keymap.impl;
-import com.intellij.ide.DataManager;
-import com.intellij.ide.IdeEventQueue;
-import com.intellij.ide.impl.DataManagerImpl;
-import com.intellij.openapi.Disposable;
+import com.intellij.ide.*;
+import com.intellij.ide.impl.*;
+import com.intellij.openapi.*;
import com.intellij.openapi.actionSystem.*;
-import com.intellij.openapi.actionSystem.ex.ActionManagerEx;
-import com.intellij.openapi.actionSystem.ex.ActionUtil;
-import com.intellij.openapi.actionSystem.impl.PresentationFactory;
-import com.intellij.openapi.application.Application;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.application.ModalityState;
-import com.intellij.openapi.keymap.KeyMapBundle;
-import com.intellij.openapi.keymap.Keymap;
-import com.intellij.openapi.keymap.KeymapManager;
-import com.intellij.openapi.keymap.KeymapUtil;
-import com.intellij.openapi.keymap.impl.keyGestures.KeyboardGestureProcessor;
-import com.intellij.openapi.keymap.impl.ui.ShortcutTextField;
-import com.intellij.openapi.project.DumbAware;
-import com.intellij.openapi.project.DumbService;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.ui.popup.JBPopup;
-import com.intellij.openapi.util.Disposer;
-import com.intellij.openapi.util.Pair;
-import com.intellij.openapi.util.SystemInfo;
-import com.intellij.openapi.util.registry.Registry;
-import com.intellij.openapi.wm.StatusBar;
-import com.intellij.openapi.wm.WindowManager;
-import com.intellij.openapi.wm.ex.StatusBarEx;
-import com.intellij.openapi.wm.impl.FloatingDecorator;
-import com.intellij.openapi.wm.impl.IdeFrameImpl;
-import com.intellij.openapi.wm.impl.IdeGlassPaneEx;
-import com.intellij.ui.popup.AbstractPopup;
-import com.intellij.util.Alarm;
-import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.openapi.actionSystem.ex.*;
+import com.intellij.openapi.actionSystem.impl.*;
+import com.intellij.openapi.application.*;
+import com.intellij.openapi.keymap.*;
+import com.intellij.openapi.keymap.impl.keyGestures.*;
+import com.intellij.openapi.keymap.impl.ui.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.ui.popup.*;
+import com.intellij.openapi.util.*;
+import com.intellij.openapi.util.registry.*;
+import com.intellij.openapi.wm.*;
+import com.intellij.openapi.wm.ex.*;
+import com.intellij.openapi.wm.impl.*;
+import com.intellij.ui.popup.*;
+import com.intellij.util.*;
+import org.jetbrains.annotations.*;
import javax.swing.*;
-import javax.swing.plaf.basic.ComboPopup;
+import javax.swing.plaf.basic.*;
import java.awt.*;
-import java.awt.event.InputEvent;
-import java.awt.event.KeyEvent;
-import java.awt.im.InputContext;
-import java.lang.reflect.Method;
-import java.util.ArrayList;
+import java.awt.event.*;
+import java.awt.im.*;
+import java.lang.reflect.*;
+import java.util.*;
import java.util.List;
/**
if (myContext != null) {
Project project = PlatformDataKeys.PROJECT.getData(myContext.getDataContext());
if (project != null) {
- StatusBar status = WindowManager.getInstance().getStatusBar(project);
- if (status != null) {
- status.setInfo(null);
- }
+ StatusBar.Info.set(null, project);
}
}
}
myFirstKeyStroke=null;
setState(KeyState.STATE_INIT);
Project project = PlatformDataKeys.PROJECT.getData(myContext.getDataContext());
- StatusBar bar = WindowManager.getInstance().getStatusBar(project);
- if (bar != null) {
- bar.setInfo(null);
- }
+ StatusBar.Info.set(null, project);
return false;
}
message.append(")");
}
- StatusBar bar = WindowManager.getInstance().getStatusBar(project);
- if (bar != null) {
- bar.setInfo(message.toString());
- }
+ StatusBar.Info.set(message.toString(), project);
mySecondStrokeTimeout.cancelAllRequests();
mySecondStrokeTimeout.addRequest(mySecondStrokeTimeoutRunnable, Registry.intValue("actionSystem.secondKeystrokeTimout"));
*/
package com.intellij.openapi.progress.impl;
-import com.intellij.openapi.progress.PerformInBackgroundOption;
-import com.intellij.openapi.progress.Task;
-import com.intellij.openapi.progress.TaskInfo;
-import com.intellij.openapi.progress.util.ProgressWindow;
+import com.intellij.openapi.progress.*;
+import com.intellij.openapi.progress.util.*;
import com.intellij.openapi.project.*;
-import com.intellij.openapi.wm.IdeFrame;
-import com.intellij.openapi.wm.WindowManager;
-import com.intellij.openapi.wm.ex.StatusBarEx;
-import com.intellij.openapi.wm.ex.WindowManagerEx;
-import org.jetbrains.annotations.Nls;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.openapi.wm.*;
+import com.intellij.openapi.wm.ex.*;
+import org.jetbrains.annotations.*;
public class BackgroundableProcessIndicator extends ProgressWindow {
protected StatusBarEx myStatusBar;
}
private void doBackground() {
- myStatusBar.add(this, myInfo);
+ myStatusBar.addProgress(this, myInfo);
}
public void dispose() {
*/
package com.intellij.openapi.vfs.newvfs;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.progress.util.ProgressIndicatorBase;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.project.ProjectManager;
-import com.intellij.openapi.wm.WindowManager;
-import com.intellij.openapi.wm.ex.StatusBarEx;
+import com.intellij.openapi.application.*;
+import com.intellij.openapi.progress.util.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.wm.*;
+import com.intellij.openapi.wm.ex.*;
import javax.swing.*;
}
for (Project project : projects) {
- final StatusBarEx statusBar = (StatusBarEx)windowManager.getStatusBar(project);
+ final StatusBarEx statusBar = (StatusBarEx) windowManager.getStatusBar(project);
if (statusBar == null) continue;
statusBar.startRefreshIndication(myMessage);
}
for (Project project : projects) {
- final StatusBarEx statusBar = (StatusBarEx)windowManager.getStatusBar(project);
+ final StatusBarEx statusBar = (StatusBarEx) windowManager.getStatusBar(project);
if (statusBar == null) continue;
statusBar.stopRefreshIndication();
*/
package com.intellij.openapi.wm.ex;
-import com.intellij.notification.impl.IdeNotificationArea;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.progress.TaskInfo;
-import com.intellij.openapi.ui.MessageType;
-import com.intellij.openapi.ui.popup.BalloonHandler;
-import com.intellij.openapi.wm.StatusBar;
-import com.intellij.openapi.wm.impl.status.StatusBarPatch;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.openapi.*;
+import com.intellij.openapi.progress.*;
+import com.intellij.openapi.ui.*;
+import com.intellij.openapi.ui.popup.*;
+import com.intellij.openapi.wm.*;
+import org.jetbrains.annotations.*;
import javax.swing.*;
-import javax.swing.event.HyperlinkListener;
+import javax.swing.event.*;
-public interface StatusBarEx extends StatusBar {
- String getInfo();
-
- void clear();
-
- void addFileStatusComponent(StatusBarPatch component);
+/**
+ * @author spleaner
+ */
+public interface StatusBarEx extends StatusBar, Disposable {
+ void startRefreshIndication(String tooltipText);
+ void stopRefreshIndication();
- void removeFileStatusComponent(StatusBarPatch component);
+ BalloonHandler notifyProgressByBalloon(@NotNull MessageType type, @NotNull String htmlBody);
+ BalloonHandler notifyProgressByBalloon(@NotNull MessageType type, @NotNull String htmlBody, @Nullable Icon icon, @Nullable HyperlinkListener listener);
- void cleanupCustomComponents();
+ void addProgress(ProgressIndicatorEx indicator, TaskInfo info);
- void add(ProgressIndicatorEx indicator, TaskInfo info);
+ void updateWidgets();
boolean isProcessWindowOpen();
void setProcessWindowOpen(boolean open);
-
- BalloonHandler notifyProgressByBalloon(@NotNull MessageType type, @NotNull String htmlBody);
-
- BalloonHandler notifyProgressByBalloon(@NotNull MessageType type, @NotNull String htmlBody, @Nullable Icon icon, @Nullable HyperlinkListener listener);
-
- void update(Editor editor);
-
- void dispose();
-
- IdeNotificationArea getNotificationArea();
}
*/
package com.intellij.openapi.wm.impl;
-import com.intellij.ide.AppLifecycleListener;
-import com.intellij.ide.DataManager;
+import com.intellij.ide.*;
import com.intellij.ide.impl.ProjectUtil;
-import com.intellij.ide.ui.UISettings;
-import com.intellij.openapi.MnemonicHelper;
-import com.intellij.openapi.actionSystem.ActionManager;
-import com.intellij.openapi.actionSystem.DataProvider;
-import com.intellij.openapi.actionSystem.PlatformDataKeys;
-import com.intellij.openapi.application.Application;
-import com.intellij.openapi.application.ApplicationInfo;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.application.ModalityState;
-import com.intellij.openapi.application.ex.ApplicationInfoEx;
-import com.intellij.openapi.application.ex.ApplicationManagerEx;
-import com.intellij.openapi.keymap.KeymapManager;
-import com.intellij.openapi.project.DumbAwareRunnable;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.project.ProjectManager;
-import com.intellij.openapi.util.registry.Registry;
-import com.intellij.openapi.wm.IdeFrame;
-import com.intellij.openapi.wm.ex.LayoutFocusTraversalPolicyExt;
-import com.intellij.openapi.wm.ex.StatusBarEx;
-import com.intellij.ui.AppUIUtil;
-import com.intellij.ui.BalloonLayout;
-import com.intellij.ui.FocusTrackback;
-import com.intellij.util.ui.UIUtil;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.intellij.ide.ui.*;
+import com.intellij.openapi.*;
+import com.intellij.openapi.actionSystem.*;
+import com.intellij.openapi.application.*;
+import com.intellij.openapi.application.ex.*;
+import com.intellij.openapi.keymap.*;
+import com.intellij.openapi.project.*;
+import com.intellij.openapi.util.*;
+import com.intellij.openapi.util.registry.*;
+import com.intellij.openapi.wm.*;
+import com.intellij.openapi.wm.ex.*;
+import com.intellij.openapi.wm.impl.status.*;
+import com.intellij.ui.*;
+import com.intellij.util.ui.*;
+import org.jetbrains.annotations.*;
import javax.swing.*;
import java.awt.*;
-import java.awt.event.WindowAdapter;
-import java.awt.event.WindowEvent;
-import java.io.File;
+import java.awt.event.*;
+import java.io.*;
/**
* @author Anton Katilin
);
}
- public StatusBarEx getStatusBar() {
+ public StatusBar getStatusBar() {
return ((IdeRootPane)getRootPane()).getStatusBar();
}
}
public void setProject(final Project project) {
- getStatusBar().cleanupCustomComponents();
myProject = project;
if (project != null) {
if (myRootPane != null) {
myRootPane.installNorthComponents(project);
}
+
+ project.getMessageBus().connect().subscribe(StatusBar.Info.TOPIC, myRootPane.getStatusBar());
+ installDefaultProjectStatusBarWidgets(myProject);
}
else {
if (myRootPane != null) { //already disposed
}
}
+ private void installDefaultProjectStatusBarWidgets(@NotNull final Project project) {
+ final StatusBar statusBar = getStatusBar();
+
+ final PositionPanel positionPanel = new PositionPanel(project);
+ statusBar.addWidget(positionPanel, "before Notifications");
+
projects / idea / community.git / commitdiff
