bundles/org.eclipse.wst.sse.ui/src/org/eclipse/wst/sse/ui/internal/StructuredDocumentCommand.java - sourceediting/webtools.sourceediting - Git at Google

 /*******************************************************************************
  * 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.Collections;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.NoSuchElementException;

 import org.eclipse.jface.text.Assert;
 import org.eclipse.jface.text.BadLocationException;
 import org.eclipse.jface.text.BadPositionCategoryException;
 import org.eclipse.jface.text.DefaultPositionUpdater;
 import org.eclipse.jface.text.DocumentCommand;
 import org.eclipse.jface.text.IDocument;
 import org.eclipse.jface.text.IDocumentListener;
 import org.eclipse.jface.text.IRegion;
 import org.eclipse.jface.text.Position;
 import org.eclipse.swt.events.VerifyEvent;

 /**
  * TODO Temporary subclass to workaround BUG44665
  *
  * Algorithm for intersects() methods changed.
  */
 /**
  * Represents a text modification as a document replace command. The text
  * modification is given as a <code>VerifyEvent</code> and translated into a
  * document replace command relative to a given offset. A document command can
  * also be used to initialize a given <code>VerifyEvent</code>.
  * <p>
  * A document command can also represent a list of related changes.
  */
 public class StructuredDocumentCommand extends DocumentCommand {

 	/**
 	 * A command which is added to document commands.
 	 *
 	 * @since 2.1
 	 */
 	private static class Command implements Comparable {
 		/** The length of the range to be replaced. */
 		final int fLength;
 		/** The offset of the range to be replaced */
 		final int fOffset;
 		/** The listern who owns this command */
 		private final IDocumentListener fOwner;
 		/** The replacement text */
 		private final String fText;

 		/**
 		 * Creates a new command with the given specification.
 		 *
 		 * @param offset
 		 *            the offset of the replace command
 		 * @param length
 		 *            the length of the replace command
 		 * @param text
 		 *            the text to replace with, may be <code>null</code>
 		 * @param owner
 		 *            the document command owner, may be <code>null</code>
 		 * @since 3.0
 		 */
 		public Command(int offset, int length, String text, IDocumentListener owner) {
 			if (offset < 0 || length < 0)
 				throw new IllegalArgumentException();
 			fOffset = offset;
 			fLength = length;
 			fText = text;
 			fOwner = owner;
 		}

 		/*
 		 * @see java.util.Comparator#compare(java.lang.Object,
 		 *      java.lang.Object)
 		 */
 		public int compareTo(final Object object) {
 			if (equals(object))
 				return 0;

 			final Command command = (Command) object;

 			// diff middle points if not intersecting
 			if (fOffset + fLength <= command.fOffset || command.fOffset + command.fLength <= fOffset) {
 				int value = (2 * fOffset + fLength) - (2 * command.fOffset + command.fLength);
 				if (value != 0)
 					return value;
 			}
 			// the answer
 			return 42;
 		}

 		/*
 		 * @see java.lang.Object#equals(java.lang.Object)
 		 */
 		public boolean equals(Object object) {
 			if (object == this)
 				return true;
 			if (!(object instanceof Command))
 				return false;
 			final Command command = (Command) object;
 			return command.fOffset == fOffset && command.fLength == fLength;
 		}

 		/**
 		 * Executes the document command on the specified document.
 		 *
 		 * @param document
 		 *            the document on which to execute the command.
 		 * @throws BadLocationException
 		 *             in case this commands cannot be executed
 		 */
 		public void execute(IDocument document) throws BadLocationException {

 			if (fLength == 0 && fText == null)
 				return;

 			if (fOwner != null)
 				document.removeDocumentListener(fOwner);

 			document.replace(fOffset, fLength, fText);

 			if (fOwner != null)
 				document.addDocumentListener(fOwner);
 		}

 		/**
 		 * Returns the length delta for this command.
 		 *
 		 * @return the length delta for this command
 		 */
 		public int getDeltaLength() {
 			return (fText == null ? 0 : fText.length()) - fLength;
 		}
 	}

 	/**
 	 * A command iterator.
 	 */
 	private static class CommandIterator implements Iterator {

 		/** The original command. */
 		private Command fCommand;

 		/** A flag indicating the direction of iteration. */
 		private boolean fForward;

 		/** The command iterator. */
 		private final Iterator fIterator;

 		/**
 		 * Creates a command iterator.
 		 *
 		 * @param commands
 		 *            an ascending ordered list of commands
 		 * @param command
 		 *            the original command
 		 * @param forward
 		 *            the direction
 		 */
 		public CommandIterator(final List commands, final Command command, final boolean forward) {
 			if (commands == null || command == null)
 				throw new IllegalArgumentException();
 			fIterator = forward ? commands.iterator() : new ReverseListIterator(commands.listIterator(commands.size()));
 			fCommand = command;
 			fForward = forward;
 		}

 		/*
 		 * @see java.util.Iterator#hasNext()
 		 */
 		public boolean hasNext() {
 			return fCommand != null || fIterator.hasNext();
 		}

 		/*
 		 * @see java.util.Iterator#next()
 		 */
 		public Object next() {

 			if (!hasNext())
 				throw new NoSuchElementException();

 			if (fCommand == null)
 				return fIterator.next();

 			if (!fIterator.hasNext()) {
 				final Command tempCommand = fCommand;
 				fCommand = null;
 				return tempCommand;
 			}

 			final Command command = (Command) fIterator.next();
 			final int compareValue = command.compareTo(fCommand);

 			if ((compareValue < 0) ^ !fForward) {
 				return command;

 			} else if ((compareValue > 0) ^ !fForward) {
 				final Command tempCommand = fCommand;
 				fCommand = command;
 				return tempCommand;

 			} else {
 				throw new IllegalArgumentException();
 			}
 		}

 		/*
 		 * @see java.util.Iterator#remove()
 		 */
 		public void remove() {
 			throw new UnsupportedOperationException();
 		}
 	}

 	/**
 	 * An iterator, which iterates in reverse over a list.
 	 */
 	private static class ReverseListIterator implements Iterator {

 		/** The list iterator. */
 		private final ListIterator fListIterator;

 		/**
 		 * Creates a reverse list iterator.
 		 *
 		 * @param listIterator
 		 *            the iterator that this reverse iterator is based upon
 		 */
 		public ReverseListIterator(ListIterator listIterator) {
 			if (listIterator == null)
 				throw new IllegalArgumentException();
 			fListIterator = listIterator;
 		}

 		/*
 		 * @see java.util.Iterator#hasNext()
 		 */
 		public boolean hasNext() {
 			return fListIterator.hasPrevious();
 		}

 		/*
 		 * @see java.util.Iterator#next()
 		 */
 		public Object next() {
 			return fListIterator.previous();
 		}

 		/*
 		 * @see java.util.Iterator#remove()
 		 */
 		public void remove() {
 			throw new UnsupportedOperationException();
 		}
 	}

 	/**
 	 * Additional document commands.
 	 *
 	 * @since 2.1
 	 */
 	private final List fCommands = new ArrayList();

 	/**
 	 * Adds an additional replace command. The added replace command must not
 	 * overlap with existing ones. If the document command owner is not
 	 * <code>null</code>, it will not get document change notifications for
 	 * the particular command.
 	 *
 	 * @param offset
 	 *            the offset of the region to replace
 	 * @param length
 	 *            the length of the region to replace
 	 * @param text
 	 *            the text to replace with, may be <code>null</code>
 	 * @param owner
 	 *            the command owner, may be <code>null</code>
 	 * @throws BadLocationException
 	 *             if the added command intersects with an existing one
 	 * @since 2.1
 	 */
 	public void addCommand(int offsetParameter, int lengthParameter, String textParameter, IDocumentListener ownerParameter) throws BadLocationException {
 		final Command command = new Command(offsetParameter, lengthParameter, textParameter, ownerParameter);

 		internalAddCommand(command);
 	}

 	/**
 	 * @param command
 	 * @throws BadLocationException
 	 */
 	private void internalAddCommand(final Command command) throws BadLocationException {
 		if (intersects(command))
 			throw new BadLocationException();

 		final int index = Collections.binarySearch(fCommands, command);

 		// a command with exactly the same ranges exists already
 		if (index >= 0)
 			throw new BadLocationException();

 		// binary search result is defined as (-(insertionIndex) - 1)
 		final int insertionIndex = -(index + 1);

 		// overlaps to the right?
 		if (insertionIndex != fCommands.size() && intersects((Command) fCommands.get(insertionIndex), command))
 			throw new BadLocationException();

 		// overlaps to the left?
 		if (insertionIndex != 0 && intersects((Command) fCommands.get(insertionIndex - 1), command))
 			throw new BadLocationException();

 		fCommands.add(insertionIndex, command);
 	}

 	/**
 	 * Executes the document commands on a document.
 	 *
 	 * @param document
 	 *            the document on which to execute the commands
 	 * @since 2.1
 	 */
 	void executeStructuredDocumentCommand(IDocument document) throws BadLocationException {

 		if (length == 0 && text == null && fCommands.size() == 0)
 			return;

 		DefaultPositionUpdater updater = new DefaultPositionUpdater(getCategory());
 		Position caretPosition = null;
 		try {
 			if (updateCaret()) {
 				document.addPositionCategory(getCategory());
 				document.addPositionUpdater(updater);
 				caretPosition = new Position(caretOffset);
 				document.addPosition(getCategory(), caretPosition);
 			}

 			final Command originalCommand = new Command(offset, length, text, owner);
 			for (final Iterator iterator = new CommandIterator(fCommands, originalCommand, false); iterator.hasNext();)
 				((Command) iterator.next()).execute(document);

 		} catch (BadLocationException e) {
 			// ignore
 		} catch (BadPositionCategoryException e) {
 			// ignore
 		} finally {
 			if (updateCaret()) {
 				document.removePositionUpdater(updater);
 				try {
 					document.removePositionCategory(getCategory());
 				} catch (BadPositionCategoryException e) {
 					Assert.isTrue(false);
 				}
 				caretOffset = caretPosition.getOffset();
 			}
 		}
 	}

 	/**
 	 * Fills the given verify event with the replace text and the doit flag of
 	 * this document command. Returns whether the document command covers the
 	 * same range as the verify event considering the given offset.
 	 *
 	 * @param event
 	 *            the event to be changed
 	 * @param modelRange
 	 *            to be considered for range comparison
 	 * @return <code>true</code> if this command and the event cover the
 	 *         same range
 	 */
 	public boolean fillEventStructuredDocumentCommand(VerifyEvent event, IRegion modelRange) {
 		event.text = text;
 		event.doit = (offset == modelRange.getOffset() && length == modelRange.getLength() && doit && caretOffset == -1);
 		return event.doit;
 	}

 	/**
 	 * Returns the position category for the caret offset position.
 	 *
 	 * @return the position category for the caret offset position
 	 * @since 3.0
 	 */
 	private String getCategory() {
 		return toString();
 	}

 	/**
 	 * Returns the number of commands including the original document command.
 	 *
 	 * @return returns the number of commands
 	 * @since 2.1
 	 */
 	public int getCommandCount() {
 		return 1 + fCommands.size();
 	}

 	/**
 	 * Returns an iterator over the commands in ascending position order. The
 	 * iterator includes the original document command. Commands cannot be
 	 * removed.
 	 *
 	 * @return returns the command iterator
 	 */
 	public Iterator getCommandIterator() {
 		Command command = new Command(offset, length, text, owner);
 		return new CommandIterator(fCommands, command, true);
 	}

 	/**
 	 * Returns whether the given command intersects with this command.
 	 *
 	 * @param command
 	 *            the command
 	 * @return <code>true</code> if the command intersects with this command
 	 * @since 2.1
 	 */
 	private boolean intersects(Command command) {
 		boolean result = false;
 		// diff middle points if not intersecting
 		if (offset + length <= command.fOffset || command.fOffset + command.fLength <= offset)
 			//			return (2 * offset + length) - (2 * command.fOffset +
 			// command.fLength) == 0;
 			result = false;
 		else
 			result = true;
 		return result;
 	}

 	/**
 	 * Returns whether the two given commands intersect.
 	 *
 	 * @param command0
 	 *            the first command
 	 * @param command1
 	 *            the second command
 	 * @return <code>true</code> if the commands intersect
 	 * @since 2.1
 	 */
 	private boolean intersects(Command command0, Command command1) {
 		boolean result = false;
 		// diff middle points if not intersecting
 		if (command0.fOffset + command0.fLength <= command1.fOffset || command1.fOffset + command1.fLength <= command0.fOffset)
 			//			return (2 * command0.fOffset + command0.fLength) - (2 *
 			// command1.fOffset + command1.fLength) == 0;
 			result = false;
 		else
 			result = true;
 		return result;
 	}

 	/**
 	 * Translates a verify event into a document replace command using the
 	 * given offset.
 	 *
 	 * @param event
 	 *            the event to be translated
 	 * @param modelRange
 	 *            the event range as model range
 	 */
 	public void setEventStructuredDocumentEvent(VerifyEvent event, IRegion modelRange) {

 		doit = true;
 		text = event.text;

 		offset = modelRange.getOffset();
 		length = modelRange.getLength();

 		owner = null;
 		caretOffset = -1;
 		shiftsCaret = true;
 		fCommands.clear();
 	}

 	/**
 	 * Returns <code>true</code> if the caret offset should be updated,
 	 * <code>false</code> otherwise.
 	 *
 	 * @return <code>true</code> if the caret offset should be updated,
 	 *         <code>false</code> otherwise
 	 * @since 3.0
 	 */
 	private boolean updateCaret() {
 		return shiftsCaret && caretOffset != -1;
 	}

 }
	/*******************************************************************************
	* 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.Collections;
	import java.util.Iterator;
	import java.util.List;
	import java.util.ListIterator;
	import java.util.NoSuchElementException;

	import org.eclipse.jface.text.Assert;
	import org.eclipse.jface.text.BadLocationException;
	import org.eclipse.jface.text.BadPositionCategoryException;
	import org.eclipse.jface.text.DefaultPositionUpdater;
	import org.eclipse.jface.text.DocumentCommand;
	import org.eclipse.jface.text.IDocument;
	import org.eclipse.jface.text.IDocumentListener;
	import org.eclipse.jface.text.IRegion;
	import org.eclipse.jface.text.Position;
	import org.eclipse.swt.events.VerifyEvent;

	/**
	* TODO Temporary subclass to workaround BUG44665
	*
	* Algorithm for intersects() methods changed.
	*/
	/**
	* Represents a text modification as a document replace command. The text
	* modification is given as a <code>VerifyEvent</code> and translated into a
	* document replace command relative to a given offset. A document command can
	* also be used to initialize a given <code>VerifyEvent</code>.
	* <p>
	* A document command can also represent a list of related changes.
	*/
	public class StructuredDocumentCommand extends DocumentCommand {

	/**
	* A command which is added to document commands.
	*
	* @since 2.1
	*/
	private static class Command implements Comparable {
	/** The length of the range to be replaced. */
	final int fLength;
	/** The offset of the range to be replaced */
	final int fOffset;
	/** The listern who owns this command */
	private final IDocumentListener fOwner;
	/** The replacement text */
	private final String fText;

	/**
	* Creates a new command with the given specification.
	*
	* @param offset
	* the offset of the replace command
	* @param length
	* the length of the replace command
	* @param text
	* the text to replace with, may be <code>null</code>
	* @param owner
	* the document command owner, may be <code>null</code>
	* @since 3.0
	*/
	public Command(int offset, int length, String text, IDocumentListener owner) {
	if (offset < 0 \|\| length < 0)
	throw new IllegalArgumentException();
	fOffset = offset;
	fLength = length;
	fText = text;
	fOwner = owner;
	}

	/*
	* @see java.util.Comparator#compare(java.lang.Object,
	* java.lang.Object)
	*/
	public int compareTo(final Object object) {
	if (equals(object))
	return 0;

	final Command command = (Command) object;

	// diff middle points if not intersecting
	if (fOffset + fLength <= command.fOffset \|\| command.fOffset + command.fLength <= fOffset) {
	int value = (2 * fOffset + fLength) - (2 * command.fOffset + command.fLength);
	if (value != 0)
	return value;
	}
	// the answer
	return 42;
	}

	/*
	* @see java.lang.Object#equals(java.lang.Object)
	*/
	public boolean equals(Object object) {
	if (object == this)
	return true;
	if (!(object instanceof Command))
	return false;
	final Command command = (Command) object;
	return command.fOffset == fOffset && command.fLength == fLength;
	}

	/**
	* Executes the document command on the specified document.
	*
	* @param document
	* the document on which to execute the command.
	* @throws BadLocationException
	* in case this commands cannot be executed
	*/
	public void execute(IDocument document) throws BadLocationException {

	if (fLength == 0 && fText == null)
	return;

	if (fOwner != null)
	document.removeDocumentListener(fOwner);

	document.replace(fOffset, fLength, fText);

	if (fOwner != null)
	document.addDocumentListener(fOwner);
	}

	/**
	* Returns the length delta for this command.
	*
	* @return the length delta for this command
	*/
	public int getDeltaLength() {
	return (fText == null ? 0 : fText.length()) - fLength;
	}
	}

	/**
	* A command iterator.
	*/
	private static class CommandIterator implements Iterator {

	/** The original command. */
	private Command fCommand;

	/** A flag indicating the direction of iteration. */
	private boolean fForward;

	/** The command iterator. */
	private final Iterator fIterator;

	/**
	* Creates a command iterator.
	*
	* @param commands
	* an ascending ordered list of commands
	* @param command
	* the original command
	* @param forward
	* the direction
	*/
	public CommandIterator(final List commands, final Command command, final boolean forward) {
	if (commands == null \|\| command == null)
	throw new IllegalArgumentException();
	fIterator = forward ? commands.iterator() : new ReverseListIterator(commands.listIterator(commands.size()));
	fCommand = command;
	fForward = forward;
	}

	/*
	* @see java.util.Iterator#hasNext()
	*/
	public boolean hasNext() {
	return fCommand != null \|\| fIterator.hasNext();
	}

	/*
	* @see java.util.Iterator#next()
	*/
	public Object next() {

	if (!hasNext())
	throw new NoSuchElementException();

	if (fCommand == null)
	return fIterator.next();

	if (!fIterator.hasNext()) {
	final Command tempCommand = fCommand;
	fCommand = null;
	return tempCommand;
	}

	final Command command = (Command) fIterator.next();
	final int compareValue = command.compareTo(fCommand);

	if ((compareValue < 0) ^ !fForward) {
	return command;

	} else if ((compareValue > 0) ^ !fForward) {
	final Command tempCommand = fCommand;
	fCommand = command;
	return tempCommand;

	} else {
	throw new IllegalArgumentException();
	}
	}

	/*
	* @see java.util.Iterator#remove()
	*/
	public void remove() {
	throw new UnsupportedOperationException();
	}
	}

	/**
	* An iterator, which iterates in reverse over a list.
	*/
	private static class ReverseListIterator implements Iterator {

	/** The list iterator. */
	private final ListIterator fListIterator;

	/**
	* Creates a reverse list iterator.
	*
	* @param listIterator
	* the iterator that this reverse iterator is based upon
	*/
	public ReverseListIterator(ListIterator listIterator) {
	if (listIterator == null)
	throw new IllegalArgumentException();
	fListIterator = listIterator;
	}

	/*
	* @see java.util.Iterator#hasNext()
	*/
	public boolean hasNext() {
	return fListIterator.hasPrevious();
	}

	/*
	* @see java.util.Iterator#next()
	*/
	public Object next() {
	return fListIterator.previous();
	}

	/*
	* @see java.util.Iterator#remove()
	*/
	public void remove() {
	throw new UnsupportedOperationException();
	}
	}

	/**
	* Additional document commands.
	*
	* @since 2.1
	*/
	private final List fCommands = new ArrayList();

	/**
	* Adds an additional replace command. The added replace command must not
	* overlap with existing ones. If the document command owner is not
	* <code>null</code>, it will not get document change notifications for
	* the particular command.
	*
	* @param offset
	* the offset of the region to replace
	* @param length
	* the length of the region to replace
	* @param text
	* the text to replace with, may be <code>null</code>
	* @param owner
	* the command owner, may be <code>null</code>
	* @throws BadLocationException
	* if the added command intersects with an existing one
	* @since 2.1
	*/
	public void addCommand(int offsetParameter, int lengthParameter, String textParameter, IDocumentListener ownerParameter) throws BadLocationException {
	final Command command = new Command(offsetParameter, lengthParameter, textParameter, ownerParameter);

	internalAddCommand(command);
	}

	/**
	* @param command
	* @throws BadLocationException
	*/
	private void internalAddCommand(final Command command) throws BadLocationException {
	if (intersects(command))
	throw new BadLocationException();

	final int index = Collections.binarySearch(fCommands, command);

	// a command with exactly the same ranges exists already
	if (index >= 0)
	throw new BadLocationException();

	// binary search result is defined as (-(insertionIndex) - 1)
	final int insertionIndex = -(index + 1);

	// overlaps to the right?
	if (insertionIndex != fCommands.size() && intersects((Command) fCommands.get(insertionIndex), command))
	throw new BadLocationException();

	// overlaps to the left?
	if (insertionIndex != 0 && intersects((Command) fCommands.get(insertionIndex - 1), command))
	throw new BadLocationException();

	fCommands.add(insertionIndex, command);
	}

	/**
	* Executes the document commands on a document.
	*
	* @param document
	* the document on which to execute the commands
	* @since 2.1
	*/
	void executeStructuredDocumentCommand(IDocument document) throws BadLocationException {

	if (length == 0 && text == null && fCommands.size() == 0)
	return;

	DefaultPositionUpdater updater = new DefaultPositionUpdater(getCategory());
	Position caretPosition = null;
	try {
	if (updateCaret()) {
	document.addPositionCategory(getCategory());
	document.addPositionUpdater(updater);
	caretPosition = new Position(caretOffset);
	document.addPosition(getCategory(), caretPosition);
	}

	final Command originalCommand = new Command(offset, length, text, owner);
	for (final Iterator iterator = new CommandIterator(fCommands, originalCommand, false); iterator.hasNext();)
	((Command) iterator.next()).execute(document);

	} catch (BadLocationException e) {
	// ignore
	} catch (BadPositionCategoryException e) {
	// ignore
	} finally {
	if (updateCaret()) {
	document.removePositionUpdater(updater);
	try {
	document.removePositionCategory(getCategory());
	} catch (BadPositionCategoryException e) {
	Assert.isTrue(false);
	}
	caretOffset = caretPosition.getOffset();
	}
	}
	}

	/**
	* Fills the given verify event with the replace text and the doit flag of
	* this document command. Returns whether the document command covers the
	* same range as the verify event considering the given offset.
	*
	* @param event
	* the event to be changed
	* @param modelRange
	* to be considered for range comparison
	* @return <code>true</code> if this command and the event cover the
	* same range
	*/
	public boolean fillEventStructuredDocumentCommand(VerifyEvent event, IRegion modelRange) {
	event.text = text;
	event.doit = (offset == modelRange.getOffset() && length == modelRange.getLength() && doit && caretOffset == -1);
	return event.doit;
	}

	/**
	* Returns the position category for the caret offset position.
	*
	* @return the position category for the caret offset position
	* @since 3.0
	*/
	private String getCategory() {
	return toString();
	}

	/**
	* Returns the number of commands including the original document command.
	*
	* @return returns the number of commands
	* @since 2.1
	*/
	public int getCommandCount() {
	return 1 + fCommands.size();
	}

	/**
	* Returns an iterator over the commands in ascending position order. The
	* iterator includes the original document command. Commands cannot be
	* removed.
	*
	* @return returns the command iterator
	*/
	public Iterator getCommandIterator() {
	Command command = new Command(offset, length, text, owner);
	return new CommandIterator(fCommands, command, true);
	}

	/**
	* Returns whether the given command intersects with this command.
	*
	* @param command
	* the command
	* @return <code>true</code> if the command intersects with this command
	* @since 2.1
	*/
	private boolean intersects(Command command) {
	boolean result = false;
	// diff middle points if not intersecting
	if (offset + length <= command.fOffset \|\| command.fOffset + command.fLength <= offset)
	// return (2 * offset + length) - (2 * command.fOffset +
	// command.fLength) == 0;
	result = false;
	else
	result = true;
	return result;
	}

	/**
	* Returns whether the two given commands intersect.
	*
	* @param command0
	* the first command
	* @param command1
	* the second command
	* @return <code>true</code> if the commands intersect
	* @since 2.1
	*/
	private boolean intersects(Command command0, Command command1) {
	boolean result = false;
	// diff middle points if not intersecting
	if (command0.fOffset + command0.fLength <= command1.fOffset \|\| command1.fOffset + command1.fLength <= command0.fOffset)
	// return (2 * command0.fOffset + command0.fLength) - (2 *
	// command1.fOffset + command1.fLength) == 0;
	result = false;
	else
	result = true;
	return result;
	}

	/**
	* Translates a verify event into a document replace command using the
	* given offset.
	*
	* @param event
	* the event to be translated
	* @param modelRange
	* the event range as model range
	*/
	public void setEventStructuredDocumentEvent(VerifyEvent event, IRegion modelRange) {

	doit = true;
	text = event.text;

	offset = modelRange.getOffset();
	length = modelRange.getLength();

	owner = null;
	caretOffset = -1;
	shiftsCaret = true;
	fCommands.clear();
	}

	/**
	* Returns <code>true</code> if the caret offset should be updated,
	* <code>false</code> otherwise.
	*
	* @return <code>true</code> if the caret offset should be updated,
	* <code>false</code> otherwise
	* @since 3.0
	*/
	private boolean updateCaret() {
	return shiftsCaret && caretOffset != -1;
	}

	}