/*
* 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.codeInspection.ex;
import com.intellij.codeInsight.FileModificationService;
import com.intellij.codeInspection.CommonProblemDescriptor;
import com.intellij.codeInspection.InspectionManager;
import com.intellij.codeInspection.ProblemDescriptor;
import com.intellij.codeInspection.reference.RefElement;
import com.intellij.codeInspection.reference.RefEntity;
import com.intellij.codeInspection.reference.RefManagerImpl;
import com.intellij.codeInspection.ui.InspectionResultsView;
import com.intellij.codeInspection.ui.InspectionTree;
import com.intellij.icons.AllIcons;
import com.intellij.openapi.actionSystem.AnAction;
import com.intellij.openapi.actionSystem.AnActionEvent;
import com.intellij.openapi.actionSystem.CustomShortcutSet;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.command.CommandProcessor;
import com.intellij.openapi.progress.ProgressIndicator;
import com.intellij.openapi.progress.ProgressManager;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.ReadonlyStatusHandler;
import com.intellij.openapi.vfs.VfsUtilCore;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.PsiDocumentManager;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import com.intellij.psi.presentation.java.SymbolPresentationUtil;
import com.intellij.util.SequentialModalProgressTask;
import com.intellij.util.SequentialTask;
import gnu.trove.THashSet;
import org.jetbrains.annotations.NotNull;
import javax.swing.*;
import java.util.*;
/**
* @author max
*/
public class QuickFixAction extends AnAction {
protected final InspectionToolWrapper myToolWrapper;
public static InspectionResultsView getInvoker(AnActionEvent e) {
return InspectionResultsView.DATA_KEY.getData(e.getDataContext());
}
protected QuickFixAction(String text, @NotNull InspectionToolWrapper toolWrapper) {
this(text, AllIcons.Actions.CreateFromUsage, null, toolWrapper);
}
protected QuickFixAction(String text, Icon icon, KeyStroke keyStroke, @NotNull InspectionToolWrapper toolWrapper) {
super(text, null, icon);
myToolWrapper = toolWrapper;
if (keyStroke != null) {
registerCustomShortcutSet(new CustomShortcutSet(keyStroke), null);
}
}
@Override
public void update(AnActionEvent e) {
final InspectionResultsView view = getInvoker(e);
if (view == null) {
e.getPresentation().setEnabled(false);
return;
}
e.getPresentation().setVisible(false);
e.getPresentation().setEnabled(false);
final InspectionTree tree = view.getTree();
final InspectionToolWrapper toolWrapper = tree.getSelectedToolWrapper();
if (!view.isSingleToolInSelection() || toolWrapper != myToolWrapper) {
return;
}
if (!isProblemDescriptorsAcceptable() && tree.getSelectedElements().length > 0 ||
isProblemDescriptorsAcceptable() && tree.getSelectedDescriptors().length > 0) {
e.getPresentation().setVisible(true);
e.getPresentation().setEnabled(true);
}
}
protected boolean isProblemDescriptorsAcceptable() {
return false;
}
public String getText(RefEntity where) {
return getTemplatePresentation().getText();
}
@Override
public void actionPerformed(final AnActionEvent e) {
final InspectionResultsView view = getInvoker(e);
final InspectionTree tree = view.getTree();
if (isProblemDescriptorsAcceptable()) {
final CommonProblemDescriptor[] descriptors = tree.getSelectedDescriptors();
if (descriptors.length > 0) {
doApplyFix(view.getProject(), descriptors, tree.getContext());
return;
}
}
doApplyFix(getSelectedElements(e), view);
}
protected void applyFix(@NotNull Project project,
@NotNull GlobalInspectionContextImpl context,
@NotNull CommonProblemDescriptor[] descriptors,
@NotNull Set<PsiElement> ignoredElements) {
}
private void doApplyFix(@NotNull final Project project,
@NotNull final CommonProblemDescriptor[] descriptors,
@NotNull final GlobalInspectionContextImpl context) {
final Set<VirtualFile> readOnlyFiles = new THashSet<VirtualFile>();
for (CommonProblemDescriptor descriptor : descriptors) {
final PsiElement psiElement = descriptor instanceof ProblemDescriptor ? ((ProblemDescriptor)descriptor).getPsiElement() : null;
if (psiElement != null && !psiElement.isWritable()) {
readOnlyFiles.add(psiElement.getContainingFile().getVirtualFile());
}
}
if (!FileModificationService.getInstance().prepareVirtualFilesForWrite(project, readOnlyFiles)) return;
final RefManagerImpl refManager = (RefManagerImpl)context.getRefManager();
final boolean initial = refManager.isInProcess();
refManager.inspectionReadActionFinished();
try {
final Set<PsiElement> ignoredElements = new HashSet<PsiElement>();
CommandProcessor.getInstance().executeCommand(project, new Runnable() {
@Override
public void run() {
CommandProcessor.getInstance().markCurrentCommandAsGlobal(project);
ApplicationManager.getApplication().runWriteAction(new Runnable() {
@Override
public void run() {
final SequentialModalProgressTask progressTask =
new SequentialModalProgressTask(project, getTemplatePresentation().getText(), false);
progressTask.setMinIterationTime(200);
progressTask.setTask(new PerformFixesTask(project, descriptors, ignoredElements, progressTask, context));
ProgressManager.getInstance().run(progressTask);
}
});
}
}, getTemplatePresentation().getText(), null);
refreshViews(project, ignoredElements, myToolWrapper);
}
finally { //to make offline view lazy
if (initial) refManager.inspectionReadActionStarted();
}
}
public void doApplyFix(@NotNull final RefEntity[] refElements, @NotNull InspectionResultsView view) {
final RefManagerImpl refManager = (RefManagerImpl)view.getGlobalInspectionContext().getRefManager();
final boolean initial = refManager.isInProcess();
refManager.inspectionReadActionFinished();
try {
final boolean[] refreshNeeded = {false};
if (refElements.length > 0) {
final Project project = refElements[0].getRefManager().getProject();
CommandProcessor.getInstance().executeCommand(project, new Runnable() {
@Override
public void run() {
CommandProcessor.getInstance().markCurrentCommandAsGlobal(project);
ApplicationManager.getApplication().runWriteAction(new Runnable() {
@Override
public void run() {
refreshNeeded[0] = applyFix(refElements);
}
});
}
}, getTemplatePresentation().getText(), null);
}
if (refreshNeeded[0]) {
refreshViews(view.getProject(), refElements, myToolWrapper);
}
}
finally { //to make offline view lazy
if (initial) refManager.inspectionReadActionStarted();
}
}
public static void removeElements(@NotNull RefEntity[] refElements, @NotNull Project project, @NotNull InspectionToolWrapper toolWrapper) {
refreshViews(project, refElements, toolWrapper);
final ArrayList<RefElement> deletedRefs = new ArrayList<RefElement>(1);
for (RefEntity refElement : refElements) {
if (!(refElement instanceof RefElement)) continue;
refElement.getRefManager().removeRefElement((RefElement)refElement, deletedRefs);
}
}
private static Set<VirtualFile> getReadOnlyFiles(@NotNull RefEntity[] refElements) {
Set<VirtualFile> readOnlyFiles = new THashSet<VirtualFile>();
for (RefEntity refElement : refElements) {
PsiElement psiElement = refElement instanceof RefElement ? ((RefElement)refElement).getElement() : null;
if (psiElement == null || psiElement.getContainingFile() == null) continue;
readOnlyFiles.add(psiElement.getContainingFile().getVirtualFile());
}
return readOnlyFiles;
}
private static RefEntity[] getSelectedElements(AnActionEvent e) {
final InspectionResultsView invoker = getInvoker(e);
if (invoker == null) return new RefElement[0];
List<RefEntity> selection = new ArrayList<RefEntity>(Arrays.asList(invoker.getTree().getSelectedElements()));
PsiDocumentManager.getInstance(invoker.getProject()).commitAllDocuments();
Collections.sort(selection, new Comparator<RefEntity>() {
@Override
public int compare(RefEntity o1, RefEntity o2) {
if (o1 instanceof RefElement && o2 instanceof RefElement) {
RefElement r1 = (RefElement)o1;
RefElement r2 = (RefElement)o2;
final PsiElement element1 = r1.getElement();
final PsiElement element2 = r2.getElement();
final PsiFile containingFile1 = element1.getContainingFile();
final PsiFile containingFile2 = element2.getContainingFile();
if (containingFile1 == containingFile2) {
int i1 = element1.getTextOffset();
int i2 = element2.getTextOffset();
if (i1 < i2) {
return 1;
} else if (i1 > i2){
return -1;
}
return 0;
}
return containingFile1.getName().compareTo(containingFile2.getName());
}
if (o1 instanceof RefElement) {
return 1;
}
if (o2 instanceof RefElement) {
return -1;
}
return o1.getName().compareTo(o2.getName());
}
});
return selection.toArray(new RefEntity[selection.size()]);
}
private static void refreshViews(@NotNull Project project, @NotNull Set<PsiElement> selectedElements, @NotNull InspectionToolWrapper toolWrapper) {
InspectionManagerEx managerEx = (InspectionManagerEx)InspectionManager.getInstance(project);
final Set<GlobalInspectionContextImpl> runningContexts = managerEx.getRunningContexts();
for (GlobalInspectionContextImpl context : runningContexts) {
for (PsiElement element : selectedElements) {
context.ignoreElement(toolWrapper.getTool(), element);
}
context.refreshViews();
}
}
private static void refreshViews(@NotNull Project project, @NotNull RefEntity[] refElements, @NotNull InspectionToolWrapper toolWrapper) {
final Set<PsiElement> ignoredElements = new HashSet<PsiElement>();
for (RefEntity element : refElements) {
final PsiElement psiElement = element instanceof RefElement ? ((RefElement)element).getElement() : null;
if (psiElement != null && psiElement.isValid()) {
ignoredElements.add(psiElement);
}
}
refreshViews(project, ignoredElements, toolWrapper);
}
/**
* @return true if immediate UI update needed.
*/
protected boolean applyFix(@NotNull RefEntity[] refElements) {
Set<VirtualFile> readOnlyFiles = getReadOnlyFiles(refElements);
if (!readOnlyFiles.isEmpty()) {
final Project project = refElements[0].getRefManager().getProject();
final ReadonlyStatusHandler.OperationStatus operationStatus = ReadonlyStatusHandler.getInstance(project).ensureFilesWritable(
VfsUtilCore.toVirtualFileArray(readOnlyFiles));
if (operationStatus.hasReadonlyFiles()) return false;
}
return true;
}
private class PerformFixesTask implements SequentialTask {
@NotNull
private final Project myProject;
private final CommonProblemDescriptor[] myDescriptors;
@NotNull
private final Set<PsiElement> myIgnoredElements;
private final SequentialModalProgressTask myTask;
@NotNull private final GlobalInspectionContextImpl myContext;
private int myCount = 0;
public PerformFixesTask(@NotNull Project project,
@NotNull CommonProblemDescriptor[] descriptors,
@NotNull Set<PsiElement> ignoredElements,
@NotNull SequentialModalProgressTask task,
@NotNull GlobalInspectionContextImpl context) {
myProject = project;
myDescriptors = descriptors;
myIgnoredElements = ignoredElements;
myTask = task;
myContext = context;
}
@Override
public void prepare() {
}
@Override
public boolean isDone() {
return myCount > myDescriptors.length - 1;
}
@Override
public boolean iteration() {
final CommonProblemDescriptor descriptor = myDescriptors[myCount++];
ProgressIndicator indicator = myTask.getIndicator();
if (indicator != null) {
indicator.setFraction((double)myCount / myDescriptors.length);
if (descriptor instanceof ProblemDescriptor) {
final PsiElement psiElement = ((ProblemDescriptor)descriptor).getPsiElement();
if (psiElement != null) {
indicator.setText("Processing " + SymbolPresentationUtil.getSymbolPresentableText(psiElement));
}
}
}
applyFix(myProject, myContext, new CommonProblemDescriptor[]{descriptor}, myIgnoredElements);
return isDone();
}
@Override
public void stop() {
}
}
}