bundles/org.eclipse.rap.draw2d/src/org/eclipse/draw2d/DeferredUpdateManager.java

/*******************************************************************************
 * Copyright (c) 2000, 2010 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.draw2d;

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

import org.eclipse.swt.SWT;
import org.eclipse.swt.SWTException;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.widgets.Display;

import org.eclipse.draw2d.geometry.Rectangle;

/**
 * An UpdateManager that asynchronously updates the affected figures.
 */
public class DeferredUpdateManager extends UpdateManager {

	/**
	 * Calls {@link DeferredUpdateManager#performUpdate()}.
	 */
	protected class UpdateRequest implements Runnable {

		public UpdateRequest() {
			super();
		}

		/**
		 * Calls {@link DeferredUpdateManager#performUpdate()}.
		 */
		public void run() {
			performUpdate();
		}
	}

	private Rectangle damage;
	private Map dirtyRegions = new HashMap();

	private GraphicsSource graphicsSource;
	private List invalidFigures = new ArrayList();
	private IFigure root;
	private boolean updateQueued;

	private boolean updating;
	private boolean validating;
	private RunnableChain afterUpdate;

	private static class RunnableChain {
		RunnableChain next;
		Runnable run;

		RunnableChain(Runnable run, RunnableChain next) {
			this.run = run;
			this.next = next;
		}

		void run() {
			if (next != null)
				next.run();
			run.run();
		}
	}

	/**
	 * Empty constructor.
	 */
	public DeferredUpdateManager() {
	}

	/**
	 * Constructs a new DererredUpdateManager with the given GraphicsSource.
	 * 
	 * @param gs
	 *            the graphics source
	 */
	public DeferredUpdateManager(GraphicsSource gs) {
		setGraphicsSource(gs);
	}

	/**
	 * Adds a dirty region (defined by the rectangle <i>x, y, w, h</i>) to the
	 * update queue. If the figure isn't visible or either the width or height
	 * are 0, the method returns without queueing the dirty region.
	 * 
	 * @param figure
	 *            the figure that contains the dirty region
	 * @param x
	 *            the x coordinate of the dirty region
	 * @param y
	 *            the y coordinate of the dirty region
	 * @param w
	 *            the width of the dirty region
	 * @param h
	 *            the height of the dirty region
	 */
	public synchronized void addDirtyRegion(IFigure figure, int x, int y,
			int w, int h) {
		if (w == 0 || h == 0 || !figure.isShowing())
			return;

		Rectangle rect = (Rectangle) dirtyRegions.get(figure);
		if (rect == null) {
			rect = new Rectangle(x, y, w, h);
			dirtyRegions.put(figure, rect);
		} else
			rect.union(x, y, w, h);

		queueWork();
	}

	/**
	 * Adds the given figure to the update queue. Invalid figures will be
	 * validated before the damaged regions are repainted.
	 * 
	 * @param f
	 *            the invalid figure
	 */
	public synchronized void addInvalidFigure(IFigure f) {
		if (invalidFigures.contains(f))
			return;
		queueWork();
		invalidFigures.add(f);
	}

	/**
	 * Returns a Graphics object for the given region.
	 * 
	 * @param region
	 *            the region to be repainted
	 * @return the Graphics object
	 */
	protected Graphics getGraphics(Rectangle region) {
		if (graphicsSource == null)
			return null;
		return graphicsSource.getGraphics(region);
	}

	/**
	 * @since 3.10
	 */
	protected void paint(GC gc) {
		if (!validating) {
			SWTGraphics graphics = new SWTGraphics(gc);
			if (!updating) {
				/**
				 * If a paint occurs not as part of an update, we should notify
				 * that the region is being painted. Otherwise, notification
				 * already occurs in repairDamage().
				 */
				Rectangle rect = graphics.getClip(new Rectangle());
				HashMap map = new HashMap();
				map.put(root, rect);
				firePainting(rect, map);
			}
			performValidation();
			root.paint(graphics);
			graphics.dispose();
		} else {
			/*
			 * If figures are being validated then we can simply add a dirty
			 * region here and update will repaint this region with other dirty
			 * regions when it gets to painting. We can't paint if we're not
			 * sure that all figures are valid.
			 */
			addDirtyRegion(root, new Rectangle(gc.getClipping()));
		}
	}

