command.emacsCompletion.description = Context insensitive completion

command.emacsCompletion.name = Text Completion

      <command

            name="%command.emacsCompletion.name"

            description="%command.emacsCompletion.description"

            categoryId="org.eclipse.ui.category.edit"

            id="org.eclipse.ui.edit.text.emacsCompletion">

      </command>

      <keyBinding

            commandId="org.eclipse.ui.edit.text.emacsCompletion"

            contextId="org.eclipse.ui.textEditorScope"

            keySequence="Alt+/"

            keyConfigurationId="org.eclipse.ui.defaultAcceleratorConfiguration">

       </keyBinding>

		action = new EmacsCompleteAction(EditorMessages.getResourceBundle(), "Editor.EmacsCompletion.", this); //$NON-NLS-1$

		// TODO action.setHelpContextId(IAbstractTextEditorHelpContextIds.EMACS_COMPLETION_ACTION);

		action.setActionDefinitionId(ITextEditorActionDefinitionIds.EMACS_COMPLETION);

		setAction(ITextEditorActionConstants.EMACS_COMPLETION, action);

	/** 

	 * Name of the action for emacs style completion. 

	 * Value: <code>"EMACS_COMPLETION"</code>

	 * @since 3.1

	 */

	static final String EMACS_COMPLETION= "EMACS_COMPLETION"; //$NON-NLS-1$

	/**

	 * Action definition ID of the edit -> text complete action

	 * Value: <code>"org.eclipse.ui.edit.text.emacsCompletion"</code>).

	 * @since 3.1

	 */

	public static final String EMACS_COMPLETION= "org.eclipse.ui.edit.text.emacsCompletion"; //$NON-NLS-1$

/*******************************************************************************

 * Copyright (c) 2000, 2005 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials 

 * are made available under the terms of the Common Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/cpl-v10.html

 * 

 * Contributors:

 *     Genady Beryozkin, me@genady.org - initial API and implementation

 *     IBM Corporation - fixes and cleaning

 *******************************************************************************/

package org.eclipse.ui.texteditor;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.ResourceBundle;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.jface.text.BadLocationException;

import org.eclipse.jface.text.DocumentEvent;

import org.eclipse.jface.text.FindReplaceDocumentAdapter;

import org.eclipse.jface.text.IDocument;

import org.eclipse.jface.text.IDocumentListener;

import org.eclipse.jface.text.IRegion;

import org.eclipse.jface.text.ITextSelection;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.IEditorPart;

import org.eclipse.ui.IEditorReference;

/**

 * This class implements the emacs style completion action.

 * Completion action is a stateful action, as the user may invoke

 * it several times in a row in order to scroll the possible completions.

 * 

 * 

 * TODO: Work on backward suggestions

 * TODO: Sort by editor type

 * TODO: Provide history option

 * 

 * @author Genady Beryozkin, me@genady.org

 */

public class EmacsCompleteAction extends TextEditorAction {

	private IDocument doc;

	/** 

	 * The completion state to continue

	 * the iteration over suggestions

	 */

	private CompletionState lastCompletion = null;

	private boolean modifyingLock = false;

	SelectionChangeListener selectionListener;

	DocumentChangeListerner contentListener;

	/* (non-Javadoc)

	 * @see org.eclipse.ui.texteditor.TextEditorAction#setEditor(org.eclipse.ui.texteditor.ITextEditor)

	 */

	public void setEditor(ITextEditor editor) {

		ITextEditor old= getTextEditor();

		if (old != null) {

			old.getSelectionProvider().removeSelectionChangedListener(selectionListener);

			doc.removeDocumentListener(contentListener);

		}

		super.setEditor(editor);

		selectionListener = new SelectionChangeListener();

		contentListener = new DocumentChangeListerner();

		IEditorInput input = editor.getEditorInput();

		doc = editor.getDocumentProvider().getDocument(input);

		editor.getSelectionProvider().addSelectionChangedListener(selectionListener);

		doc.addDocumentListener(contentListener);

	}

	class SelectionChangeListener implements ISelectionChangedListener {

