org.eclipse.gmf.runtime.diagram.ui.render/src/org/eclipse/gmf/runtime/diagram/ui/render/clipboard/DiagramGenerator.java

/******************************************************************************
 * Copyright (c) 2002, 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.gmf.runtime.diagram.ui.render.clipboard;

import java.awt.Image;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Stack;

import org.eclipse.core.runtime.Assert;
import org.eclipse.draw2d.Graphics;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.PrecisionPoint;
import org.eclipse.draw2d.geometry.PrecisionRectangle;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.gef.ConnectionEditPart;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.GraphicalEditPart;
import org.eclipse.gef.LayerConstants;
import org.eclipse.gef.editparts.LayerManager;
import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramRootEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart;
import org.eclipse.gmf.runtime.diagram.ui.figures.IExpandableFigure;
import org.eclipse.gmf.runtime.diagram.ui.image.PartPositionInfo;
import org.eclipse.gmf.runtime.diagram.ui.l10n.SharedImages;
import org.eclipse.gmf.runtime.diagram.ui.render.util.DiagramImageUtils;
import org.eclipse.gmf.runtime.diagram.ui.render.util.PartPositionInfoGenerator;
import org.eclipse.gmf.runtime.diagram.ui.services.decorator.Decoration;
import org.eclipse.gmf.runtime.draw2d.ui.internal.graphics.ScaledGraphics;
import org.eclipse.gmf.runtime.draw2d.ui.mapmode.IMapMode;
import org.eclipse.gmf.runtime.draw2d.ui.mapmode.MapModeUtil;
import org.eclipse.gmf.runtime.draw2d.ui.render.internal.graphics.RenderedMapModeGraphics;
import org.eclipse.gmf.runtime.draw2d.ui.render.internal.graphics.RenderedScaledGraphics;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.swt.graphics.ImageData;

/**
 * Provides the framework to generate SWT and AWT images of a diagram or a
 * subset of editparts on a diagram.
 * 
 * @author sshaw
 * @author Barys Dubauski
 */
abstract public class DiagramGenerator {

	private int image_margin = 0;

	private DiagramEditPart _dgrmEP;
	
	private IFigure printableLayer;
	
	private Dimension emptyImageSize;
	
	private static final int DEFAULT_IMAGE_MARGIN_PIXELS = 10;
	
	private static final int DEFAULT_EMPTY_IMAGE_SIZE_PIXELS = 100;

	/**
	 * Creates a new instance.
	 * 
	 * @param dgrmEP
	 *            the diagram editpart
	 */
	public DiagramGenerator(DiagramEditPart dgrmEP) {
		this._dgrmEP = dgrmEP;
		this.printableLayer = LayerManager.Helper.find(_dgrmEP).getLayer(LayerConstants.PRINTABLE_LAYERS);
		IMapMode mm = getMapMode();
		image_margin = mm.DPtoLP(DEFAULT_IMAGE_MARGIN_PIXELS);
		emptyImageSize = (Dimension) mm.DPtoLP(new Dimension(
				DEFAULT_EMPTY_IMAGE_SIZE_PIXELS,
				DEFAULT_EMPTY_IMAGE_SIZE_PIXELS));
	}

	/**
	 * @return DiagramEditPart
	 */
	protected DiagramEditPart getDiagramEditPart() {
		return this._dgrmEP;
	}

	/**
	 * Allows hook for the creation of a <code>Graphics</code> object that is
	 * used for the rendering of the diagram.
	 * 
	 * @param width
	 *            of the clipping area
	 * @param height
	 *            of the clipping area
	 * @return Graphics element that is the target for rendering.
	 */
	abstract protected Graphics setUpGraphics(int width, int height);

	/**
	 * Allows hook to dispose of any artifacts around the creation of the
	 * <code>Graphics</code> object used for rendering.
	 * 
	 * @param g
	 *            Graphics element that is to be disposed.
	 */
	protected void disposeGraphics(Graphics g) {
		g.dispose();
	}

	/**
	 * Creates an image descriptor representing the image rendered from the
	 * diagram.
	 * 
	 * @param g
	 *            Graphics object where information to form the image descriptor
	 *            can be retrieved from.
	 * @return ImageDescriptor representing the image rendered from the diagram.
	 */
	abstract protected ImageDescriptor getImageDescriptor(Graphics g);

