org.eclipse.text/src/org/eclipse/jface/text/source/AnnotationModel.java - platform/eclipse.platform.text - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2003 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Common Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/cpl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/

 package org.eclipse.jface.text.source;


 import org.eclipse.core.runtime.CoreException;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.NoSuchElementException;

 import org.eclipse.jface.text.Assert;
 import org.eclipse.jface.text.BadLocationException;
 import org.eclipse.jface.text.DocumentEvent;
 import org.eclipse.jface.text.IDocument;
 import org.eclipse.jface.text.IDocumentListener;
 import org.eclipse.jface.text.Position;


 /**
  * Standard implementation of <code>IAnnotationModel</code>. This class can directly
  * be used by clients. Subclasses may adapt this annotation model to other existing
  * annotation mechanisms.
  */
 public class AnnotationModel implements IAnnotationModel, IAnnotationModelExtension {

 	/** The list of managed annotations */
 	protected Map fAnnotations;
 	/** The list of annotation model listeners */
 	protected ArrayList fAnnotationModelListeners;
 	/** The document connected with this model */
 	protected IDocument fDocument;
 	/** The number of open connections to the same document */
 	private int fOpenConnections= 0;
 	/** The document listener for tracking whether document positions might have been changed. */
 	private IDocumentListener fDocumentListener;
 	/** The flag indicating whether the document positions might have been changed. */
 	private boolean fDocumentChanged= true;
 	/**
 	 * The model's attachment.
 	 * @since 3.0
 	 */
 	private Map fAttachments= new HashMap();
 	/**
 	 * The annotation model listener on attached sub-models.
 	 * @since 3.0
 	 */
 	private IAnnotationModelListener fModelListener= new IAnnotationModelListener() {
 		public void modelChanged(IAnnotationModel model) {
 			AnnotationModel.this.fireModelChanged();
 		}
 	};
 	/**
 	 * The current annotation model event.
 	 * @since 3.0
 	 */
 	private AnnotationModelEvent fModelEvent= new AnnotationModelEvent(this);


 	/**
 	 * Creates a new annotation model. The annotation is empty, i.e. does not
 	 * manage any annotations and is not connected to any document.
 	 */
 	public AnnotationModel() {
 		fAnnotations= Collections.synchronizedMap(new HashMap(10));
 		fAnnotationModelListeners= new ArrayList(2);

 		fDocumentListener= new IDocumentListener() {

 			public void documentAboutToBeChanged(DocumentEvent event) {
 			}

 			public void documentChanged(DocumentEvent event) {
 				fDocumentChanged= true;
 			}
 		};
 	}

 	/*
 	 * @see IAnnotationModel#addAnnotation(Annotation, Position)
 	 */
 	public void addAnnotation(Annotation annotation, Position position) {
 		try {
 			addAnnotation(annotation, position, true);
 		} catch (BadLocationException e) {
 			// ignore invalid position
 		}
 	}

 	/*
 	 * @see IAnnotationModelExtension#replaceAnnotations(Annotation[], Map)
 	 * @since 3.0
 	 */
 	public void replaceAnnotations(Annotation[] annotationsToRemove, Map annotationsToAdd) {
 		try {
 			replaceAnnotations(annotationsToRemove, annotationsToAdd, false);
 		} catch (BadLocationException x) {
 		}
 	}

 	protected void replaceAnnotations(Annotation[] annotationsToRemove, Map annotationsToAdd, boolean fireModelChanged) throws BadLocationException {

 		if (annotationsToRemove != null) {
 			for (int i= 0, length= annotationsToRemove.length; i < length; i++)
 				removeAnnotation(annotationsToRemove[i]);
 		}

 		if (annotationsToAdd != null) {
 			Iterator iter= annotationsToAdd.entrySet().iterator();
 			while (iter.hasNext()) {
 				Map.Entry mapEntry= (Map.Entry) iter.next();
 				Annotation annotation= (Annotation) mapEntry.getKey();
 				Position position= (Position) mapEntry.getValue();
 				addAnnotation(annotation, position, false);
 			}
 		}

 		if (fireModelChanged)
 			fireModelChanged();
 	}

 	/**
 	 * Adds the given annotation to this model. Associates the
 	 * annotation with the given position. If requested, all annotation
 	 * model listeners are informed about this model change. If the annotation
 	 * is already managed by this model nothing happens.
 	 *
 	 * @param annotation the annotation to add
 	 * @param position the associate position
 	 * @param fireModelChange indicates whether to notify all model listeners
 	 * @throws BadLocationException if the position is not a valid document position
 	 */
 	protected void addAnnotation(Annotation annotation, Position position, boolean fireModelChanged) throws BadLocationException {
 		if (!fAnnotations.containsKey(annotation)) {

 			addPosition(fDocument, position);
 			fAnnotations.put(annotation, position);
 			fModelEvent.annotationAdded(annotation);

 			if (fireModelChanged)
 				fireModelChanged();
 		}
 	}

 	/*
 	 * @see IAnnotationModel#addAnnotationModelListener(IAnnotationModelListener)
 	 */
 	public void addAnnotationModelListener(IAnnotationModelListener listener) {
 		if (!fAnnotationModelListeners.contains(listener)) {
 			fAnnotationModelListeners.add(listener);
 			listener.modelChanged(this);
 		}
 	}

 	/**
 	 * Adds the given position to the default position category of the
 	 * given document.
 	 *
 	 * @param document the document to which to add the position
 	 * @param position the position to add
 	 * @throws BadLocationException if the position is not a valid document position
 	 */
 	protected void addPosition(IDocument document, Position position) throws BadLocationException {
 		if (document != null)
 			document.addPosition(position);
 	}

 	/*
 	 * @see IAnnotationModel#connect(IDocument)
 	 */
 	public void connect(IDocument document) {
 		Assert.isTrue(fDocument == null || fDocument == document);

 		if (fDocument == null) {
 			fDocument= document;
 			Iterator e= fAnnotations.values().iterator();
 			while (e.hasNext())
 				try {
 					addPosition(fDocument, (Position) e.next());
 				} catch (BadLocationException x) {
 					// ignore invalid position
 				}
 		}

 		++ fOpenConnections;
 		if (fOpenConnections == 1) {
 			fDocument.addDocumentListener(fDocumentListener);
 			connected();
 		}

 		for (Iterator it= fAttachments.keySet().iterator(); it.hasNext();) {
 			IAnnotationModel model= (IAnnotationModel) fAttachments.get(it.next());
 			model.connect(document);
 		}
 	}

 	/**
 	 * Hook method. Is called as soon as this model becomes connected to a document.
 	 * Subclasses may re-implement.
 	 */
 	protected void connected() {
 	}

 	/**
 	 * Hook method. Is called as soon as this model becomes disconnected from its document.
 	 * Subclasses may re-implement.
 	 */
 	protected void disconnected() {
 	}

 	/*
 	 * @see IAnnotationModel#disconnect(IDocument)
 	 */
 	public void disconnect(IDocument document) {

 		Assert.isTrue(fDocument == document);

 		for (Iterator it= fAttachments.keySet().iterator(); it.hasNext();) {
 			IAnnotationModel model= (IAnnotationModel) fAttachments.get(it.next());
 			model.disconnect(document);
 		}

 		-- fOpenConnections;
 		if (fOpenConnections == 0) {

 			disconnected();
 			fDocument.removeDocumentListener(fDocumentListener);

 			if (fDocument != null) {
 				Iterator e= fAnnotations.values().iterator();
 				while (e.hasNext()) {
 					Position p= (Position) e.next();
 					fDocument.removePosition(p);
 				}
 				fDocument= null;
 			}
 		}
 	}

 	/**
 	 * Informs all annotation model listeners that this model has been changed.
 	 */
 	protected void fireModelChanged() {
 		AnnotationModelEvent event= fModelEvent;
 		fModelEvent= new AnnotationModelEvent(this);
 		fireModelChanged(event);
 	}

 	/**
 	 * Informs all annotation model listeners that this model has been changed
 	 * as described in the annotation model event. The event is sent out
 	 * to all listeners implementing <code>IAnnotationModelListenerExtension</code>.
 	 * All other listeners are notified by just calling <code>modelChanged(IAnnotationModel)</code>.
 	 *
 	 * @param event the event to be sent out to the listeners
 	 * @since 2.0
 	 */
 	protected void fireModelChanged(AnnotationModelEvent event) {

 		if (event.isEmpty())
 			return;

 		ArrayList v= new ArrayList(fAnnotationModelListeners);
 		Iterator e= v.iterator();
 		while (e.hasNext()) {
 			IAnnotationModelListener l= (IAnnotationModelListener) e.next();
 			if (l instanceof IAnnotationModelListenerExtension)
 				((IAnnotationModelListenerExtension) l).modelChanged(event);
 			else
 				l.modelChanged(this);
 		}
 	}

 	/**
 	 * Removes the given annotations from this model. If requested all
 	 * annotation model listeners will be informed about this change.
 	 * <code>modelInitiated</code> indicates whether the deletion has
 	 * been initiated by this model or by one of its clients.
 	 *
 	 * @param annotations the annotations to be removed
 	 * @param fireModelChanged indicates whether to notify all model listeners
 	 * @param modelInitiated indicates whether this changes has been initiated by this model
 	 */
 	protected void removeAnnotations(List annotations, boolean fireModelChanged, boolean modelInitiated) {
 		if (annotations.size() > 0) {
 			Iterator e= annotations.iterator();
 			while (e.hasNext())
 				removeAnnotation((Annotation) e.next(), false);

 			if (fireModelChanged)
 				fireModelChanged();
 		}
 	}

 	/**
 	 * Removes all annotations from the model whose associated positions have been
 	 * deleted. If requested inform all model listeners about the change.
 	 *
 	 * @param fireModelChanged indicates whether to notify all model listeners
 	 */
 	protected void cleanup(boolean fireModelChanged) {
 		if (fDocumentChanged) {
 			fDocumentChanged= false;

 			ArrayList deleted= new ArrayList();
 			Iterator e= new ArrayList(fAnnotations.keySet()).iterator();
 			while (e.hasNext()) {
 				Annotation a= (Annotation) e.next();
 				Position p= (Position) fAnnotations.get(a);
 				if (p == null || p.isDeleted())
 					deleted.add(a);
 			}

 			removeAnnotations(deleted, fireModelChanged, false);
 		}
 	}

 	/*
 	 * @see IAnnotationModel#getAnnotationsIterator()
 	 */
 	public Iterator getAnnotationIterator() {
 		return getAnnotationIterator(true, true);
 	}

 	/**
 	 * Returns all annotations managed by this model. <code>cleanup</code>
 	 * indicates whether all annotations whose associated positions are
 	 * deleted should previously be removed from the model. <code>recurse</code> indicates
 	 * whether annotations of attached sub-models should also be returned.
 	 *
 	 * @param cleanup indicates whether annotations with deleted associated positions are removed
 	 * @param recurse whether to return annotations managed by sub-models.
 	 * @return all annotations managed by this model
 	 * @since 3.0
 	 */
 	private Iterator getAnnotationIterator(boolean cleanup, boolean recurse) {

 		if (!recurse)
 			return getAnnotationIterator(cleanup);

 		List iterators= new ArrayList(fAttachments.size() + 1);
 		iterators.add(getAnnotationIterator(cleanup));
 		for (Iterator it= fAttachments.keySet().iterator(); it.hasNext();) {
 			iterators.add(((IAnnotationModel)fAttachments.get(it.next())).getAnnotationIterator());
 		}

 		final Iterator iter= iterators.iterator();

 		// Meta iterator...
 		return new Iterator() {

 			/** The current iterator. */
 			private Iterator fCurrent= (Iterator) iter.next(); // there is at least one.

 			public void remove() {
 				throw new UnsupportedOperationException();
 			}

 			public boolean hasNext() {
 				if (fCurrent.hasNext())
 					return true;
 				else if (iter.hasNext()) {
 					fCurrent= (Iterator) iter.next();
 					return hasNext();
 				} else
 					return false;
 			}

 			public Object next() {
 				if (!hasNext())
 					throw new NoSuchElementException();
 				else
 					return fCurrent.next();
 			}

 		};
 	}

 	/**
 	 * Returns all annotations managed by this model. <code>cleanup</code>
 	 * indicates whether all annotations whose associated positions are
 	 * deleted should previously be removed from the model.
 	 *
 	 * @param cleanup indicates whether annotations with deleted associated positions are removed
 	 * @return all annotations managed by this model
 	 */
 	protected Iterator getAnnotationIterator(boolean cleanup) {
 		if (cleanup)
 			cleanup(false);

 		synchronized (fAnnotations) {
 			return new ArrayList(fAnnotations.keySet()).iterator();
 		}
 	}

 	/*
 	 * @see IAnnotationModel#getPosition(Annotation)
 	 */
 	public Position getPosition(Annotation annotation) {
 		Position position= (Position) fAnnotations.get(annotation);
 		if (position != null)
 			return position;

 		Iterator it= fAttachments.values().iterator();
 		while (position == null && it.hasNext())
 			position= ((IAnnotationModel)it.next()).getPosition(annotation);
 		return position;
 	}

 	/**
 	 * Removes all annotations from the annotation model and
 	 * informs all model listeners about this change.
 	 */
 	public void removeAllAnnotations() {
 		removeAllAnnotations(true);
 	}

 	/**
 	 * Removes all annotations from the annotation model. If requested
 	 * inform all model change listeners about this change.
 	 *
 	 * @param fireModelChanged indicates whether to notify all model listeners
 	 */
 	protected void removeAllAnnotations(boolean fireModelChanged) {

 		if (fDocument != null) {
 			Iterator e= fAnnotations.keySet().iterator();
 			while (e.hasNext()) {
 				Annotation a= (Annotation) e.next();
 				Position p= (Position) fAnnotations.get(a);
 				fDocument.removePosition(p);
 				fModelEvent.annotationRemoved(a);
 			}
 		}

 		fAnnotations.clear();

 		if (fireModelChanged)
 			fireModelChanged();
 	}

 	/*
 	 * @see IAnnotationModel#removeAnnotation(Annotation)
 	 */
 	public void removeAnnotation(Annotation annotation) {
 		removeAnnotation(annotation, true);
 	}

 	/**
 	 * Removes the given annotation from the annotation model.
 	 * If requested inform all model change listeners about this change.
 	 *
 	 * @param annotation the annotation to be removed
 	 * @param fireModelChanged indicates whether to notify all model listeners
 	 */
 	protected void removeAnnotation(Annotation annotation, boolean fireModelChanged) {
 		if (fAnnotations.containsKey(annotation)) {

 			if (fDocument != null) {
 				Position p= (Position) fAnnotations.get(annotation);
 				fDocument.removePosition(p);
 			}

 			fAnnotations.remove(annotation);
 			fModelEvent.annotationRemoved(annotation);

 			if (fireModelChanged)
 				fireModelChanged();
 		}
 	}

 	/**
 	 * Modifies the position associated with the given annotation to the given position.
 	 * If the annotation is not yet managed by this annotation model, the annotation
 	 * is added. All annotation model change listeners will be informed about the change.
 	 *
 	 * @param annotation the annotation whose associated position should be modified
 	 * @param position the position to whose values the associated position should be changed
 	 */
 	public void modifyAnnotation(Annotation annotation, Position position) {
 		modifyAnnotation(annotation, position, true);
 	}

 	/**
 	 * Modifies the associated position of the given annotation to the given position.
 	 * If the annotation is not yet managed by this annotation model, the annotation
 	 * is added. If requested, all annotation model change listeners will be informed
 	 * about the change.
 	 *
 	 * @param annotation the annotation whose associated position should be modified
 	 * @param position the position to whose values the associated position should be changed
 	 * @param fireModelChanged indicates whether to notify all model listeners
 	 */
 	protected void modifyAnnotation(Annotation annotation, Position position, boolean fireModelChanged) {
 		if (position == null) {
 			removeAnnotation(annotation, fireModelChanged);
 		} else {
 			Position p= (Position) fAnnotations.get(annotation);
 			if (p != null) {

 				if (position.getOffset() != p.getOffset() && position.getLength() != p.getLength()) {
 					p.setOffset(position.getOffset());
 					p.setLength(position.getLength());
 					fModelEvent.annotationChanged(annotation);
 					if (fireModelChanged)
 						fireModelChanged();
 				}

 				// TODO check whether this is OK
 				annotation.fireAnnotationChanged();

 			} else {
 				try {
 					addAnnotation(annotation, position, fireModelChanged);
 				} catch (BadLocationException e) {
 					// ignore invalid position
 				}
 			}
 		}
 	}

 	/*
 	 * @see IAnnotationModel#removeAnnotationModelListener(IAnnotationModelListener)
 	 */
 	public void removeAnnotationModelListener(IAnnotationModelListener listener) {
 		fAnnotationModelListeners.remove(listener);
 	}

 	/*
 	 * @see org.eclipse.jface.text.source.IAnnotationModelExtension#attach(java.lang.Object, java.lang.Object)
 	 * @since 3.0
 	 */
 	public void addAnnotationModel(Object key, IAnnotationModel attachment) {
 		Assert.isNotNull(attachment);
 		if (!fAttachments.containsValue(attachment)) {
 			fAttachments.put(key, attachment);
 			for (int i= 0; i < fOpenConnections; i++)
 				attachment.connect(fDocument);
 			attachment.addAnnotationModelListener(fModelListener);
 		}
 	}

 	/*
 	 * @see org.eclipse.jface.text.source.IAnnotationModelExtension#get(java.lang.Object)
 	 * @since 3.0
 	 */
 	public IAnnotationModel getAnnotationModel(Object key) {
 		return (IAnnotationModel) fAttachments.get(key);
 	}

 	/*
 	 * @see org.eclipse.jface.text.source.IAnnotationModelExtension#detach(java.lang.Object)
 	 * @since 3.0
 	 */
 	public IAnnotationModel removeAnnotationModel(Object key) {
 		IAnnotationModel ret= (IAnnotationModel) fAttachments.remove(key);
 		if (ret != null) {
 			for (int i= 0; i < fOpenConnections; i++)
 				ret.disconnect(fDocument);
 			ret.removeAnnotationModelListener(fModelListener);
 		}
 		return ret;
 	}

 	/*
 	 * @see org.eclipse.jface.text.source.IAnnotationModelExtension#commit()
 	 */
 	public void commit() throws CoreException {
 	}

 	/*
 	 * @see org.eclipse.jface.text.source.IAnnotationModelExtension#revert()
 	 */
 	public void revert() throws CoreException {
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2003 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Common Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/cpl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/

	package org.eclipse.jface.text.source;


	import org.eclipse.core.runtime.CoreException;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;
	import java.util.NoSuchElementException;

	import org.eclipse.jface.text.Assert;
	import org.eclipse.jface.text.BadLocationException;
	import org.eclipse.jface.text.DocumentEvent;
	import org.eclipse.jface.text.IDocument;
	import org.eclipse.jface.text.IDocumentListener;
	import org.eclipse.jface.text.Position;


	/**
	* Standard implementation of <code>IAnnotationModel</code>. This class can directly
	* be used by clients. Subclasses may adapt this annotation model to other existing
	* annotation mechanisms.
	*/
	public class AnnotationModel implements IAnnotationModel, IAnnotationModelExtension {

	/** The list of managed annotations */
	protected Map fAnnotations;
	/** The list of annotation model listeners */
	protected ArrayList fAnnotationModelListeners;
	/** The document connected with this model */
	protected IDocument fDocument;
	/** The number of open connections to the same document */
	private int fOpenConnections= 0;
	/** The document listener for tracking whether document positions might have been changed. */
	private IDocumentListener fDocumentListener;
	/** The flag indicating whether the document positions might have been changed. */
	private boolean fDocumentChanged= true;
	/**
	* The model's attachment.
	* @since 3.0
	*/
	private Map fAttachments= new HashMap();
	/**
	* The annotation model listener on attached sub-models.
	* @since 3.0
	*/
	private IAnnotationModelListener fModelListener= new IAnnotationModelListener() {
	public void modelChanged(IAnnotationModel model) {
	AnnotationModel.this.fireModelChanged();
	}
	};
	/**
	* The current annotation model event.
	* @since 3.0
	*/
	private AnnotationModelEvent fModelEvent= new AnnotationModelEvent(this);




	/**
	* Creates a new annotation model. The annotation is empty, i.e. does not
	* manage any annotations and is not connected to any document.
	*/
	public AnnotationModel() {
	fAnnotations= Collections.synchronizedMap(new HashMap(10));
	fAnnotationModelListeners= new ArrayList(2);

	fDocumentListener= new IDocumentListener() {

	public void documentAboutToBeChanged(DocumentEvent event) {
	}

	public void documentChanged(DocumentEvent event) {
	fDocumentChanged= true;
	}
	};
	}

	/*
	* @see IAnnotationModel#addAnnotation(Annotation, Position)
	*/
	public void addAnnotation(Annotation annotation, Position position) {
	try {
	addAnnotation(annotation, position, true);
	} catch (BadLocationException e) {
	// ignore invalid position
	}
	}

	/*
	* @see IAnnotationModelExtension#replaceAnnotations(Annotation[], Map)
	* @since 3.0
	*/
	public void replaceAnnotations(Annotation[] annotationsToRemove, Map annotationsToAdd) {
	try {
	replaceAnnotations(annotationsToRemove, annotationsToAdd, false);
	} catch (BadLocationException x) {
	}
	}

	protected void replaceAnnotations(Annotation[] annotationsToRemove, Map annotationsToAdd, boolean fireModelChanged) throws BadLocationException {

	if (annotationsToRemove != null) {
	for (int i= 0, length= annotationsToRemove.length; i < length; i++)
	removeAnnotation(annotationsToRemove[i]);
	}

	if (annotationsToAdd != null) {
	Iterator iter= annotationsToAdd.entrySet().iterator();
	while (iter.hasNext()) {
	Map.Entry mapEntry= (Map.Entry) iter.next();
	Annotation annotation= (Annotation) mapEntry.getKey();
	Position position= (Position) mapEntry.getValue();
	addAnnotation(annotation, position, false);
	}
	}

	if (fireModelChanged)
	fireModelChanged();
	}

	/**
	* Adds the given annotation to this model. Associates the
	* annotation with the given position. If requested, all annotation
	* model listeners are informed about this model change. If the annotation
	* is already managed by this model nothing happens.
	*
	* @param annotation the annotation to add
	* @param position the associate position
	* @param fireModelChange indicates whether to notify all model listeners
	* @throws BadLocationException if the position is not a valid document position
	*/
	protected void addAnnotation(Annotation annotation, Position position, boolean fireModelChanged) throws BadLocationException {
	if (!fAnnotations.containsKey(annotation)) {

	addPosition(fDocument, position);
	fAnnotations.put(annotation, position);
	fModelEvent.annotationAdded(annotation);

	if (fireModelChanged)
	fireModelChanged();
	}
	}

	/*
	* @see IAnnotationModel#addAnnotationModelListener(IAnnotationModelListener)
	*/
	public void addAnnotationModelListener(IAnnotationModelListener listener) {
	if (!fAnnotationModelListeners.contains(listener)) {
	fAnnotationModelListeners.add(listener);
	listener.modelChanged(this);
	}
	}

	/**
	* Adds the given position to the default position category of the
	* given document.
	*
	* @param document the document to which to add the position
	* @param position the position to add
	* @throws BadLocationException if the position is not a valid document position
	*/
	protected void addPosition(IDocument document, Position position) throws BadLocationException {
	if (document != null)
	document.addPosition(position);
	}

	/*
	* @see IAnnotationModel#connect(IDocument)
	*/
	public void connect(IDocument document) {
	Assert.isTrue(fDocument == null \|\| fDocument == document);

	if (fDocument == null) {
	fDocument= document;
	Iterator e= fAnnotations.values().iterator();
	while (e.hasNext())
	try {
	addPosition(fDocument, (Position) e.next());
	} catch (BadLocationException x) {
	// ignore invalid position
	}
	}

	++ fOpenConnections;
	if (fOpenConnections == 1) {
	fDocument.addDocumentListener(fDocumentListener);
	connected();
	}

	for (Iterator it= fAttachments.keySet().iterator(); it.hasNext();) {
	IAnnotationModel model= (IAnnotationModel) fAttachments.get(it.next());
	model.connect(document);
	}
	}

	/**
	* Hook method. Is called as soon as this model becomes connected to a document.
	* Subclasses may re-implement.
	*/
	protected void connected() {
	}

	/**
	* Hook method. Is called as soon as this model becomes disconnected from its document.
	* Subclasses may re-implement.
	*/
	protected void disconnected() {
	}

	/*
	* @see IAnnotationModel#disconnect(IDocument)
	*/
	public void disconnect(IDocument document) {

	Assert.isTrue(fDocument == document);

	for (Iterator it= fAttachments.keySet().iterator(); it.hasNext();) {
	IAnnotationModel model= (IAnnotationModel) fAttachments.get(it.next());
	model.disconnect(document);
	}

	-- fOpenConnections;
	if (fOpenConnections == 0) {

	disconnected();
	fDocument.removeDocumentListener(fDocumentListener);

	if (fDocument != null) {
	Iterator e= fAnnotations.values().iterator();
	while (e.hasNext()) {
	Position p= (Position) e.next();
	fDocument.removePosition(p);
	}
	fDocument= null;
	}
	}
	}

	/**
	* Informs all annotation model listeners that this model has been changed.
	*/
	protected void fireModelChanged() {
	AnnotationModelEvent event= fModelEvent;
	fModelEvent= new AnnotationModelEvent(this);
	fireModelChanged(event);
	}

	/**
	* Informs all annotation model listeners that this model has been changed
	* as described in the annotation model event. The event is sent out
	* to all listeners implementing <code>IAnnotationModelListenerExtension</code>.
	* All other listeners are notified by just calling <code>modelChanged(IAnnotationModel)</code>.
	*
	* @param event the event to be sent out to the listeners
	* @since 2.0
	*/
	protected void fireModelChanged(AnnotationModelEvent event) {

	if (event.isEmpty())
	return;

	ArrayList v= new ArrayList(fAnnotationModelListeners);
	Iterator e= v.iterator();
	while (e.hasNext()) {
	IAnnotationModelListener l= (IAnnotationModelListener) e.next();
	if (l instanceof IAnnotationModelListenerExtension)
	((IAnnotationModelListenerExtension) l).modelChanged(event);
	else
	l.modelChanged(this);
	}
	}

	/**
	* Removes the given annotations from this model. If requested all
	* annotation model listeners will be informed about this change.
	* <code>modelInitiated</code> indicates whether the deletion has
	* been initiated by this model or by one of its clients.
	*
	* @param annotations the annotations to be removed
	* @param fireModelChanged indicates whether to notify all model listeners
	* @param modelInitiated indicates whether this changes has been initiated by this model
	*/
	protected void removeAnnotations(List annotations, boolean fireModelChanged, boolean modelInitiated) {
	if (annotations.size() > 0) {
	Iterator e= annotations.iterator();
	while (e.hasNext())
	removeAnnotation((Annotation) e.next(), false);

	if (fireModelChanged)
	fireModelChanged();
	}
	}

	/**
	* Removes all annotations from the model whose associated positions have been
	* deleted. If requested inform all model listeners about the change.
	*
	* @param fireModelChanged indicates whether to notify all model listeners
	*/
	protected void cleanup(boolean fireModelChanged) {
	if (fDocumentChanged) {
	fDocumentChanged= false;

	ArrayList deleted= new ArrayList();
	Iterator e= new ArrayList(fAnnotations.keySet()).iterator();
	while (e.hasNext()) {
	Annotation a= (Annotation) e.next();
	Position p= (Position) fAnnotations.get(a);
	if (p == null \|\| p.isDeleted())
	deleted.add(a);
	}

	removeAnnotations(deleted, fireModelChanged, false);
	}
	}

	/*
	* @see IAnnotationModel#getAnnotationsIterator()
	*/
	public Iterator getAnnotationIterator() {
	return getAnnotationIterator(true, true);
	}

	/**
	* Returns all annotations managed by this model. <code>cleanup</code>
	* indicates whether all annotations whose associated positions are
	* deleted should previously be removed from the model. <code>recurse</code> indicates
	* whether annotations of attached sub-models should also be returned.
	*
	* @param cleanup indicates whether annotations with deleted associated positions are removed
	* @param recurse whether to return annotations managed by sub-models.
	* @return all annotations managed by this model
	* @since 3.0
	*/
	private Iterator getAnnotationIterator(boolean cleanup, boolean recurse) {

	if (!recurse)
	return getAnnotationIterator(cleanup);

	List iterators= new ArrayList(fAttachments.size() + 1);
	iterators.add(getAnnotationIterator(cleanup));
	for (Iterator it= fAttachments.keySet().iterator(); it.hasNext();) {
	iterators.add(((IAnnotationModel)fAttachments.get(it.next())).getAnnotationIterator());
	}

	final Iterator iter= iterators.iterator();

	// Meta iterator...
	return new Iterator() {

	/** The current iterator. */
	private Iterator fCurrent= (Iterator) iter.next(); // there is at least one.

	public void remove() {
	throw new UnsupportedOperationException();
	}

	public boolean hasNext() {
	if (fCurrent.hasNext())
	return true;
	else if (iter.hasNext()) {
	fCurrent= (Iterator) iter.next();
	return hasNext();
	} else
	return false;
	}

	public Object next() {
	if (!hasNext())
	throw new NoSuchElementException();
	else
	return fCurrent.next();
	}

	};
	}

	/**
	* Returns all annotations managed by this model. <code>cleanup</code>
	* indicates whether all annotations whose associated positions are
	* deleted should previously be removed from the model.
	*
	* @param cleanup indicates whether annotations with deleted associated positions are removed
	* @return all annotations managed by this model
	*/
	protected Iterator getAnnotationIterator(boolean cleanup) {
	if (cleanup)
	cleanup(false);

	synchronized (fAnnotations) {
	return new ArrayList(fAnnotations.keySet()).iterator();
	}
	}

	/*
	* @see IAnnotationModel#getPosition(Annotation)
	*/
	public Position getPosition(Annotation annotation) {
	Position position= (Position) fAnnotations.get(annotation);
	if (position != null)
	return position;

	Iterator it= fAttachments.values().iterator();
	while (position == null && it.hasNext())
	position= ((IAnnotationModel)it.next()).getPosition(annotation);
	return position;
	}

	/**
	* Removes all annotations from the annotation model and
	* informs all model listeners about this change.
	*/
	public void removeAllAnnotations() {
	removeAllAnnotations(true);
	}

	/**
	* Removes all annotations from the annotation model. If requested
	* inform all model change listeners about this change.
	*
	* @param fireModelChanged indicates whether to notify all model listeners
	*/
	protected void removeAllAnnotations(boolean fireModelChanged) {

	if (fDocument != null) {
	Iterator e= fAnnotations.keySet().iterator();
	while (e.hasNext()) {
	Annotation a= (Annotation) e.next();
	Position p= (Position) fAnnotations.get(a);
	fDocument.removePosition(p);
	fModelEvent.annotationRemoved(a);
	}
	}

	fAnnotations.clear();

	if (fireModelChanged)
	fireModelChanged();
	}

	/*
	* @see IAnnotationModel#removeAnnotation(Annotation)
	*/
	public void removeAnnotation(Annotation annotation) {
	removeAnnotation(annotation, true);
	}

	/**
	* Removes the given annotation from the annotation model.
	* If requested inform all model change listeners about this change.
	*
	* @param annotation the annotation to be removed
	* @param fireModelChanged indicates whether to notify all model listeners
	*/
	protected void removeAnnotation(Annotation annotation, boolean fireModelChanged) {
	if (fAnnotations.containsKey(annotation)) {

	if (fDocument != null) {
	Position p= (Position) fAnnotations.get(annotation);
	fDocument.removePosition(p);
	}

	fAnnotations.remove(annotation);
	fModelEvent.annotationRemoved(annotation);

	if (fireModelChanged)
	fireModelChanged();
	}
	}

	/**
	* Modifies the position associated with the given annotation to the given position.
	* If the annotation is not yet managed by this annotation model, the annotation
	* is added. All annotation model change listeners will be informed about the change.
	*
	* @param annotation the annotation whose associated position should be modified
	* @param position the position to whose values the associated position should be changed
	*/
	public void modifyAnnotation(Annotation annotation, Position position) {
	modifyAnnotation(annotation, position, true);
	}

	/**
	* Modifies the associated position of the given annotation to the given position.
	* If the annotation is not yet managed by this annotation model, the annotation
	* is added. If requested, all annotation model change listeners will be informed
	* about the change.
	*
	* @param annotation the annotation whose associated position should be modified
	* @param position the position to whose values the associated position should be changed
	* @param fireModelChanged indicates whether to notify all model listeners
	*/
	protected void modifyAnnotation(Annotation annotation, Position position, boolean fireModelChanged) {
	if (position == null) {
	removeAnnotation(annotation, fireModelChanged);
	} else {
	Position p= (Position) fAnnotations.get(annotation);
	if (p != null) {

	if (position.getOffset() != p.getOffset() && position.getLength() != p.getLength()) {
	p.setOffset(position.getOffset());
	p.setLength(position.getLength());
	fModelEvent.annotationChanged(annotation);
	if (fireModelChanged)
	fireModelChanged();
	}

	// TODO check whether this is OK
	annotation.fireAnnotationChanged();

	} else {
	try {
	addAnnotation(annotation, position, fireModelChanged);
	} catch (BadLocationException e) {
	// ignore invalid position
	}
	}
	}
	}

	/*
	* @see IAnnotationModel#removeAnnotationModelListener(IAnnotationModelListener)
	*/
	public void removeAnnotationModelListener(IAnnotationModelListener listener) {
	fAnnotationModelListeners.remove(listener);
	}

	/*
	* @see org.eclipse.jface.text.source.IAnnotationModelExtension#attach(java.lang.Object, java.lang.Object)
	* @since 3.0
	*/
	public void addAnnotationModel(Object key, IAnnotationModel attachment) {
	Assert.isNotNull(attachment);
	if (!fAttachments.containsValue(attachment)) {
	fAttachments.put(key, attachment);
	for (int i= 0; i < fOpenConnections; i++)
	attachment.connect(fDocument);
	attachment.addAnnotationModelListener(fModelListener);
	}
	}

	/*
	* @see org.eclipse.jface.text.source.IAnnotationModelExtension#get(java.lang.Object)
	* @since 3.0
	*/
	public IAnnotationModel getAnnotationModel(Object key) {
	return (IAnnotationModel) fAttachments.get(key);
	}

	/*
	* @see org.eclipse.jface.text.source.IAnnotationModelExtension#detach(java.lang.Object)
	* @since 3.0
	*/
	public IAnnotationModel removeAnnotationModel(Object key) {
	IAnnotationModel ret= (IAnnotationModel) fAttachments.remove(key);
	if (ret != null) {
	for (int i= 0; i < fOpenConnections; i++)
	ret.disconnect(fDocument);
	ret.removeAnnotationModelListener(fModelListener);
	}
	return ret;
	}

	/*
	* @see org.eclipse.jface.text.source.IAnnotationModelExtension#commit()
	*/
	public void commit() throws CoreException {
	}

	/*
	* @see org.eclipse.jface.text.source.IAnnotationModelExtension#revert()
	*/
	public void revert() throws CoreException {
	}
	}