path: root/plugins/org.eclipse.gmf.runtime.lite.svg/src/org/eclipse/gmf/runtime/lite/svg/SVGFigure.java

/**
 * Copyright (c) 2008 Borland Software Corporation
 * 
 * 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:
 *    Dmitry Stadnik - initial API and implementation
 */
package org.eclipse.gmf.runtime.lite.svg;

import java.awt.RenderingHints;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.awt.image.WritableRaster;
import java.io.IOException;
import java.util.WeakHashMap;

import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;

import org.apache.batik.bridge.BridgeContext;
import org.apache.batik.dom.svg.SAXSVGDocumentFactory;
import org.apache.batik.util.XMLResourceDescriptor;
import org.eclipse.draw2d.Figure;
import org.eclipse.draw2d.Graphics;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.gmf.internal.runtime.lite.svg.Activator;
import org.eclipse.gmf.internal.runtime.lite.svg.InferringNamespaceContext;
import org.eclipse.gmf.internal.runtime.lite.svg.SimpleImageTranscoder;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Device;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.PaletteData;
import org.eclipse.swt.widgets.Display;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

public class SVGFigure extends Figure {

	private String uri;
	private boolean failedToLoadDocument, specifyCanvasWidth = true, specifyCanvasHeight = true;
	private SimpleImageTranscoder transcoder;

	private static WeakHashMap<String, Document> documentsMap = new WeakHashMap<String, Document>();
	
	public final String getURI() {
		return uri;
	}

	public final void setURI(String uri) {
		setURI(uri, true);
	}

	public void setURI(String uri, boolean loadOnDemand) {
		this.uri = uri;
		transcoder = null;
		failedToLoadDocument = false;
		if (loadOnDemand) {
			loadDocument();
		}
	}

	private void loadDocument() {
		transcoder = null;
		failedToLoadDocument = true;
		if (uri == null) {
			return;
		}
		String parser = XMLResourceDescriptor.getXMLParserClassName();
		SAXSVGDocumentFactory factory = new SAXSVGDocumentFactory(parser);
		try {
			Document document;
			if (documentsMap.containsKey(uri))
				 document = documentsMap.get(uri);
			else {
				document = factory.createDocument(uri);
				documentsMap.put(uri, document);
			}
			transcoder = new SimpleImageTranscoder(document);
			failedToLoadDocument = false;
		} catch (IOException e) {
			Activator.logError("Error loading SVG file", e);
		}
	}

	
	protected final Document getDocument() {
		if (failedToLoadDocument) {
			return null;
		}
		if (transcoder == null) {
			loadDocument();
		}
		return transcoder == null ? null : transcoder.getDocument();
	}

	/**
	 * Returns true if document was loaded without errors; tries to load document if needed.
	 */
	public final boolean checkContentAvailable() {
		return getDocument() != null;
	}

	private XPath getXPath() {
		XPath xpath = XPathFactory.newInstance().newXPath();
		xpath.setNamespaceContext(new InferringNamespaceContext(getDocument().getDocumentElement()));
		return xpath;
	}

	/**
	 * Executes XPath query over the SVG document.
	 */
	protected final NodeList getNodes(String query) {
		Document document = getDocument();
		if (document != null) {
			try {
				return (NodeList) getXPath().evaluate(query, document, XPathConstants.NODESET);
			} catch (XPathExpressionException e) {
				throw new RuntimeException(e);
			}
		}
		return null;
	}

	/**
	 * Reads color value from the document.
	 */
	protected Color getColor(Element element, String attributeName) {
		if (getDocument() == null || getDocument() != element.getOwnerDocument()) {
			return null;
		}
		Color color = null;
		// Make sure that CSSEngine is available.
		BridgeContext ctx = transcoder.initCSSEngine();
		try {
			color = SVGUtils.toSWTColor(element, attributeName);
		} finally {
			if (ctx != null) {
				ctx.dispose();
			}
		}
		return color;
	}

	@Override
	protected void paintFigure(Graphics graphics) {
		super.paintFigure(graphics);
		Document document = getDocument();
		if (document == null) {
			return;
		}
		Image image = null;
		try {
			Rectangle r = getClientArea();
			transcoder.setCanvasSize(specifyCanvasWidth ? r.width : -1, specifyCanvasHeight ? r.height : -1);
			updateRenderingHints(graphics);
			BufferedImage awtImage = transcoder.getBufferedImage();
			if (awtImage != null) {
				image = toSWT(Display.getCurrent(), awtImage);
				graphics.drawImage(image, r.x, r.y);
			}
		} finally {
			if (image != null) {
				image.dispose();
			}
		}
	}

