bundles/org.eclipse.wst.sse.ui/src/org/eclipse/wst/sse/ui/SpellCheckTargetImpl.java

/*******************************************************************************
 * Copyright (c) 2001, 2004 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
 *     Jens Lukowski/Innoopract - initial renaming/restructuring
 *     
 *******************************************************************************/
package org.eclipse.wst.sse.ui;

/**
 * @deprecated - to be removed in M4
 */

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IFindReplaceTarget;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.ui.texteditor.ITextEditorExtension;
import org.eclipse.ui.texteditor.ITextEditorExtension2;
import org.eclipse.wst.sse.core.IStructuredModel;
import org.eclipse.wst.sse.core.StructuredModelManager;
import org.eclipse.wst.sse.core.text.IStructuredDocument;
import org.eclipse.wst.sse.core.text.IStructuredDocumentRegion;
import org.eclipse.wst.sse.core.text.ITextRegion;
import org.eclipse.wst.sse.core.text.ITextRegionList;
import org.eclipse.wst.sse.ui.extensions.spellcheck.SpellCheckElement;
import org.eclipse.wst.sse.ui.extensions.spellcheck.SpellCheckException;
import org.eclipse.wst.sse.ui.extensions.spellcheck.SpellCheckOptionDialog;
import org.eclipse.wst.sse.ui.extensions.spellcheck.SpellCheckSelectionManager;
import org.eclipse.wst.sse.ui.extensions.spellcheck.SpellCheckTarget;
import org.eclipse.wst.sse.ui.extensions.spellcheck.SpellChecker;
import org.eclipse.wst.sse.ui.internal.SSEUIPlugin;

/**
 * @deprecated - will be removed in M4
 */
public class SpellCheckTargetImpl implements SpellCheckTarget {

	public static class EditorSpellCheckException extends SpellCheckException {
		/**
		 * Comment for <code>serialVersionUID</code>
		 */
		private static final long serialVersionUID = 1L;

		EditorSpellCheckException(String msg) {
			super(msg);
		}

		public IStatus getStatus() {
			return new Status(IStatus.ERROR, SSEUIPlugin.ID, 0, getMessage(), this);
		}
	}

	public static final String ID = "spellchecktarget"; //$NON-NLS-1$

	private SpellChecker checker;
	private ITextEditor fTextEditor;
	private IFindReplaceTarget target;
	private IStructuredModel fUndoRecorder = null;

	public SpellCheckTargetImpl() {
		super();
	}

	/**
	 * @see ISpellCheckTarget#beginRecording()
	 */
	public void beginRecording(Object requester, String label) {
		if (fTextEditor == null)
			return;

		fUndoRecorder = StructuredModelManager.getModelManager().getExistingModelForEdit(getEditingDocument());
		if (fUndoRecorder == null)
			return;

		fUndoRecorder.beginRecording(requester, label);
	}

	/**
	 * @see ISpellCheckTarget#canPerformChange()
	 */
	public boolean canPerformChange() {
		if (fTextEditor == null || checker == null || target == null)
			return false;

		return target.isEditable() && fTextEditor.isEditable();
	}

	/**
	 * @see ISpellCheckTarget#canPerformChangeAll()
	 */
	public boolean canPerformChangeAll() {
		return canPerformChange();
	}

	/**
	 * @see ISpellCheckTarget#canPerformIgnore()
	 */
	public boolean canPerformIgnore() {
		return fTextEditor != null && checker != null;
	}

	/**
	 * @see ISpellCheckTarget#canPerformIgnoreAll()
	 */
	public boolean canPerformIgnoreAll() {
		return canPerformIgnore();
	}

	/**
	 * @see ISpellCheckTarget#canPerformSpellCheck()
	 */
	public boolean canPerformSpellCheck() {
		return fTextEditor != null && checker != null;
	}

	/**
	 * @see ISpellCheckTarget#endRecording()
	 */
	public void endRecording(Object requester) {
		if (fUndoRecorder == null)
			return;

		fUndoRecorder.endRecording(requester);
		fUndoRecorder = null;
	}

	/**
	 * @see ISpellCheckTarget#findAndSelect(int, String)
	 */
	public int findAndSelect(int pos, String find) {
		return (target != null ? target.findAndSelect(pos, find, true, true, true) : -1);
	}

