trunk/ruta-ep-ide-ui/src/main/java/org/apache/uima/ruta/ide/ui/text/RutaCorrectionAssistant.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 org.apache.uima.ruta.ide.ui.text;

import java.util.ArrayList;
import java.util.Iterator;

import org.apache.uima.ruta.ide.RutaIdeUIPlugin;
import org.eclipse.core.runtime.Assert;
import org.eclipse.dltk.ui.DLTKUIPlugin;
import org.eclipse.dltk.ui.PreferenceConstants;
import org.eclipse.dltk.ui.text.IColorManager;
import org.eclipse.jface.internal.text.html.HTMLTextPresenter;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.PreferenceConverter;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.DefaultInformationControl;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IInformationControl;
import org.eclipse.jface.text.IInformationControlCreator;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.text.quickassist.IQuickAssistAssistant;
import org.eclipse.jface.text.quickassist.QuickAssistAssistant;
import org.eclipse.jface.text.source.Annotation;
import org.eclipse.jface.text.source.IAnnotationModel;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.texteditor.IDocumentProvider;
import org.eclipse.ui.texteditor.ITextEditor;

public class RutaCorrectionAssistant extends QuickAssistAssistant {

  private ITextViewer fViewer;

  private ITextEditor fEditor;

  private Position fPosition;

  private Annotation[] fCurrentAnnotations;

  // private RutaQuickAssistLightBulbUpdater fLightBulbUpdater;

  /**
   * Constructor for JavaCorrectionAssistant.
   * 
   * @param editor
   *          the editor
   */
  public RutaCorrectionAssistant(ITextEditor editor) {
    super();
    Assert.isNotNull(editor);
    fEditor = editor;

    RutaCorrectionProcessor processor = new RutaCorrectionProcessor(this);

    setQuickAssistProcessor(processor);

    setInformationControlCreator(getInformationControlCreator());

    RutaTextTools textTools = RutaIdeUIPlugin.getDefault().getTextTools();
    IColorManager manager = textTools.getColorManager();

    IPreferenceStore store = RutaIdeUIPlugin.getDefault().getPreferenceStore();

    Color c = getColor(store, PreferenceConstants.CODEASSIST_PROPOSALS_FOREGROUND, manager);
    setProposalSelectorForeground(c);

    c = getColor(store, PreferenceConstants.CODEASSIST_PROPOSALS_BACKGROUND, manager);
    setProposalSelectorBackground(c);
  }

  public IEditorPart getEditor() {
    return fEditor;
  }

  private IInformationControlCreator getInformationControlCreator() {
    return new IInformationControlCreator() {
      public IInformationControl createInformationControl(Shell parent) {
        return new DefaultInformationControl(parent, new HTMLTextPresenter());
      }
    };
  }

  private static Color getColor(IPreferenceStore store, String key, IColorManager manager) {
    RGB rgb = PreferenceConverter.getColor(store, key);
    return manager.getColor(rgb);
  }

  /*
   * (non-Javadoc)
   * 
   * @see org.eclipse.jface.text.contentassist.IContentAssistant#install(org.eclipse
   * .jface.text.ITextViewer)
   */
  @Override
  public void install(ISourceViewer sourceViewer) {
    super.install(sourceViewer);
    fViewer = sourceViewer;

    // fLightBulbUpdater = new
    // RutaQuickAssistLightBulbUpdater(fEditor,
    // sourceViewer);
    // fLightBulbUpdater.install();
  }

  /*
   * (non-Javadoc)
   * 
   * @see org.eclipse.jface.text.contentassist.ContentAssistant#uninstall()
   */
  @Override
  public void uninstall() {
    // if (fLightBulbUpdater != null) {
    // fLightBulbUpdater.uninstall();
    // fLightBulbUpdater = null;
    // }
    super.uninstall();
  }

  /*
   * @seeorg.eclipse.jface.text.quickassist.QuickAssistAssistant# showPossibleQuickAssists()
   * 
   * @since 3.2
   */

  /**
   * Show completions at caret position. If current position does not contain quick fixes look for
   * next quick fix on same line by moving from left to right and restarting at end of line if the
   * beginning of the line is reached.
   * 
   * @see IQuickAssistAssistant#showPossibleQuickAssists()
   */
  @Override
  public String showPossibleQuickAssists() {
    fPosition = null;
    fCurrentAnnotations = null;

    if (fViewer == null || fViewer.getDocument() == null)
      // Let superclass deal with this
      return super.showPossibleQuickAssists();

    ArrayList resultingAnnotations = new ArrayList(20);
    try {
      Point selectedRange = fViewer.getSelectedRange();
      int currOffset = selectedRange.x;
      int currLength = selectedRange.y;
      boolean goToClosest = (currLength == 0);

      int newOffset = collectQuickFixableAnnotations(fEditor, currOffset, goToClosest,
              resultingAnnotations);
      if (newOffset != currOffset) {
        storePosition(currOffset, currLength);
        fViewer.setSelectedRange(newOffset, 0);
        fViewer.revealRange(newOffset, 0);
      }
    } catch (BadLocationException e) {
      // JavaPlugin.log(e);
    }
    fCurrentAnnotations = (Annotation[]) resultingAnnotations
            .toArray(new Annotation[resultingAnnotations.size()]);

    return super.showPossibleQuickAssists();
  }

  private static IRegion getRegionOfInterest(ITextEditor editor, int invocationLocation)
          throws BadLocationException {
    IDocumentProvider documentProvider = editor.getDocumentProvider();
    if (documentProvider == null) {
      return null;
    }
    IDocument document = documentProvider.getDocument(editor.getEditorInput());
    if (document == null) {
      return null;
    }
    return document.getLineInformationOfOffset(invocationLocation);
  }