	private void updateRenderingHints(Graphics graphics) {
		{
			int aa = SWT.DEFAULT;
			try {
				aa = graphics.getAntialias();
			} catch (Exception e) {
				// not supported
			}
			Object aaHint;
			if (aa == SWT.ON) {
				aaHint = RenderingHints.VALUE_ANTIALIAS_ON;
			} else if (aa == SWT.OFF) {
				aaHint = RenderingHints.VALUE_ANTIALIAS_OFF;
			} else {
				aaHint = RenderingHints.VALUE_ANTIALIAS_DEFAULT;
			}
			if (transcoder.getRenderingHints().get(RenderingHints.KEY_ANTIALIASING) != aaHint) {
				transcoder.getRenderingHints().put(RenderingHints.KEY_ANTIALIASING, aaHint);
				transcoder.contentChanged();
			}
		}
		{
			int aa = SWT.DEFAULT;
			try {
				aa = graphics.getTextAntialias();
			} catch (Exception e) {
				// not supported
			}
			Object aaHint;
			if (aa == SWT.ON) {
				aaHint = RenderingHints.VALUE_TEXT_ANTIALIAS_ON;
			} else if (aa == SWT.OFF) {
				aaHint = RenderingHints.VALUE_TEXT_ANTIALIAS_OFF;
			} else {
				aaHint = RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT;
			}
			if (transcoder.getRenderingHints().get(RenderingHints.KEY_TEXT_ANTIALIASING) != aaHint) {
				transcoder.getRenderingHints().put(RenderingHints.KEY_TEXT_ANTIALIASING, aaHint);
				transcoder.contentChanged();
			}
		}
	}

	/**
	 * Converts an AWT based buffered image into an SWT <code>Image</code>. This will always return an <code>Image</code> that
	 * has 24 bit depth regardless of the type of AWT buffered image that is passed into the method.
	 * 
	 * @param awtImage the {@link java.awt.image.BufferedImage} to be converted to an <code>Image</code>
	 * @return an <code>Image</code> that represents the same image data as the AWT <code>BufferedImage</code> type.
	 */
	private static org.eclipse.swt.graphics.Image toSWT(Device device, BufferedImage awtImage) {
		// We can force bitdepth to be 24 bit because BufferedImage getRGB
		// allows us to always retrieve 24 bit data regardless of source color depth.
		PaletteData palette = new PaletteData(0xFF0000, 0xFF00, 0xFF);
		ImageData swtImageData = new ImageData(awtImage.getWidth(), awtImage.getHeight(), 24, palette);
		// Ensure scansize is aligned on 32 bit.
		int scansize = (((awtImage.getWidth() * 3) + 3) * 4) / 4;
		WritableRaster alphaRaster = awtImage.getAlphaRaster();
		byte[] alphaBytes = new byte[awtImage.getWidth()];
		for (int y = 0; y < awtImage.getHeight(); y++) {
			int[] buff = awtImage.getRGB(0, y, awtImage.getWidth(), 1, null, 0, scansize);
			swtImageData.setPixels(0, y, awtImage.getWidth(), buff, 0);
			if (alphaRaster != null) {
				int[] alpha = alphaRaster.getPixels(0, y, awtImage.getWidth(), 1, (int[]) null);
				for (int i = 0; i < awtImage.getWidth(); i++) {
					alphaBytes[i] = (byte) alpha[i];
				}
				swtImageData.setAlphas(0, y, awtImage.getWidth(), alphaBytes, 0);
			}
		}
		return new org.eclipse.swt.graphics.Image(device, swtImageData);
	}

	public final Rectangle2D getAreaOfInterest() {
		getDocument();
		return transcoder == null ? null : transcoder.getCanvasAreaOfInterest();
	}

	public void setAreaOfInterest(Rectangle2D value) {
		getDocument();
		if (transcoder != null) {
			transcoder.setCanvasAreaOfInterest(value);
		}
		repaint();
	}

	public final boolean isSpecifyCanvasWidth() {
		return specifyCanvasWidth;
	}

	public void setSpecifyCanvasWidth(boolean specifyCanvasWidth) {
		this.specifyCanvasWidth = specifyCanvasWidth;
		contentChanged();
	}

	public final boolean isSpecifyCanvasHeight() {
		return specifyCanvasHeight;
	}

	public void setSpecifyCanvasHeight(boolean specifyCanvasHeight) {
		this.specifyCanvasHeight = specifyCanvasHeight;
		contentChanged();
	}

	/**
	 * Should be called when SVG document has been changed. It will be re-rendered and figure will be repainted.
	 */
	public void contentChanged() {
		getDocument();
		if (transcoder != null) {
			transcoder.contentChanged();
		}
		repaint();
	}
}