	/**
	 * Creates an AWT image for the contents of the diagram editpart.
	 * 
	 * @return an image in AWT format
	 */
	final public Image createAWTImageForDiagram() {
		List editparts = getDiagramEditPart().getPrimaryEditParts();

		return createAWTImageForParts(editparts);
	}

	/**
	 * Creates an AWT image for the list of editparts passed in.
	 * 
	 * @param editparts
	 *            the list of <code>IGraphicalEditParts</code> that will be
	 *            rendered to the Image
	 * @return an image in AWT format
	 */
	public Image createAWTImageForParts(List editparts) {
		org.eclipse.swt.graphics.Rectangle diagramArea = calculateImageRectangle(editparts);
		return createAWTImageForParts(editparts, diagramArea);
	}

	/**
	 * Creates an SWT image descriptor for the contents of the diagram editpart.
	 * 
	 * @return an image descriptor for an SWT image
	 */
	final public ImageDescriptor createSWTImageDescriptorForDiagram() {
		List editparts = getDiagramEditPart().getPrimaryEditParts();

		return createSWTImageDescriptorForParts(editparts);
	}

	/**
	 * Creates an SWT image descriptor for the list of editparts passed in.Any
	 * connections where both the source and target editparts are passed in are
	 * also drawn.
	 * 
	 * @param editparts
	 *            the list of <code>IGraphicalEditParts</code> that will be
	 *            rendered to the Image
	 * @return an image descriptor for an SWT image
	 */
	final public ImageDescriptor createSWTImageDescriptorForParts(List editparts) {
		org.eclipse.swt.graphics.Rectangle sourceRect = calculateImageRectangle(editparts);
		return createSWTImageDescriptorForParts(editparts, sourceRect);
	}

	/**
	 * @return
	 */
	protected IMapMode getMapMode() {
		return MapModeUtil.getMapMode(getDiagramEditPart().getFigure());
	}

	/**
	 * Renders the list of editparts to the graphics object. Any connections
	 * where both the source and target editparts are passed in are also drawn.
	 * 
	 * @param graphics
	 *            the graphics object on which to draw
	 * @param translateOffset
	 *            a <code>Point</code> that the value the
	 *            <code>graphics</code> object will be translated by in
	 *            relative coordinates.
	 * @param editparts
	 *            the list of <code>IGraphicalEditParts</code> that will be
	 *            rendered to the graphics object
	 */
	final protected void renderToGraphics(Graphics graphics,
			Point translateOffset, List editparts) {

//		List sortedEditparts = sortSelection(editparts);

		graphics.translate((-translateOffset.x), (-translateOffset.y));
		graphics.pushState();

		List<GraphicalEditPart> connectionsToPaint = new LinkedList<GraphicalEditPart>();

		Map decorations = findDecorations(editparts);

		for (Iterator editPartsItr = editparts.listIterator(); editPartsItr.hasNext();) {
			IGraphicalEditPart editPart = (IGraphicalEditPart) editPartsItr.next();

			// do not paint selected connection part
			if (editPart instanceof ConnectionEditPart) {
				connectionsToPaint.add(editPart);
			} else {				
				connectionsToPaint.addAll(findConnectionsToPaint(editPart));
				// paint shape figure
				IFigure figure = editPart.getFigure();
				paintFigure(graphics, figure);

				paintDecorations(graphics, figure, decorations);
			}
		}
		
		// paint the connection parts after shape parts paint
		decorations = findDecorations(connectionsToPaint);

		for (Iterator<GraphicalEditPart> connItr = connectionsToPaint.iterator(); connItr.hasNext();) {
			IFigure figure = connItr.next().getFigure();
			paintFigure(graphics, figure);
			paintDecorations(graphics, figure, decorations);
		}
	}
	
