ACTRCompletionProposal.java

package org.jactr.eclipse.ui.editor.assist;

/*
 * default logging
 */
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.contentassist.ICompletionProposal;
import org.eclipse.jface.text.contentassist.ICompletionProposalExtension4;
import org.eclipse.jface.text.contentassist.IContextInformation;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;

/**
 * Based (almost entirely) on the CompletionProposal in
 * org.eclipse.jface.text.contentassist. Why there isn't an abstract
 * implementation.. I dunno
 * 
 * @author harrison
 */
public class ACTRCompletionProposal implements ICompletionProposal,
    ICompletionProposalExtension4
{
  /**
   * Logger definition
   */
  static private final transient Log LOGGER = LogFactory
                                                .getLog(ACTRCompletionProposal.class);

  /** The string to be displayed in the completion proposal popup. */
  private String                     fDisplayString;

  /** The replacement string. */
  private String                     fReplacementString;

  /** The replacement offset. */
  private int                        fReplacementOffset;

  /** The replacement length. */
  private int                        fReplacementLength;

  /** The cursor position after this proposal has been applied. */
  private int                        fCursorPosition;

  /** The image to be displayed in the completion proposal popup. */
  private Image                      fImage;

  /** The context information of this proposal. */
  private IContextInformation        fContextInformation;

  /** The additional info of this proposal. */
  private String                     fAdditionalProposalInfo;

  private boolean                    fAutoInsert;

  /**
   * Creates a new completion proposal based on the provided information. The
   * replacement string is considered being the display string too. All
   * remaining fields are set to <code>null</code>.
   * 
   * @param replacementString
   *          the actual string to be inserted into the document
   * @param replacementOffset
   *          the offset of the text to be replaced
   * @param replacementLength
   *          the length of the text to be replaced
   * @param cursorPosition
   *          the position of the cursor following the insert relative to
   *          replacementOffset
   */
  public ACTRCompletionProposal(String replacementString,
      int replacementOffset, int replacementLength, int cursorPosition)
  {
    this(replacementString, replacementOffset, replacementLength,
        cursorPosition, null, null, null, null, true);
  }

  /**
   * Creates a new completion proposal. All fields are initialized based on the
   * provided information.
   * 
   * @param replacementString
   *          the actual string to be inserted into the document
   * @param replacementOffset
   *          the offset of the text to be replaced
   * @param replacementLength
   *          the length of the text to be replaced
   * @param cursorPosition
   *          the position of the cursor following the insert relative to
   *          replacementOffset
   * @param image
   *          the image to display for this proposal
   * @param displayString
   *          the string to be displayed for the proposal
   * @param contextInformation
   *          the context information associated with this proposal
   * @param additionalProposalInfo
   *          the additional information associated with this proposal
   */
  public ACTRCompletionProposal(String replacementString,
      int replacementOffset, int replacementLength, int cursorPosition,
      Image image, String displayString,
      IContextInformation contextInformation, String additionalProposalInfo,
      boolean autoInsert)
  {
    Assert.isNotNull(replacementString);
    Assert.isTrue(replacementOffset >= 0);
    Assert.isTrue(replacementLength >= 0);
    Assert.isTrue(cursorPosition >= 0);

    fReplacementString = replacementString;
    fReplacementOffset = replacementOffset;
    fReplacementLength = replacementLength;
    fCursorPosition = cursorPosition;
    fImage = image;
    fDisplayString = displayString;
    fContextInformation = contextInformation;
    fAdditionalProposalInfo = additionalProposalInfo;
    fAutoInsert = autoInsert;
  }

  /*
   * @see ICompletionProposal#apply(IDocument)
   */
  public void apply(IDocument document)
  {
    try
    {
      document.replace(fReplacementOffset, fReplacementLength,
          fReplacementString);
    }
    catch (BadLocationException x)
    {
      // ignore
    }
  }

  /*
   * @see ICompletionProposal#getSelection(IDocument)
   */
  public Point getSelection(IDocument document)
  {
    return new Point(fReplacementOffset + fCursorPosition, 0);
  }

  /*
   * @see ICompletionProposal#getContextInformation()
   */
  public IContextInformation getContextInformation()
  {
    return fContextInformation;
  }

  /*
   * @see ICompletionProposal#getImage()
   */
  public Image getImage()
  {
    return fImage;
  }

  /*
   * @see ICompletionProposal#getDisplayString()
   */
  public String getDisplayString()
  {
    if (fDisplayString != null) return fDisplayString;
    return fReplacementString;
  }

  /*
   * @see ICompletionProposal#getAdditionalProposalInfo()
   */
  public String getAdditionalProposalInfo()
  {
    return fAdditionalProposalInfo;
  }

  public boolean isAutoInsertable()
  {
    return fAutoInsert;
  }
}