--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2000, 2011 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.ui.text.correction;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.eclipse.swt.graphics.Image;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.NullProgressMonitor;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IMarker;
+import org.eclipse.core.resources.IResource;
+
+import org.eclipse.jface.text.IDocument;
+import org.eclipse.jface.text.Position;
+import org.eclipse.jface.text.source.Annotation;
+import org.eclipse.jface.text.source.IAnnotationModel;
+
+import org.eclipse.ui.IEditorInput;
+import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.IMarkerResolution;
+import org.eclipse.ui.IMarkerResolutionGenerator2;
+import org.eclipse.ui.views.markers.WorkbenchMarkerResolution;
+
+import org.eclipse.ui.texteditor.ITextEditor;
+import org.eclipse.ui.texteditor.MarkerUtilities;
+
+import org.eclipse.jdt.core.CorrectionEngine;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IJavaElement;
+import org.eclipse.jdt.core.IJavaModelMarker;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.core.compiler.IProblem;
+
+import org.eclipse.jdt.internal.corext.fix.CleanUpRefactoring.MultiFixTarget;
+
+import org.eclipse.jdt.ui.JavaUI;
+import org.eclipse.jdt.ui.cleanup.ICleanUp;
+import org.eclipse.jdt.ui.text.java.CompletionProposalComparator;
+import org.eclipse.jdt.ui.text.java.IInvocationContext;
+import org.eclipse.jdt.ui.text.java.IJavaCompletionProposal;
+import org.eclipse.jdt.ui.text.java.IProblemLocation;
+
+import org.eclipse.jdt.internal.ui.JavaPlugin;
+import org.eclipse.jdt.internal.ui.fix.IMultiFix;
+import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;
+import org.eclipse.jdt.internal.ui.javaeditor.JavaMarkerAnnotation;
+import org.eclipse.jdt.internal.ui.text.correction.proposals.FixCorrectionProposal;
+
+
+public class CorrectionMarkerResolutionGenerator implements IMarkerResolutionGenerator2 {
+
+ public static class CorrectionMarkerResolution extends WorkbenchMarkerResolution {
+
+ private static final IMarker[] NO_MARKERS= new IMarker[0];
+
+ private ICompilationUnit fCompilationUnit;
+ private int fOffset;
+ private int fLength;
+ private IJavaCompletionProposal fProposal;
+ private final IMarker fMarker;
+
+ /**
+ * Constructor for CorrectionMarkerResolution.
+ * @param cu the compilation unit
+ * @param offset the offset
+ * @param length the length
+ * @param proposal the proposal for the given marker
+ * @param marker the marker to fix
+ */
+ public CorrectionMarkerResolution(ICompilationUnit cu, int offset, int length, IJavaCompletionProposal proposal, IMarker marker) {
+ fCompilationUnit= cu;
+ fOffset= offset;
+ fLength= length;
+ fProposal= proposal;
+ fMarker= marker;
+ }
+
+ /* (non-Javadoc)
+ * @see IMarkerResolution#getLabel()
+ */
+ public String getLabel() {
+ return fProposal.getDisplayString();
+ }
+
+ /* (non-Javadoc)
+ * @see IMarkerResolution#run(IMarker)
+ */
+ public void run(IMarker marker) {
+ try {
+ IEditorPart part= EditorUtility.isOpenInEditor(fCompilationUnit);
+ if (part == null) {
+ part= JavaUI.openInEditor(fCompilationUnit, true, false);
+ if (part instanceof ITextEditor) {
+ ((ITextEditor) part).selectAndReveal(fOffset, fLength);
+ }
+ }
+ if (part != null) {
+ IEditorInput input= part.getEditorInput();
+ IDocument doc= JavaPlugin.getDefault().getCompilationUnitDocumentProvider().getDocument(input);
+ fProposal.apply(doc);
+ }
+ } catch (CoreException e) {
+ JavaPlugin.log(e);
+ }
+ }
+
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void run(IMarker[] markers, IProgressMonitor monitor) {
+ if (markers.length == 1) {
+ run(markers[0]);
+ return;
+ }
+
+ if (!(fProposal instanceof FixCorrectionProposal))
+ return;
+
+ if (monitor == null)
+ monitor= new NullProgressMonitor();
+
+ try {
+ MultiFixTarget[] problems= getCleanUpTargets(markers);
+
+ ((FixCorrectionProposal)fProposal).resolve(problems, monitor);
+
+ IEditorPart part= EditorUtility.isOpenInEditor(fCompilationUnit);
+ if (part instanceof ITextEditor) {
+ ((ITextEditor) part).selectAndReveal(fOffset, fLength);
+ part.setFocus();
+ }
+ } catch (CoreException e) {
+ JavaPlugin.log(e);
+ } finally {
+ monitor.done();
+ }
+ }
+
+ private MultiFixTarget[] getCleanUpTargets(IMarker[] markers) {
+ Hashtable<ICompilationUnit, List<IProblemLocation>> problemLocations= new Hashtable<ICompilationUnit, List<IProblemLocation>>();
+ for (int i= 0; i < markers.length; i++) {
+ IMarker marker= markers[i];
+ ICompilationUnit cu= getCompilationUnit(marker);
+
+ if (cu != null) {
+ IEditorInput input= EditorUtility.getEditorInput(cu);
+ IProblemLocation location= findProblemLocation(input, marker);
+ if (location != null) {
+ List<IProblemLocation> l= problemLocations.get(cu.getPrimary());
+ if (l == null) {
+ l= new ArrayList<IProblemLocation>();
+ problemLocations.put(cu.getPrimary(), l);
+ }
+ l.add(location);
+ }
+ }
+ }
+
+ MultiFixTarget[] result= new MultiFixTarget[problemLocations.size()];
+ int i= 0;
+ for (Iterator<Map.Entry<ICompilationUnit, List<IProblemLocation>>> iterator= problemLocations.entrySet().iterator(); iterator.hasNext();) {
+ Map.Entry<ICompilationUnit, List<IProblemLocation>> entry= iterator.next();
+ ICompilationUnit cu= entry.getKey();
+ List<IProblemLocation> locations= entry.getValue();
+ result[i]= new MultiFixTarget(cu, locations.toArray(new IProblemLocation[locations.size()]));
+ i++;
+ }
+
+ return result;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.ui.IMarkerResolution2#getDescription()
+ */
+ public String getDescription() {
+ return fProposal.getAdditionalProposalInfo();
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.ui.IMarkerResolution2#getImage()
+ */
+ public Image getImage() {
+ return fProposal.getImage();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public IMarker[] findOtherMarkers(IMarker[] markers) {
+ if (!(fProposal instanceof FixCorrectionProposal))
+ return NO_MARKERS;
+
+ FixCorrectionProposal fix= (FixCorrectionProposal)fProposal;
+ final ICleanUp cleanUp= fix.getCleanUp();
+ if (!(cleanUp instanceof IMultiFix))
+ return NO_MARKERS;
+
+ IMultiFix multiFix= (IMultiFix) cleanUp;
+
+ final Hashtable<IFile, List<IMarker>> fileMarkerTable= getMarkersForFiles(markers);
+ if (fileMarkerTable.isEmpty())
+ return NO_MARKERS;
+
+ final List<IMarker> result= new ArrayList<IMarker>();
+
+ for (Iterator<Entry<IFile, List<IMarker>>> iterator= fileMarkerTable.entrySet().iterator(); iterator.hasNext();) {
+ Map.Entry<IFile, List<IMarker>> entry= iterator.next();
+ IFile file= entry.getKey();
+ List<IMarker> fileMarkers= entry.getValue();
+
+ IJavaElement element= JavaCore.create(file);
+ if (element instanceof ICompilationUnit) {
+ ICompilationUnit unit= (ICompilationUnit) element;
+
+ for (int i= 0, size= fileMarkers.size(); i < size; i++) {
+ IMarker marker= fileMarkers.get(i);
+ IProblemLocation problem= createFromMarker(marker, unit);
+ if (problem != null && multiFix.canFix(unit, problem)) {
+ result.add(marker);
+ }
+ }
+ }
+ }
+
+ if (result.size() == 0)
+ return NO_MARKERS;
+
+ return result.toArray(new IMarker[result.size()]);
+ }
+
+ /**
+ * Returns the markers with the same type as fMarker.getType for each IFile.
+ * @param markers the markers
+ * @return mapping files to markers
+ */
+ private Hashtable<IFile, List<IMarker>> getMarkersForFiles(IMarker[] markers) {
+ final Hashtable<IFile, List<IMarker>> result= new Hashtable<IFile, List<IMarker>>();
+
+ String markerType;
+ try {
+ markerType= fMarker.getType();
+ } catch (CoreException e1) {
+ JavaPlugin.log(e1);
+ return result;
+ }
+
+ for (int i= 0; i < markers.length; i++) {
+ IMarker marker= markers[i];
+ if (!marker.equals(fMarker)) {
+ String currMarkerType= null;
+ try {
+ currMarkerType= marker.getType();
+ } catch (CoreException e1) {
+ JavaPlugin.log(e1);
+ }
+
+ if (currMarkerType != null && currMarkerType.equals(markerType)) {
+ IResource res= marker.getResource();
+ if (res instanceof IFile && res.isAccessible()) {
+ List<IMarker> markerList= result.get(res);
+ if (markerList == null) {
+ markerList= new ArrayList<IMarker>();
+ result.put((IFile) res, markerList);
+ }
+ markerList.add(marker);
+ }
+ }
+ }
+ }
+ return result;
+ }
+ }
+
+ private static final IMarkerResolution[] NO_RESOLUTIONS= new IMarkerResolution[0];
+
+
+ /**
+ * Constructor for CorrectionMarkerResolutionGenerator.
+ */
+ public CorrectionMarkerResolutionGenerator() {
+ super();
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.ui.IMarkerResolutionGenerator2#hasResolutions(org.eclipse.core.resources.IMarker)
+ */
+ public boolean hasResolutions(IMarker marker) {
+ return internalHasResolutions(marker);
+ }
+
+ /* (non-Javadoc)
+ * @see IMarkerResolutionGenerator#getResolutions(IMarker)
+ */
+ public IMarkerResolution[] getResolutions(IMarker marker) {
+ return internalGetResolutions(marker);
+ }
+
+ private static boolean internalHasResolutions(IMarker marker) {
+ int id= marker.getAttribute(IJavaModelMarker.ID, -1);
+ ICompilationUnit cu= getCompilationUnit(marker);
+ return cu != null && JavaCorrectionProcessor.hasCorrections(cu, id, MarkerUtilities.getMarkerType(marker));
+ }
+
+ private static IMarkerResolution[] internalGetResolutions(IMarker marker) {
+ if (!internalHasResolutions(marker)) {
+ return NO_RESOLUTIONS;
+ }
+
+ ICompilationUnit cu= getCompilationUnit(marker);
+ if (cu != null) {
+ IEditorInput input= EditorUtility.getEditorInput(cu);
+ if (input != null) {
+ IProblemLocation location= findProblemLocation(input, marker);
+ if (location != null) {
+
+ IInvocationContext context= new AssistContext(cu, location.getOffset(), location.getLength());
+ if (!hasProblem (context.getASTRoot().getProblems(), location))
+ return NO_RESOLUTIONS;
+
+ ArrayList<IJavaCompletionProposal> proposals= new ArrayList<IJavaCompletionProposal>();
+ JavaCorrectionProcessor.collectCorrections(context, new IProblemLocation[] { location }, proposals);
+ Collections.sort(proposals, new CompletionProposalComparator());
+
+ int nProposals= proposals.size();
+ IMarkerResolution[] resolutions= new IMarkerResolution[nProposals];
+ for (int i= 0; i < nProposals; i++) {
+ resolutions[i]= new CorrectionMarkerResolution(context.getCompilationUnit(), location.getOffset(), location.getLength(), proposals.get(i), marker);
+ }
+ return resolutions;
+ }
+ }
+ }
+ return NO_RESOLUTIONS;
+ }
+
+ private static boolean hasProblem(IProblem[] problems, IProblemLocation location) {
+ for (int i= 0; i < problems.length; i++) {
+ IProblem problem= problems[i];
+ if (problem.getID() == location.getProblemId() && problem.getSourceStart() == location.getOffset())
+ return true;
+ }
+ return false;
+ }
+
+ private static ICompilationUnit getCompilationUnit(IMarker marker) {
+ IResource res= marker.getResource();
+ if (res instanceof IFile && res.isAccessible()) {
+ IJavaElement element= JavaCore.create((IFile) res);
+ if (element instanceof ICompilationUnit)
+ return (ICompilationUnit) element;
+ }
+ return null;
+ }
+
+ private static IProblemLocation findProblemLocation(IEditorInput input, IMarker marker) {
+ IAnnotationModel model= JavaPlugin.getDefault().getCompilationUnitDocumentProvider().getAnnotationModel(input);
+ if (model != null) { // open in editor
+ Iterator<Annotation> iter= model.getAnnotationIterator();
+ while (iter.hasNext()) {
+ Annotation curr= iter.next();
+ if (curr instanceof JavaMarkerAnnotation) {
+ JavaMarkerAnnotation annot= (JavaMarkerAnnotation) curr;
+ if (marker.equals(annot.getMarker())) {
+ Position pos= model.getPosition(annot);
+ if (pos != null) {
+ return new ProblemLocation(pos.getOffset(), pos.getLength(), annot);
+ }
+ }
+ }
+ }
+ } else { // not open in editor
+ ICompilationUnit cu= getCompilationUnit(marker);
+ return createFromMarker(marker, cu);
+ }
+ return null;
+ }
+
+ private static IProblemLocation createFromMarker(IMarker marker, ICompilationUnit cu) {
+ try {
+ int id= marker.getAttribute(IJavaModelMarker.ID, -1);
+ int start= marker.getAttribute(IMarker.CHAR_START, -1);
+ int end= marker.getAttribute(IMarker.CHAR_END, -1);
+ int severity= marker.getAttribute(IMarker.SEVERITY, IMarker.SEVERITY_INFO);
+ String[] arguments= CorrectionEngine.getProblemArguments(marker);
+ String markerType= marker.getType();
+ if (cu != null && id != -1 && start != -1 && end != -1 && arguments != null) {
+ boolean isError= (severity == IMarker.SEVERITY_ERROR);
+ return new ProblemLocation(start, end - start, id, arguments, isError, markerType);
+ }
+ } catch (CoreException e) {
+ JavaPlugin.log(e);
+ }
+ return null;
+ }
+
+
+}
git://git.uio.no / ifi-stolz-refaktor.git / blobdiff