	/**
	 * Collects all connections contained within the given edit part
	 * 
	 * @param editPart the container editpart
	 * @return connections within it
	 */
	private Collection<ConnectionEditPart> findConnectionsToPaint(IGraphicalEditPart editPart) {
		/*
		 * Set of node editparts contained within the given editpart
		 */
		HashSet<GraphicalEditPart> editParts = new HashSet<GraphicalEditPart>();
		
		/*
		 * All connection editparts that have a source contained within the given editpart
		 */
		HashSet<ConnectionEditPart> connectionEPs = new HashSet<ConnectionEditPart>();
		
		/*
		 * Connections contained within the given editpart (or just the connections to paint
		 */
		HashSet<ConnectionEditPart> connectionsToPaint = new HashSet<ConnectionEditPart>();
		
		/*
		 * Populate the set of node editparts
		 */
		getNestedEditParts(editPart, editParts);
		
		/*
		 * Populate the set of connections whose source is within the given editpart
		 */
		for (Iterator<GraphicalEditPart> editPartsItr = editParts.iterator(); editPartsItr.hasNext();) {
			connectionEPs.addAll(getAllConnectionsFrom(editPartsItr.next()));
		}
		
		/*
		 * Create a set of connections constained within the given editpart
		 */
		while (!connectionEPs.isEmpty()) {
			/*
			 * Take the first connection and check whethe there is a path
			 * through that connection that leads to the target contained within
			 * the given editpart
			 */
			Stack<ConnectionEditPart> connectionsPath = new Stack<ConnectionEditPart>();
			ConnectionEditPart conn = connectionEPs.iterator().next();
			connectionEPs.remove(conn);
			connectionsPath.add(conn);
			
			/*
			 * Initialize the target for the current path
			 */
			EditPart target = conn.getTarget();
			while(connectionEPs.contains(target)) {
				/*
				 * If the target end is a connection, check if it's one of the
				 * connection's whose target is a connection and within the
				 * given editpart. Append it to the path if it is. Otherwise
				 * check if the target is within the actual connections or nodes
				 * contained within the given editpart
				 */
				ConnectionEditPart targetConn = (ConnectionEditPart) target;
				connectionEPs.remove(targetConn);
				connectionsPath.add(targetConn);
				
				/*
				 * Update the target for the new path
				 */
				target = targetConn.getTarget();
			}
			
			/*
			 * The path is built, check if it's target is a node or a connection
			 * contained within the given editpart
			 */
			if (editParts.contains(target) || connectionsToPaint.contains(target)) {
				connectionsToPaint.addAll(connectionsPath);
			}
		}
		return connectionsToPaint;
	}
	
	/**
	 * Returns all connections orginating from a given editpart. All means that
	 * connections originating from connections that have a source given
	 * editpart will be included
	 * 
	 * @param ep the editpart 
	 * @return all source connections
	 */
	private List<ConnectionEditPart> getAllConnectionsFrom(GraphicalEditPart ep) {
		LinkedList<ConnectionEditPart> connections = new LinkedList<ConnectionEditPart>();
		for (Iterator itr = ep.getSourceConnections().iterator(); itr.hasNext();) {
			ConnectionEditPart sourceConn = (ConnectionEditPart) itr.next();
			connections.add(sourceConn);
			connections.addAll(getAllConnectionsFrom(sourceConn));
		}
		return connections;
	}

	/**
	 * This method is used when a figure needs to be painted to the graphics.
	 * The figure will be translated based on its absolute positioning.
	 * 
	 * @param graphics
	 *            Graphics object to render figure
	 * @param figure
	 *            the figure to be rendered
	 */
	private void paintFigure(Graphics graphics, IFigure figure) {

		if (!figure.isVisible() || figure.getBounds().isEmpty())
			return;

		// Calculate the Relative bounds and absolute bounds
		Rectangle relBounds = null;
		if (figure instanceof IExpandableFigure)
			relBounds = ((IExpandableFigure) figure).getExtendedBounds()
					.getCopy();
		else
			relBounds = figure.getBounds().getCopy();

		Rectangle abBounds = relBounds.getCopy();
		DiagramImageUtils.translateTo(abBounds, figure, printableLayer);

		// Calculate the difference
		int transX = abBounds.x - relBounds.x;
		int transY = abBounds.y - relBounds.y;

		// Paint the figure
		graphics.pushState();
		graphics.translate(transX, transY);
		figure.paint(graphics);
		graphics.popState();
		graphics.restoreState();
	}
	