		public void selectionChanged(SelectionChangedEvent event) {

			if (!modifyingLock) {

				lastCompletion = null;

			}

		}

	}

	class DocumentChangeListerner implements IDocumentListener {

		public void documentAboutToBeChanged(DocumentEvent event) {

		}

		public void documentChanged(DocumentEvent event) {

			if (!modifyingLock) {

				lastCompletion = null;

			}

		}

	}	

	/**

	 * Perform the next completion.

	 */

	private void completeNext() {

		// we don't wish to receive events on our own changes

		modifyingLock = true;

		try {

			doc.replace(lastCompletion.startOffset, lastCompletion.length, 

					lastCompletion.suggestions[lastCompletion.nextSuggestion]);

		} catch (BadLocationException e) {

			// we should never get here

			throw new IllegalStateException(e.toString());

		}

		// advance the suggestion state

		lastCompletion.advance();

		// move the cursor to the insertion point

		((AbstractTextEditor) getTextEditor()).getSourceViewer().setSelectedRange(lastCompletion.startOffset+lastCompletion.length, 0);

		// allow changes

		modifyingLock = false;

	}

	/**

	 * This class represents the state of the last completion process.

	 * Each time the user moves to a new position and calls this action

	 * an instance of this inner classs is created  and saved in

	 * {@link #lastCompletion}.

	 */

	private static class CompletionState {

		/** The list of suggestions that was computed when the completion

		 * action was first invoked 

		 */

		final String[] suggestions;

		/** The caret position at which we insert the suggestions */

		final int startOffset;

		/** The length of the last suggestion string */

		int length;

		/** The index of next suggestion (index into the suggestion array) */

		int nextSuggestion;

		CompletionState(String[] suggestions, int startOffset) {

			this.suggestions = suggestions;

			this.startOffset = startOffset;

			length = 0;

			nextSuggestion = 0;

		}

		public void advance() {

			length = suggestions[nextSuggestion].length();

			nextSuggestion = (nextSuggestion + 1) % suggestions.length;	

		}

	}

	/**

	 * @param bundle the resource bundle

	 * @param prefix a prefix to be prepended to the various resource keys

	 *   (described in <code>ResourceAction</code> constructor), or 

	 *   <code>null</code> if none

	 * @param editor the text editor

	 */

