Source Code : SWT Completion Editor

Java Is Open Source Programming Language You Can Download From Java and Java Libraries From http://www.oracle.com. Click Here to download
We provide this code related to title for you to solve your developing problem easily. Libraries which is import in this program you can download from http://www.oracle.com. Click Here or search from google with Libraries Name you get jar file related it

SWT Completion Editor

/*
SWT/JFace in Action
GUI Design with Eclipse 3.0
Matthew Scarpino, Stephen Holder, Stanford Ng, and Laurent Mihalkovic

ISBN: 1932394273

Publisher: Manning
*/


import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextListener;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.text.TextEvent;
import org.eclipse.jface.text.TextViewer;
import org.eclipse.jface.text.contentassist.CompletionProposal;
import org.eclipse.jface.text.contentassist.ContentAssistant;
import org.eclipse.jface.text.contentassist.ContextInformationValidator;
import org.eclipse.jface.text.contentassist.ICompletionProposal;
import org.eclipse.jface.text.contentassist.IContentAssistProcessor;
import org.eclipse.jface.text.contentassist.IContextInformation;
import org.eclipse.jface.text.contentassist.IContextInformationValidator;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Composite;

public class Ch5CompletionEditor extends Composite {
  private TextViewer textViewer;

  private WordTracker wordTracker;

  private static final int MAX_QUEUE_SIZE = 200;

  public Ch5CompletionEditor(Composite parent) {
    super(parent, SWT.NULL);
    wordTracker = new WordTracker(MAX_QUEUE_SIZE);
    buildControls();
  }

  private void buildControls() {
    setLayout(new FillLayout());
    textViewer = new TextViewer(this, SWT.MULTI | SWT.V_SCROLL);

    textViewer.setDocument(new Document());

    final ContentAssistant assistant = new ContentAssistant();
    assistant.setContentAssistProcessor(
        new RecentWordContentAssistProcessor(wordTracker),
        IDocument.DEFAULT_CONTENT_TYPE);

    assistant.install(textViewer);

    textViewer.getControl().addKeyListener(new KeyAdapter() {
      public void keyPressed(KeyEvent e) {
        switch (e.keyCode) {
        case SWT.F1:
          assistant.showPossibleCompletions();
          break;
        default:
        //ignore everything else
        }
      }
    });

    textViewer.addTextListener(new ITextListener() {
      public void textChanged(TextEvent e) {
        if (isWhitespaceString(e.getText())) {
          wordTracker.add(findMostRecentWord(e.getOffset() - 1));
        }
      }
    });
  }

  protected String findMostRecentWord(int startSearchOffset) {
    int currOffset = startSearchOffset;
    char currChar;
    String word = "";
    try {
      while (currOffset > 0
          && !Character.isWhitespace(currChar = textViewer
              .getDocument().getChar(currOffset))) {
        word = currChar + word;
        currOffset--;
      }
      return word;
    } catch (BadLocationException e) {
      e.printStackTrace();
      return null;
    }
  }

  protected boolean isWhitespaceString(String string) {
    StringTokenizer tokenizer = new StringTokenizer(string);
    //if there is at least 1 token, this string is not whitespace
    return !tokenizer.hasMoreTokens();
  }

}

class WordTracker {
  private int maxQueueSize;

  private List wordBuffer;

  private Map knownWords = new HashMap();

  public WordTracker(int queueSize) {
    maxQueueSize = queueSize;
    wordBuffer = new LinkedList();
  }

  public int getWordCount() {
    return wordBuffer.size();
  }

  public void add(String word) {
    if (wordIsNotKnown(word)) {
      flushOldestWord();
      insertNewWord(word);
    }
  }

  private void insertNewWord(String word) {
    wordBuffer.add(0, word);
    knownWords.put(word, word);
  }

  private void flushOldestWord() {
    if (wordBuffer.size() == maxQueueSize) {
      String removedWord = (String) wordBuffer.remove(maxQueueSize - 1);
      knownWords.remove(removedWord);
    }
  }

  private boolean wordIsNotKnown(String word) {
    return knownWords.get(word) == null;
  }

  public List suggest(String word) {
    List suggestions = new LinkedList();
    for (Iterator i = wordBuffer.iterator(); i.hasNext();) {
      String currWord = (String) i.next();
      if (currWord.startsWith(word)) {
        suggestions.add(currWord);
      }
    }
    return suggestions;
  }

}

class RecentWordContentAssistProcessor implements IContentAssistProcessor {
  private String lastError = null;

  private IContextInformationValidator contextInfoValidator;

  private WordTracker wordTracker;

  public RecentWordContentAssistProcessor(WordTracker tracker) {
    super();
    contextInfoValidator = new ContextInformationValidator(this);
    wordTracker = tracker;
  }

  public ICompletionProposal[] computeCompletionProposals(
      ITextViewer textViewer, int documentOffset) {
    IDocument document = textViewer.getDocument();
    int currOffset = documentOffset - 1;

    try {
      String currWord = "";
      char currChar;
      while (currOffset > 0
          && !Character.isWhitespace(currChar = document
              .getChar(currOffset))) {
        currWord = currChar + currWord;
        currOffset--;
      }

      List suggestions = wordTracker.suggest(currWord);
      ICompletionProposal[] proposals = null;
      if (suggestions.size() > 0) {
        proposals = buildProposals(suggestions, currWord,
            documentOffset - currWord.length());
        lastError = null;
      }
      return proposals;
    } catch (BadLocationException e) {
      e.printStackTrace();
      lastError = e.getMessage();
      return null;
    }
  }

  private ICompletionProposal[] buildProposals(List suggestions,
      String replacedWord, int offset) {
    ICompletionProposal[] proposals = new ICompletionProposal[suggestions
        .size()];
    int index = 0;
    for (Iterator i = suggestions.iterator(); i.hasNext();) {
      String currSuggestion = (String) i.next();
      proposals[index] = new CompletionProposal(currSuggestion, offset,
          replacedWord.length(), currSuggestion.length());
      index++;
    }
    return proposals;
  }

  public IContextInformation[] computeContextInformation(
      ITextViewer textViewer, int documentOffset) {
    lastError = "No Context Information available";
    return null;
  }

  public char[] getCompletionProposalAutoActivationCharacters() {
    //we always wait for the user to explicitly trigger completion
    return null;
  }

  public char[] getContextInformationAutoActivationCharacters() {
    //we have no context information
    return null;
  }

  public String getErrorMessage() {
    return lastError;
  }

  public IContextInformationValidator getContextInformationValidator() {
    return contextInfoValidator;
  }
}

           
       

Thank with us