	/**
	 * Find the decorations that adorn the specified <code>editParts</code>.
	 * 
	 * @param editparts
	 *            the list of <code>IGraphicalEditParts</code> for which to
	 *            find decorations
	 * @return a mapping of {@link IFigure}to ({@link Decoration}or
	 *         {@link Collection}of decorations})
	 */
	private Map findDecorations(Collection editparts) {
		// create inverse mapping of figures to edit parts (need this to map
		// decorations to edit parts)
		Map figureMap = mapFiguresToEditParts(editparts);

		Map result = new java.util.HashMap();

		if (!editparts.isEmpty()) {
			IGraphicalEditPart first = (IGraphicalEditPart) editparts.iterator().next();

			IFigure decorationLayer = LayerManager.Helper.find(first).getLayer(
					DiagramRootEditPart.DECORATION_PRINTABLE_LAYER);

			if (decorationLayer != null) {
				// compute the figures of the shapes
				List figures = new java.util.ArrayList(editparts);
				for (ListIterator iter = figures.listIterator(); iter.hasNext();) {
					iter.set(((IGraphicalEditPart) iter.next()).getFigure());
				}

				// find the decorations on figures that were selected
				for (Iterator iter = decorationLayer.getChildren().iterator(); iter
						.hasNext();) {
					Object next = iter.next();

					if (next instanceof Decoration) {
						Decoration decoration = (Decoration) next;
						IFigure owner = decoration.getOwnerFigure();

						while (owner != null) {
    						if (figureMap.containsKey(owner)) {
    							Object existing = result.get(owner);
    
    							if (existing == null) {
    								result.put(owner, decoration);
    							} else if (existing instanceof Collection) {
    								((Collection) existing).add(decoration);
    							} else {
    								Collection c = new java.util.ArrayList(2);
    								c.add(existing);
    								c.add(decoration);
    								result.put(owner, c);
    							}
    							break;
    						} else {
    						    owner = owner.getParent();
    						}
						}
					}
				}
			}
		}

		return result;
	}

	/**
	 * Constructs a mapping of figures to their corresponding edit parts.
	 * 
	 * @param editParts
	 *            a collection of <code>IGraphicalEditParts</code>
	 * @return a mapping of {@link IFigure}to {@link IGraphicalEditPart}
	 */
	private Map mapFiguresToEditParts(Collection editParts) {
		Map result = new java.util.HashMap();

		for (Iterator iter = editParts.iterator(); iter.hasNext();) {
			IGraphicalEditPart next = (IGraphicalEditPart) iter.next();

			result.put(next.getFigure(), next);
		}

		return result;
	}

	/**
	 * Paints the decorations adorning the specified <code>figure</code>, if
	 * any.
	 * 
	 * @param graphics
	 *            the graphics to paint on
	 * @param figure
	 *            the figure
	 * @param decorations
	 *            mapping of figures to decorations, in which we will find the
	 *            <code>figure</code>'s decorations
	 */
	private void paintDecorations(Graphics graphics, IFigure figure,
			Map decorations) {
		Object decoration = decorations.get(figure);

		if (decoration != null) {
			if (decoration instanceof Collection) {
				for (Iterator iter = ((Collection) decoration).iterator(); iter
						.hasNext();) {
					paintFigure(graphics, (IFigure) iter.next());
				}
			} else {
				paintFigure(graphics, (IFigure) decoration);
			}
		}
	}

	/**
	 * This is a recursive method that search a tree of edit parts looking for
	 * edit parts contained in the open list. If the edit part is found it is
	 * removed from the open list and placed in the closed list.
	 * 
	 * @param editPart
	 * @param open
	 * @param closed
	 */
	/*
	 * The 2 commented out methods are not being used currently
	 */
//	private void sortSelection(GraphicalEditPart editPart, List open,
//			List closed) {
//
//		// Do nothing if the open list is empty
//		if (open.isEmpty()) {
//			return;
//		}
//
//		// IF the edit part is contained in the open list (we are searching for
//		// it)
//		if (open.contains(editPart)) {
//			// Add the Edit Part to the closed list and remove it from
//			// the open list
//			closed.add(editPart);
//			open.remove(editPart);
//		}
//
//		for (Iterator iter = editPart.getChildren().iterator(); iter.hasNext();) {
//			GraphicalEditPart child = (GraphicalEditPart) iter.next();
//			sortSelection(child, open, closed);
//		}
//	}
//
//	private List sortSelection(List toSort) {
//		List closed = new ArrayList(toSort.size());
//		List open = new ArrayList(toSort.size());
//		open.addAll(toSort);
//
//		sortSelection(getDiagramEditPart(), open, closed);
//		if (!open.isEmpty()) {
//			closed.addAll(open);
//		}
//
//		return closed;
//	}

