EDIT

/**

 * Copyright (C) 2007 EDIT

 * European Distributed Institute of Taxonomy 

 * http://www.e-taxonomy.eu

 * 

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.taxeditor.singlesource.editor.name.container;

import java.util.Iterator;

import javax.naming.OperationNotSupportedException;

import org.eclipse.core.commands.operations.IUndoContext;

import org.eclipse.core.runtime.Assert;

import org.eclipse.jface.text.Document;

import org.eclipse.jface.text.IUndoManager;

import org.eclipse.jface.text.IUndoManagerExtension;

import org.eclipse.jface.text.Position;

import org.eclipse.jface.text.TextViewerUndoManager;

import org.eclipse.jface.text.source.Annotation;

import org.eclipse.jface.text.source.AnnotationModel;

import org.eclipse.jface.text.source.AnnotationPainter;

import org.eclipse.jface.text.source.IAnnotationAccess;

import org.eclipse.jface.text.source.IVerticalRuler;

import org.eclipse.jface.text.source.SourceViewer;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.FocusListener;

import org.eclipse.swt.events.ModifyListener;

import org.eclipse.swt.events.MouseListener;

import org.eclipse.swt.events.VerifyListener;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.graphics.Font;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.widgets.Canvas;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Layout;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.swt.widgets.Widget;

import org.eclipse.ui.IActionBars;

import org.eclipse.ui.IEditorSite;

import org.eclipse.ui.actions.ActionFactory;

import org.eclipse.ui.forms.widgets.TableWrapData;

import org.eclipse.ui.forms.widgets.TableWrapLayout;

import org.eclipse.ui.operations.OperationHistoryActionHandler;

import org.eclipse.ui.operations.RedoActionHandler;

import org.eclipse.ui.operations.UndoActionHandler;

import org.eclipse.ui.texteditor.DefaultMarkerAnnotationAccess;

import org.eclipse.ui.texteditor.IWorkbenchActionDefinitionIds;

import eu.etaxonomy.taxeditor.singlesource.editor.ViewerConfiguration;

import eu.etaxonomy.taxeditor.singlesource.editor.name.container.EditorAnnotationFacade.EditorAnnotationType;

import eu.etaxonomy.taxeditor.singlesource.org.eclipse.jface.text.IPosition;

import eu.etaxonomy.taxeditor.singlesource.org.eclipse.jface.text.PositionFacade;

import eu.etaxonomy.taxeditor.singlesource.org.eclipse.swt.widgets.DisplayProxy;

/**

 * SourceViewer implementation called by NameComposite.

 *

 * @author p.ciardelli

 * @created 27.05.2008

 * @version 1.0

 */

public class NameViewerFacadeImpl extends SourceViewer implements INameViewer {

	private final IVerticalRuler ruler;

	private final AnnotationModel annotationModel;

	/**

	 * <p>Constructor for NameViewer.</p>

	 *

	 * @param parent a {@link org.eclipse.swt.widgets.Composite} object.

	 */

	public NameViewerFacadeImpl(Composite parent) {

		super(parent, new RulerWithIcon(RULER_WIDTH), SWT.WRAP | SWT.MULTI | SWT.RESIZE);

		this.ruler = getVerticalRuler();

		Canvas canvas = (Canvas) getControl();

		TableWrapLayout layout = (TableWrapLayout) canvas.getLayout();

		layout.topMargin = 0;

		layout.rightMargin = 0;

		layout.bottomMargin = 0;

		layout.leftMargin = 0;

		layout.verticalSpacing = 10;

		layout.horizontalSpacing = 0;

		canvas.setLayout(layout);

		TableWrapData twdata = new TableWrapData(TableWrapData.FILL_GRAB);

		getTextWidget().setLayoutData(twdata);

		getTextWidget().setLineSpacing(5);

		// Default implementation adds ruler after the text widget, then 

		//	uses a custom layout to display it before the text widget

		try {

			getVerticalRulerControl().moveAbove(getTextWidget());

		} catch (OperationNotSupportedException e) {

		}

		annotationModel = new AnnotationModel();

		this.setDocument(new Document(""), annotationModel);

		createAnnotationPainter();

		this.configure(new ViewerConfiguration());		

//		setDecorationSupport();

//		DocumentUndoManagerRegistry.connect(this.getDocument());

//		IDocumentUndoManager docUndoManager = DocumentUndoManagerRegistry.getDocumentUndoManager(this.getDocument());

		/**

		getEditorSite().getActionBars().setGlobalActionHandler(ActionFactory.UNDO.getId(), new UndoActionHandler(getSite(), undoContext));

		getEditorSite().getActionBars().setGlobalActionHandler(ActionFactory.REDO.getId(), new RedoActionHandler(getSite(), undoContext));		

		**/

	}

