bundles/org.eclipse.wst.dtd.ui/src/org/eclipse/wst/dtd/ui/internal/projection/StructuredTextFoldingProviderDTD.java - sourceediting/webtools.sourceediting - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005 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
  *
  *******************************************************************************/
 package org.eclipse.wst.dtd.ui.internal.projection;

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

 import org.eclipse.core.runtime.Platform;
 import org.eclipse.jface.text.DocumentEvent;
 import org.eclipse.jface.text.IDocument;
 import org.eclipse.jface.text.IDocumentExtension;
 import org.eclipse.jface.text.IDocumentListener;
 import org.eclipse.jface.text.ITextInputListener;
 import org.eclipse.jface.text.Position;
 import org.eclipse.jface.text.source.projection.IProjectionListener;
 import org.eclipse.jface.text.source.projection.ProjectionAnnotation;
 import org.eclipse.jface.text.source.projection.ProjectionAnnotationModel;
 import org.eclipse.jface.text.source.projection.ProjectionViewer;
 import org.eclipse.swt.graphics.FontMetrics;
 import org.eclipse.swt.graphics.GC;
 import org.eclipse.swt.graphics.Rectangle;
 import org.eclipse.swt.widgets.Canvas;
 import org.eclipse.wst.dtd.core.internal.DTDFile;
 import org.eclipse.wst.dtd.core.internal.DTDNode;
 import org.eclipse.wst.dtd.core.internal.TopLevelNode;
 import org.eclipse.wst.dtd.core.internal.document.DTDModelImpl;
 import org.eclipse.wst.dtd.core.internal.event.IDTDFileListener;
 import org.eclipse.wst.dtd.core.internal.event.NodesEvent;
 import org.eclipse.wst.dtd.ui.internal.Logger;
 import org.eclipse.wst.sse.core.StructuredModelManager;
 import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
 import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion;
 import org.eclipse.wst.sse.ui.internal.projection.IStructuredTextFoldingProvider;
 import org.w3c.dom.Node;

 /**
  * Updates the projection model of a structured model for DTD.
  */
 public class StructuredTextFoldingProviderDTD implements IStructuredTextFoldingProvider, IProjectionListener, IDTDFileListener, ITextInputListener {
 	private final static boolean debugProjectionPerf = "true".equalsIgnoreCase(Platform.getDebugOption("org.eclipse.wst.dtd.ui/projectionperf")); //$NON-NLS-1$ //$NON-NLS-2$

 	private class TagProjectionAnnotation extends ProjectionAnnotation {
 		private boolean fIsVisible = false; /* workaround for BUG85874 */
 		private Node fNode;

 		public TagProjectionAnnotation(Node node, boolean isCollapsed) {
 			super(isCollapsed);
 			fNode = node;
 		}

 		public Node getNode() {
 			return fNode;
 		}

 		public void setNode(Node node) {
 			fNode = node;
 		}

 		/**
 		 * Does not paint hidden annotations. Annotations are hidden when they
 		 * only span one line.
 		 *
 		 * @see ProjectionAnnotation#paint(org.eclipse.swt.graphics.GC,
 		 *      org.eclipse.swt.widgets.Canvas,
 		 *      org.eclipse.swt.graphics.Rectangle)
 		 */
 		public void paint(GC gc, Canvas canvas, Rectangle rectangle) {
 			/* workaround for BUG85874 */
 			/*
 			 * only need to check annotations that are expanded because hidden
 			 * annotations should never have been given the chance to
 			 * collapse.
 			 */
 			if (!isCollapsed()) {
 				// working with rectangle, so line height
 				FontMetrics metrics = gc.getFontMetrics();
 				if (metrics != null) {
 					// do not draw annotations that only span one line and
 					// mark them as not visible
 					if ((rectangle.height / metrics.getHeight()) <= 1) {
 						fIsVisible = false;
 						return;
 					}
 				}
 			}
 			fIsVisible = true;
 			super.paint(gc, canvas, rectangle);
 		}

 		/*
 		 * (non-Javadoc)
 		 *
 		 * @see org.eclipse.jface.text.source.projection.ProjectionAnnotation#markCollapsed()
 		 */
 		public void markCollapsed() {
 			/* workaround for BUG85874 */
 			// do not mark collapsed if annotation is not visible
 			if (fIsVisible)
 				super.markCollapsed();
 		}
 	}

 	/**
 	 * Listens to document to be aware of when to update the projection
 	 * annotation model.
 	 */
 	class DocumentListener implements IDocumentListener {
 		public void documentAboutToBeChanged(DocumentEvent event) {
 			if (fDocument == event.getDocument())
 				fIsDocumentChanging = true;
 		}

 		public void documentChanged(DocumentEvent event) {
 			// register a post notification replace so that projection
 			// annotation model will be updated after all documentChanged
 			// listeners have been notified
 			IDocument document = event.getDocument();
 			if (document instanceof IDocumentExtension && fDocument == document) {
 				if (fViewer != null && fQueuedNodeChanges != null && !fQueuedNodeChanges.isEmpty()) {
 					((IDocumentExtension) document).registerPostNotificationReplace(this, new PostDocumentChangedListener());
 				}
 			}
 		}
 	}

 	/**
 	 * Essentially a post document changed listener because it is called after
 	 * documentchanged has been fired.
 	 */
 	class PostDocumentChangedListener implements IDocumentExtension.IReplace {
 		public void perform(IDocument document, IDocumentListener owner) {
 			applyAnnotationModelChanges();
 			fIsDocumentChanging = false;
 		}
 	}

 	/**
 	 * Contains node and an indication on how it changed
 	 */
 	class NodeChange {
 		static final int ADD = 1;
 		static final int REMOVE = 2;

 		private Node fNode;
 		private int fChangeType;

 		public NodeChange(Node node, int changeType) {
 			fNode = node;
 			fChangeType = changeType;
 		}

 		public Node getNode() {
 			return fNode;
 		}

 		public int getChangeType() {
 			return fChangeType;
 		}
 	}

 	IDocument fDocument;
 	ProjectionViewer fViewer;
 	private boolean fProjectionNeedsToBeEnabled = false;
 	/**
 	 * Listener to fProjectionViewer's document
 	 */
 	private IDocumentListener fDocumentListener;
 	/**
 	 * Indicates whether or not document is in the middle of changing
 	 */
 	boolean fIsDocumentChanging = false;
 	/**
 	 * List of changed nodes that need to be recalculated
 	 */
 	List fQueuedNodeChanges = null;

 	/**
 	 * Processes all the queued node changes and updates projection annotation
 	 * model.
 	 */
 	void applyAnnotationModelChanges() {
 		if (fViewer != null && fQueuedNodeChanges != null && !fQueuedNodeChanges.isEmpty()) {
 			ProjectionAnnotationModel annotationModel = fViewer.getProjectionAnnotationModel();

 			// go through all the pending annotation changes and apply them to
 			// the projection annotation model
 			while (!fQueuedNodeChanges.isEmpty()) {
 				NodeChange changes = (NodeChange) fQueuedNodeChanges.remove(0);
 				if (changes.getChangeType() == NodeChange.ADD) {
 					// add
 					Node node = changes.getNode();
 					Position newPos = createProjectionPosition(node);
 					if (newPos != null) {
 						TagProjectionAnnotation newAnnotation = new TagProjectionAnnotation(node, false);
 						// add to map containing annotations to add
 						try {
 							annotationModel.addAnnotation(newAnnotation, newPos);
 						}
 						catch (Exception e) {
 							// if anything goes wrong, log it and continue
 							Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
 						}
 					}
 				}
 				else if (changes.getChangeType() == NodeChange.REMOVE) {
 					// remove
 					Node node = changes.getNode();
 					TagProjectionAnnotation anno = findExistingAnnotation(node);
 					if (anno != null) {
 						try {
 							annotationModel.removeAnnotation(anno);
 						}
 						catch (Exception e) {
 							// if anything goes wrong, log it and continue
 							Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
 						}
 					}
 				}
 			}
 			fQueuedNodeChanges = null;
 		}
 	}

 	/**
 	 * Goes through every node creates projection annotation if needed
 	 *
 	 * @param DTDFile
 	 *            assumes file is not null
 	 */
 	private void addAllAnnotations(DTDFile file) {
 		long start = System.currentTimeMillis();

 		List nodes = file.getNodes();
 		Iterator it = nodes.iterator();
 		while (it.hasNext()) {
 			DTDNode node = (DTDNode) it.next();
 			Position newPos = createProjectionPosition(node);
 			if (newPos != null) {
 				TagProjectionAnnotation newAnnotation = new TagProjectionAnnotation(node, false);
 				// add to map containing annotations to add
 				fViewer.getProjectionAnnotationModel().addAnnotation(newAnnotation, newPos);
 			}
 		}

 		if (debugProjectionPerf) {
 			long end = System.currentTimeMillis();
 			System.out.println("StructuredTextFoldingProviderDTD.addAllAnnotations: " + (end - start)); //$NON-NLS-1$
 		}
 	}

 	/**
 	 * Create a projection position from the given node. Able to get
 	 * projection position if node isNodeProjectable.
 	 *
 	 * @param node
 	 * @return null if no projection position possible, a Position otherwise
 	 */
 	private Position createProjectionPosition(Node node) {
 		Position pos = null;
 		if (isNodeProjectable(node) && node instanceof IndexedRegion) {
 			IDocument document = fViewer.getDocument();
 			if (document != null) {
 				IndexedRegion inode = (IndexedRegion) node;
 				int start = inode.getStartOffset();
 				int end = inode.getEndOffset();
 				if (start >= 0 && start < end) {
 					pos = new Position(start, end - start);
 				}
 			}
 		}
 		return pos;
 	}

 	/**
 	 * Searches through projection annotation model and retrieves
 	 * TagProjectionAnnotation for node
 	 *
 	 * @param node
 	 * @return TagProjectionAnnotation for node or null if could not be found
 	 */
 	private TagProjectionAnnotation findExistingAnnotation(Node node) {
 		TagProjectionAnnotation anno = null;

 		if (node != null) {
 			Iterator it = fViewer.getProjectionAnnotationModel().getAnnotationIterator();
 			while (it.hasNext() && anno == null) {
 				TagProjectionAnnotation a = (TagProjectionAnnotation) it.next();
 				if (node.equals(a.getNode()))
 					anno = a;
 			}
 		}
 		return anno;
 	}

 	/**
 	 * Get the dtd file for the fDocument
 	 *
 	 * @return DTDFile if it exists, null otherwise
 	 */
 	private DTDFile getDTDFile() {
 		DTDFile dtdFile = null;

 		if (fDocument != null) {
 			IStructuredModel sModel = null;
 			try {
 				sModel = StructuredModelManager.getModelManager().getExistingModelForRead(fDocument);
 				if (sModel instanceof DTDModelImpl) {
 					dtdFile = ((DTDModelImpl) sModel).getDTDFile();
 				}
 			}
 			finally {
 				if (sModel != null) {
 					sModel.releaseFromRead();
 				}
 			}
 		}
 		return dtdFile;
 	}

 	/**
 	 * Initialize this provider with the correct document. Assumes projection
 	 * is enabled. (otherwise, only install would have been called)
 	 */
 	public void initialize() {
 		if (!isInstalled())
 			return;

 		// remove old info
 		projectionDisabled();

 		fDocument = fViewer.getDocument();
 		DTDFile file = getDTDFile();

 		if (fDocument != null && file != null && fViewer.getProjectionAnnotationModel() != null) {
 			if (fDocumentListener == null)
 				fDocumentListener = new DocumentListener();

 			fDocument.addDocumentListener(fDocumentListener);

 			// add dtd file listener to new dtd file
 			file.addDTDFileListener(this);

 			addAllAnnotations(file);
 		}
 		fProjectionNeedsToBeEnabled = false;
 	}

 	/**
 	 * Associate a ProjectionViewer with this IStructuredTextFoldingProvider
 	 *
 	 * @param viewer
 	 */
 	public void install(ProjectionViewer viewer) {
 		// uninstall before trying to install new viewer
 		if (isInstalled()) {
 			uninstall();
 		}
 		fViewer = viewer;
 		fViewer.addProjectionListener(this);
 		fViewer.addTextInputListener(this);
 	}

 	private boolean isInstalled() {
 		return fViewer != null;
 	}

 	/**
 	 * Returns true if node is a node type able to fold
 	 *
 	 * @param node
 	 * @return boolean true if node is projectable, false otherwise
 	 */
 	private boolean isNodeProjectable(Node node) {
 		if (node != null) {
 			if (node instanceof TopLevelNode)
 				return true;
 		}
 		return false;
 	}

 	public void nodeChanged(DTDNode node) {
 		/*
 		 * Don't believe this is necessary (used to need it to only add
 		 * projection annotations to elements that span more than one line,
 		 * but now just always add projection annotation)
 		 */
 		// long start = System.currentTimeMillis();
 		// // recalculate projection annotations for node
 		// // check if this was even a projectable node to start with
 		// if (isNodeProjectable(node)) {
 		// // find the existing annotation
 		// TagProjectionAnnotation anno = findExistingAnnotation(node);
 		// // if able to project node see if projection annotation was
 		// // already created and create new if needed
 		// Position newPos = createProjectionPosition(node);
 		// if (newPos != null && anno == null) {
 		// TagProjectionAnnotation newAnnotation = new
 		// TagProjectionAnnotation(node, false);
 		// // add to map containing annotations to add
 		// fViewer.getProjectionAnnotationModel().addAnnotation(newAnnotation,
 		// newPos);
 		// }
 		// // if not able to project node see if projection annotation was
 		// // already created and remove it
 		// if (newPos == null && anno != null) {
 		// fViewer.getProjectionAnnotationModel().removeAnnotation(anno);
 		// }
 		// }
 		//
 		// long end = System.currentTimeMillis();
 		// if (debugProjectionPerf) {
 		// String nodeName = node != null ? node.getNodeName() : "null";
 		// //$NON-NLS-1$
 		// System.out.println("StructuredTextFoldingProviderDTD.nodeChanged ("
 		// + nodeName + "):" + (end - start)); //$NON-NLS-1$ //$NON-NLS-2$
 		// }
 	}

 	public void nodesAdded(NodesEvent event) {
 		long start = System.currentTimeMillis();

 		processNodesEvent(event, NodeChange.ADD);

 		if (debugProjectionPerf) {
 			long end = System.currentTimeMillis();
 			System.out.println("StructuredTextFoldingProviderDTD.nodesAdded: " + (end - start)); //$NON-NLS-1$
 		}
 	}

 	/**
 	 * Goes through every changed node in event and add to queue of node
 	 * changes that will be recalculated for projection annotation model.
 	 *
 	 * @param event
 	 * @param changeType
 	 */
 	private void processNodesEvent(NodesEvent event, int changeType) {
 		List nodes = event.getNodes();
 		Iterator it = nodes.iterator();
 		while (it.hasNext()) {
 			DTDNode node = (DTDNode) it.next();
 			if (isNodeProjectable(node)) {
 				if (fQueuedNodeChanges == null) {
 					fQueuedNodeChanges = new ArrayList();
 				}

 				int existingIndex = fQueuedNodeChanges.indexOf(node);
 				if (existingIndex > -1) {
 					// node is already queued up
 					NodeChange existingChange = (NodeChange) fQueuedNodeChanges.remove(existingIndex);
 					// don't add if added then removed node or vice versa
 					if (existingChange.getChangeType() == changeType) {
 						NodeChange newChange = new NodeChange(node, changeType);
 						fQueuedNodeChanges.add(newChange);
 					}
 				}
 				else {
 					// not queued up yet, so queue node
 					NodeChange newChange = new NodeChange(node, changeType);
 					fQueuedNodeChanges.add(newChange);
 				}
 			}
 		}
 		// if document isn't changing, go ahead and apply it
 		if (!fIsDocumentChanging) {
 			applyAnnotationModelChanges();
 		}
 	}

 	public void nodesRemoved(NodesEvent event) {
 		long start = System.currentTimeMillis();

 		processNodesEvent(event, NodeChange.REMOVE);

 		if (debugProjectionPerf) {
 			long end = System.currentTimeMillis();
 			System.out.println("StructuredTextFoldingProviderDTD.nodesRemoved: " + (end - start)); //$NON-NLS-1$
 		}
 	}

 	public void projectionDisabled() {
 		DTDFile file = getDTDFile();
 		if (file != null) {
 			file.removeDTDFileListener(this);
 		}

 		// remove document listener
 		if (fDocumentListener != null && fDocument != null) {
 			fDocument.removeDocumentListener(fDocumentListener);
 			fDocument = null;

 			// clear out list of queued changes since it may no longer be
 			// accurate
 			if (fQueuedNodeChanges != null) {
 				fQueuedNodeChanges.clear();
 				fQueuedNodeChanges = null;
 			}
 		}

 		fDocument = null;
 		fProjectionNeedsToBeEnabled = false;
 	}

 	public void projectionEnabled() {
 		initialize();
 	}

 	public void inputDocumentAboutToBeChanged(IDocument oldInput, IDocument newInput) {
 		// if folding is enabled and new document is going to be a totally
 		// different document, disable projection
 		if (fDocument != null && fDocument != newInput) {
 			// disable projection and disconnect everything
 			projectionDisabled();
 			fProjectionNeedsToBeEnabled = true;
 		}
 	}

 	public void inputDocumentChanged(IDocument oldInput, IDocument newInput) {
 		// if projection was previously enabled before input document changed
 		// and new document is different than old document
 		if (fProjectionNeedsToBeEnabled && fDocument == null && newInput != null) {
 			projectionEnabled();
 			fProjectionNeedsToBeEnabled = false;
 		}
 	}

 	/**
 	 * Disconnect this IStructuredTextFoldingProvider from projection viewer
 	 */
 	public void uninstall() {
 		if (isInstalled()) {
 			projectionDisabled();

 			fViewer.removeProjectionListener(this);
 			fViewer.addTextInputListener(this);
 			fViewer = null;
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2005 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
	*
	*******************************************************************************/
	package org.eclipse.wst.dtd.ui.internal.projection;

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

	import org.eclipse.core.runtime.Platform;
	import org.eclipse.jface.text.DocumentEvent;
	import org.eclipse.jface.text.IDocument;
	import org.eclipse.jface.text.IDocumentExtension;
	import org.eclipse.jface.text.IDocumentListener;
	import org.eclipse.jface.text.ITextInputListener;
	import org.eclipse.jface.text.Position;
	import org.eclipse.jface.text.source.projection.IProjectionListener;
	import org.eclipse.jface.text.source.projection.ProjectionAnnotation;
	import org.eclipse.jface.text.source.projection.ProjectionAnnotationModel;
	import org.eclipse.jface.text.source.projection.ProjectionViewer;
	import org.eclipse.swt.graphics.FontMetrics;
	import org.eclipse.swt.graphics.GC;
	import org.eclipse.swt.graphics.Rectangle;
	import org.eclipse.swt.widgets.Canvas;
	import org.eclipse.wst.dtd.core.internal.DTDFile;
	import org.eclipse.wst.dtd.core.internal.DTDNode;
	import org.eclipse.wst.dtd.core.internal.TopLevelNode;
	import org.eclipse.wst.dtd.core.internal.document.DTDModelImpl;
	import org.eclipse.wst.dtd.core.internal.event.IDTDFileListener;
	import org.eclipse.wst.dtd.core.internal.event.NodesEvent;
	import org.eclipse.wst.dtd.ui.internal.Logger;
	import org.eclipse.wst.sse.core.StructuredModelManager;
	import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
	import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion;
	import org.eclipse.wst.sse.ui.internal.projection.IStructuredTextFoldingProvider;
	import org.w3c.dom.Node;

	/**
	* Updates the projection model of a structured model for DTD.
	*/
	public class StructuredTextFoldingProviderDTD implements IStructuredTextFoldingProvider, IProjectionListener, IDTDFileListener, ITextInputListener {
	private final static boolean debugProjectionPerf = "true".equalsIgnoreCase(Platform.getDebugOption("org.eclipse.wst.dtd.ui/projectionperf")); //$NON-NLS-1$ //$NON-NLS-2$

	private class TagProjectionAnnotation extends ProjectionAnnotation {
	private boolean fIsVisible = false; /* workaround for BUG85874 */
	private Node fNode;

	public TagProjectionAnnotation(Node node, boolean isCollapsed) {
	super(isCollapsed);
	fNode = node;
	}

	public Node getNode() {
	return fNode;
	}

	public void setNode(Node node) {
	fNode = node;
	}

	/**
	* Does not paint hidden annotations. Annotations are hidden when they
	* only span one line.
	*
	* @see ProjectionAnnotation#paint(org.eclipse.swt.graphics.GC,
	* org.eclipse.swt.widgets.Canvas,
	* org.eclipse.swt.graphics.Rectangle)
	*/
	public void paint(GC gc, Canvas canvas, Rectangle rectangle) {
	/* workaround for BUG85874 */
	/*
	* only need to check annotations that are expanded because hidden
	* annotations should never have been given the chance to
	* collapse.
	*/
	if (!isCollapsed()) {
	// working with rectangle, so line height
	FontMetrics metrics = gc.getFontMetrics();
	if (metrics != null) {
	// do not draw annotations that only span one line and
	// mark them as not visible
	if ((rectangle.height / metrics.getHeight()) <= 1) {
	fIsVisible = false;
	return;
	}
	}
	}
	fIsVisible = true;
	super.paint(gc, canvas, rectangle);
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.jface.text.source.projection.ProjectionAnnotation#markCollapsed()
	*/
	public void markCollapsed() {
	/* workaround for BUG85874 */
	// do not mark collapsed if annotation is not visible
	if (fIsVisible)
	super.markCollapsed();
	}
	}

	/**
	* Listens to document to be aware of when to update the projection
	* annotation model.
	*/
	class DocumentListener implements IDocumentListener {
	public void documentAboutToBeChanged(DocumentEvent event) {
	if (fDocument == event.getDocument())
	fIsDocumentChanging = true;
	}

	public void documentChanged(DocumentEvent event) {
	// register a post notification replace so that projection
	// annotation model will be updated after all documentChanged
	// listeners have been notified
	IDocument document = event.getDocument();
	if (document instanceof IDocumentExtension && fDocument == document) {
	if (fViewer != null && fQueuedNodeChanges != null && !fQueuedNodeChanges.isEmpty()) {
	((IDocumentExtension) document).registerPostNotificationReplace(this, new PostDocumentChangedListener());
	}
	}
	}
	}

	/**
	* Essentially a post document changed listener because it is called after
	* documentchanged has been fired.
	*/
	class PostDocumentChangedListener implements IDocumentExtension.IReplace {
	public void perform(IDocument document, IDocumentListener owner) {
	applyAnnotationModelChanges();
	fIsDocumentChanging = false;
	}
	}

	/**
	* Contains node and an indication on how it changed
	*/
	class NodeChange {
	static final int ADD = 1;
	static final int REMOVE = 2;

	private Node fNode;
	private int fChangeType;

	public NodeChange(Node node, int changeType) {
	fNode = node;
	fChangeType = changeType;
	}

	public Node getNode() {
	return fNode;
	}

	public int getChangeType() {
	return fChangeType;
	}
	}

	IDocument fDocument;
	ProjectionViewer fViewer;
	private boolean fProjectionNeedsToBeEnabled = false;
	/**
	* Listener to fProjectionViewer's document
	*/
	private IDocumentListener fDocumentListener;
	/**
	* Indicates whether or not document is in the middle of changing
	*/
	boolean fIsDocumentChanging = false;
	/**
	* List of changed nodes that need to be recalculated
	*/
	List fQueuedNodeChanges = null;

	/**
	* Processes all the queued node changes and updates projection annotation
	* model.
	*/
	void applyAnnotationModelChanges() {
	if (fViewer != null && fQueuedNodeChanges != null && !fQueuedNodeChanges.isEmpty()) {
	ProjectionAnnotationModel annotationModel = fViewer.getProjectionAnnotationModel();

	// go through all the pending annotation changes and apply them to
	// the projection annotation model
	while (!fQueuedNodeChanges.isEmpty()) {
	NodeChange changes = (NodeChange) fQueuedNodeChanges.remove(0);
	if (changes.getChangeType() == NodeChange.ADD) {
	// add
	Node node = changes.getNode();
	Position newPos = createProjectionPosition(node);
	if (newPos != null) {
	TagProjectionAnnotation newAnnotation = new TagProjectionAnnotation(node, false);
	// add to map containing annotations to add
	try {
	annotationModel.addAnnotation(newAnnotation, newPos);
	}
	catch (Exception e) {
	// if anything goes wrong, log it and continue
	Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
	}
	}
	}
	else if (changes.getChangeType() == NodeChange.REMOVE) {
	// remove
	Node node = changes.getNode();
	TagProjectionAnnotation anno = findExistingAnnotation(node);
	if (anno != null) {
	try {
	annotationModel.removeAnnotation(anno);
	}
	catch (Exception e) {
	// if anything goes wrong, log it and continue
	Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
	}
	}
	}
	}
	fQueuedNodeChanges = null;
	}
	}

	/**
	* Goes through every node creates projection annotation if needed
	*
	* @param DTDFile
	* assumes file is not null
	*/
	private void addAllAnnotations(DTDFile file) {
	long start = System.currentTimeMillis();

	List nodes = file.getNodes();
	Iterator it = nodes.iterator();
	while (it.hasNext()) {
	DTDNode node = (DTDNode) it.next();
	Position newPos = createProjectionPosition(node);
	if (newPos != null) {
	TagProjectionAnnotation newAnnotation = new TagProjectionAnnotation(node, false);
	// add to map containing annotations to add
	fViewer.getProjectionAnnotationModel().addAnnotation(newAnnotation, newPos);
	}
	}

	if (debugProjectionPerf) {
	long end = System.currentTimeMillis();
	System.out.println("StructuredTextFoldingProviderDTD.addAllAnnotations: " + (end - start)); //$NON-NLS-1$
	}
	}

	/**
	* Create a projection position from the given node. Able to get
	* projection position if node isNodeProjectable.
	*
	* @param node
	* @return null if no projection position possible, a Position otherwise
	*/
	private Position createProjectionPosition(Node node) {
	Position pos = null;
	if (isNodeProjectable(node) && node instanceof IndexedRegion) {
	IDocument document = fViewer.getDocument();
	if (document != null) {
	IndexedRegion inode = (IndexedRegion) node;
	int start = inode.getStartOffset();
	int end = inode.getEndOffset();
	if (start >= 0 && start < end) {
	pos = new Position(start, end - start);
	}
	}
	}
	return pos;
	}

	/**
	* Searches through projection annotation model and retrieves
	* TagProjectionAnnotation for node
	*
	* @param node
	* @return TagProjectionAnnotation for node or null if could not be found
	*/
	private TagProjectionAnnotation findExistingAnnotation(Node node) {
	TagProjectionAnnotation anno = null;

	if (node != null) {
	Iterator it = fViewer.getProjectionAnnotationModel().getAnnotationIterator();
	while (it.hasNext() && anno == null) {
	TagProjectionAnnotation a = (TagProjectionAnnotation) it.next();
	if (node.equals(a.getNode()))
	anno = a;
	}
	}
	return anno;
	}

	/**
	* Get the dtd file for the fDocument
	*
	* @return DTDFile if it exists, null otherwise
	*/
	private DTDFile getDTDFile() {
	DTDFile dtdFile = null;

	if (fDocument != null) {
	IStructuredModel sModel = null;
	try {
	sModel = StructuredModelManager.getModelManager().getExistingModelForRead(fDocument);
	if (sModel instanceof DTDModelImpl) {
	dtdFile = ((DTDModelImpl) sModel).getDTDFile();
	}
	}
	finally {
	if (sModel != null) {
	sModel.releaseFromRead();
	}
	}
	}
	return dtdFile;
	}

	/**
	* Initialize this provider with the correct document. Assumes projection
	* is enabled. (otherwise, only install would have been called)
	*/
	public void initialize() {
	if (!isInstalled())
	return;

	// remove old info
	projectionDisabled();

	fDocument = fViewer.getDocument();
	DTDFile file = getDTDFile();

	if (fDocument != null && file != null && fViewer.getProjectionAnnotationModel() != null) {
	if (fDocumentListener == null)
	fDocumentListener = new DocumentListener();

	fDocument.addDocumentListener(fDocumentListener);

	// add dtd file listener to new dtd file
	file.addDTDFileListener(this);

	addAllAnnotations(file);
	}
	fProjectionNeedsToBeEnabled = false;
	}

	/**
	* Associate a ProjectionViewer with this IStructuredTextFoldingProvider
	*
	* @param viewer
	*/
	public void install(ProjectionViewer viewer) {
	// uninstall before trying to install new viewer
	if (isInstalled()) {
	uninstall();
	}
	fViewer = viewer;
	fViewer.addProjectionListener(this);
	fViewer.addTextInputListener(this);
	}

	private boolean isInstalled() {
	return fViewer != null;
	}

	/**
	* Returns true if node is a node type able to fold
	*
	* @param node
	* @return boolean true if node is projectable, false otherwise
	*/
	private boolean isNodeProjectable(Node node) {
	if (node != null) {
	if (node instanceof TopLevelNode)
	return true;
	}
	return false;
	}

	public void nodeChanged(DTDNode node) {
	/*
	* Don't believe this is necessary (used to need it to only add
	* projection annotations to elements that span more than one line,
	* but now just always add projection annotation)
	*/
	// long start = System.currentTimeMillis();
	// // recalculate projection annotations for node
	// // check if this was even a projectable node to start with
	// if (isNodeProjectable(node)) {
	// // find the existing annotation
	// TagProjectionAnnotation anno = findExistingAnnotation(node);
	// // if able to project node see if projection annotation was
	// // already created and create new if needed
	// Position newPos = createProjectionPosition(node);
	// if (newPos != null && anno == null) {
	// TagProjectionAnnotation newAnnotation = new
	// TagProjectionAnnotation(node, false);
	// // add to map containing annotations to add
	// fViewer.getProjectionAnnotationModel().addAnnotation(newAnnotation,
	// newPos);
	// }
	// // if not able to project node see if projection annotation was
	// // already created and remove it
	// if (newPos == null && anno != null) {
	// fViewer.getProjectionAnnotationModel().removeAnnotation(anno);
	// }
	// }
	//
	// long end = System.currentTimeMillis();
	// if (debugProjectionPerf) {
	// String nodeName = node != null ? node.getNodeName() : "null";
	// //$NON-NLS-1$
	// System.out.println("StructuredTextFoldingProviderDTD.nodeChanged ("
	// + nodeName + "):" + (end - start)); //$NON-NLS-1$ //$NON-NLS-2$
	// }
	}

	public void nodesAdded(NodesEvent event) {
	long start = System.currentTimeMillis();

	processNodesEvent(event, NodeChange.ADD);

	if (debugProjectionPerf) {
	long end = System.currentTimeMillis();
	System.out.println("StructuredTextFoldingProviderDTD.nodesAdded: " + (end - start)); //$NON-NLS-1$
	}
	}

	/**
	* Goes through every changed node in event and add to queue of node
	* changes that will be recalculated for projection annotation model.
	*
	* @param event
	* @param changeType
	*/
	private void processNodesEvent(NodesEvent event, int changeType) {
	List nodes = event.getNodes();
	Iterator it = nodes.iterator();
	while (it.hasNext()) {
	DTDNode node = (DTDNode) it.next();
	if (isNodeProjectable(node)) {
	if (fQueuedNodeChanges == null) {
	fQueuedNodeChanges = new ArrayList();
	}

	int existingIndex = fQueuedNodeChanges.indexOf(node);
	if (existingIndex > -1) {
	// node is already queued up
	NodeChange existingChange = (NodeChange) fQueuedNodeChanges.remove(existingIndex);
	// don't add if added then removed node or vice versa
	if (existingChange.getChangeType() == changeType) {
	NodeChange newChange = new NodeChange(node, changeType);
	fQueuedNodeChanges.add(newChange);
	}
	}
	else {
	// not queued up yet, so queue node
	NodeChange newChange = new NodeChange(node, changeType);
	fQueuedNodeChanges.add(newChange);
	}
	}
	}
	// if document isn't changing, go ahead and apply it
	if (!fIsDocumentChanging) {
	applyAnnotationModelChanges();
	}
	}

	public void nodesRemoved(NodesEvent event) {
	long start = System.currentTimeMillis();

	processNodesEvent(event, NodeChange.REMOVE);

	if (debugProjectionPerf) {
	long end = System.currentTimeMillis();
	System.out.println("StructuredTextFoldingProviderDTD.nodesRemoved: " + (end - start)); //$NON-NLS-1$
	}
	}

	public void projectionDisabled() {
	DTDFile file = getDTDFile();
	if (file != null) {
	file.removeDTDFileListener(this);
	}

	// remove document listener
	if (fDocumentListener != null && fDocument != null) {
	fDocument.removeDocumentListener(fDocumentListener);
	fDocument = null;

	// clear out list of queued changes since it may no longer be
	// accurate
	if (fQueuedNodeChanges != null) {
	fQueuedNodeChanges.clear();
	fQueuedNodeChanges = null;
	}
	}

	fDocument = null;
	fProjectionNeedsToBeEnabled = false;
	}

	public void projectionEnabled() {
	initialize();
	}

	public void inputDocumentAboutToBeChanged(IDocument oldInput, IDocument newInput) {
	// if folding is enabled and new document is going to be a totally
	// different document, disable projection
	if (fDocument != null && fDocument != newInput) {
	// disable projection and disconnect everything
	projectionDisabled();
	fProjectionNeedsToBeEnabled = true;
	}
	}

	public void inputDocumentChanged(IDocument oldInput, IDocument newInput) {
	// if projection was previously enabled before input document changed
	// and new document is different than old document
	if (fProjectionNeedsToBeEnabled && fDocument == null && newInput != null) {
	projectionEnabled();
	fProjectionNeedsToBeEnabled = false;
	}
	}

	/**
	* Disconnect this IStructuredTextFoldingProvider from projection viewer
	*/
	public void uninstall() {
	if (isInstalled()) {
	projectionDisabled();

	fViewer.removeProjectionListener(this);
	fViewer.addTextInputListener(this);
	fViewer = null;
	}
	}
	}