	/**
	 * This method is used to obtain the list of child edit parts for shape
	 * compartments.
	 * 
	 * @param childEditPart
	 *            base edit part to get the list of children editparts
	 * @param editParts
	 *            list of nested shape edit parts
	 */
	private void getNestedEditParts(IGraphicalEditPart childEditPart,
			Collection editParts) {

		for (Iterator iter = childEditPart.getChildren().iterator(); iter
				.hasNext();) {

			IGraphicalEditPart child = (IGraphicalEditPart) iter.next();
			editParts.add(child);
			getNestedEditParts(child, editParts);
		}
	}

	/**
	 * Determine the minimal rectangle required to bound the list of editparts.
	 * A margin is used around each of the editpart's figures when calculating
	 * the size.
	 * 
	 * @param editparts
	 *            the list of <code>IGraphicalEditParts</code> from which
	 *            their figure bounds will be used
	 * @return Rectangle the minimal rectangle that can bound the figures of the
	 *         list of editparts
	 */
	public org.eclipse.swt.graphics.Rectangle calculateImageRectangle(
			List editparts) {
		Rectangle rect = DiagramImageUtils.calculateImageRectangle(editparts,
				getImageMargin(), emptyImageSize);
		return new org.eclipse.swt.graphics.Rectangle(rect.x, rect.y,
				rect.width, rect.height);
	}
	
	/**
	 * Get the positional data and the semantic elements for each
	 * <code>ShapeEditPart</code>, <code>ShapeCompartmentEditPart</code>,
	 * and <code>ConnectionEditPart</code> on the diagram.
	 * 
	 * @return A list of {@link PartPositionInfo}objects with positional data
	 *         and the semantic element for the relevant editparts on the
	 *         diagram.
	 */
	public List getDiagramPartInfo() {
		Assert.isNotNull(_dgrmEP);
		return getDiagramPartInfo(_dgrmEP);
	}

	/**
	 * Get the positional data and the semantic elements for each
	 * <code>ShapeEditPart</code>, <code>ShapeCompartmentEditPart</code>,
	 * and <code>ConnectionEditPart</code> on the diagram.
	 * 
	 * @param diagramEditPart
	 *            The diagram edit part.
	 * @return A list of {@link PartPositionInfo}objects with positional data
	 *         and the semantic element for the relevant editparts on the
	 *         diagram.
	 */
	public List getDiagramPartInfo(DiagramEditPart diagramEditPart) {
		Map<String, Object> options = new HashMap<String, Object>();
		Point origin = DiagramImageUtils.calculateImageRectangle(
				diagramEditPart.getPrimaryEditParts(), getImageMargin(),
				emptyImageSize).getLocation();
		options.put(PartPositionInfoGenerator.CONNECTION_MARGIN,
				new Double(getImageMargin() >> 1));
		options.put(PartPositionInfoGenerator.DIAGRAM_ORIGIN, origin);
		return PartPositionInfoGenerator.getDiagramPartInfo(diagramEditPart,
				options);
	}
	
	public List<PartPositionInfo> getConstrainedDiagramPartInfo(int maxWidth,
			int maxHeight, boolean useMargins) {
		return getConstrainedDiagramPartInfo(_dgrmEP, maxWidth, maxHeight,
				useMargins);
	}
	