	IDocument getEditingDocument() {
		return fTextEditor.getDocumentProvider().getDocument(fTextEditor.getEditorInput());
	}

	/**
	 * @see ISpellCheckTarget#getAndSelectNextMisspelledElement(boolean)
	 */
	public SpellCheckElement getAndSelectNextMisspelledElement(boolean init) throws SpellCheckException {
		if (checker == null || fTextEditor == null || target == null)
			return null;

		IDocument document = getEditingDocument();
		
		if (document instanceof IStructuredDocument) {
			IStructuredDocument structuredDocument = (IStructuredDocument) getEditingDocument();

			int start;
			if (init) {
				start = 0;
			}
			else {
				Point pt = target.getSelection();
				start = pt.x + pt.y;
			}

			IStructuredDocumentRegion documentRegion = structuredDocument.getRegionAtCharacterOffset(start);
			if (documentRegion == null) {
				return null;
			}

			ITextRegion startRegion = documentRegion.getRegionAtCharacterOffset(start);
			if (startRegion == null) {
				return null;
			}

			boolean skip = true;
			while (documentRegion != null) {
				ITextRegionList regions = documentRegion.getRegions();
				int size = regions.size();
				for (int i = 0; i < size; ++i) {
					ITextRegion r = regions.get(i);
					if (skip && startRegion.equals(r)) {
						skip = false;
					}
					if (skip == false) {
						if (isValidType(r.getType())) {
							String text;
							if (start > documentRegion.getStartOffset(r)) {
								text = documentRegion.getText(r);
								int offset = start - documentRegion.getStartOffset(r);
								for (; offset < text.length(); ++offset) {
									if (!Character.isLetterOrDigit(text.charAt(offset - 1))) {
										break;
									}
								}
								text = text.substring(offset);
							}
							else {
								text = documentRegion.getText(r);
							}
							SpellCheckElement[] elms = checker.createSingleWords(text);
							if (elms != null) {
								for (int j = 0; j < elms.length; ++j) {
									SpellCheckElement element = checker.verifySpell(elms[j]);
									if (element.isSpellError()) {
										target.findAndSelect(start, element.getString(), true, true, true);
										return element;
									}
								}
							}
						}
					}
				}
				documentRegion = documentRegion.getNext();
			}
		}

		return null;
	}

	/**
	 * @see ISpellCheckTarget#getOptionDialog()
	 */
	public SpellCheckOptionDialog getOptionDialog() {
		return null;
	}

	/**
	 * @see ISpellCheckTarget#getSpellCheckSelectionManager()
	 */
	public SpellCheckSelectionManager getSpellCheckSelectionManager() {
		if (fTextEditor == null)
			return null;

		ViewerSelectionManager manager = (ViewerSelectionManager) fTextEditor.getAdapter(ViewerSelectionManager.class);
		if (!(manager instanceof SpellCheckSelectionManager))
			return null;
		return (SpellCheckSelectionManager) manager;
	}

	private boolean isModifyable() {
		if (fTextEditor instanceof ITextEditorExtension2)
			return ((ITextEditorExtension2) fTextEditor).validateEditorInputState();
		else if (fTextEditor instanceof ITextEditorExtension)
			return !((ITextEditorExtension) fTextEditor).isEditorInputReadOnly();
		else if (fTextEditor != null)
			return fTextEditor.isEditable();
		else
			return false;
	}

	/**
	 */
	protected boolean isValidType(String type) {
		return false;
	}

	/**
	 * @see ISpellCheckTarget#replaceSelection(String)
	 */
	public void replaceSelection(String text, Shell shell) throws SpellCheckException {
		if (target == null || !isModifyable())
			return;

		target.replaceSelection(text);
	}

	/**
	 * @see ISpellCheckTarget#setSpellChecker(ISpellChecker)
	 */
	public void setSpellChecker(SpellChecker spellChecker) {
		checker = spellChecker;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.wst.sse.ui.extensions.spellcheck.SpellCheckTarget#setTextEditor(org.eclipse.ui.texteditor.ITextEditor)
	 */
	public void setTextEditor(ITextEditor editor) {
		fTextEditor = editor;
		target = (IFindReplaceTarget) editor.getAdapter(IFindReplaceTarget.class);
	}
}