/*******************************************************************************
 * 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.internal;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.jobs.ILock;
import org.eclipse.jface.text.AbstractDocument;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.ConfigurableLineTracker;
import org.eclipse.jface.text.DefaultLineTracker;
import org.eclipse.jface.text.DocumentEvent;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IDocumentAdapter;
import org.eclipse.jface.text.IDocumentAdapterExtension;
import org.eclipse.jface.text.IDocumentListener;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.IRepairableDocument;
import org.eclipse.jface.text.ITextStore;
import org.eclipse.jface.text.Region;
import org.eclipse.jface.text.TextUtilities;
import org.eclipse.jface.text.projection.ProjectionDocument;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.custom.TextChangeListener;
import org.eclipse.swt.custom.TextChangedEvent;
import org.eclipse.swt.custom.TextChangingEvent;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.PlatformUI;
import org.eclipse.wst.sse.core.internal.ILockable;
import org.eclipse.wst.sse.core.internal.provisional.events.IStructuredDocumentListener;
import org.eclipse.wst.sse.core.internal.provisional.events.NewDocumentEvent;
import org.eclipse.wst.sse.core.internal.provisional.events.NoChangeEvent;
import org.eclipse.wst.sse.core.internal.provisional.events.RegionChangedEvent;
import org.eclipse.wst.sse.core.internal.provisional.events.RegionsReplacedEvent;
import org.eclipse.wst.sse.core.internal.provisional.events.StructuredDocumentEvent;
import org.eclipse.wst.sse.core.internal.provisional.events.StructuredDocumentRegionsReplacedEvent;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegionList;
import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegionList;
import org.eclipse.wst.sse.core.internal.util.Debug;
import org.eclipse.wst.sse.core.internal.util.Utilities;
import org.eclipse.wst.sse.ui.internal.util.Assert;


/**
 * Adapts IStructuredDocument events and methods to StyledTextContent events
 * and methods
 */
public class StructuredDocumentToTextAdapter implements IDocumentAdapter, IDocumentAdapterExtension {

	private class DocumentClone extends AbstractDocument {


		/**
		 * Creates a new document clone with the given content.
		 * 
		 * @param content
		 *            the content
		 * @param lineDelimiters
		 *            the line delimiters
		 */
		public DocumentClone(String content, String[] lineDelimiters) {
			super();
			setTextStore(new StringTextStore(content));
			ConfigurableLineTracker tracker = new ConfigurableLineTracker(lineDelimiters);
			setLineTracker(tracker);
			getTracker().set(content);
			completeInitialization();
		}
	}

	// A pre-notification listener for the viewer's Document
	class DocumentListener implements IDocumentListener {
		protected boolean allTextChanged = false;

		protected DocumentEvent currentEvent;

		synchronized public void documentAboutToBeChanged(DocumentEvent event) {
			if (isStoppedForwardingChanges())
				return;

			pendingDocumentChangedEvent = true;
			allTextChanged = event.getOffset() <= 0 && event.getLength() >= StructuredDocumentToTextAdapter.this.getDocument().getLength();
			currentEvent = event;

			StructuredDocumentToTextAdapter.this.relayTextChanging(event.getOffset(), event.getLength(), event.getText());
		}

		synchronized public void documentChanged(DocumentEvent event) {
			if (isStoppedForwardingChanges())
				return;

			if (currentEvent != null && event == currentEvent) {
				if (allTextChanged) {
					StructuredDocumentToTextAdapter.this.relayTextSet();
				}
				else {
					// temp work around for immediate thread
					// problem.
					// should have more general solution
					// soon. 'syncExec' are rumored to be
					// prone to hang.
					StructuredDocumentToTextAdapter.this.relayTextChanged();
				}
			}

			currentEvent = null;
			pendingDocumentChangedEvent = false;
			handlePendingEvents();
			lastEvent = null;

		}
	}

	private static class StringTextStore implements ITextStore {

		private String fContent;

		/**
		 * Creates a new string text store with the given content.
		 * 
		 * @param content
		 *            the content
		 */
		public StringTextStore(String content) {
			Assert.isNotNull(content, "content can not be null when setting text store");
			fContent = content;
		}

		/*
		 * @see org.eclipse.jface.text.ITextStore#get(int)
		 */
		public char get(int offset) {
			return fContent.charAt(offset);
		}

		/*
		 * @see org.eclipse.jface.text.ITextStore#get(int, int)
		 */
		public String get(int offset, int length) {
			return fContent.substring(offset, offset + length);
		}

		/*
		 * @see org.eclipse.jface.text.ITextStore#getLength()
		 */
		public int getLength() {
			return fContent.length();
		}

		/*
		 * @see org.eclipse.jface.text.ITextStore#replace(int, int,
		 *      java.lang.String)
		 */
		public void replace(int offset, int length, String text) {
		}

		/*
		 * @see org.eclipse.jface.text.ITextStore#set(java.lang.String)
		 */
		public void set(String text) {
		}

	}

	/**
	 * Changes to the Document/IStructuredDocument can extend beyond the text
	 * change area and require more redrawing to keep the hilighting correct.
	 * The event must be saved so that the redraw is only sent after a
	 * textChanged event is received.
	 */
	class StructuredDocumentListener implements IStructuredDocumentListener {