	public List<PartPositionInfo> getConstrainedDiagramPartInfo(
			DiagramEditPart diagramEditPart, int maxWidth, int maxHeight,
			boolean useMargins) {
		List<IGraphicalEditPart> children = (List<IGraphicalEditPart>) diagramEditPart
				.getPrimaryEditParts();
		IMapMode mm = getMapMode();

		// We will use the diagram generate that was used to generate the image
		// to figure out the outer-bound rectangle so that we are calculating
		// the
		// image positions using the same box as was used to create the image.
		ConstrainedImageRenderingData data = getConstrainedImageRenderingData(
				children, maxWidth, maxHeight, useMargins);
		Rectangle imageRect = data.imageOriginalBounds.getCopy();
		mm.DPtoLP(imageRect);
		if (useMargins) {
			imageRect.shrink(getImageMargin(), getImageMargin());
		}
		imageRect.performScale(data.scalingFactor);
		if (useMargins) {
			imageRect.expand(getImageMargin(), getImageMargin());
		}

		Map<String, Object> options = new HashMap<String, Object>();
		options.put(PartPositionInfoGenerator.CONNECTION_MARGIN,
				new Double(mm.DPtoLP(5)));
		options.put(PartPositionInfoGenerator.DIAGRAM_ORIGIN, imageRect.getLocation());
		options.put(PartPositionInfoGenerator.SCALE_FACTOR, new Double(data.scalingFactor));
		
		return PartPositionInfoGenerator.getDiagramPartInfo(diagramEditPart, options);
	}

	/**
	 * @return <code>int</code> value that is the margin around the generated
	 *         image in logical coordinates.
	 * @since 1.3
	 */
	public int getImageMargin() {
		return image_margin;
	}

	/**
	 * Sets the image margin value (width of the white frame around the image).
	 * The value must be in logical units.
	 * 
	 * @param imageMargin
	 * @since 1.3
	 */
	public void setImageMargin(int imageMargin) {
		Assert.isTrue(imageMargin >= 0);
		image_margin = imageMargin;
	}

	/**
	 * Generates AWT image of specified editparts on the specified rectangle.
	 * 
	 * @param editParts editparts
	 * @param diagramArea clipping rectangle
	 * @return AWT image
	 */
	public Image createAWTImageForParts(List editParts,
			org.eclipse.swt.graphics.Rectangle diagramArea) {
		return null;
	}

	final public ImageDescriptor createSWTImageDescriptorForParts(
			List editparts, org.eclipse.swt.graphics.Rectangle sourceRect) {

		// initialize imageDesc to the error icon
		ImageDescriptor imageDesc = new ImageDescriptor() {

			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.jface.resource.ImageDescriptor#getImageData()
			 */
			public ImageData getImageData() {
				return SharedImages.get(SharedImages.IMG_ERROR).getImageData();
			}
		};

		Graphics graphics = null;
		try {
			IMapMode mm = getMapMode();
			
			PrecisionRectangle rect = new PrecisionRectangle();
			rect.setX(sourceRect.x);
			rect.setY(sourceRect.y);
			rect.setWidth(sourceRect.width);
			rect.setHeight(sourceRect.height);
			
			mm.LPtoDP(rect);

			// Create the graphics and wrap it with the HiMetric graphics object
			graphics = setUpGraphics((int) Math.round(rect.preciseWidth),
					(int) Math.round(rect.preciseHeight));

			RenderedMapModeGraphics mapModeGraphics = new RenderedMapModeGraphics(
					graphics, getMapMode());

			renderToGraphics(mapModeGraphics, new Point(sourceRect.x,
					sourceRect.y), editparts);
			imageDesc = getImageDescriptor(graphics);
		} finally {
			if (graphics != null)
				disposeGraphics(graphics);
		}

		return imageDesc;
	}
	