  public static int collectQuickFixableAnnotations(ITextEditor editor, int invocationLocation,
          boolean goToClosest, ArrayList resultingAnnotations) throws BadLocationException {
    IAnnotationModel model = DLTKUIPlugin.getDocumentProvider().getAnnotationModel(
            editor.getEditorInput());
    if (model == null) {
      return invocationLocation;
    }

    ensureUpdatedAnnotations(editor);

    Iterator iter = model.getAnnotationIterator();
    if (goToClosest) {
      IRegion lineInfo = getRegionOfInterest(editor, invocationLocation);
      if (lineInfo == null) {
        return invocationLocation;
      }
      int rangeStart = lineInfo.getOffset();
      int rangeEnd = rangeStart + lineInfo.getLength();

      ArrayList allAnnotations = new ArrayList();
      ArrayList allPositions = new ArrayList();
      int bestOffset = Integer.MAX_VALUE;
      while (iter.hasNext()) {
        Annotation annot = (Annotation) iter.next();
        if (RutaCorrectionProcessor.isQuickFixableType(annot)) {
          Position pos = model.getPosition(annot);
          if (pos != null && isInside(pos.offset, rangeStart, rangeEnd)) { // inside
            // our
            // range?
            allAnnotations.add(annot);
            allPositions.add(pos);
            bestOffset = processAnnotation(annot, pos, invocationLocation, bestOffset);
          }
        }
      }
      if (bestOffset == Integer.MAX_VALUE) {
        return invocationLocation;
      }
      for (int i = 0; i < allPositions.size(); i++) {
        Position pos = (Position) allPositions.get(i);
        if (isInside(bestOffset, pos.offset, pos.offset + pos.length)) {
          resultingAnnotations.add(allAnnotations.get(i));
        }
      }
      return bestOffset;
    } else {
      while (iter.hasNext()) {
        Annotation annot = (Annotation) iter.next();
        if (RutaCorrectionProcessor.isQuickFixableType(annot)) {
          Position pos = model.getPosition(annot);
          if (pos != null && isInside(invocationLocation, pos.offset, pos.offset + pos.length)) {
            resultingAnnotations.add(annot);
          }
        }
      }
      return invocationLocation;
    }
  }

  private static void ensureUpdatedAnnotations(ITextEditor editor) {
    // Object inputElement = editor.getEditorInput().getAdapter(
    // IModelElement.class);

  }

  private static int processAnnotation(Annotation annot, Position pos, int invocationLocation,
          int bestOffset) {
    int posBegin = pos.offset;
    int posEnd = posBegin + pos.length;
    if (isInside(invocationLocation, posBegin, posEnd)) { // covers
      // invocation
      // location?
      return invocationLocation;
    } else if (bestOffset != invocationLocation) {
      int newClosestPosition = computeBestOffset(posBegin, invocationLocation, bestOffset);
      if (newClosestPosition != -1) {
        if (newClosestPosition != bestOffset) { // new best
          // if (JavaCorrectionProcessor.hasCorrections(annot)) { //
          // only
          // // jump
          // // to
          // // it
          // // if
          // // there
          // // are
          // // proposals
          // return newClosestPosition;
          // }
        }
      }
    }
    return bestOffset;
  }

  private static boolean isInside(int offset, int start, int end) {
    return offset == start || offset == end || (offset > start && offset < end); // make sure to
    // handle
    // 0-length ranges
  }

  /**
   * Computes and returns the invocation offset given a new position, the initial offset and the
   * best invocation offset found so far.
   * <p>
   * The closest offset to the left of the initial offset is the best. If there is no offset on the
   * left, the closest on the right is the best.
   * </p>
   * 
   * @param newOffset
   *          the offset to llok at
   * @param invocationLocation
   *          the invocation location
   * @param bestOffset
   *          the current best offset
   * @return -1 is returned if the given offset is not closer or the new best offset
   */
  private static int computeBestOffset(int newOffset, int invocationLocation, int bestOffset) {
    if (newOffset <= invocationLocation) {
      if (bestOffset > invocationLocation) {
        return newOffset; // closest was on the right, prefer on the
        // left
      } else if (bestOffset <= newOffset) {
        return newOffset; // we are closer or equal
      }
      return -1; // further away
    }

    if (newOffset <= bestOffset)
      return newOffset; // we are closer or equal

    return -1; // further away
  }

  /*
   * @seeorg.eclipse.jface.text.contentassist.ContentAssistant# possibleCompletionsClosed()
   */
  @Override
  protected void possibleCompletionsClosed() {
    super.possibleCompletionsClosed();
    restorePosition();
  }

  private void storePosition(int currOffset, int currLength) {
    fPosition = new Position(currOffset, currLength);
  }

  private void restorePosition() {
    if (fPosition != null && !fPosition.isDeleted() && fViewer.getDocument() != null) {
      fViewer.setSelectedRange(fPosition.offset, fPosition.length);
      fViewer.revealRange(fPosition.offset, fPosition.length);
    }
    fPosition = null;
  }

  /**
   * Returns true if the last invoked completion was called with an updated offset.
   * 
   * @return <code> true</code> if the last invoked completion was called with an updated offset.
   */
  public boolean isUpdatedOffset() {
    return fPosition != null;
  }

  /**
   * Returns the annotations at the current offset
   * 
   * @return the annotations at the offset
   */
  public Annotation[] getAnnotationsAtOffset() {
    return fCurrentAnnotations;
  }
}