	/**

	 * <p>setBackground</p>

	 *

	 * @param color a {@link org.eclipse.swt.graphics.Color} object.

	 */

	public void setBackground(Color color) {

		// Set background color of ruler

		try {

			getVerticalRulerControl().setBackground(color);

		} catch (OperationNotSupportedException e) {

		}

		// Set background color of text widget

		getTextWidget().setBackground(color);

		// Set background color of strip between ruler and textWidget

		getTextWidget().getParent().setBackground(color); 

	}

	/**

	 * <p>setIcon</p>

	 *

	 * @param icon a {@link org.eclipse.swt.graphics.Image} object.

	 */

	public void setIcon(Image icon) {

		if (ruler instanceof RulerWithIcon) {

			((RulerWithIcon) ruler).setIcon(icon);

		} else {

			throw new IllegalStateException("Viewer's IVerticalRuler is not an instance of RulerWithIcon.");

		}

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.text.source.SourceViewer#createLayout()

	 */

	/**

	 * <p>createLayout</p>

	 *

	 * @return a {@link org.eclipse.swt.widgets.Layout} object.

	 */

	@Override

	protected Layout createLayout() {

		TableWrapLayout layout = new TableWrapLayout();

		layout.numColumns = 2;

		layout.verticalSpacing = 0;

		return layout;

	}

	private void createAnnotationPainter(){

		// Annotations section

		IAnnotationAccess fAnnotationAccess = new DefaultMarkerAnnotationAccess();

		// To paint the annotations

		AnnotationPainter annotationPainter = new AnnotationPainter(this, fAnnotationAccess);

		// Default SquigglesStrategy doesn't recognize line wraps

		annotationPainter.addDrawingStrategy(LineWrapSquigglesStrategy.ID, new LineWrapSquigglesStrategy());

		// Add ability to paint red squigglies

		annotationPainter.addAnnotationType(EditorAnnotationType.ERROR.name(), LineWrapSquigglesStrategy.ID);

		annotationPainter.setAnnotationTypeColor(EditorAnnotationType.ERROR.image, 

				new Color(DisplayProxy.getDefault(), EditorAnnotationType.ERROR.color));

		// Add ability to paint yellow squigglies

		annotationPainter.addAnnotationType(EditorAnnotationType.WARNING.name(), LineWrapSquigglesStrategy.ID);

		annotationPainter.setAnnotationTypeColor(EditorAnnotationType.WARNING.image, 

				new Color(DisplayProxy.getDefault(), EditorAnnotationType.WARNING.color));

		this.addPainter(annotationPainter);

	}

	/**

	 * <p>clearAnnotations</p>

	 */

	public void clearAnnotations() throws OperationNotSupportedException {

		Iterator<Annotation> annotations = this.getAnnotationModel().getAnnotationIterator();

		while (annotations.hasNext()) {

			Annotation annotation = annotations.next(); 

			this.getAnnotationModel().removeAnnotation(annotation);

		}

	}

	/**

	 * If <code>name.hasProblem()</code> is <code>true</code>, underlines section

	 * of text bounded by <code>name.getProblemStarts()</code> and

	 * <code>name.getProblemEnds()</code>.

	 *

	 * @param name a {@link eu.etaxonomy.cdm.model.name.TaxonNameBase} object.

	 */

//	public void setShowParsingErrors(TaxonNameBase<?, ?> name) {

//				

//		String text = this.getTextWidget().getText();

//						

//		if (name.hasProblem() && text.length() > 0) {

//			int start = name.getProblemStarts();

//			int length = name.getProblemEnds() - start;

//			

//			if (start == -1 || name.getProblemEnds() == -1) {

//				return;

//			}

//			

//			// Don't let squigglies try to draw beyond the end of the text

//			if (text.length() < start + length) {

//				length = text.length() - start;

//			}

//			

//			for (ParserProblem problem : name.getParsingProblems()) {

//				

//				String type = null;

//				if (problem.isWarning()) {

//					type = EditorAnnotation.WARNING_TYPE;

//				}

//				if (problem.isError()) {

//					type = EditorAnnotation.ERROR_TYPE;

//				}

//				if (type == null) {

//					continue;

//				}

//				this.getAnnotationModel().addAnnotation(

//						new EditorAnnotation(type, 0, problem.getMessage()), 

//						new Position(start, length));

//			}

//			

//		}

//	}

	@Override

	public void addAnnotation(IEditorAnnotation annotation, IPosition position) throws OperationNotSupportedException {

		if(position == null){

			position = new PositionFacade(0, 0);

		}

		if (position instanceof Position){

			this.getAnnotationModel().addAnnotation((Annotation)annotation, (Position)position);

		}else{

			throw new OperationNotSupportedException("type of argument 'position' must be org.eclipse.jface.text.Position.");

		}

	}

	/**

	 * <p>setText</p>

	 *

	 * @param text a {@link java.lang.String} object.

	 */

	public void setText(String text) {

		if (text == null) {

			text = "";

		}

		try {

			Assert.isNotNull(text);

			// TODO figure out why getTextWidget() returns null!

			if (this.getTextWidget() == null) {

				return;

			}

			Assert.isNotNull(this.getTextWidget());

			this.getTextWidget().setText(text);

		} catch (RuntimeException e) {

			throw e;

		}

	}

	/**

	 * <p>setMenu</p>

	 *

	 * @param menu a {@link org.eclipse.swt.widgets.Menu} object.

	 */

	public void setMenu(Menu menu) {

		try {

			getVerticalRulerControl().setMenu(menu);

		} catch (OperationNotSupportedException e) {

		}

		getTextWidget().setMenu(menu);

	}

	/**

	 * <p>setCursorToEOL</p>

	 */

	public void setCursorToEOL() throws OperationNotSupportedException {

		getTextWidget().setCaretOffset(getTextWidget().getText().length());

		getTextWidget().setFocus();

	}

	/**

	 * <p>getCursorPosition</p>

	 *

	 * @return a int.

	 */

	public int getCursorPosition() throws OperationNotSupportedException {

		return getTextWidget().getCaretOffset();

	}

	/**

	 * <p>setCursorPosition</p>

	 *

	 * @param offset a int.

	 */

	public void setCursorPosition(int offset) throws OperationNotSupportedException {

		try{

			getTextWidget().setCaretOffset(offset);

		}catch(IllegalArgumentException e){

			// do nothing

		}

	}

	/**

	 * <p>createUndoSupport</p>

	 *

	 * @param editorSite a {@link org.eclipse.ui.IEditorSite} object.

	 */

	public void createUndoSupport(IEditorSite editorSite) throws OperationNotSupportedException {

		IUndoManager undoManager = new TextViewerUndoManager(25);

		this.setUndoManager(undoManager);

		undoManager.connect(this);

//		IUndoContext workbenchUndoContext = UiUtil.getWorkbenchUndoContext();

		IUndoContext workbenchUndoContext = ((IUndoManagerExtension)undoManager).getUndoContext();

		OperationHistoryActionHandler undoAction = new UndoActionHandler(editorSite, workbenchUndoContext);

//		undoAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.UNDO);

		undoAction.setActionDefinitionId(ActionFactory.UNDO.getId());

		// Create the redo action.

		OperationHistoryActionHandler redoAction = new RedoActionHandler(editorSite, workbenchUndoContext);

//		redoAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.REDO);

		undoAction.setActionDefinitionId(ActionFactory.REDO.getId());

		IActionBars actionBars = editorSite.getActionBars();

		if (actionBars != null) {

//				actionBars.setGlobalActionHandler(IWorkbenchActionDefinitionIds.UNDO, undoAction);

//				actionBars.setGlobalActionHandler(IWorkbenchActionDefinitionIds.REDO, redoAction);

			actionBars.setGlobalActionHandler(ActionFactory.UNDO.getId(), undoAction);

			actionBars.setGlobalActionHandler(ActionFactory.REDO.getId(), redoAction);

		}		

//		actionBars.setGlobalActionHandler(ActionFactory.UNDO.getId(), undoAction);

//		actionBars.setGlobalActionHandler(ActionFactory.REDO.getId(), redoAction);

	}

	/**

	 * <p>createUndoSupport_</p>

	 *

	 * @param editorSite a {@link org.eclipse.ui.IEditorSite} object.

	 */

	public void createUndoSupport_(IEditorSite editorSite) throws OperationNotSupportedException {

		IUndoManager undoManager = new TextViewerUndoManager(25);

		this.setUndoManager(undoManager);

		undoManager.connect(this);

		IUndoContext undoContext;

		if (undoManager instanceof IUndoManagerExtension) {

			undoContext = ((IUndoManagerExtension)undoManager).getUndoContext();

			OperationHistoryActionHandler undoAction = new UndoActionHandler(editorSite, undoContext);

//			PlatformUI.getWorkbench().getHelpSystem().setHelp(undoAction, IAbstractTextEditorHelpContextIds.UNDO_ACTION);

			undoAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.UNDO);

			// Create the redo action.

			OperationHistoryActionHandler redoAction = new RedoActionHandler(editorSite, undoContext);

//			PlatformUI.getWorkbench().getHelpSystem().setHelp(redoAction, IAbstractTextEditorHelpContextIds.REDO_ACTION);

			redoAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.REDO);

			IActionBars actionBars = editorSite.getActionBars();

			if (actionBars != null) {

				actionBars.setGlobalActionHandler(IWorkbenchActionDefinitionIds.UNDO, undoAction);

				actionBars.setGlobalActionHandler(IWorkbenchActionDefinitionIds.REDO, redoAction);

			}

		}

	}

	@Override

	public void setLayoutData(Object layoutData) {

		getControl().setLayoutData(layoutData);

	}

	@Override

	public void setForeground(Color color) {

		getTextWidget().setForeground(color);

	}

	@Override

	public boolean setFocus() {

		return getTextWidget().setFocus();

	}

	@Override

	public void setFont(Font font) {

		getTextWidget().setFont(font);

	}

	@Override

	public String getText() {

		return getTextWidget().getText();

	}

	@Override

	public void addFocusListener(FocusListener listener) {

		getTextWidget().addFocusListener(listener);

	}

	@Override

	public void removeFocusListener(FocusListener listener) {

		getTextWidget().removeFocusListener(listener);

	}

	@Override

	public void addMouseListener(MouseListener listener) {

		try {

			getVerticalRulerControl().addMouseListener(listener);

		} catch (OperationNotSupportedException e) {

		}

		getTextWidget().addMouseListener(listener);

	}

	@Override

	public void removeMouseListener(MouseListener listener) {

		try {

			getVerticalRulerControl().removeMouseListener(listener);

		} catch (OperationNotSupportedException e) {

		}

		getTextWidget().removeMouseListener(listener);

	}

	@Override

	public void addModifyListener(ModifyListener listener) {

		getTextWidget().addModifyListener(listener);

	}

	@Override

	public void removeModifyListener(ModifyListener listener) {

		getTextWidget().removeModifyListener(listener);

	}

	@Override

	public void addVerifyListener(VerifyListener listener) {

		getTextWidget().addVerifyListener(listener);

	}

	@Override

	public void removeVerifyListener(VerifyListener listener) {

		getTextWidget().removeVerifyListener(listener);

	}

	@Override

	public Control getVerticalRulerControl() throws OperationNotSupportedException {

		return ruler.getControl();

	}

	@Override

	public void setEnabled(boolean enabled) {

		getTextWidget().setEnabled(enabled);

	}

	@Override

	public Control getDraggableControl() {

		try {

			return getVerticalRulerControl();

		} catch (OperationNotSupportedException e) {

			return null;

		}

	}

	@Override

	public Widget getStyledText() throws OperationNotSupportedException {

		return getTextWidget();

	}

	@Override

	public String getDocumentAsString() throws OperationNotSupportedException {

		return getDocument().get();

	}

	@Override

	public void setDocumentAsString(String text) throws OperationNotSupportedException {

		getDocument().set(text);

	}

	@Override

	public int getDocumentLength() throws OperationNotSupportedException {

		return getDocument().getLength();

	}

}