	/**
	 * Performs the update. Validates the invalid figures and then repaints the
	 * dirty regions.
	 * 
	 * @see #validateFigures()
	 * @see #repairDamage()
	 */
	public synchronized void performUpdate() {
		if (isDisposed() || updating)
			return;
		updating = true;
		try {
			performValidation();
			updateQueued = false;
			repairDamage();
			if (afterUpdate != null) {
				RunnableChain chain = afterUpdate;
				afterUpdate = null;
				chain.run(); // chain may queue additional Runnable.
				if (afterUpdate != null)
					queueWork();
			}
		} finally {
			updating = false;
		}
	}

	/**
	 * @see UpdateManager#performValidation()
	 */
	public synchronized void performValidation() {
		if (invalidFigures.isEmpty() || validating)
			return;
		try {
			IFigure fig;
			validating = true;
			fireValidating();
			for (int i = 0; i < invalidFigures.size(); i++) {
				fig = (IFigure) invalidFigures.get(i);
				invalidFigures.set(i, null);
				fig.validate();
			}
		} finally {
			invalidFigures.clear();
			validating = false;
		}
	}

	/**
	 * Adds the given exposed region to the update queue and then performs the
	 * update.
	 * 
	 * @param exposed
	 *            the exposed region
	 */
	public synchronized void performUpdate(Rectangle exposed) {
		addDirtyRegion(root, exposed);
		performUpdate();
	}

	/**
	 * Posts an {@link UpdateRequest} using {@link Display#asyncExec(Runnable)}.
	 * If work has already been queued, a new request is not needed.
	 */
	protected void queueWork() {
		if (!updateQueued) {
			sendUpdateRequest();
			updateQueued = true;
		}
	}

	/**
	 * Fires the <code>UpdateRequest</code> to the current display
	 * asynchronously.
	 * 
	 * @since 3.2
	 */
	protected void sendUpdateRequest() {
		Display display = Display.getCurrent();
		if (display == null) {
			throw new SWTException(SWT.ERROR_THREAD_INVALID_ACCESS);
		}
		display.asyncExec(new UpdateRequest());
	}

	/**
	 * Releases the graphics object, which causes the GraphicsSource to flush.
	 * 
	 * @param graphics
	 *            the graphics object
	 */
	protected void releaseGraphics(Graphics graphics) {
		graphics.dispose();
		graphicsSource.flushGraphics(damage);
	}

	/**
	 * Repaints the dirty regions on the update queue and calls
	 * {@link UpdateManager#firePainting(Rectangle, Map)}, unless there are no
	 * dirty regions.
	 */
	protected void repairDamage() {
		Iterator keys = dirtyRegions.keySet().iterator();
		Rectangle contribution;
		IFigure figure;
		IFigure walker;

		while (keys.hasNext()) {
			figure = (IFigure) keys.next();
			walker = figure.getParent();
			contribution = (Rectangle) dirtyRegions.get(figure);
			// A figure can't paint beyond its own bounds
			contribution.intersect(figure.getBounds());
			while (!contribution.isEmpty() && walker != null) {
				walker.translateToParent(contribution);
				contribution.intersect(walker.getBounds());
				walker = walker.getParent();
			}
			if (damage == null)
				damage = new Rectangle(contribution);
			else
				damage.union(contribution);
		}

		if (!dirtyRegions.isEmpty()) {
			Map oldRegions = dirtyRegions;
			dirtyRegions = new HashMap();
			firePainting(damage, oldRegions);
		}

		if (damage != null && !damage.isEmpty()) {
			// ystem.out.println(damage);
			Graphics graphics = getGraphics(damage);
			if (graphics != null) {
				root.paint(graphics);
				releaseGraphics(graphics);
			}
		}
		damage = null;
	}

	/**
	 * Adds the given runnable and queues an update if an update is not under
	 * progress.
	 * 
	 * @param runnable
	 *            the runnable
	 */
	public synchronized void runWithUpdate(Runnable runnable) {
		afterUpdate = new RunnableChain(runnable, afterUpdate);
		if (!updating)
			queueWork();
	}

	/**
	 * Sets the graphics source.
	 * 
	 * @param gs
	 *            the graphics source
	 */
	public void setGraphicsSource(GraphicsSource gs) {
		graphicsSource = gs;
	}

	/**
	 * Sets the root figure.
	 * 
	 * @param figure
	 *            the root figure
	 */
	public void setRoot(IFigure figure) {
		root = figure;
	}

	/**
	 * Validates all invalid figures on the update queue and calls
	 * {@link UpdateManager#fireValidating()} unless there are no invalid
	 * figures.
	 */
	protected void validateFigures() {
		performValidation();
	}

}