plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/services/impl/GefService.java - graphiti/org.eclipse.graphiti - Git at Google

 /*******************************************************************************
  * <copyright>
  *
  * Copyright (c) 2005, 2013 SAP AG.
  * 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:
  *    SAP AG - initial API, implementation and documentation
  *    mwenz - Bug 415884 - Cannot query size of a multi-line text
  *
  * </copyright>
  *
  *******************************************************************************/
 package org.eclipse.graphiti.ui.internal.services.impl;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;

 import org.eclipse.draw2d.ExclusionSearch;
 import org.eclipse.draw2d.IFigure;
 import org.eclipse.draw2d.TextUtilities;
 import org.eclipse.draw2d.geometry.Dimension;
 import org.eclipse.draw2d.geometry.Point;
 import org.eclipse.draw2d.geometry.Rectangle;
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.gef.EditPart;
 import org.eclipse.gef.EditPartViewer;
 import org.eclipse.gef.GraphicalEditPart;
 import org.eclipse.gef.LayerConstants;
 import org.eclipse.gef.editparts.ScalableFreeformRootEditPart;
 import org.eclipse.graphiti.datatypes.IDimension;
 import org.eclipse.graphiti.datatypes.ILocation;
 import org.eclipse.graphiti.internal.datatypes.impl.DimensionImpl;
 import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
 import org.eclipse.graphiti.mm.algorithms.styles.Font;
 import org.eclipse.graphiti.mm.pictograms.Anchor;
 import org.eclipse.graphiti.mm.pictograms.AnchorContainer;
 import org.eclipse.graphiti.mm.pictograms.ChopboxAnchor;
 import org.eclipse.graphiti.mm.pictograms.Connection;
 import org.eclipse.graphiti.mm.pictograms.ConnectionDecorator;
 import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;
 import org.eclipse.graphiti.mm.pictograms.Shape;
 import org.eclipse.graphiti.services.Graphiti;
 import org.eclipse.graphiti.services.ILayoutService;
 import org.eclipse.graphiti.ui.internal.services.IGefService;
 import org.eclipse.graphiti.ui.internal.util.DataTypeTransformation;
 import org.eclipse.graphiti.ui.internal.util.gef.ScalableRootEditPartAnimated;

 /**
  * A collection of static helper methods regarding GEF.
  *
  * @noinstantiate This class is not intended to be instantiated by clients.
  * @noextend This class is not intended to be subclassed by clients.
  */
 public class GefService implements IGefService {

 	protected static final String PE = "*PE* "; //$NON-NLS-1$

 	public void selectEditPart(EditPartViewer viewer, Object modelObject) {
 		if (modelObject == null)
 			return;

 		viewer.getControl().forceFocus();
 		Object editpart = viewer.getEditPartRegistry().get(modelObject);
 		if (editpart instanceof EditPart) {
 			viewer.flush();
 			viewer.select((EditPart) editpart);
 		}
 	}

 	public Point calculateTranslation(EditPart source, EditPart target) {
 		if (!(source instanceof GraphicalEditPart && target instanceof GraphicalEditPart))
 			throw new RuntimeException("Both EditParts must be an instance of GraphicalEditPart: " + source + " " + target); //$NON-NLS-1$ //$NON-NLS-2$

 		Point result = new Point(0, 0);
 		if (source == target) // quick-check
 			return result;

 		((GraphicalEditPart) source).getContentPane().translateToAbsolute(result);
 		((GraphicalEditPart) target).getContentPane().translateToRelative(result);
 		return result;
 	}

 	public Object getLayoutConstraint(EditPart editPart) {
 		if (editPart instanceof GraphicalEditPart) {
 			IFigure childFigure = ((GraphicalEditPart) editPart).getFigure();
 			if (childFigure.getParent() != null && childFigure.getParent().getLayoutManager() != null) { // should
 				// always be
 				// true
 				// ask the parent for the current constraints
 				Object constraint = childFigure.getParent().getLayoutManager().getConstraint(childFigure);
 				return constraint;
 			}
 		}
 		return null;
 	}

 	public EditPart findEditPartAt(EditPartViewer viewer, Point location, boolean includeConnections) {

 		EditPart editPart = findObjectAt(viewer, location, includeConnections);

 		if (editPart instanceof ScalableRootEditPartAnimated) {
 			List<EditPart> children = getEditPartChildren(editPart);
 			if (children.size() > 0) {
 				editPart = children.get(0);
 			}
 		}
 		return editPart;
 	}

 	private EditPart findObjectAt(final EditPartViewer viewer, Point pt, boolean includeConnections) {
 		class ConditionalTreeSearch extends ExclusionSearch {
 			ConditionalTreeSearch(Collection<?> coll) {
 				super(coll);
 			}

 			@Override
 			public boolean accept(IFigure figure) {
 				EditPart editpart = null;
 				while (editpart == null && figure != null) {
 					editpart = (EditPart) viewer.getVisualPartMap().get(figure);
 					figure = figure.getParent();
 				}
 				return editpart != null;
 			}
 		}

 		ScalableFreeformRootEditPart rootEditPart = (ScalableFreeformRootEditPart) viewer.getRootEditPart();
 		IFigure figure = null;

 		if (includeConnections) {
 			IFigure connectionLayer = rootEditPart.getLayer(LayerConstants.CONNECTION_LAYER);
 			figure = connectionLayer.findFigureAt(pt.x, pt.y, new ConditionalTreeSearch(Collections.EMPTY_LIST));
 		}
 		// if figure not searched or not found on connection layer try to find a
 		// figure on the primary layer
 		if (figure == null) {
 			IFigure primaryLayer = rootEditPart.getLayer(LayerConstants.PRIMARY_LAYER);
 			figure = primaryLayer.findFigureAt(pt.x, pt.y, new ConditionalTreeSearch(Collections.EMPTY_LIST));
 		}

 		EditPart part = null;
 		while (part == null && figure != null) {
 			part = (EditPart) viewer.getVisualPartMap().get(figure);
 			figure = figure.getParent();
 		}
 		if (part == null)
 			return viewer.getContents();
 		return part;
 	}

 	public List<EditPart> getConnectionsContainedInEditPart(EditPart ep) {
 		// Compute connections whose start and target are somewhere in the
 		// editpart sub hierarchy of ep
 		List<EditPart> childEditParts = getAllEditPartChildren(ep);
 		List<Connection> sourceConnections = new ArrayList<Connection>();
 		List<Connection> targetConnections = new ArrayList<Connection>();
 		for (EditPart cep : childEditParts) {
 			if (cep.getModel() instanceof AnchorContainer) {
 				AnchorContainer anchorContainer = (AnchorContainer) cep.getModel();
 				EList<Anchor> anchors = anchorContainer.getAnchors();
 				for (Anchor anchor : anchors) {
 					sourceConnections.addAll(anchor.getIncomingConnections());
 					targetConnections.addAll(anchor.getOutgoingConnections());
 				}
 			}
 		}
 		sourceConnections.retainAll(targetConnections);

 		// Extract edit parts and decorators from the connections
 		List<EditPart> result = new ArrayList<EditPart>();
 		for (Connection connection : sourceConnections) {
 			Object connectionEditPart = ep.getRoot().getViewer().getEditPartRegistry().get(connection);
 			result.add((EditPart) connectionEditPart);
 			EList<ConnectionDecorator> connectionDecorators = connection.getConnectionDecorators();
 			for (ConnectionDecorator decorator : connectionDecorators) {
 				Object decoratorEditPart = ep.getRoot().getViewer().getEditPartRegistry().get(decorator);
 				result.add((EditPart) decoratorEditPart);
 			}
 		}
 		return result;

 	}

 	private List<EditPart> getAllEditPartChildren(EditPart ep) {
 		List<EditPart> res = new ArrayList<EditPart>();
 		List<EditPart> children = getEditPartChildren(ep);
 		for (EditPart editPart : children) {
 			res.add(editPart);
 			res.addAll(getAllEditPartChildren(editPart));
 		}
 		return res;
 	}

 	public Point getConnectionPointAt(Connection c, double d) {
 		Point ret = null;

 		Anchor startAnchor = c.getStart();
 		final ILayoutService layoutService = Graphiti.getLayoutService();
 		ILocation startLocation = layoutService.getLocationRelativeToDiagram(startAnchor);
 		Point startPoint = new Point(startLocation.getX(), startLocation.getY());

 		Anchor endAnchor = c.getEnd();
 		ILocation endLocation = layoutService.getLocationRelativeToDiagram(endAnchor);
 		Point endPoint = new Point(endLocation.getX(), endLocation.getY());

 		// special solutions for chopbox anchors
 		if (startAnchor instanceof ChopboxAnchor || endAnchor instanceof ChopboxAnchor) {
 			if (startAnchor instanceof ChopboxAnchor) {
 				ChopboxAnchor cbStartAnchor = (ChopboxAnchor) startAnchor;
 				GraphicsAlgorithm parentGa = cbStartAnchor.getParent().getGraphicsAlgorithm();
 				Shape shape = (Shape) cbStartAnchor.getParent();
 				ILocation location = layoutService.getLocationRelativeToDiagram(shape);
 				Rectangle parentRect = new Rectangle(location.getX(), location.getY(), parentGa.getWidth(), parentGa.getHeight());

 				Point pointNextToStartAnchor = endPoint.getCopy();

 				if (c instanceof FreeFormConnection) {
 					FreeFormConnection ffc = (FreeFormConnection) c;
 					List<org.eclipse.graphiti.mm.algorithms.styles.Point> bendpoints = ffc.getBendpoints();
 					if (!bendpoints.isEmpty()) {
 						org.eclipse.graphiti.mm.algorithms.styles.Point firstBendpoint = bendpoints.get(0);
 						pointNextToStartAnchor.setLocation(firstBendpoint.getX(), firstBendpoint.getY());
 					}
 				}

 				Point chopboxLocationOnBox = getChopboxLocationOnBox(pointNextToStartAnchor, parentRect);
 				startPoint.setLocation(chopboxLocationOnBox);
 			}

 			if (endAnchor instanceof ChopboxAnchor) {
 				ChopboxAnchor cbEndAnchor = (ChopboxAnchor) endAnchor;
 				GraphicsAlgorithm parentGa = cbEndAnchor.getParent().getGraphicsAlgorithm();
 				Shape shape = (Shape) cbEndAnchor.getParent();
 				ILocation location = layoutService.getLocationRelativeToDiagram(shape);
 				Rectangle parentRect = new Rectangle(location.getX(), location.getY(), parentGa.getWidth(), parentGa.getHeight());

 				Point pointNextToEndAnchor = startPoint.getCopy();

 				if (c instanceof FreeFormConnection) {
 					FreeFormConnection ffc = (FreeFormConnection) c;
 					List<org.eclipse.graphiti.mm.algorithms.styles.Point> bendpoints = ffc.getBendpoints();
 					if (!bendpoints.isEmpty()) {
 						org.eclipse.graphiti.mm.algorithms.styles.Point lastBendpoint = bendpoints.get(bendpoints.size() - 1);
 						pointNextToEndAnchor.setLocation(lastBendpoint.getX(), lastBendpoint.getY());
 					}
 				}

 				Point chopboxLocationOnBox = getChopboxLocationOnBox(pointNextToEndAnchor, parentRect);
 				endPoint.setLocation(chopboxLocationOnBox);
 			}

 		}

 		if (c instanceof FreeFormConnection) {
 			FreeFormConnection ffc = (FreeFormConnection) c;
 			List<org.eclipse.graphiti.mm.algorithms.styles.Point> bendpoints = ffc.getBendpoints();
 			Point[] draw2dPoints = new Point[bendpoints.size() + 2];
 			{
 				draw2dPoints[0] = startPoint;
 				int i = 1;
 				for (org.eclipse.graphiti.mm.algorithms.styles.Point pictogramsPoint : bendpoints) {
 					draw2dPoints[i] = new Point(pictogramsPoint.getX(), pictogramsPoint.getY());
 					i++;
 				}
 				draw2dPoints[i] = endPoint;
 			}

 			double completeDistance = getDistance(draw2dPoints);
 			double absDistanceToRelPoint = completeDistance * d;

 			double distanceSum = 0;
 			for (int i = 0; i < draw2dPoints.length - 1; i++) {
 				double oldDistanceSum = distanceSum;
 				Point currentPoint = draw2dPoints[i];
 				Point nextPoint = draw2dPoints[i + 1];
 				// no need to check both points
 				// actually this would lead to division-by-zero in the following
 				// calculation
 				if (currentPoint.equals(nextPoint))
 					continue;

 				double additionalDistanceToNext = getDistance(currentPoint, nextPoint);
 				distanceSum += additionalDistanceToNext;
 				if (distanceSum >= absDistanceToRelPoint) {
 					double thisRelative = ((completeDistance * d) - oldDistanceSum) / additionalDistanceToNext;
 					ret = getPointAt(currentPoint, nextPoint, thisRelative);
 					break; // or return ret;
 				}
 			}

 		} else {
 			ret = getPointAt(startPoint.x, startPoint.y, endPoint.x, endPoint.y, d);
 		}
 		return ret;
 	}

 	public Point getChopboxLocationOnBox(Point reference, Rectangle box) {
 		Rectangle r = Rectangle.SINGLETON;
 		r.setBounds(box);
 		r.translate(-1, -1);
 		r.resize(1, 1);

 		// getOwner().translateToAbsolute(r);
 		float centerX = r.x + 0.5f * r.width;
 		float centerY = r.y + 0.5f * r.height;

 		// CHANGED: returning the center in case of a divide-by-zero is not a
 		// good result
 		// if (r.isEmpty() || (reference.x == (int)centerX && reference.y ==
 		// (int)centerY))
 		// return new Point((int)centerX, (int)centerY); //This avoids
 		// divide-by-zero

 		float dx = reference.x - centerX;
 		float dy = reference.y - centerY;

 		// r.width, r.height, dx, and dy are guaranteed to be non-zero.

 		// CHANGED: in case of "nearly zero" (divide-by-zero or
 		// rounding-problems) would happen.
 		// Instead return a point on the border of the figure.
 		// Doesn't matter which one, because it is directly in the center, so
 		// take top-middle.
 		float max = Math.max(Math.abs(dx) / r.width, Math.abs(dy) / r.height);
 		if (max <= 0.001f) {
 			return new Point((int) centerX, r.y);
 		}

 		float scale = 0.5f / max;

 		dx *= scale;
 		dy *= scale;
 		centerX += dx;
 		centerY += dy;

 		return new Point(Math.round(centerX), Math.round(centerY));
 	}

 	public Point getAbsolutePointOnConnection(Connection c, double distance) {
 		Point ret = null;

 		Anchor startAnchor = c.getStart();
 		ILocation startLocation = Graphiti.getLayoutService().getLocationRelativeToDiagram(startAnchor);
 		Point startPoint = new Point(startLocation.getX(), startLocation.getY());

 		Anchor endAnchor = c.getEnd();
 		ILocation endLocation = Graphiti.getLayoutService().getLocationRelativeToDiagram(endAnchor);
 		Point endPoint = new Point(endLocation.getX(), endLocation.getY());

 		// special solutions for chopbox anchors
 		if (startAnchor instanceof ChopboxAnchor || endAnchor instanceof ChopboxAnchor) {
 			if (startAnchor instanceof ChopboxAnchor) {
 				ChopboxAnchor cbStartAnchor = (ChopboxAnchor) startAnchor;
 				GraphicsAlgorithm parentGa = cbStartAnchor.getParent().getGraphicsAlgorithm();
 				Rectangle parentRect = new Rectangle(parentGa.getX(), parentGa.getY(), parentGa.getWidth(), parentGa.getHeight());

 				Point pointNextToStartAnchor = endPoint.getCopy();

 				if (c instanceof FreeFormConnection) {
 					FreeFormConnection ffc = (FreeFormConnection) c;
 					List<org.eclipse.graphiti.mm.algorithms.styles.Point> bendpoints = ffc.getBendpoints();
 					if (!bendpoints.isEmpty()) {
 						org.eclipse.graphiti.mm.algorithms.styles.Point firstBendpoint = bendpoints.get(0);
 						pointNextToStartAnchor.setLocation(firstBendpoint.getX(), firstBendpoint.getY());
 					}
 				}

 				Point chopboxLocationOnBox = getChopboxLocationOnBox(pointNextToStartAnchor, parentRect);
 				startPoint.setLocation(chopboxLocationOnBox);
 			}

 			if (endAnchor instanceof ChopboxAnchor) {
 				ChopboxAnchor cbEndAnchor = (ChopboxAnchor) endAnchor;
 				GraphicsAlgorithm parentGa = cbEndAnchor.getParent().getGraphicsAlgorithm();
 				Rectangle parentRect = new Rectangle(parentGa.getX(), parentGa.getY(), parentGa.getWidth(), parentGa.getHeight());

 				Point pointNextToEndAnchor = startPoint.getCopy();

 				if (c instanceof FreeFormConnection) {
 					FreeFormConnection ffc = (FreeFormConnection) c;
 					List<org.eclipse.graphiti.mm.algorithms.styles.Point> bendpoints = ffc.getBendpoints();
 					if (!bendpoints.isEmpty()) {
 						org.eclipse.graphiti.mm.algorithms.styles.Point lastBendpoint = bendpoints.get(bendpoints.size() - 1);
 						pointNextToEndAnchor.setLocation(lastBendpoint.getX(), lastBendpoint.getY());
 					}
 				}

 				Point chopboxLocationOnBox = getChopboxLocationOnBox(pointNextToEndAnchor, parentRect);
 				endPoint.setLocation(chopboxLocationOnBox);
 			}

 		}

 		if (c instanceof FreeFormConnection) {
 			FreeFormConnection ffc = (FreeFormConnection) c;
 			List<org.eclipse.graphiti.mm.algorithms.styles.Point> bendpoints = ffc.getBendpoints();
 			Point[] draw2dPoints = new Point[bendpoints.size() + 2];
 			{
 				draw2dPoints[0] = startPoint;
 				int i = 1;
 				for (org.eclipse.graphiti.mm.algorithms.styles.Point pictogramsPoint : bendpoints) {
 					draw2dPoints[i] = new Point(pictogramsPoint.getX(), pictogramsPoint.getY());
 					i++;
 				}
 				draw2dPoints[i] = endPoint;
 			}

 			if (distance < 0) {
 				// mirror the array
 				mirrorArray(draw2dPoints);
 			}

 			double absDistance = Math.abs(distance);

 			double distanceSum = 0;
 			for (int i = 0; i < draw2dPoints.length - 1; i++) {
 				Point currentPoint = draw2dPoints[i];
 				Point nextPoint = draw2dPoints[i + 1];
 				double additionalDistanceToNext = getDistance(currentPoint, nextPoint);
 				distanceSum += additionalDistanceToNext;
 				if (distanceSum >= absDistance) {
 					// double thisDistance = (distance - oldDistanceSum) /
 					// additionalDistanceToNext;
 					// ret = getMidpoint(currentPoint, nextPoint, thisDistance);
 					ret = getDistantPoint(currentPoint, nextPoint, absDistance);
 					break; // or return ret;
 				}
 			}

 		} else {
 			ret = getDistantPoint(startLocation.getX(), startLocation.getY(), endLocation.getX(), endLocation.getY(), distance);
 		}

 		if (ret == null) {
 			ret = startPoint;
 		}

 		return ret;
 	}

 	public Point getDistantPoint(Point start, Point end, double distance) {
 		Point ret = getDistantPoint(start.x, start.y, end.x, end.y, distance);
 		return ret;
 	}

 	public Point getDistantPoint(int startX, int startY, int endX, int endY, double distance) {
 		Point ret;
 		double completeDistance = Math.sqrt(((endX - startX) * (endX - startX)) + ((endY - startY) * (endY - startY)));
 		double relative;
 		if (distance >= 0) {
 			relative = (distance > completeDistance) ? 1 : distance / completeDistance;
 			ret = getPointAt(startX, startY, endX, endY, relative);
 		} else {
 			relative = (-distance > completeDistance) ? 0 : 1 - (distance / completeDistance);
 			ret = getPointAt(startX, startY, endX, endY, relative);
 		}

 		return ret;
 	}

 	public Point getPointAt(int startX, int startY, int endX, int endY, double d) {
 		Point ret;
 		int midX = (int) Math.round((startX + d * (endX - startX)));
 		int midY = (int) Math.round((startY + d * (endY - startY)));
 		ret = new Point(midX, midY);
 		return ret;
 	}

 	public Point getPointAt(Point start, Point end, double d) {
 		Point ret = getPointAt(start.x, start.y, end.x, end.y, d);
 		return ret;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see
 	 * org.eclipse.graphiti.ui.internal.util.gef.IGefService#getDistance(org
 	 * .eclipse.draw2d.geometry.Point[])
 	 */
 	public double getDistance(Point[] points) {
 		double ret = 0;
 		for (int i = 0; i < points.length - 1; i++) {
 			Point currentPoint = points[i];
 			Point nextPoint = points[i + 1];
 			ret += getDistance(currentPoint, nextPoint);
 		}
 		return ret;
 	}

 	private double getDistance(Point start, Point end) {
 		int xDist = end.x - start.x;
 		int yDist = end.y - start.y;
 		double ret = Math.sqrt((xDist * xDist) + (yDist * yDist));
 		return ret;
 	}

 	public IDimension calculateTextSize(String text, Font font) {
 		return calculateTextSize(text, font, false);
 	}

 	public IDimension calculateTextSize(String text, Font font, boolean handleMultiline) {
 		IDimension dimension = null;
 		if (text == null || font == null || font.getName() == null) {
 			return dimension;
 		}

 		org.eclipse.swt.graphics.Font swtFont = DataTypeTransformation.toSwtFont(font);
 		if (swtFont != null) {
 			Dimension se;
 			if (handleMultiline) {
 				se = TextUtilities.INSTANCE.getTextExtents(text, swtFont);
 			} else {
 				se = TextUtilities.INSTANCE.getStringExtents(text, swtFont);
 			}

 			if (se != null) {
 				dimension = new DimensionImpl(se.width, se.height);
 			}
 			if (!swtFont.isDisposed()) {
 				swtFont.dispose();
 			}
 		}
 		return dimension;
 	}

 	public void mirrorArray(Point[] draw2dPoints) {
 		int length = draw2dPoints.length;
 		for (int i = 0; i < length / 2; i++) {
 			Point pTemp = draw2dPoints[length - 1 - i];
 			draw2dPoints[length - 1 - i] = draw2dPoints[i];
 			draw2dPoints[i] = pTemp;
 		}
 	}

 	public List<EditPart> getEditPartChildren(EditPart editPart) {
 		@SuppressWarnings("unchecked")
 		List<EditPart> ret = editPart.getChildren();
 		return ret;
 	}

 	public List<GraphicalEditPart> getSourceConnections(GraphicalEditPart graphicalEditPart) {
 		@SuppressWarnings("unchecked")
 		List<GraphicalEditPart> sourceConnections = graphicalEditPart.getSourceConnections();
 		return sourceConnections;
 	}

 	public List<GraphicalEditPart> getTargetConnections(GraphicalEditPart graphicalEditPart) {
 		@SuppressWarnings("unchecked")
 		List<GraphicalEditPart> targetConnections = graphicalEditPart.getTargetConnections();
 		return targetConnections;
 	}

 	public List<EditPart> getSelectedEditParts(EditPartViewer editPartViewer) {
 		@SuppressWarnings("unchecked")
 		List<EditPart> selectedEditParts = editPartViewer.getSelectedEditParts();
 		return selectedEditParts;
 	}
 }
	/*******************************************************************************
	* <copyright>
	*
	* Copyright (c) 2005, 2013 SAP AG.
	* 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:
	* SAP AG - initial API, implementation and documentation
	* mwenz - Bug 415884 - Cannot query size of a multi-line text
	*
	* </copyright>
	*
	*******************************************************************************/
	package org.eclipse.graphiti.ui.internal.services.impl;

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.List;

	import org.eclipse.draw2d.ExclusionSearch;
	import org.eclipse.draw2d.IFigure;
	import org.eclipse.draw2d.TextUtilities;
	import org.eclipse.draw2d.geometry.Dimension;
	import org.eclipse.draw2d.geometry.Point;
	import org.eclipse.draw2d.geometry.Rectangle;
	import org.eclipse.emf.common.util.EList;
	import org.eclipse.gef.EditPart;
	import org.eclipse.gef.EditPartViewer;
	import org.eclipse.gef.GraphicalEditPart;
	import org.eclipse.gef.LayerConstants;
	import org.eclipse.gef.editparts.ScalableFreeformRootEditPart;
	import org.eclipse.graphiti.datatypes.IDimension;
	import org.eclipse.graphiti.datatypes.ILocation;
	import org.eclipse.graphiti.internal.datatypes.impl.DimensionImpl;
	import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
	import org.eclipse.graphiti.mm.algorithms.styles.Font;
	import org.eclipse.graphiti.mm.pictograms.Anchor;
	import org.eclipse.graphiti.mm.pictograms.AnchorContainer;
	import org.eclipse.graphiti.mm.pictograms.ChopboxAnchor;
	import org.eclipse.graphiti.mm.pictograms.Connection;
	import org.eclipse.graphiti.mm.pictograms.ConnectionDecorator;
	import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;
	import org.eclipse.graphiti.mm.pictograms.Shape;
	import org.eclipse.graphiti.services.Graphiti;
	import org.eclipse.graphiti.services.ILayoutService;
	import org.eclipse.graphiti.ui.internal.services.IGefService;
	import org.eclipse.graphiti.ui.internal.util.DataTypeTransformation;
	import org.eclipse.graphiti.ui.internal.util.gef.ScalableRootEditPartAnimated;

	/**
	* A collection of static helper methods regarding GEF.
	*
	* @noinstantiate This class is not intended to be instantiated by clients.
	* @noextend This class is not intended to be subclassed by clients.
	*/
	public class GefService implements IGefService {

	protected static final String PE = "PE "; //$NON-NLS-1$

	public void selectEditPart(EditPartViewer viewer, Object modelObject) {
	if (modelObject == null)
	return;

	viewer.getControl().forceFocus();
	Object editpart = viewer.getEditPartRegistry().get(modelObject);
	if (editpart instanceof EditPart) {
	viewer.flush();
	viewer.select((EditPart) editpart);
	}
	}

	public Point calculateTranslation(EditPart source, EditPart target) {
	if (!(source instanceof GraphicalEditPart && target instanceof GraphicalEditPart))
	throw new RuntimeException("Both EditParts must be an instance of GraphicalEditPart: " + source + " " + target); //$NON-NLS-1$ //$NON-NLS-2$

	Point result = new Point(0, 0);
	if (source == target) // quick-check
	return result;

	((GraphicalEditPart) source).getContentPane().translateToAbsolute(result);
	((GraphicalEditPart) target).getContentPane().translateToRelative(result);
	return result;
	}

	public Object getLayoutConstraint(EditPart editPart) {
	if (editPart instanceof GraphicalEditPart) {
	IFigure childFigure = ((GraphicalEditPart) editPart).getFigure();
	if (childFigure.getParent() != null && childFigure.getParent().getLayoutManager() != null) { // should
	// always be
	// true
	// ask the parent for the current constraints
	Object constraint = childFigure.getParent().getLayoutManager().getConstraint(childFigure);
	return constraint;
	}
	}
	return null;
	}

	public EditPart findEditPartAt(EditPartViewer viewer, Point location, boolean includeConnections) {

	EditPart editPart = findObjectAt(viewer, location, includeConnections);

	if (editPart instanceof ScalableRootEditPartAnimated) {
	List<EditPart> children = getEditPartChildren(editPart);
	if (children.size() > 0) {
	editPart = children.get(0);
	}
	}
	return editPart;
	}

	private EditPart findObjectAt(final EditPartViewer viewer, Point pt, boolean includeConnections) {
	class ConditionalTreeSearch extends ExclusionSearch {
	ConditionalTreeSearch(Collection<?> coll) {
	super(coll);
	}

	@Override
	public boolean accept(IFigure figure) {
	EditPart editpart = null;
	while (editpart == null && figure != null) {
	editpart = (EditPart) viewer.getVisualPartMap().get(figure);
	figure = figure.getParent();
	}
	return editpart != null;
	}
	}

	ScalableFreeformRootEditPart rootEditPart = (ScalableFreeformRootEditPart) viewer.getRootEditPart();
	IFigure figure = null;

	if (includeConnections) {
	IFigure connectionLayer = rootEditPart.getLayer(LayerConstants.CONNECTION_LAYER);
	figure = connectionLayer.findFigureAt(pt.x, pt.y, new ConditionalTreeSearch(Collections.EMPTY_LIST));
	}
	// if figure not searched or not found on connection layer try to find a
	// figure on the primary layer
	if (figure == null) {
	IFigure primaryLayer = rootEditPart.getLayer(LayerConstants.PRIMARY_LAYER);
	figure = primaryLayer.findFigureAt(pt.x, pt.y, new ConditionalTreeSearch(Collections.EMPTY_LIST));
	}

	EditPart part = null;
	while (part == null && figure != null) {
	part = (EditPart) viewer.getVisualPartMap().get(figure);
	figure = figure.getParent();
	}
	if (part == null)
	return viewer.getContents();
	return part;
	}

	public List<EditPart> getConnectionsContainedInEditPart(EditPart ep) {
	// Compute connections whose start and target are somewhere in the
	// editpart sub hierarchy of ep
	List<EditPart> childEditParts = getAllEditPartChildren(ep);
	List<Connection> sourceConnections = new ArrayList<Connection>();
	List<Connection> targetConnections = new ArrayList<Connection>();
	for (EditPart cep : childEditParts) {
	if (cep.getModel() instanceof AnchorContainer) {
	AnchorContainer anchorContainer = (AnchorContainer) cep.getModel();
	EList<Anchor> anchors = anchorContainer.getAnchors();
	for (Anchor anchor : anchors) {
	sourceConnections.addAll(anchor.getIncomingConnections());
	targetConnections.addAll(anchor.getOutgoingConnections());
	}
	}
	}
	sourceConnections.retainAll(targetConnections);

	// Extract edit parts and decorators from the connections
	List<EditPart> result = new ArrayList<EditPart>();
	for (Connection connection : sourceConnections) {
	Object connectionEditPart = ep.getRoot().getViewer().getEditPartRegistry().get(connection);
	result.add((EditPart) connectionEditPart);
	EList<ConnectionDecorator> connectionDecorators = connection.getConnectionDecorators();
	for (ConnectionDecorator decorator : connectionDecorators) {
	Object decoratorEditPart = ep.getRoot().getViewer().getEditPartRegistry().get(decorator);
	result.add((EditPart) decoratorEditPart);
	}
	}
	return result;

	}

	private List<EditPart> getAllEditPartChildren(EditPart ep) {
	List<EditPart> res = new ArrayList<EditPart>();
	List<EditPart> children = getEditPartChildren(ep);
	for (EditPart editPart : children) {
	res.add(editPart);
	res.addAll(getAllEditPartChildren(editPart));
	}
	return res;
	}

	public Point getConnectionPointAt(Connection c, double d) {
	Point ret = null;

	Anchor startAnchor = c.getStart();
	final ILayoutService layoutService = Graphiti.getLayoutService();
	ILocation startLocation = layoutService.getLocationRelativeToDiagram(startAnchor);
	Point startPoint = new Point(startLocation.getX(), startLocation.getY());

	Anchor endAnchor = c.getEnd();
	ILocation endLocation = layoutService.getLocationRelativeToDiagram(endAnchor);
	Point endPoint = new Point(endLocation.getX(), endLocation.getY());

	// special solutions for chopbox anchors
	if (startAnchor instanceof ChopboxAnchor \|\| endAnchor instanceof ChopboxAnchor) {
	if (startAnchor instanceof ChopboxAnchor) {
	ChopboxAnchor cbStartAnchor = (ChopboxAnchor) startAnchor;
	GraphicsAlgorithm parentGa = cbStartAnchor.getParent().getGraphicsAlgorithm();
	Shape shape = (Shape) cbStartAnchor.getParent();
	ILocation location = layoutService.getLocationRelativeToDiagram(shape);
	Rectangle parentRect = new Rectangle(location.getX(), location.getY(), parentGa.getWidth(), parentGa.getHeight());

	Point pointNextToStartAnchor = endPoint.getCopy();

	if (c instanceof FreeFormConnection) {
	FreeFormConnection ffc = (FreeFormConnection) c;
	List<org.eclipse.graphiti.mm.algorithms.styles.Point> bendpoints = ffc.getBendpoints();
	if (!bendpoints.isEmpty()) {
	org.eclipse.graphiti.mm.algorithms.styles.Point firstBendpoint = bendpoints.get(0);
	pointNextToStartAnchor.setLocation(firstBendpoint.getX(), firstBendpoint.getY());
	}
	}

	Point chopboxLocationOnBox = getChopboxLocationOnBox(pointNextToStartAnchor, parentRect);
	startPoint.setLocation(chopboxLocationOnBox);
	}

	if (endAnchor instanceof ChopboxAnchor) {
	ChopboxAnchor cbEndAnchor = (ChopboxAnchor) endAnchor;
	GraphicsAlgorithm parentGa = cbEndAnchor.getParent().getGraphicsAlgorithm();
	Shape shape = (Shape) cbEndAnchor.getParent();
	ILocation location = layoutService.getLocationRelativeToDiagram(shape);
	Rectangle parentRect = new Rectangle(location.getX(), location.getY(), parentGa.getWidth(), parentGa.getHeight());

	Point pointNextToEndAnchor = startPoint.getCopy();

	if (c instanceof FreeFormConnection) {
	FreeFormConnection ffc = (FreeFormConnection) c;
	List<org.eclipse.graphiti.mm.algorithms.styles.Point> bendpoints = ffc.getBendpoints();
	if (!bendpoints.isEmpty()) {
	org.eclipse.graphiti.mm.algorithms.styles.Point lastBendpoint = bendpoints.get(bendpoints.size() - 1);
	pointNextToEndAnchor.setLocation(lastBendpoint.getX(), lastBendpoint.getY());
	}
	}

	Point chopboxLocationOnBox = getChopboxLocationOnBox(pointNextToEndAnchor, parentRect);
	endPoint.setLocation(chopboxLocationOnBox);
	}

	}

	if (c instanceof FreeFormConnection) {
	FreeFormConnection ffc = (FreeFormConnection) c;
	List<org.eclipse.graphiti.mm.algorithms.styles.Point> bendpoints = ffc.getBendpoints();
	Point[] draw2dPoints = new Point[bendpoints.size() + 2];
	{
	draw2dPoints[0] = startPoint;
	int i = 1;
	for (org.eclipse.graphiti.mm.algorithms.styles.Point pictogramsPoint : bendpoints) {
	draw2dPoints[i] = new Point(pictogramsPoint.getX(), pictogramsPoint.getY());
	i++;
	}
	draw2dPoints[i] = endPoint;
	}

	double completeDistance = getDistance(draw2dPoints);
	double absDistanceToRelPoint = completeDistance * d;

	double distanceSum = 0;
	for (int i = 0; i < draw2dPoints.length - 1; i++) {
	double oldDistanceSum = distanceSum;
	Point currentPoint = draw2dPoints[i];
	Point nextPoint = draw2dPoints[i + 1];
	// no need to check both points
	// actually this would lead to division-by-zero in the following
	// calculation
	if (currentPoint.equals(nextPoint))
	continue;

	double additionalDistanceToNext = getDistance(currentPoint, nextPoint);
	distanceSum += additionalDistanceToNext;
	if (distanceSum >= absDistanceToRelPoint) {
	double thisRelative = ((completeDistance * d) - oldDistanceSum) / additionalDistanceToNext;
	ret = getPointAt(currentPoint, nextPoint, thisRelative);
	break; // or return ret;
	}
	}

	} else {
	ret = getPointAt(startPoint.x, startPoint.y, endPoint.x, endPoint.y, d);
	}
	return ret;
	}

	public Point getChopboxLocationOnBox(Point reference, Rectangle box) {
	Rectangle r = Rectangle.SINGLETON;
	r.setBounds(box);
	r.translate(-1, -1);
	r.resize(1, 1);

	// getOwner().translateToAbsolute(r);
	float centerX = r.x + 0.5f * r.width;
	float centerY = r.y + 0.5f * r.height;

	// CHANGED: returning the center in case of a divide-by-zero is not a
	// good result
	// if (r.isEmpty() \|\| (reference.x == (int)centerX && reference.y ==
	// (int)centerY))
	// return new Point((int)centerX, (int)centerY); //This avoids
	// divide-by-zero

	float dx = reference.x - centerX;
	float dy = reference.y - centerY;

	// r.width, r.height, dx, and dy are guaranteed to be non-zero.

	// CHANGED: in case of "nearly zero" (divide-by-zero or
	// rounding-problems) would happen.
	// Instead return a point on the border of the figure.
	// Doesn't matter which one, because it is directly in the center, so
	// take top-middle.
	float max = Math.max(Math.abs(dx) / r.width, Math.abs(dy) / r.height);
	if (max <= 0.001f) {
	return new Point((int) centerX, r.y);
	}

	float scale = 0.5f / max;

	dx *= scale;
	dy *= scale;
	centerX += dx;
	centerY += dy;

	return new Point(Math.round(centerX), Math.round(centerY));
	}

	public Point getAbsolutePointOnConnection(Connection c, double distance) {
	Point ret = null;

	Anchor startAnchor = c.getStart();
	ILocation startLocation = Graphiti.getLayoutService().getLocationRelativeToDiagram(startAnchor);
	Point startPoint = new Point(startLocation.getX(), startLocation.getY());

	Anchor endAnchor = c.getEnd();
	ILocation endLocation = Graphiti.getLayoutService().getLocationRelativeToDiagram(endAnchor);
	Point endPoint = new Point(endLocation.getX(), endLocation.getY());

	// special solutions for chopbox anchors
	if (startAnchor instanceof ChopboxAnchor \|\| endAnchor instanceof ChopboxAnchor) {
	if (startAnchor instanceof ChopboxAnchor) {
	ChopboxAnchor cbStartAnchor = (ChopboxAnchor) startAnchor;
	GraphicsAlgorithm parentGa = cbStartAnchor.getParent().getGraphicsAlgorithm();
	Rectangle parentRect = new Rectangle(parentGa.getX(), parentGa.getY(), parentGa.getWidth(), parentGa.getHeight());

	Point pointNextToStartAnchor = endPoint.getCopy();

	if (c instanceof FreeFormConnection) {
	FreeFormConnection ffc = (FreeFormConnection) c;
	List<org.eclipse.graphiti.mm.algorithms.styles.Point> bendpoints = ffc.getBendpoints();
	if (!bendpoints.isEmpty()) {
	org.eclipse.graphiti.mm.algorithms.styles.Point firstBendpoint = bendpoints.get(0);
	pointNextToStartAnchor.setLocation(firstBendpoint.getX(), firstBendpoint.getY());
	}
	}

	Point chopboxLocationOnBox = getChopboxLocationOnBox(pointNextToStartAnchor, parentRect);
	startPoint.setLocation(chopboxLocationOnBox);
	}

	if (endAnchor instanceof ChopboxAnchor) {
	ChopboxAnchor cbEndAnchor = (ChopboxAnchor) endAnchor;
	GraphicsAlgorithm parentGa = cbEndAnchor.getParent().getGraphicsAlgorithm();
	Rectangle parentRect = new Rectangle(parentGa.getX(), parentGa.getY(), parentGa.getWidth(), parentGa.getHeight());

	Point pointNextToEndAnchor = startPoint.getCopy();

	if (c instanceof FreeFormConnection) {
	FreeFormConnection ffc = (FreeFormConnection) c;
	List<org.eclipse.graphiti.mm.algorithms.styles.Point> bendpoints = ffc.getBendpoints();
	if (!bendpoints.isEmpty()) {
	org.eclipse.graphiti.mm.algorithms.styles.Point lastBendpoint = bendpoints.get(bendpoints.size() - 1);
	pointNextToEndAnchor.setLocation(lastBendpoint.getX(), lastBendpoint.getY());
	}
	}

	Point chopboxLocationOnBox = getChopboxLocationOnBox(pointNextToEndAnchor, parentRect);
	endPoint.setLocation(chopboxLocationOnBox);
	}

	}

	if (c instanceof FreeFormConnection) {
	FreeFormConnection ffc = (FreeFormConnection) c;
	List<org.eclipse.graphiti.mm.algorithms.styles.Point> bendpoints = ffc.getBendpoints();
	Point[] draw2dPoints = new Point[bendpoints.size() + 2];
	{
	draw2dPoints[0] = startPoint;
	int i = 1;
	for (org.eclipse.graphiti.mm.algorithms.styles.Point pictogramsPoint : bendpoints) {
	draw2dPoints[i] = new Point(pictogramsPoint.getX(), pictogramsPoint.getY());
	i++;
	}
	draw2dPoints[i] = endPoint;
	}

	if (distance < 0) {
	// mirror the array
	mirrorArray(draw2dPoints);
	}

	double absDistance = Math.abs(distance);

	double distanceSum = 0;
	for (int i = 0; i < draw2dPoints.length - 1; i++) {
	Point currentPoint = draw2dPoints[i];
	Point nextPoint = draw2dPoints[i + 1];
	double additionalDistanceToNext = getDistance(currentPoint, nextPoint);
	distanceSum += additionalDistanceToNext;
	if (distanceSum >= absDistance) {
	// double thisDistance = (distance - oldDistanceSum) /
	// additionalDistanceToNext;
	// ret = getMidpoint(currentPoint, nextPoint, thisDistance);
	ret = getDistantPoint(currentPoint, nextPoint, absDistance);
	break; // or return ret;
	}
	}

	} else {
	ret = getDistantPoint(startLocation.getX(), startLocation.getY(), endLocation.getX(), endLocation.getY(), distance);
	}

	if (ret == null) {
	ret = startPoint;
	}

	return ret;
	}

	public Point getDistantPoint(Point start, Point end, double distance) {
	Point ret = getDistantPoint(start.x, start.y, end.x, end.y, distance);
	return ret;
	}

	public Point getDistantPoint(int startX, int startY, int endX, int endY, double distance) {
	Point ret;
	double completeDistance = Math.sqrt(((endX - startX) * (endX - startX)) + ((endY - startY) * (endY - startY)));
	double relative;
	if (distance >= 0) {
	relative = (distance > completeDistance) ? 1 : distance / completeDistance;
	ret = getPointAt(startX, startY, endX, endY, relative);
	} else {
	relative = (-distance > completeDistance) ? 0 : 1 - (distance / completeDistance);
	ret = getPointAt(startX, startY, endX, endY, relative);
	}

	return ret;
	}

	public Point getPointAt(int startX, int startY, int endX, int endY, double d) {
	Point ret;
	int midX = (int) Math.round((startX + d * (endX - startX)));
	int midY = (int) Math.round((startY + d * (endY - startY)));
	ret = new Point(midX, midY);
	return ret;
	}

	public Point getPointAt(Point start, Point end, double d) {
	Point ret = getPointAt(start.x, start.y, end.x, end.y, d);
	return ret;
	}

	/*
	* (non-Javadoc)
	*
	* @see
	* org.eclipse.graphiti.ui.internal.util.gef.IGefService#getDistance(org
	* .eclipse.draw2d.geometry.Point[])
	*/
	public double getDistance(Point[] points) {
	double ret = 0;
	for (int i = 0; i < points.length - 1; i++) {
	Point currentPoint = points[i];
	Point nextPoint = points[i + 1];
	ret += getDistance(currentPoint, nextPoint);
	}
	return ret;
	}

	private double getDistance(Point start, Point end) {
	int xDist = end.x - start.x;
	int yDist = end.y - start.y;
	double ret = Math.sqrt((xDist * xDist) + (yDist * yDist));
	return ret;
	}

	public IDimension calculateTextSize(String text, Font font) {
	return calculateTextSize(text, font, false);
	}

	public IDimension calculateTextSize(String text, Font font, boolean handleMultiline) {
	IDimension dimension = null;
	if (text == null \|\| font == null \|\| font.getName() == null) {
	return dimension;
	}

	org.eclipse.swt.graphics.Font swtFont = DataTypeTransformation.toSwtFont(font);
	if (swtFont != null) {
	Dimension se;
	if (handleMultiline) {
	se = TextUtilities.INSTANCE.getTextExtents(text, swtFont);
	} else {
	se = TextUtilities.INSTANCE.getStringExtents(text, swtFont);
	}

	if (se != null) {
	dimension = new DimensionImpl(se.width, se.height);
	}
	if (!swtFont.isDisposed()) {
	swtFont.dispose();
	}
	}
	return dimension;
	}

	public void mirrorArray(Point[] draw2dPoints) {
	int length = draw2dPoints.length;
	for (int i = 0; i < length / 2; i++) {
	Point pTemp = draw2dPoints[length - 1 - i];
	draw2dPoints[length - 1 - i] = draw2dPoints[i];
	draw2dPoints[i] = pTemp;
	}
	}

	public List<EditPart> getEditPartChildren(EditPart editPart) {
	@SuppressWarnings("unchecked")
	List<EditPart> ret = editPart.getChildren();
	return ret;
	}

	public List<GraphicalEditPart> getSourceConnections(GraphicalEditPart graphicalEditPart) {
	@SuppressWarnings("unchecked")
	List<GraphicalEditPart> sourceConnections = graphicalEditPart.getSourceConnections();
	return sourceConnections;
	}

	public List<GraphicalEditPart> getTargetConnections(GraphicalEditPart graphicalEditPart) {
	@SuppressWarnings("unchecked")
	List<GraphicalEditPart> targetConnections = graphicalEditPart.getTargetConnections();
	return targetConnections;
	}

	public List<EditPart> getSelectedEditParts(EditPartViewer editPartViewer) {
	@SuppressWarnings("unchecked")
	List<EditPart> selectedEditParts = editPartViewer.getSelectedEditParts();
	return selectedEditParts;
	}
	}