plugins/org.eclipse.mylyn.docs.intent.client.ui/src/org/eclipse/mylyn/docs/intent/client/ui/editor/IntentReconcilingStrategy.java

/*******************************************************************************
 * Copyright (c) 2011 Obeo.
 * 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:
 *     Obeo - initial API and implementation
 *******************************************************************************/
package org.eclipse.mylyn.docs.intent.client.ui.editor;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.text.reconciler.DirtyRegion;
import org.eclipse.jface.text.reconciler.IReconcilingStrategy;
import org.eclipse.jface.text.reconciler.IReconcilingStrategyExtension;
import org.eclipse.jface.text.source.Annotation;
import org.eclipse.jface.text.source.projection.ProjectionAnnotation;
import org.eclipse.mylyn.docs.intent.client.ui.IntentEditorActivator;
import org.eclipse.mylyn.docs.intent.client.ui.editor.scanner.IntentPartitionScanner;
import org.eclipse.mylyn.docs.intent.client.ui.preferences.IntentPreferenceConstants;
import org.eclipse.swt.widgets.Display;

/**
 * This reconciling strategy will allow us to enable folding support in the Intent editor.
 * 
 * @author <a href="mailto:william.piers@obeo.fr">William Piers</a>
 */
public final class IntentReconcilingStrategy implements IReconcilingStrategy, IReconcilingStrategyExtension {

	/**
	 * This will hold the list of all annotations that have been added since the last reconciling.
	 */
	private final Map<Annotation, Position> addedAnnotations = new HashMap<Annotation, Position>();

	/** Current known positions of foldable block. */
	private final Map<Annotation, Position> currentAnnotations = new HashMap<Annotation, Position>();

	/**
	 * This will hold the list of all annotations that have been removed since the last reconciling.
	 */
	private final List<Annotation> deletedAnnotations = new ArrayList<Annotation>();

	/** Editor this provides folding support to. */
	private final IntentEditor editor;

	/**
	 * This will hold the list of all annotations that have been modified since the last reconciling.
	 */
	private final Map<Annotation, Position> modifiedAnnotations = new HashMap<Annotation, Position>();

	/** The document we'll seek foldable blocks in. */
	private IDocument document;

	/** Current offset. */
	private int offset;

	/**
	 * Pair matcher used to reconcile document.
	 */
	private IntentPairMatcher pairMatcher = new IntentPairMatcher();