		public void newModel(NewDocumentEvent structuredDocumentEvent) {

			if (isStoppedForwardingChanges()) {
				// if
				// (StructuredDocumentToTextAdapter.this.fStopRelayingChanges)
				// {
				if (Debug.debugStructuredDocument) {
					System.out.println("skipped relaying StructuredDocumentEvent " + structuredDocumentEvent.getClass().getName()); //$NON-NLS-1$
				}
				return;
			}
			// should use textSet when all contents have
			// changed
			// otherwise need to use the pair of
			// textChanging and
			// textChanged.
			StructuredDocumentToTextAdapter.this.lastEvent = structuredDocumentEvent;
		}

		public void noChange(final NoChangeEvent structuredDocumentEvent) {

			if (Debug.debugStructuredDocument) {
				System.out.println("skipped relaying StructuredDocumentEvent " + structuredDocumentEvent.getClass().getName()); //$NON-NLS-1$
			}
			if (structuredDocumentEvent.reason == NoChangeEvent.READ_ONLY_STATE_CHANGE) {
				if (pendingDocumentChangedEvent) {
					if (lastEventQueue == null) {
						lastEventQueue = new ArrayList();
					}
					lastEventQueue.add(structuredDocumentEvent);
				}
				else {
					StructuredDocumentToTextAdapter.this.lastEvent = structuredDocumentEvent;
				}
			}
		}

		public void nodesReplaced(StructuredDocumentRegionsReplacedEvent structuredDocumentEvent) {

			if (isStoppedForwardingChanges()) {
				// if
				// (StructuredDocumentToTextAdapter.this.fStopRelayingChanges)
				// {
				if (Debug.debugStructuredDocument) {
					System.out.println("not relaying StructuredDocumentEvent " + structuredDocumentEvent.getClass().getName()); //$NON-NLS-1$
				}
				return;
			}
			if (Debug.debugStructuredDocument) {
				System.out.println("saving StructuredDocumentEvent " + structuredDocumentEvent.getClass().getName()); //$NON-NLS-1$
			}
			StructuredDocumentToTextAdapter.this.lastEvent = structuredDocumentEvent;
		}

		public void regionChanged(RegionChangedEvent structuredDocumentEvent) {

			if (isStoppedForwardingChanges()) {
				// if
				// (StructuredDocumentToTextAdapter.this.fStopRelayingChanges)
				// {
				if (Debug.debugStructuredDocument) {
					System.out.println("not relaying StructuredDocumentEvent " + structuredDocumentEvent.getClass().getName()); //$NON-NLS-1$
				}
				return;
			}
			if (Debug.debugStructuredDocument) {
				System.out.println("saving StructuredDocumentEvent " + structuredDocumentEvent.getClass().getName()); //$NON-NLS-1$
			}
			StructuredDocumentToTextAdapter.this.lastEvent = structuredDocumentEvent;
		}

		public void regionsReplaced(RegionsReplacedEvent structuredDocumentEvent) {

			if (isStoppedForwardingChanges()) {
				// if
				// (StructuredDocumentToTextAdapter.this.fStopRelayingChanges)
				// {
				if (Debug.debugStructuredDocument) {
					System.out.println("not relaying StructuredDocumentEvent " + structuredDocumentEvent.getClass().getName()); //$NON-NLS-1$
				}
				return;
			}
			if (Debug.debugStructuredDocument) {
				System.out.println("saving StructuredDocumentEvent " + structuredDocumentEvent.getClass().getName()); //$NON-NLS-1$
			}
			StructuredDocumentToTextAdapter.this.lastEvent = structuredDocumentEvent;
		}
	}

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

	private final static boolean redrawBackground = true;

	/** The visible child document. */
	private ProjectionDocument fChildDocument;

	/** The master document */
	private IDocument fDocument;
	/** The document clone for the non-forwarding case. */
	private IDocument fDocumentClone;

	// only use this temp work around if on GTK
	// it causes funny "cursor blinking" if used on windows
	private final boolean forceRedrawOnRegionChanged = Platform.getWS().equals("gtk"); //$NON-NLS-1$
	/** The original content */
	private String fOriginalContent;
	/** The original line delimiters */
	private String[] fOriginalLineDelimiters;

	private int fStopRelayingChangesRequests = 0;

	private StyledText fStyledTextWidget;

	/** The registered text changed listeners */
	TextChangeListener[] fTextChangeListeners;
	protected DocumentListener internalDocumentListener;

	// The listeners for relaying DocumentEvents and
	// requesting repaints
	// after modification
	private IStructuredDocumentListener internalStructuredDocumentListener;

	protected StructuredDocumentEvent lastEvent = null;
	List lastEventQueue;
	boolean pendingDocumentChangedEvent;

	private static final boolean DEBUG = false;

	/**
	 * TEST ONLY - TEST ONLY - TEST ONLY NOT API use this constructor only for
	 * tests. Creates a new document adapter which is initiallly not connected
	 * to any document.
	 */
	public StructuredDocumentToTextAdapter() {

		internalStructuredDocumentListener = new StructuredDocumentListener();
		internalDocumentListener = new DocumentListener();
		// for testing only
		// setDocument(getModelManager().createStructuredDocumentFor(ContentTypeIdentifierForXML.ContentTypeID_XML));
	}