	/**
	 * Creates an SWT image descriptor for editparts. Editparts are scaled to fit in maxDeviceWidth and maxDeviceHeight
	 * frame
	 * 
	 * @param editParts editparts
	 * @param maxDeviceWidth max width for the image
	 * @param maxDeviceHeight max height for the image
	 * @param useMargins true if 10 pisels margins are required to bound the editparts image
	 * @return the image descriptor
	 */
	final public ImageDescriptor createConstrainedSWTImageDecriptorForParts(
			List editParts, int maxDeviceWidth, int maxDeviceHeight,
			boolean useMargins) {
		ImageDescriptor imageDesc = new ImageDescriptor() {

			/*
			 * (non-Javadoc)
			 * 
			 * @see org.eclipse.jface.resource.ImageDescriptor#getImageData()
			 */
			public ImageData getImageData() {
				return SharedImages.get(SharedImages.IMG_ERROR).getImageData();
			}
		};
		
		Graphics graphics = null;
		try {
			IMapMode mm = getMapMode();

			ConstrainedImageRenderingData data = getConstrainedImageRenderingData(
					editParts, maxDeviceWidth, maxDeviceHeight, useMargins);

			// Create the graphics and wrap it with the HiMetric graphics object
			graphics = setUpGraphics(data.imageWidth, data.imageHeight);

			ScaledGraphics scaledGraphics = new RenderedScaledGraphics(graphics);
			
			RenderedMapModeGraphics mapModeGraphics = new RenderedMapModeGraphics(
					scaledGraphics, getMapMode());
			
			graphics.translate(data.margin, data.margin);
			mapModeGraphics.scale(data.scalingFactor);

			Point location = new PrecisionPoint(data.imageOriginalBounds
					.preciseX(), data.imageOriginalBounds.preciseY());
			mm.DPtoLP(location);
			renderToGraphics(mapModeGraphics, location, editParts);
			imageDesc = getImageDescriptor(graphics);
		} finally {
			if (graphics != null)
				disposeGraphics(graphics);
		}

		return imageDesc;
	}
	
	class ConstrainedImageRenderingData {
		double scalingFactor;
		int imageWidth; // in pixels
		int imageHeight; // in pixels
		Rectangle imageOriginalBounds; // in pixels
		int margin; // margins size in pixels
	}
	
	ConstrainedImageRenderingData getConstrainedImageRenderingData(
			List editParts, int maxDeviceWidth, int maxDeviceHeight,
			boolean useMargins) {
		ConstrainedImageRenderingData data = new ConstrainedImageRenderingData();
		IMapMode mm = getMapMode();

		data.imageOriginalBounds = new PrecisionRectangle(new Rectangle(
				calculateImageRectangle(editParts)));
		mm.LPtoDP(data.imageOriginalBounds);

		int deviceMargins = mm.LPtoDP(getImageMargin());
		data.margin = useMargins ? deviceMargins : 0;
		double xScalingFactor = 1.0, yScalingFactor = xScalingFactor;

		data.imageOriginalBounds.shrink(deviceMargins, deviceMargins);

		if (maxDeviceWidth > data.margin) {
			xScalingFactor = (maxDeviceWidth - data.margin - data.margin)
					/ (data.imageOriginalBounds.preciseWidth());
		}
		if (maxDeviceHeight > data.margin) {
			yScalingFactor = (maxDeviceHeight - data.margin - data.margin)
					/ (data.imageOriginalBounds.preciseHeight());
		}

		data.scalingFactor = Math.min(Math.min(xScalingFactor, yScalingFactor),
				1);

		data.imageWidth = data.imageOriginalBounds.width + data.margin
				+ data.margin;
		data.imageHeight = data.imageOriginalBounds.height + data.margin
				+ data.margin;

		if (data.scalingFactor < 1) {
			data.imageWidth = (int) Math.round(data.imageOriginalBounds
					.preciseWidth()
					* data.scalingFactor)
					+ data.margin + data.margin;
			data.imageHeight = (int) Math.round(data.imageOriginalBounds
					.preciseHeight()
					* data.scalingFactor)
					+ data.margin + data.margin;
		} else {
			data.scalingFactor = 1;
		}
		return data;
	}
	
	/**
	 * Creates an AWT image for editparts. Editparts are scaled to fit in maxDeviceWidth and maxDeviceHeight
	 * frame
	 * 
	 * @param editParts editparts
	 * @param maxDeviceWidth max width for the image
	 * @param maxDeviceHeight max height for the image
	 * @param useMargins true if 10 pisels margins are required to bound the editparts image
	 * @return the image
	 */
	public Image createConstrainedAWTImageForParts(List editParts,
			int maxDeviceWidth, int maxDeviceHeight, boolean useMargins) {
		return null;
	}

}