	/**
	 * Instantiates the reconciling strategy for a given editor.
	 * 
	 * @param editor
	 *            Editor which we seek to provide folding support for.
	 */
	public IntentReconcilingStrategy(IntentEditor editor) {
		this.editor = editor;
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @see org.eclipse.jface.text.reconciler.IReconcilingStrategyExtension#initialReconcile()
	 */
	public void initialReconcile() {
		offset = 0;
		computePositions();
		updateFoldingStructure();
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @see org.eclipse.jface.text.reconciler.IReconcilingStrategy#reconcile(org.eclipse.jface.text.reconciler.DirtyRegion,
	 *      org.eclipse.jface.text.IRegion)
	 */
	public void reconcile(DirtyRegion dirtyRegion, IRegion subRegion) {
		reconcile(subRegion);
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @see org.eclipse.jface.text.reconciler.IReconcilingStrategy#reconcile(org.eclipse.jface.text.IRegion)
	 */
	public void reconcile(IRegion partition) {
		offset = partition.getOffset();
		computePositions();
		updateFoldingStructure();
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @see org.eclipse.jface.text.reconciler.IReconcilingStrategy#setDocument(org.eclipse.jface.text.IDocument)
	 */
	public void setDocument(IDocument document) {
		this.document = document;
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @see org.eclipse.jface.text.reconciler.IReconcilingStrategyExtension#setProgressMonitor(org.eclipse.core.runtime.IProgressMonitor)
	 */
	public void setProgressMonitor(IProgressMonitor monitor) {
		// none
	}

	/**
	 * This will compute the current block positions. The offset at which computations start is determined by
	 * {@link #offset}.
	 */
	private void computePositions() {
		deletedAnnotations.clear();
		modifiedAnnotations.clear();
		addedAnnotations.clear();
		deletedAnnotations.addAll(currentAnnotations.keySet());

		for (Map.Entry<Annotation, Position> entry : currentAnnotations.entrySet()) {
			final Position position = entry.getValue();
			if (position.getOffset() + position.getLength() < offset) {
				deletedAnnotations.remove(entry.getKey());
			}
		}
		try {
			boolean eof = seekBlockStart();
			int startOffset = offset;
			while (!eof) {
				offset++;
				// Case 1: Structural Content folding
				if (document.getLineOfOffset(startOffset) > 0
						&& document.getContentType(startOffset).equals(
								IntentPartitionScanner.INTENT_STRUCTURAL_CONTENT)) {
					IRegion match = pairMatcher.match(document, offset);
					if (match != null) {
						int endOffset = match.getOffset() + match.getLength() + 1;
						if (document.getNumberOfLines(startOffset, endOffset - startOffset) > 2) {
							createOrUpdateAnnotation(startOffset, endOffset - startOffset, false);
						}
					}
				} else if (document.getLineOfOffset(startOffset) > 0
						&& document.getContentType(startOffset).equals(
								IntentPartitionScanner.INTENT_MODELINGUNIT)) {
					// Case 2: Modeling Unit folding
					// Search for modeling unit end
					String documentZone = document.get().substring(startOffset);
					int endOffset = documentZone.indexOf("M@") + 2;
					if (endOffset > -1) {
						createOrUpdateAnnotation(startOffset - 1, endOffset,
								shouldCollapseModelingUnitByDefault());
					}
				}
				eof = seekBlockStart();
				startOffset = offset;
			}
		} catch (BadLocationException e) {
			// Nothing to do
		}
		for (Annotation deleted : deletedAnnotations) {
			currentAnnotations.remove(deleted);
		}
	}

	/**
	 * Eats chars away till we find a start char.
	 * 
	 * @return <code>true</code> if the end of file has been reached. <code>false</code> otherwise.
	 * @throws BadLocationException
	 *             Thrown if we try and get an out of range character. Should not happen.
	 */
	private boolean seekBlockStart() throws BadLocationException {
		char next = document.getChar(offset);
		char previous = ' ';
		boolean eof = offset + 1 >= document.getLength();
		boolean foundModelingUnit = false;
		while (!eof && next != '{' && !foundModelingUnit) {
			offset++;
			previous = next;
			next = document.getChar(offset);
			eof = offset + 1 == document.getLength();
			foundModelingUnit = next == 'M' && previous == '@';
		}
		return eof;
	}

	/**
	 * This will update lists {@link #deletedAnnotations}, {@link #addedAnnotations} and
	 * {@link #modifiedAnnotations} according to the given values.
	 * 
	 * @param newOffset
	 *            Offset of the text we want the annotation updated of.
	 * @param newLength
	 *            Length of the text we want the annotation updated of.
	 * @param initiallyCollapsed
	 *            Indicates that the created annotation should be folded from start.
	 * @throws BadLocationException
	 *             Thrown if we try and get an out of range character. Should not happen.
	 */
	private void createOrUpdateAnnotation(final int newOffset, final int newLength, boolean initiallyCollapsed)
			throws BadLocationException {
		boolean createAnnotation = true;
		final Map<Annotation, Position> copy = new HashMap<Annotation, Position>(currentAnnotations);
		final String text = document.get(newOffset, newLength);
		for (Iterator<Entry<Annotation, Position>> iterator = copy.entrySet().iterator(); iterator.hasNext();) {
			Entry<Annotation, Position> entry = iterator.next();
			// added checking to avoid same text elements to bo ignored
			if (entry.getKey().getText().equals(text) && entry.getValue().getOffset() == newOffset) {
				createAnnotation = false;
				final Position oldPosition = entry.getValue();
				if (oldPosition.getOffset() != newOffset || oldPosition.getLength() != newLength) {
					final Position newPosition = new Position(newOffset, newLength);
					modifiedAnnotations.put(entry.getKey(), newPosition);
					currentAnnotations.put(entry.getKey(), newPosition);
				}
				deletedAnnotations.remove(entry.getKey());
				break;
			}
		}
		if (createAnnotation) {
			Annotation annotation = null;
			annotation = new ProjectionAnnotation(initiallyCollapsed);
			annotation.setText(text);
			final Position position = new Position(newOffset, newLength);
			currentAnnotations.put(annotation, position);
			addedAnnotations.put(annotation, position);
		}
	}

	/**
	 * Updates the editor's folding structure.
	 */
	private void updateFoldingStructure() {
		Display.getDefault().asyncExec(new Runnable() {
			public void run() {
				editor.updateFoldingStructure(addedAnnotations, deletedAnnotations, modifiedAnnotations);
			}
		});
	}

	/**
	 * Indicates whether Modeling units should be initially collapsed in the Intent editor.
	 * 
	 * @return true if Modeling units should be initially collapsed in the Intent editor, false otherwise
	 */
	private boolean shouldCollapseModelingUnitByDefault() {
		// We should collapse modeling units if

		return
		// - preference say so
		IntentEditorActivator.getDefault().getPreferenceStore()
				.getBoolean(IntentPreferenceConstants.COLLAPSE_MODELING_UNITS)
				&&
				// - and this is editor opening
				!editor.isInitialFoldingStructureComplete();
	}

}