	/**
	 * Creates a new document adapter which is initiallly not connected to any
	 * document.
	 */
	public StructuredDocumentToTextAdapter(StyledText styledTextWidget) {

		// do not use 'this()' in this case
		super();
		internalStructuredDocumentListener = new StructuredDocumentListener();
		internalDocumentListener = new DocumentListener();
		fStyledTextWidget = styledTextWidget;
	}

	private void _setDocument(IDocument newDoc) {
		if (fDocument instanceof IStructuredDocument) {
			((IStructuredDocument) fDocument).removeDocumentChangedListener(internalStructuredDocumentListener);
		}
		fDocument = newDoc;
		if (!isStoppedForwardingChanges()) {
			fDocumentClone = null;
			fOriginalContent = getDocument() != null ? getDocument().get() : null;
			fOriginalLineDelimiters = getDocument() != null ? getDocument().getLegalLineDelimiters() : null;
		}

		if (DEBUG && fDocument != null && !(fDocument instanceof ILockable)) {

			System.out.println("Warning: non ILockable document used in StructuredDocumentToTextAdapter"); //$NON-NLS-1$
			System.out.println("         document updates on non-display thread will not be safe if editor open"); //$NON-NLS-1$
		}
		if (fDocument instanceof IStructuredDocument) {
			((IStructuredDocument) fDocument).addDocumentChangedListener(internalStructuredDocumentListener);
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.swt.custom.StyledTextContent#addTextChangeListener(org.eclipse.swt.custom.TextChangeListener)
	 */
	public synchronized void addTextChangeListener(TextChangeListener listener) {

		// make sure listener is not already in listening
		// (and if it is, print a warning to aid debugging,
		// if needed)

		if (Utilities.contains(fTextChangeListeners, listener)) {
			if (Debug.displayWarnings) {
				System.out.println("StructuredDocumentToTextAdapter::addTextChangedListeners. listener " + listener + " was added more than once. "); //$NON-NLS-2$//$NON-NLS-1$
			}
		}
		else {
			if (Debug.debugStructuredDocument) {
				System.out.println("StructuredDocumentToTextAdapter::addTextChangedListeners. Adding an instance of " + listener.getClass() + " as a listener on text adapter."); //$NON-NLS-2$//$NON-NLS-1$
			}
			int oldSize = 0;
			if (fTextChangeListeners != null) {
				// normally won't be null, but we need to be
				// sure, for first time through
				oldSize = fTextChangeListeners.length;
			}
			int newSize = oldSize + 1;
			TextChangeListener[] newListeners = new TextChangeListener[newSize];
			if (fTextChangeListeners != null) {
				System.arraycopy(fTextChangeListeners, 0, newListeners, 0, oldSize);
			}
			// add listener to last position
			newListeners[newSize - 1] = listener;
			//
			// now switch new for old
			fTextChangeListeners = newListeners;
			//
		}
	}

	/*
	 * @see org.eclipse.swt.custom.StyledTextContent#getCharCount()
	 */
	public int getCharCount() {

		// getDocument can sometimes be null during startup
		// and dispose
		int result = 0;
		IDocument doc = getDocument();
		if (doc != null) {
			result = getSafeDocument().getLength();
		}
		return result;
	}

	private IDocument getClonedDocument() {
		if (fDocumentClone == null) {
			String content = fOriginalContent == null ? "" : fOriginalContent; //$NON-NLS-1$
			String[] delims = fOriginalLineDelimiters == null ? DefaultLineTracker.DELIMITERS : fOriginalLineDelimiters;
			fDocumentClone = new DocumentClone(content, delims);
		}
		return fDocumentClone;
	}

	Display getDisplay() {

		// Note: the workbench should always have a display
		// (unless running headless), whereas Display.getCurrent()
		// only returns the display if the currently executing thread
		// has one.
		if (PlatformUI.isWorkbenchRunning())
			return PlatformUI.getWorkbench().getDisplay();
		else
			return null;
	}

	/**
	 * Returns the visible document.
	 * 
	 * @return IDocument
	 */
	protected IDocument getDocument() {

		if (fChildDocument == null)
			return fDocument;
		return fChildDocument;
	}

	/**
	 * Returns region in master document of given region (should be region in
	 * projection document)
	 * 
	 * @return region if no projection document exists, region of master
	 *         document if possible, null otherwise
	 */
	private IRegion getProjectionToMasterRegion(IRegion region) {
		IRegion originalRegion = region;
		if (fChildDocument != null) {
			try {
				originalRegion = fChildDocument.getProjectionMapping().toOriginRegion(region);
			}
			catch (BadLocationException e) {
				Logger.logException(e);
			}
		}

		return originalRegion;
	}

	/**
	 * Returns offset in projection document of given offset (should be offset
	 * in master document)
	 * 
	 * @return offset if no projection document exists, offset of projection
	 *         document if possible, -1 otherwise
	 */
	private int getMasterToProjectionOffset(int offset) {
		int originalOffset = offset;
		if (fChildDocument != null) {
			try {
				originalOffset = fChildDocument.getProjectionMapping().toImageOffset(offset);
			}
			catch (BadLocationException e) {
				Logger.logException(e);
			}
		}

		return originalOffset;
	}

	/**
	 * Return the line at the given character offset without delimiters.
	 * <p>
	 * 
	 * @param offset
	 *            offset of the line to return. Does not include delimiters of
	 *            preceeding lines. Offset 0 is the first character of the
	 *            document.
	 * @return the line text without delimiters
	 */
	public java.lang.String getLine(int lineNumber) {

		String result = null;
		if (lineNumber >= getLineCount()) {
			if (Debug.displayWarnings) {
				System.out.println("Development Debug: IStructuredDocument:getLine() error. lineNumber requested (" + lineNumber + ") was greater than number of lines(" + getLineCount() + "). EmptyString returned"); //$NON-NLS-1$//$NON-NLS-3$//$NON-NLS-2$
			}
			result = EMPTY_STRING;
		}
		else {
			IDocument doc = getSafeDocument();
			if (doc == null) {
				result = EMPTY_STRING;
			}
			else {
				try {
					IRegion r = doc.getLineInformation(lineNumber);
					if (r.getLength() > 0) {
						result = doc.get(r.getOffset(), r.getLength());
					}
					else {
						result = EMPTY_STRING;
					}
				}
				catch (BadLocationException e) {
					result = EMPTY_STRING;
				}
			}
		}
		return result;
	}

	/**
	 * Tries to repair the line information.
	 * 
	 * @param document
	 *            the document
	 * @see IRepairableDocument#repairLineInformation()
	 * @see Eclipse 3.0
	 */
	private void repairLineInformation(IDocument document) {
		if (document instanceof IRepairableDocument) {
			IRepairableDocument repairable = (IRepairableDocument) document;
			repairable.repairLineInformation();
		}
	}

	/**
	 * Return the line index at the given character offset.
	 * <p>
	 * 
	 * @param offset
	 *            offset of the line to return. The first character of the
	 *            document is at offset 0. An offset of getLength() is valid
	 *            and should answer the number of lines.
	 * @return the line index. The first line is at index 0. If the character
	 *         at offset is a delimiter character, answer the line index of
	 *         the line that is delimited. For example, text = "\r\n\r\n",
	 *         delimiter = "\r\n", then: getLineAtOffset(0) == 0
	 *         getLineAtOffset(1) == 0 getLineAtOffset(2) == 1
	 *         getLineAtOffset(3) == 1 getLineAtOffset(4) == 2
	 */
	public int getLineAtOffset(int offset) {

		int result = 0;
		IDocument doc = getSafeDocument();
		if (doc != null) {
			try {
				result = doc.getLineOfOffset(offset);
			}
			catch (BadLocationException x) {
				repairLineInformation(doc);
				try {
					result = doc.getLineOfOffset(offset);
				}
				catch (BadLocationException x2) {
					// should not occur, but seems to for projection
					// documents, related to repainting overview ruler
					result = 0;
				}
			}
		}
		return result;
	}

	public int getLineCount() {
		int result = 0;
		IDocument doc = getSafeDocument();
		if (doc != null) {
			result = doc.getNumberOfLines();
		}
		return result;
	}

	/*
	 * @see org.eclipse.swt.custom.StyledTextContent#getLineDelimiter
	 */
	public String getLineDelimiter() {
		String result = null;
		if (getParentDocument() instanceof IStructuredDocument) {
			result = ((IStructuredDocument) getParentDocument()).getLineDelimiter();
		}
		else {
			IDocument doc = getSafeDocument();
			result = TextUtilities.getDefaultLineDelimiter(doc);
		}
		return result;
	}

	/**
	 * Return the character offset of the first character of the given line.
	 * <p>
	 * 
	 * @param lineIndex
	 *            index of the line. The first line is at index 0.
	 * @return offset offset of the first character of the line. The first
	 *         character of the document is at offset 0. The return value
	 *         should include line delimiters. For example, text =
	 *         "\r\ntest\r\n", delimiter = "\r\n", then: getOffsetAtLine(0) ==
	 *         0 getOffsetAtLine(1) == 2 getOffsetAtLine(2) == 8 NOTE: When
	 *         there is no text (i.e., no lines), getOffsetAtLine(0) is a
	 *         valid call that should return 0.
	 */
	public int getOffsetAtLine(int lineIndex) {

		int result = 0;
		IDocument doc = getSafeDocument();
		if (doc != null) {
			try {
				result = doc.getLineOffset(lineIndex);
			}
			catch (BadLocationException e) {
				result = 0;
			}
		}
		return result;
	}

	/**
	 * Returns the parent document
	 * 
	 * @return the parent document
	 */
	private IDocument getParentDocument() {
		return fDocument;
	}

	/**
	 * This is the document to use for request from the StyledText widget. Its
	 * either the live documnet or a clone of it, depending on stop/resume
	 * state.
	 */
	private IDocument getSafeDocument() {
		IDocument result = null;
		if (isStoppedForwardingChanges()) {
			result = getClonedDocument();
		}
		else {
			// note, this document can be normal structured text document,
			// or the projection/child document
			result = getDocument();
		}
		return result;
	}

	/**
	 * @return org.eclipse.swt.custom.StyledText
	 */
	StyledText getStyledTextWidget() {
		return fStyledTextWidget;
	}

	/**
	 * Returns a string representing the content at the given range.
	 * <p>
	 * 
	 * @param start
	 *            the start offset of the text to return. Offset 0 is the
	 *            first character of the document.
	 * @param length
	 *            the length of the text to return
	 * @return the text at the given range
	 */
	public String getTextRange(int start, int length) {
		String result = null;
		try {
			IDocument doc = getSafeDocument();
			result = doc.get(start, length);
		}
		catch (BadLocationException e) {
			result = EMPTY_STRING;
		}
		return result;
	}

	/**
	 * assume only for "no change" events, for now
	 */
	protected void handlePendingEvents() {

		if (lastEventQueue == null)
			return;

		Iterator iterator = lastEventQueue.iterator();
		while (iterator.hasNext()) {
			NoChangeEvent noChangeEvent = (NoChangeEvent) iterator.next();
			redrawNoChange(noChangeEvent);
		}

		lastEventQueue = null;
		lastEvent = null;
	}

	boolean isStoppedForwardingChanges() {
		return fStopRelayingChangesRequests > 0;
	}

	/**
	 * this method is assumed to be called only for read only region changes.
	 */
	protected void redrawNoChange(NoChangeEvent structuredDocumentEvent) {

		if (isStoppedForwardingChanges())
			return;
		if (Debug.debugStructuredDocument) {
			System.out.println("maybe redraw stuff"); //$NON-NLS-1$
		}

		int startOffset = structuredDocumentEvent.getOffset();
		int length = structuredDocumentEvent.getLength();
		redrawRangeWithLength(startOffset, length);

	}

	/**
	 * Request a redraw of the text range occupied by the given
	 * StructuredDocumentRegionsReplacedEvent
	 * 
	 * @param structuredDocumentEvent
	 */
	protected void redrawNodesReplaced(StructuredDocumentRegionsReplacedEvent structuredDocumentEvent) {

		if (isStoppedForwardingChanges())
			return;
		if (Debug.debugStructuredDocument) {
			System.out.println("maybe redraw stuff"); //$NON-NLS-1$
		}
		// just the new stuff
		IStructuredDocumentRegionList newStructuredDocumentRegions = structuredDocumentEvent.getNewStructuredDocumentRegions();

		int nNewNodes = newStructuredDocumentRegions.getLength();
		if (nNewNodes > 0) {
			IStructuredDocumentRegion firstNode = newStructuredDocumentRegions.item(0);
			IStructuredDocumentRegion lastNode = newStructuredDocumentRegions.item(nNewNodes - 1);
			redrawRange(firstNode.getStartOffset(), lastNode.getEndOffset());
		}
	}

	/**
	 * Redraws the give offsets in terms of the StructuredDocument. If only
	 * part of the model is visible, ensures that only the visible portion of
	 * the given range is redrawn.
	 * 
	 * @param startModelOffset
	 * @param endModelOffset
	 */
	private void redrawRange(final int startModelOffset, final int endModelOffset) {

		if (getDocument() == null)
			return;
		if (Debug.debugStructuredDocument) {
			System.out.println("redraw stuff: " + startModelOffset + "-" + endModelOffset); //$NON-NLS-1$ //$NON-NLS-2$
		}
		if (fChildDocument == null) {
			Runnable runnable = new Runnable() {
				public void run() {
					getStyledTextWidget().redrawRange(startModelOffset, endModelOffset - startModelOffset, redrawBackground);
				}
			};
			runOnDisplayThreadIfNeedede(runnable);

		}
		else {
			int high = getDocument().getLength();
			int startOffset = getMasterToProjectionOffset(startModelOffset);

			int endOffset = getMasterToProjectionOffset(endModelOffset);

			// if offsets were not visible, just try to redraw everything in
			// the child document
			// // not visible
			// if (endOffset < 0 || startOffset > high)
			// return;
			// restrict lower bound
			if (startOffset < 0) {
				startOffset = 0;
			}
			// restrict upper bound
			// if (endOffset > high) {
			// endOffset = high;
			// }
			if (endOffset < 0) {
				endOffset = high;
			}

			int length = endOffset - startOffset;
			// redrawBackground with false would be faster
			// but assumes background (or font) is not
			// changing
			final int finalStartOffset = startOffset;
			final int finallength = length;

			Runnable runnable = new Runnable() {
				public void run() {
					getStyledTextWidget().redrawRange(finalStartOffset, finallength, redrawBackground);
				}
			};
			runOnDisplayThreadIfNeedede(runnable);

		}
	}

	/**
	 * Redraws the give offsets in terms of the Flat Node model. If only part
	 * of the model is visible, ensures that only the visible portion of the
	 * given range is redrawn.
	 * 
	 * @param startModelOffset
	 * @param endModelOffset
	 */
	private void redrawRangeWithLength(final int startModelOffset, final int length) {

		if (getDocument() == null)
			return;
		if (Debug.debugStructuredDocument) {
			System.out.println("redraw stuff: " + startModelOffset + "-" + length); //$NON-NLS-1$ //$NON-NLS-2$
		}
		if (fChildDocument == null) {
			Runnable runnable = new Runnable() {
				public void run() {
					getStyledTextWidget().redrawRange(startModelOffset, length, redrawBackground);
				}
			};
			runOnDisplayThreadIfNeedede(runnable);
		}
		else {
			int high = getDocument().getLength();
			// TODO need to take into account segmented visible regions
			int startOffset = getMasterToProjectionOffset(startModelOffset);
			// not visible
			if (startOffset > high || length < 1)
				return;
			// restrict lower bound
			if (startOffset < 0) {
				startOffset = 0;
			}
			int endOffset = startOffset + length - 1;
			// restrict upper bound
			if (endOffset > high) {
				endOffset = high;
			}

			// note: length of the child documnet should be
			// updated,
			// need to investigate why its not at this
			// point, but is
			// probably just because the document event
			// handling is not
			// completely finished.
			int newLength = endOffset - startOffset; // d283007

			// redrawBackground with false would be faster
			// but assumes background (or font) is not
			// changing
			final int finalStartOffset = startOffset;
			final int finalNewLength = newLength;
			Runnable runnable = new Runnable() {
				public void run() {
					getStyledTextWidget().redrawRange(finalStartOffset, finalNewLength, redrawBackground);
				}
			};
			runOnDisplayThreadIfNeedede(runnable);
		}
	}

	/**
	 * Request a redraw of the text range occupied by the given
	 * RegionChangedEvent for certain (not all) ITextRegion contexts
	 * 
	 * @param structuredDocumentEvent
	 */
	protected void redrawRegionChanged(RegionChangedEvent structuredDocumentEvent) {

		if (isStoppedForwardingChanges()) {
			return;
		}
		if (Debug.debugStructuredDocument) {
			System.out.println("maybe redraw stuff"); //$NON-NLS-1$
		}


		// (nsd) TODO: try to make this reliable somehow
		// without being directly content dependent
		// if ((region instanceof ITextRegionContainer) ||
		// (type == XMLJSPRegionContexts.BLOCK_TEXT) ||
		// (type == XMLJSPRegionContexts.JSP_CONTENT)) {
		// IStructuredDocumentRegion flatNode =
		// structuredDocumentEvent.getStructuredDocumentRegion();
		// // redraw background of false is faster,
		// // but assumes background (or font) is not
		// changing
		// redrawRange(flatNode.getStartOffset(region),
		// flatNode.getEndOffset(region));
		// }
		if (forceRedrawOnRegionChanged) {
			// workaround for redrawing problems on Linux-GTK
			int startOffset = structuredDocumentEvent.getOffset();
			int endOffset = structuredDocumentEvent.getOffset() + structuredDocumentEvent.getLength();
			try {
				IRegion startLine = structuredDocumentEvent.fDocument.getLineInformationOfOffset(startOffset);
				IRegion endLine = structuredDocumentEvent.fDocument.getLineInformationOfOffset(endOffset);
				if (startLine != null && endLine != null) {
					redrawRange(startLine.getOffset(), endLine.getOffset() + endLine.getLength());
				}
			}
			catch (BadLocationException e) {
				// nothing for now
			}
		}
	}

	/**
	 * Request a redraw of the text range occupied by the given
	 * RegionsReplacedEvent
	 * 
	 * @param structuredDocumentEvent
	 */
	protected void redrawRegionsReplaced(RegionsReplacedEvent structuredDocumentEvent) {

		if (isStoppedForwardingChanges())
			return;
		if (Debug.debugStructuredDocument) {
			System.out.println("maybe redraw stuff"); //$NON-NLS-1$
		}
		ITextRegionList newRegions = structuredDocumentEvent.getNewRegions();
		int nRegions = newRegions.size();
		if (nRegions > 0) {
			ITextRegion firstRegion = newRegions.get(0);
			ITextRegion lastRegion = newRegions.get(nRegions - 1);
			IStructuredDocumentRegion flatNode = structuredDocumentEvent.getStructuredDocumentRegion();
			redrawRange(flatNode.getStartOffset(firstRegion), flatNode.getEndOffset(lastRegion));
		}
	}

	protected void redrawTextChanged() {

		if (lastEvent != null) {
			// update display, since some cases can effect
			// highlighting beyond the changed text area.
			if (lastEvent instanceof StructuredDocumentRegionsReplacedEvent)
				redrawNodesReplaced((StructuredDocumentRegionsReplacedEvent) lastEvent);
			if (lastEvent instanceof RegionsReplacedEvent)
				redrawRegionsReplaced((RegionsReplacedEvent) lastEvent);
			if (lastEvent instanceof RegionChangedEvent)
				redrawRegionChanged((RegionChangedEvent) lastEvent);
			// moved following line to 'document changed' so
			// the "last event" can be
			// re-drawn after pending re-draws
			// lastEvent = null;
		}
	}

	/**
	 * Sends a text replace event to all registered listeners.
	 */
	protected void relayTextChanged() {

		if (isStoppedForwardingChanges()) {
			if (Debug.debugStructuredDocument && getDocument() != null) {
				System.out.println("NOT relaying text changed (" + getDocument().getLength() + ")"); //$NON-NLS-1$ //$NON-NLS-2$
			}
			return;
		}
		if (Debug.debugStructuredDocument && getDocument() != null) {
			System.out.println("relaying text changed (" + getDocument().getLength() + ")"); //$NON-NLS-1$ //$NON-NLS-2$
		}
		final TextChangedEvent textChangedEvent = new TextChangedEvent(this);

		// we must assign listeners to local variable, since
		// the add and remove listener
		// methods can change the actual instance of the
		// listener array from another thread

		Runnable runnable = new Runnable() {
			public void run() {
				if (fTextChangeListeners != null) {
					Object[] holdListeners = fTextChangeListeners;
					for (int i = 0; i < holdListeners.length; i++) {
						// this is a safe cast, since addListeners
						// requires a IStructuredDocumentListener
						((TextChangeListener) holdListeners[i]).textChanged(textChangedEvent);
					}
				}
			}
		};
		runOnDisplayThreadIfNeedede(runnable);
		redrawTextChanged();
	}

	/**
	 * Sends a text change to all registered listeners
	 */
	protected void relayTextChanging(int requestedStart, int requestedLength, String requestedChange) {

		if (getDocument() == null)
			return;
		if (isStoppedForwardingChanges()) {
			if (Debug.debugStructuredDocument && getDocument() != null) {
				System.out.println("NOT relaying text changing: " + requestedStart + ":" + getDocument().getLength()); //$NON-NLS-1$ //$NON-NLS-2$
			}
			return;
		}
		if (Debug.debugStructuredDocument && getDocument() != null) {
			System.out.println("relaying text changing: " + requestedStart + ":" + getDocument().getLength()); //$NON-NLS-1$ //$NON-NLS-2$
		}
		lastEvent = null;
		try {
			final TextChangingEvent textChangingEvent = new TextChangingEvent(this);

			textChangingEvent.start = requestedStart;
			textChangingEvent.replaceCharCount = requestedLength;
			textChangingEvent.newCharCount = (requestedChange == null ? 0 : requestedChange.length());
			textChangingEvent.replaceLineCount = getDocument().getNumberOfLines(requestedStart, requestedLength) - 1;
			textChangingEvent.newText = requestedChange;
			textChangingEvent.newLineCount = (requestedChange == null ? 0 : getDocument().computeNumberOfLines(requestedChange));

			// we must assign listeners to local variable,
			// since the add and remove listner
			// methods can change the actual instance of the
			// listener array from another thread
			Runnable runnable = new Runnable() {
				public void run() {
					if (fTextChangeListeners != null) {
						TextChangeListener[] holdListeners = fTextChangeListeners;
						for (int i = 0; i < holdListeners.length; i++) {
							// this is a safe cast, since
							// addListeners requires a
							// IStructuredDocumentListener
							holdListeners[i].textChanging(textChangingEvent);
						}
					}
				}
			};
			runOnDisplayThreadIfNeedede(runnable);
		}
		catch (BadLocationException e) {
			// log for now, unless we find reason not to
			Logger.log(Logger.INFO, e.getMessage());
		}
	}

	/**
	 * Sends a text set event to all registered listeners. Widget should
	 * redraw itself automatically.
	 */
	protected void relayTextSet() {

		if (isStoppedForwardingChanges()) {
			if (Debug.debugStructuredDocument && getDocument() != null) {
				System.out.println("NOT relaying text set (" + getDocument().getLength() + ")"); //$NON-NLS-1$ //$NON-NLS-2$
			}
			return;
		}
		if (Debug.debugStructuredDocument && getDocument() != null) {
			System.out.println("relaying text set (" + getDocument().getLength() + ")"); //$NON-NLS-1$ //$NON-NLS-2$
		}
		lastEvent = null;
		final TextChangedEvent textChangedEvent = new TextChangedEvent(this);

		// we must assign listeners to local variable, since
		// the add and remove listner
		// methods can change the actual instance of the
		// listener array from another thread
		Runnable runnable = new Runnable() {
			public void run() {
				if (fTextChangeListeners != null) {
					TextChangeListener[] holdListeners = fTextChangeListeners;
					for (int i = 0; i < holdListeners.length; i++) {
						holdListeners[i].textSet(textChangedEvent);
					}
				}
			}
		};
		runOnDisplayThreadIfNeedede(runnable);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.swt.custom.StyledTextContent#removeTextChangeListener(org.eclipse.swt.custom.TextChangeListener)
	 */
	public synchronized void removeTextChangeListener(final TextChangeListener listener) {

		if ((fTextChangeListeners != null) && (listener != null)) {
			// if its not in the listeners, we'll ignore the
			// request
			if (!Utilities.contains(fTextChangeListeners, listener)) {
				if (Debug.displayWarnings) {
					System.out.println("StructuredDocumentToTextAdapter::removeTextChangedListeners. listener " + listener + " was not present. "); //$NON-NLS-2$//$NON-NLS-1$
				}
			}
			else {
				if (Debug.debugStructuredDocument) {
					System.out.println("StructuredDocumentToTextAdapter::addTextChangedListeners. Removing an instance of " + listener.getClass() + " as a listener on text adapter."); //$NON-NLS-2$//$NON-NLS-1$
				}
				final int oldSize = fTextChangeListeners.length;
				int newSize = oldSize - 1;
				final TextChangeListener[] newListeners = new TextChangeListener[newSize];

				Runnable runnable = new Runnable() {
					public void run() {
						int index = 0;
						for (int i = 0; i < oldSize; i++) {
							if (fTextChangeListeners[i] != listener) {
								// copy old to new if its not the
								// one we are removing
								newListeners[index++] = fTextChangeListeners[i];
							}
						}
					}
				};
				runOnDisplayThreadIfNeedede(runnable);
				// now that we have a new array, let's
				// switch it for the old one
				fTextChangeListeners = newListeners;
			}
		}
	}

	/**
	 * Replace the text with "newText" starting at position "start" for a
	 * length of "replaceLength".
	 * <p>
	 * Implementors have to notify TextChanged listeners after the content has
	 * been updated. The TextChangedEvent should be set as follows:
	 * <ul>
	 * <li>event.type = SWT.TextReplaced
	 * <li>event.start = start of the replaced text
	 * <li>event.numReplacedLines = number of replaced lines
	 * <li>event.numNewLines = number of new lines
	 * <li>event.replacedLength = length of the replaced text
	 * <li>event.newLength = length of the new text
	 * </ul>
	 * <b>NOTE: </b> numNewLines is the number of inserted lines and
	 * numReplacedLines is the number of deleted lines based on the change
	 * that occurs visually. For example:
	 * <ul>
	 * <li>(replacedText, newText) ==> (numReplacedLines, numNewLines)
	 * <li>("", "\n") ==> (0, 1)
	 * <li>("\n\n", "a") ==> (2, 0)
	 * <li>("a", "\n\n") ==> (0, 2)
	 * <li>("\n", "") ==> (1, 0)
	 * </ul>
	 * </p>
	 * 
	 * @param start
	 *            start offset of text to replace, none of the offsets include
	 *            delimiters of preceeding lines, offset 0 is the first
	 *            character of the document
	 * @param replaceLength
	 *            start offset of text to replace
	 * @param newText
	 *            start offset of text to replace
	 */
	public void replaceTextRange(int start, int replaceLength, String text) {

		if (getParentDocument() instanceof IStructuredDocument) {
			// the structuredDocument initiates the "changing"
			// and "changed" events.
			// they are both fired by the time this method
			// returns.
			IRegion region = getProjectionToMasterRegion(new Region(start, replaceLength));
			if (region != null) {
				((IStructuredDocument) getParentDocument()).replaceText(this, region.getOffset(), region.getLength(), text);
				return;
			}
		}
		// default is to just try and replace text range in current document
		try {
			getDocument().replace(start, replaceLength, text);
		}
		catch (BadLocationException e) {
			// log for now, unless we find reason not to
			Logger.log(Logger.INFO, e.getMessage());
		}
	}

	/**
	 * @see org.eclipse.jface.text.IDocumentAdapterExtension#resumeForwardingDocumentChanges()
	 */
	public void resumeForwardingDocumentChanges() {

		// from re-reading the textSet API in StyledText, we
		// must call
		// textSet if all the contents changed. If all the
		// contents did
		// not change, we need to call the pair of APIs,
		// textChanging and
		// textChanged. So, if we ever keep careful track of
		// changes
		// during stop forwarding and resume forwarding, we
		// can
		// investigate change make use of the pair of APIs.
		fStopRelayingChangesRequests--;
		if (fStopRelayingChangesRequests == 0) {
			// fIsForwarding= true;
			fDocumentClone = null;
			fOriginalContent = null;
			fOriginalLineDelimiters = null;
			// fireTextSet();
			relayTextSet();
		}
	}

	/**
	 * This 'Runnable' should be very brief, and should not "call out" to
	 * other code which itself might call syncExec, or deadlock might occur.
	 * 
	 * @param r
	 */
	private void runOnDisplayThreadIfNeedede(Runnable r) {
		// if there is no Display at all (that is, running headless),
		// or if we are already running on the display thread, then
		// simply execute the runnable.
		if (getDisplay() == null || (Thread.currentThread() == getDisplay().getThread())) {
			r.run();
		}
		else {
			// otherwise force the runnable to run on the display thread.
			//
			// Its unclear if we need this at all, once
			// we "force" document update to always take place on display
			// thread.
			IDocument doc = getDocument();
			if (doc instanceof ILockable) {

				ILock lock = null;
				try {
					lock = ((ILockable) doc).getLockObject();
					lock.acquire();
					getDisplay().syncExec(r);
				}
				finally {
					if (lock != null) {
						lock.release();
					}
				}
			}
			else {
				// else, ignore!, since risk of deadlock
				throw new IllegalStateException("non lockable document used for structuredDocumentToTextAdapter"); //$NON-NLS-1$
			}
		}
	}

	/**
	 * @param newModel
	 */
	public void setDocument(IDocument document) {

		if (getDocument() != null) {
			getDocument().removePrenotifiedDocumentListener(internalDocumentListener);
		}
		lastEvent = null;
		if (document instanceof ProjectionDocument) {
			fChildDocument = (ProjectionDocument) document;
			_setDocument(fChildDocument.getMasterDocument());
		}
		else {
			fChildDocument = null;
			_setDocument(document);
		}
		if (getDocument() != null) {
			getDocument().addPrenotifiedDocumentListener(internalDocumentListener);
		}
	}

	/**
	 * @see IDocument#setText
	 */
	public void setText(String string) {

		if (isStoppedForwardingChanges()) {
			fDocumentClone = null;
			fOriginalContent = getDocument().get();
			fOriginalLineDelimiters = getDocument().getLegalLineDelimiters();
		}
		else if (getParentDocument() instanceof IStructuredDocument) {
			((IStructuredDocument) getDocument()).setText(this, string);
		}
		else {
			getDocument().set(string);
		}
		relayTextSet();
	}

	/**
	 * This method was added to make testing easier. Normally, the widget is
	 * specified on the constructor.
	 */
	public void setWidget(StyledText widget) {

		fStyledTextWidget = widget;
	}

	/**
	 * @see org.eclipse.jface.text.IDocumentAdapterExtension#stopForwardingDocumentChanges()
	 */
	public void stopForwardingDocumentChanges() {

		fStopRelayingChangesRequests++;
		// only need to take snapshot on first request
		if (fStopRelayingChangesRequests == 1) {
			fDocumentClone = null;
			fOriginalContent = getDocument().get();
			fOriginalLineDelimiters = getDocument().getLegalLineDelimiters();
		}
	}
}