	protected EmacsCompleteAction(ResourceBundle bundle, String prefix, ITextEditor editor) {

		super(bundle, prefix, editor);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.action.Action#run()

	 */

	public void run() {

		if (lastCompletion != null) 

		{

			completeNext();

			return;

		} 

		String prefix = getCurrentPrefix();

		if (prefix == null) {

			getTextEditor().getSite().getShell().getDisplay().beep();

			return;

		}

		String[] suggestions = getSuggestions(prefix);

		// if it is single empty suggestion

		if (suggestions.length == 1) {

			getTextEditor().getSite().getShell().getDisplay().beep();

			return;

		}

		lastCompletion = new CompletionState(suggestions, 

				((ITextSelection) getTextEditor().getSelectionProvider().getSelection()).getOffset());

		completeNext();

	}

	/**

	 * Create the array of suggestions. It scan all open text editors

	 * and prefers suggestion from the currently open editor.

	 * It also addes the empty suggestion at the end.

     * 

     * @param currEditor The current editor

	 */

	public String[] getSuggestions(String prefix) {

		// Change the order of open editors, to make the active editor

		// to appear first.

		IEditorReference editorsArray[] = getTextEditor().getSite().getWorkbenchWindow().getActivePage().getEditorReferences();

		ArrayList editorsVector = new ArrayList();

		for (int i = 0; i < editorsArray.length; i++) {

			IEditorPart realEditor = editorsArray[i].getEditor(false);

			if (realEditor != null) {

				editorsVector.add(realEditor);

			}

		}

		editorsVector.remove(getTextEditor());

		editorsVector.add(0, getTextEditor());

		// collect the suggestions from all open text editors

		LinkedList suggestions = new LinkedList();

		for (int i = 0; i < editorsVector.size(); i++) {

			if (editorsVector.get(i) instanceof ITextEditor) {

				ITextEditor textEditor = (ITextEditor) editorsVector.get(i);

				IEditorInput input = textEditor.getEditorInput();

				IDocument doc = textEditor.getDocumentProvider().getDocument(input);

				try {

					suggestions.addAll(getForwardSuggestions(doc, prefix));

				} catch (BadLocationException e) {

					// TODO Auto-generated catch block

					e.printStackTrace();

				}

			}

		}

		makeUnique(suggestions);

		suggestions.add(""); // empty suggestion

		return (String[])suggestions.toArray(new String[0]);

	}

	/**

	 * Remove duplicate suggestions, leaving the closest to list head. 

	 * @param suggestions

	 */

	private void makeUnique(LinkedList suggestions) {

		HashSet seenAlready = new HashSet();

		for (Iterator i = suggestions.iterator(); i.hasNext();) {

			String suggestion = (String) i.next();

			if (seenAlready.contains(suggestion)) {

				i.remove();

			} else {

				seenAlready.add(suggestion);

			}

		}

	}

	/**

	 * Copied from {@link FindReplaceDocumentAdapter}.

	 * 

	 * Converts a non-regex string to a pattern

	 * that can be used with the regex search engine.

	 * 

	 * @param string the non-regex pattern

	 * @return the string converted to a regex pattern

	 */

	private static String asRegPattern(String string) {

		StringBuffer out= new StringBuffer(string.length());

		boolean quoting= false;

		for (int i= 0, length= string.length(); i < length; i++) {

			char ch= string.charAt(i);

			if (ch == '\\') {

				if (quoting) {

					out.append("\\E"); //$NON-NLS-1$

					quoting= false;

				}

				out.append("\\\\"); //$NON-NLS-1$

				continue;								

			}

			if (!quoting) {

				out.append("\\Q"); //$NON-NLS-1$

				quoting= true;

			}

			out.append(ch);

		}

		if (quoting)

			out.append("\\E"); //$NON-NLS-1$

		return out.toString();

	}

	/**

	 * Return the list of completion suggestions the correspond to the provided

	 * prefix

	 * 

	 * @param document

	 * @param prefix

	 * @return

	 * @throws BadLocationException

	 */

	private static ArrayList getForwardSuggestions(IDocument document, String prefix) throws BadLocationException {

		ArrayList res = new ArrayList();

		FindReplaceDocumentAdapter searcher = new 

			FindReplaceDocumentAdapter(document);

		// search only at word boundaries 

		String searchPattern = "\\b" + asRegPattern(prefix);

		IRegion reg = searcher.find(0, searchPattern, true, true, false, true);

		while (reg != null) {

			// try to complete to a word

			IRegion word = searcher.find(reg.getOffset(), "\\w+", true, true, false, true);

			if (word.getLength() > reg.getLength() ) { // empty suggestion will be added later

				String found = document.get(word.getOffset(), word.getLength());

				res.add(found.substring(prefix.length()));

			}

			int nextPos = word.getOffset() + word.getLength();

			if (nextPos >= document.getLength() ) {

				break;

			}

			reg = searcher.find(nextPos, searchPattern, true, true, false, true);

		}

		return res;

	}

	/**

	 * Return the part of a word before the caret.

	 * If the caret is not at a middle/end of a word, 

	 * returns null.

	 */

	public String getCurrentPrefix() {

		ITextSelection selection = (ITextSelection) getTextEditor().getSelectionProvider().getSelection();

		if (selection.getLength() > 0) {

			return null;

		}

		int pos = selection.getOffset();

        String docText = doc.get();

        int prevNonAlpha = pos;

        while (prevNonAlpha > 0 && 

        	    Character.isJavaIdentifierPart(docText.charAt(prevNonAlpha-1))) 

        {

        	prevNonAlpha--;

        }

        if (prevNonAlpha != pos) {

            return docText.substring(prevNonAlpha, pos);

        } else {

        	return null;

        }

	}

}