//------------------------------------------------------------------------------
// Copyright (c) 2005, 2006 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 implementation
//------------------------------------------------------------------------------
package org.eclipse.epf.diagram.add.service;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.PositionConstants;
import org.eclipse.draw2d.RectangleFigure;
import org.eclipse.draw2d.ToolbarLayout;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.transaction.Transaction;
import org.eclipse.emf.transaction.impl.InternalTransactionalEditingDomain;
import org.eclipse.epf.diagram.add.edit.parts.ActivityDetailDiagramEditPart;
import org.eclipse.epf.diagram.add.edit.parts.RoleNodeEditPart;
import org.eclipse.epf.diagram.add.edit.parts.RoleTaskCompositeEditPart;
import org.eclipse.epf.diagram.add.edit.parts.TaskNodeEditPart;
import org.eclipse.epf.diagram.add.edit.parts.WorkProductCompositeEditPart;
import org.eclipse.epf.diagram.core.commands.ChangeBoundsCommand;
import org.eclipse.epf.diagram.core.util.DiagramConstants;
import org.eclipse.gef.DefaultEditDomain;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.GraphicalEditPart;
import org.eclipse.gef.GraphicalViewer;
import org.eclipse.gef.commands.Command;
import org.eclipse.gef.commands.CommandStack;
import org.eclipse.gef.editparts.AbstractGraphicalEditPart;
import org.eclipse.gef.ui.actions.ActionRegistry;
import org.eclipse.gmf.runtime.diagram.core.util.ViewUtil;
import org.eclipse.gmf.runtime.diagram.ui.editparts.ConnectionNodeEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editparts.ShapeNodeEditPart;
import org.eclipse.gmf.runtime.draw2d.ui.figures.FigureUtilities;
import org.eclipse.gmf.runtime.draw2d.ui.figures.WrapLabel;
import org.eclipse.gmf.runtime.gef.ui.figures.NodeFigure;
import org.eclipse.gmf.runtime.notation.Node;
import org.eclipse.gmf.runtime.notation.NotationPackage;
import org.eclipse.gmf.runtime.notation.View;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.swt.graphics.Font;

/**
 * Service class for reset the Activity Detail Diagram.
 * Code migrated from old diagram code.   
 * 
 * @author Shashidhar Kannoori
 * @author Phong Nguyen Le
 * @since 1.2
 **/
public class DiagramResetService {

	private DefaultEditDomain editDomain;

	private GraphicalViewer graphicalViewer;

	private ActionRegistry actionRegistry;

	private InternalTransactionalEditingDomain transactionDomain;
	
	int delta = 0;
	
	private static final int IMG_HEIGHT = 32;

	public DiagramResetService(InternalTransactionalEditingDomain transactionDomain, 
			GraphicalViewer graphicalViewer, DefaultEditDomain editDomain,
			ActionRegistry actionRegistry) {
		this.transactionDomain = transactionDomain;
		this.graphicalViewer = graphicalViewer;
		this.editDomain = editDomain;
		this.actionRegistry = actionRegistry;
	}

	private GraphicalViewer getGraphicalViewer() {
		return graphicalViewer;
	}

	/**
	 * Returns the command stack.
	 * 
	 * @return the command stack
	 */
	protected CommandStack getCommandStack() {
		return getEditDomain().getCommandStack();
	}

	/**
	 * Returns the edit domain.
	 * 
	 * @return the edit domain
	 */
	protected DefaultEditDomain getEditDomain() {
		return editDomain;
	}

	/**
	 * Lazily creates and returns the action registry.
	 * 
	 * @return the action registry
	 */
	protected ActionRegistry getActionRegistry() {
		return actionRegistry;
	}

	/**
	 * Method used only in ActivityDetailDiagram or any diagram need auto-layout.
	 * Method will verify recently added editparts in the Activitydetaildiagram editpart
	 * indirectly from WorkBreakdownStructure (means any descriptors created in wbs, corresponding
	 * EditPart will get created in ActivityDetailDiagram Viewer) and does auto-layout
	 * all the new added editparts and existing ones. 
	 * 
	 */
	public void cleanUpDiagram() {
		if (getGraphicalViewer().getContents() instanceof ActivityDetailDiagramEditPart) {
			ActivityDetailDiagramEditPart dep = (ActivityDetailDiagramEditPart) getGraphicalViewer()
					.getContents();
			List children = dep.getRecentlyAddedParts();
			
			// If any oblique links rectify them to straight. 
//			anyObliqueLinks(dep, children);
			
			if (!children.isEmpty()) {
				Comparator<Object> comparator = new Comparator<Object>() {

					public int compare(Object arg0, Object arg1) {
						int rc = 0;
						if (arg0 instanceof RoleTaskCompositeEditPart) {
							if (!(arg1 instanceof RoleTaskCompositeEditPart))
								rc = -1;
						} else if (arg1 instanceof RoleTaskCompositeEditPart)
							rc = 1;
						return rc;
					}
					
				};

				Object[] array = children.toArray();
				Arrays.sort(array, comparator);
				for (int a = 0; a < array.length; a++) {
					AbstractGraphicalEditPart ep = (AbstractGraphicalEditPart) array[a];
					adjustSize(ep);
				}
				
				// force relayout after size adjustment
				//
				dep.getViewport().validate();
				
				for (int b = 0; b < array.length; b++) {
					AbstractGraphicalEditPart ep = (AbstractGraphicalEditPart) array[b];
					cleanUp(ep);
				}
				for (int c = 0; c < array.length; c++) {
					AbstractGraphicalEditPart ep = (AbstractGraphicalEditPart) array[c];
					reduceLinkLength(ep);
				}
//				for (int c = 0; c < array.length; c++) {
//					AbstractGraphicalEditPart ep = (AbstractGraphicalEditPart) array[c];
//					if(ep instanceof RoleTaskCompositeEditPart){
//						resetSizes(ep, ep);
//					}
//				}
				packDiagram();
				dep.refresh();
				dep.clearRecentlyAddedParts();
				getGraphicalViewer().setSelection(new StructuredSelection());
			}
		}
	}

	/**
	 * This method does a vertical alignment of all nodes with links
	 */
	private void cleanUp(AbstractGraphicalEditPart ep) {
		if (!(ep instanceof WorkProductCompositeEditPart)) {
			List sourceLinks = ep.getSourceConnections();
			if (sourceLinks.size() > 0) {
				for (int b = 0; b < sourceLinks.size(); b++) {
					ConnectionNodeEditPart link = (ConnectionNodeEditPart) sourceLinks.get(b);
					AbstractGraphicalEditPart target = (AbstractGraphicalEditPart) link
							.getTarget();
					int w = target.getFigure().getBounds().width;
					int ew = ep.getFigure().getPreferredSize().width;
					if (w < ew) {
						Command c = new ChangeBoundsCommand(transactionDomain, ((Node) ep
								.getModel()), target.getFigure().getBounds()
								.getLocation(), w, target.getFigure().getPreferredSize().height);
						getCommandStack().execute(c);
						int h = target.getFigure().getPreferredSize().height;
						target.getFigure()
								.setPreferredSize(new Dimension(w, h));
						target.getFigure().setSize(new Dimension(w, h));
					}
					List list = new ArrayList();
					list.add(ep);
					list.add(target);
					verticalAlignToFirstSelected(list);
				}
			}
			List targetLinks = ep.getTargetConnections();
			if (targetLinks.size() > 0) {
				for (int b = 0; b < targetLinks.size(); b++) {
					ConnectionNodeEditPart link = (ConnectionNodeEditPart) targetLinks.get(b);
					AbstractGraphicalEditPart source = (AbstractGraphicalEditPart) link
							.getSource();
					int w = source.getFigure().getBounds().width;
					int ew = ep.getFigure().getPreferredSize().width;
					if (w < ew) {
						Command c = new ChangeBoundsCommand(transactionDomain,((Node) ep
								.getModel()), source.getFigure().getBounds()
								.getLocation(), w,-1);
						getCommandStack().execute(c);
						int h = source.getFigure().getPreferredSize().height;
						source.getFigure()
								.setPreferredSize(new Dimension(w, h));
						source.getFigure().setSize(new Dimension(w, h));
					}
					List list = new ArrayList();
					list.add(ep);
					list.add(source);
					verticalAlignToFirstSelected(list);
				}
			}
			if (ep instanceof WorkProductCompositeEditPart || 
					ep instanceof RoleTaskCompositeEditPart) {
				List children = ep.getChildren();
				for (int d = 0; d < children.size(); d++) {
					AbstractGraphicalEditPart p = (AbstractGraphicalEditPart) children
							.get(d);
					cleanUp(p);
				}
			}
		}
	}

	/**
	 *  For auto-layout, need to adjust connection(or link) length, based on
	 *  connecting editparts(figures).
	 * 
	 */
	private boolean reduceLinkLength(AbstractGraphicalEditPart part) {
		boolean moved = false;
		// only move new WorkProductComposite elements
		if (part instanceof WorkProductCompositeEditPart) {
			AbstractGraphicalEditPart linkedPart = null;
			int position = PositionConstants.CENTER;
			// is this element linked to another item?
			if (part.getTargetConnections().size() > 0) {
				linkedPart = (AbstractGraphicalEditPart) ((ConnectionNodeEditPart) part
						.getTargetConnections().get(0)).getSource();
				position = PositionConstants.NORTH;
			} else if (part.getSourceConnections().size() > 0) {
				linkedPart = (AbstractGraphicalEditPart) ((ConnectionNodeEditPart) part
						.getSourceConnections().get(0)).getTarget();
				position = PositionConstants.SOUTH;
			}
			if (linkedPart != null) {
				if (!(linkedPart.getParent() instanceof DiagramEditPart)) {
					linkedPart = (AbstractGraphicalEditPart) linkedPart
							.getParent();
				}
				// get the part's position
				Rectangle partBounds = part.getFigure().getBounds();
				// get the linked part's position
				Rectangle linkedPartBounds = linkedPart.getFigure().getBounds();
				// determine in which direction is the linked part
				// int position = partBounds.getPosition(linkedPartBounds
				// .getLocation());
				// assume it is below us, so this part moves up
				int direction = -1;
				if ((position & PositionConstants.NORTH) == PositionConstants.NORTH
						|| (position & PositionConstants.CENTER) == PositionConstants.CENTER) {
					// above us, move down
					direction = 1;
				}
				// set new bounds for the part so that it sites just outside of
				// the linked part
				Rectangle testBounds = partBounds.getCopy();
				if (direction == 1) {
					testBounds.y = linkedPartBounds.y + linkedPartBounds.height
							+ VERT_PIX_PADDING;
				} else {
					testBounds.y = linkedPartBounds.y - VERT_PIX_PADDING
							- partBounds.height;
				}
				// set the new location for the part in the model
				Point np = new Point(testBounds.x, testBounds.y);
				part.getFigure().setLocation(np);
				Command c = new ChangeBoundsCommand(transactionDomain,(Node) part.getModel(), np,
						partBounds.width, -1);
				getCommandStack().execute(c);
			}
		}
		return moved;
	}

	/**
	 * Method to adjust the size of editpart.  
	 * 
	 */
	private void adjustSize(AbstractGraphicalEditPart ep) {
		if (ep instanceof WorkProductCompositeEditPart) {
			adjustSize((WorkProductCompositeEditPart) ep, 1);
		}
		else if (ep instanceof RoleTaskCompositeEditPart) {
			adjustSize((RoleTaskCompositeEditPart) ep, 50);
		}
	}

	protected final static int HORIZ_PIX_PADDING = 30;

	protected final static int VERT_PIX_PADDING = 20;

	/**
	 * Adjusts the size of ContainerEditPart to accomodate number of editparts in a row,
	 * push the remaining the editparts in two second row. 
	 * This is useful for {@link ToolbarLayout}
	 * 
	 */
	private void adjustSize(ShapeNodeEditPart ep, int horizCount) {
		int requiredWidth = 0;
		int rowMaxHeight = 0;
		int rows = 0;
		int widthSum = 0;
		int heightSum = 0;
		int column = 0;

		delta = 0;
		List children = ep.getChildren();
		IFigure parentFigure  = ep.getFigure();
		//TODO: need revisit transaction usage
		try{
		Transaction tx = ((InternalTransactionalEditingDomain)transactionDomain).startTransaction(false, Collections.EMPTY_MAP);
		for (int p = 0; p < children.size();) {
			if (column == 0) {
				rows++;
			}
			if (column < horizCount) {
				AbstractGraphicalEditPart child = (AbstractGraphicalEditPart) children
						.get(p);
				if(child instanceof RoleNodeEditPart || child instanceof TaskNodeEditPart){
					resetSize((ShapeNodeEditPart)child, parentFigure);
//					List list = new ArrayList();
//					list.add(child.getModel());
//					PersistViewsCommand cmd = new PersistViewsCommand(transactionDomain, list);
//					cmd.execute(new NullProgressMonitor(), null);
				}
				Dimension d = child.getFigure().getPreferredSize();
				widthSum += d.width;
				if (d.height > rowMaxHeight) {
					rowMaxHeight = d.height;
				}
				p++;
				column++;
			} else {
				if (widthSum > requiredWidth) {
					requiredWidth = widthSum;
				}
				heightSum += rowMaxHeight;
				rowMaxHeight = 0;
				widthSum = 0;
				column = 0;
			}
		}
		tx.commit();
		}catch(Exception e){
			
		}
		if (widthSum > requiredWidth) {
			requiredWidth = widthSum;
		}
		heightSum += rowMaxHeight;
		requiredWidth += HORIZ_PIX_PADDING
				* Math.min(horizCount, children.size());
		int requiredHeight = heightSum + (VERT_PIX_PADDING * rows);
		Command cmd = new ChangeBoundsCommand(transactionDomain, ((Node) ep.getModel()), ep
				.getFigure().getBounds().getLocation(), requiredWidth, requiredHeight);
		getCommandStack().execute(cmd);
		ep.getFigure().setPreferredSize(
				new Dimension(requiredWidth, requiredHeight));
		//((Node) ep.getModel()).setHeight(requiredHeight);
		ep.getFigure().setSize(new Dimension(requiredWidth, requiredHeight));
		ep.getFigure().getLayoutManager().layout(ep.getFigure());
		// after layout, check the bottom-most child figure against the bottom
		// of the container, adjust the bottom of the container is necessary
		if (ep instanceof WorkProductCompositeEditPart && children.size() > 0) {
			int totalCalculatedHeight = 0;
			for (int i=0; i < children.size(); i++)		{
				GraphicalEditPart part = (GraphicalEditPart) children.get(i);
				Node nodeObj = (Node) part.getModel();
				EObject o = nodeObj.getElement();				
				totalCalculatedHeight += part.getFigure().getPreferredSize().height;
			}
			int height = totalCalculatedHeight + 20 + 5 * (children.size() - 1);
			GraphicalEditPart last = (GraphicalEditPart) children.get(children
					.size() - 1);
			Point childBottom = last.getFigure().getBounds().getBottom();
			Point parentBottom = ep.getFigure().getBounds().getBottom();
			int delta = parentBottom.y - childBottom.y - (VERT_PIX_PADDING / 2);
//			ep.getFigure().setPreferredSize(
//					new Dimension(requiredWidth, requiredHeight - delta));
//			cmd = new ChangeBoundsCommand(transactionDomain, ((Node) ep.getModel()), ep
//					.getFigure().getBounds().getLocation(), -1, requiredHeight-delta);
//			getCommandStack().execute(cmd);
//			ep.getFigure().setSize(
//					new Dimension(requiredWidth, requiredHeight - delta));
			ep.getFigure().setPreferredSize(
					new Dimension(requiredWidth, height));
			cmd = new ChangeBoundsCommand(transactionDomain, ((Node) ep.getModel()), ep
					.getFigure().getBounds().getLocation(), -1, height);
			getCommandStack().execute(cmd);			
			ep.getFigure().setSize(
					new Dimension(requiredWidth, height));
		}
	}
	
	
	
	
	private void resetSize(ShapeNodeEditPart ep, IFigure parentFigure){
		
		Node model = (Node)ep.getModel();
		IGraphicalEditPart child = (IGraphicalEditPart)ep.getChildren().get(0);
		NodeFigure nodeFigure = (NodeFigure)ep.getFigure();
		List nodeFigureChildren =  nodeFigure.getChildren();
		IFigure childFigure = (IFigure)nodeFigureChildren.get(0);
		if(childFigure instanceof RectangleFigure){
			IFigure labelFigure = (IFigure)((RectangleFigure)childFigure).getChildren().get(0);
			if(labelFigure instanceof WrapLabel){
				Dimension figDimension = labelFigure.getSize();
				Dimension d = labelFigure.getPreferredSize();
				Point p = nodeFigure.getLocation().getCopy();
				p.x = p.x + delta;
				nodeFigure.setLocation(p);
				if (d.width > nodeFigure.getSize().width) {
					// System.out.println("Node figure width: "+nodeFigure.getSize().width);
					// System.out.println("Text width: "+ d.width);
					delta += d.width - nodeFigure.getSize().width;
				}
				if(d.width > figDimension.width){
					int width = d.width;
					View view = ((View)child.getModel());
					ViewUtil.setStructuralFeatureValue(view,
							NotationPackage.eINSTANCE.getSize_Width(), new Integer(
									width));
					ViewUtil.setStructuralFeatureValue(model,
							NotationPackage.eINSTANCE.getSize_Width(), new Integer(
									width));
					nodeFigure.setPreferredSize(new Dimension(width, nodeFigure.getPreferredSize().height));
					if (childFigure.getPreferredSize().height > nodeFigure.getPreferredSize().height) 
						nodeFigure.setPreferredSize(new Dimension(width, childFigure.getPreferredSize().height));
					childFigure.setPreferredSize(new Dimension(width, childFigure.getPreferredSize().height));
					labelFigure.setPreferredSize(new Dimension(width, labelFigure.getPreferredSize().height));
					
					nodeFigure.setSize(new Dimension(width, nodeFigure.getPreferredSize().height));
					if (childFigure.getPreferredSize().height > nodeFigure.getPreferredSize().height) 
						nodeFigure.setPreferredSize(new Dimension(width, childFigure.getPreferredSize().height));
					childFigure.setSize(new Dimension(width, childFigure.getPreferredSize().height));
					labelFigure.setSize(new Dimension(width, labelFigure.getPreferredSize().height));

//					nodeFigure.setConstraint(childFigure, new Rectangle(nodeFigure.getLocation().x,
//							nodeFigure.getLocation().y, width, childFigure.getBounds().height));
					// Change the location 
//					System.out.println("child bounds before: " + nodeFigure.getBounds() +"delta: " + delta);					
				}				
			}
		}
	}
	

	protected void enumerateConnectedParts(AbstractGraphicalEditPart part,
			List<EditPart> connected) {
		// only add parts directly on the diagram surface
		if (!connected.contains(part)) {
			if (!(part.getParent() instanceof DiagramEditPart)) {
				if (!connected.contains(part.getParent())) {
					connected.add(part.getParent());
				}
			} else {
				connected.add(part);
			}
			AbstractGraphicalEditPart linkedPart = null;
			List children = part.getChildren();
			for (int x = 0; x < children.size(); x++) {
				AbstractGraphicalEditPart p = (AbstractGraphicalEditPart) children
						.get(x);
				enumerateConnectedParts(p, connected);
			}
			// is this element linked to another item?
			for (int x = 0; x < part.getTargetConnections().size(); x++) {
				linkedPart = (AbstractGraphicalEditPart) ((ConnectionNodeEditPart) part
						.getTargetConnections().get(x)).getSource();
				enumerateConnectedParts(linkedPart, connected);
			}
			for (int x = 0; x < part.getSourceConnections().size(); x++) {
				linkedPart = (AbstractGraphicalEditPart) ((ConnectionNodeEditPart) part
						.getSourceConnections().get(x)).getTarget();
				enumerateConnectedParts(linkedPart, connected);
			}
		}
	}

	/**
	 * This method finds single elements and groups of elements, and positions
	 * them starting from the top of the diagram and continuously down the page.
	 */
	private void packDiagram() {
		ActivityDetailDiagramEditPart diagram = (ActivityDetailDiagramEditPart) getGraphicalViewer()
				.getContents();
		// start at the top of the diagram
		// Dimension diagramSize = diagram.getFigure().getSize();
		// no new shapes can be moved above this y-axis value
		int reserved = 0;
		// these are elements without connections
		List<EditPart> stragglers = new ArrayList<EditPart>();
		// these are groups of elements connected with links
		List<List> groups = new ArrayList<List>();
		// these are top level parts on the diagram that have been added
		List diagramParts = diagram.getRecentlyAddedParts();
		for (int x = 0; x < diagramParts.size(); x++) {
			AbstractGraphicalEditPart p = (AbstractGraphicalEditPart) diagramParts
					.get(x);
			boolean found = false;
			for (int g = 0; g < groups.size() && found == false; g++) {
				List group = (List) groups.get(g);
				if (group.contains(p)) {
					found = true;
					break;
				}
			}
			if (!found) {
				List<EditPart> connected = new ArrayList<EditPart>();
				enumerateConnectedParts(p, connected);
				if (connected.size() == 1) {
					stragglers.add(p);
				} else {
					groups.add(connected);
				}
			}
		}
		// process each group closest to the top (min y value)
		while (groups.size() > 0) {
			List top = (List) groups.get(0);
			int topY = getVerticalMinPart(top).getFigure().getBounds().y;
			for (int x = 0; x < groups.size(); x++) {
				List g = (List) groups.get(x);
				int y = getVerticalMinPart(g).getFigure().getBounds().y;
				if (y < topY) {
					top = g;
					topY = y;
				}
			}
			int limit = reserved + 1;
			int verticalDelta = limit - topY;
			int leftX = getHorizontalMinPart(top).getFigure().getBounds().x;
			int horizontalDelta = HORIZ_PIX_PADDING - leftX;
			for (int x = 0; x < top.size(); x++) {
				AbstractGraphicalEditPart p = (AbstractGraphicalEditPart) top
						.get(x);
				Rectangle bounds = p.getFigure().getBounds();
				ChangeBoundsCommand cbc = new ChangeBoundsCommand(transactionDomain,(Node) p
						.getModel(), new Point(bounds.x + horizontalDelta,
						bounds.y + verticalDelta), bounds.width, -1);
				getCommandStack().execute(cbc);
				p.getFigure().setLocation(
						new Point(bounds.x + horizontalDelta, bounds.y
								+ verticalDelta));
				p.refresh();
			}
			int bottomY = getVerticalMaxPart(top).getFigure().getBounds()
					.bottom();
			reserved = bottomY + (VERT_PIX_PADDING * 2);
			groups.remove(top);
		}
		int next = HORIZ_PIX_PADDING;
		for (int x = 0; x < stragglers.size(); x++) {
			int limit = reserved + 1;
			AbstractGraphicalEditPart p = (AbstractGraphicalEditPart) stragglers
					.get(x);
			Rectangle bounds = p.getFigure().getBounds();
			ChangeBoundsCommand cbc = new ChangeBoundsCommand(transactionDomain, (Node) p
					.getModel(), new Point(next, limit), bounds.width, -1);
			getCommandStack().execute(cbc);
			p.getFigure().setLocation(new Point(next, limit));
			p.refresh();
			next += bounds.width + HORIZ_PIX_PADDING;
		}
	}

	private AbstractGraphicalEditPart getVerticalMinPart(List parts) {
		AbstractGraphicalEditPart rc = parts.size() > 0 ? (AbstractGraphicalEditPart) parts
				.get(0)
				: null;
		for (int x = 0; x < parts.size(); x++) {
			AbstractGraphicalEditPart p = (AbstractGraphicalEditPart) parts
					.get(x);
			if (p.getFigure().getBounds().y < rc.getFigure().getBounds().y) {
				rc = p;
			}
		}
		return rc;
	}

	private AbstractGraphicalEditPart getHorizontalMinPart(List parts) {
		AbstractGraphicalEditPart rc = parts.size() > 0 ? (AbstractGraphicalEditPart) parts
				.get(0)
				: null;
		for (int x = 0; x < parts.size(); x++) {
			AbstractGraphicalEditPart p = (AbstractGraphicalEditPart) parts
					.get(x);
			if (p.getFigure().getBounds().x < rc.getFigure().getBounds().x) {
				rc = p;
			}
		}
		return rc;
	}

	private AbstractGraphicalEditPart getVerticalMaxPart(List parts) {
		AbstractGraphicalEditPart rc = parts.size() > 0 ? (AbstractGraphicalEditPart) parts
				.get(0)
				: null;
		for (int x = 0; x < parts.size(); x++) {
			AbstractGraphicalEditPart p = (AbstractGraphicalEditPart) parts
					.get(x);
			if (p.getFigure().getBounds().bottom() > rc.getFigure().getBounds()
					.bottom()) {
				rc = p;
			}
		}
		return rc;
	}

	public void verticalAlignToFirstSelected(List editParts) {
		// get the selected items
		//		List editParts = getGraphicalViewer().getSelectedEditParts();
		AbstractGraphicalEditPart alignToPart = null;
		// find the first diagram part we can align to
		for (int a = 0; a < editParts.size(); a++) {
			if (editParts.get(a) instanceof ShapeNodeEditPart) {
				AbstractGraphicalEditPart ep = (AbstractGraphicalEditPart) editParts
						.get(a);
				if (alignToPart == null) {
					// remember it and stop
					alignToPart = ep;
					break;
				}
			}
		}
		// loop through the elements and set their new position
		for (int a = 0; a < editParts.size(); a++) {
			if (editParts.get(a) instanceof ShapeNodeEditPart) {
				AbstractGraphicalEditPart ep = (AbstractGraphicalEditPart) editParts
						.get(a);
				// we can skip the first one since this is an align-to
				if (ep != alignToPart) {
					// calculate the offset for centerline alignment
					Rectangle bounds = ep.getFigure().getBounds();
					Rectangle alignToPartBounds = alignToPart.getFigure().getBounds();					
					Dimension ps = alignToPart.getFigure().getPreferredSize();					
					int offset =  bounds.getCenter().x - alignToPartBounds.getCenter().x;
					// is this inside a container?
					if (!(ep.getParent() instanceof DiagramEditPart)) {
						// adjust the offset since we are moving the
						// container
						ep = (AbstractGraphicalEditPart) ep.getParent();
						Rectangle parentBounds = ep.getFigure().getBounds();
						offset += bounds.x - parentBounds.x;
						bounds = parentBounds;
					}
					// send the command to move the element
					org.eclipse.gef.commands.Command c = new ChangeBoundsCommand(
							transactionDomain, (Node) ep.getModel(), new Point(
									alignToPart.getFigure().getBounds().x
											- offset, bounds.y), bounds.width,
							-1);
					getCommandStack().execute(c);
					ep.getFigure().setLocation(
							new Point(alignToPart.getFigure().getBounds().x
									- offset, bounds.y));
					Point sp = alignToPart.getFigure().getBounds().getCenter();
					boolean connected = false;
					// check if the part is connected via source connections
					List list = ((ShapeNodeEditPart) alignToPart)
							.getSourceConnections();
					for (Iterator itor = list.iterator(); itor.hasNext();) {
						ConnectionNodeEditPart lp = (ConnectionNodeEditPart) itor
								.next();
						if (lp.getTarget().equals(ep)) {
							connected = true;
							break;
						}
					}
					// if not found above, check if it is connected via target connections
					if (!connected) {
						list = ((ShapeNodeEditPart) alignToPart)
								.getTargetConnections();
						for (Iterator itor = list.iterator(); itor.hasNext();) {
							ConnectionNodeEditPart lp = (ConnectionNodeEditPart) itor
									.next();
							if (lp.getSource().equals(ep)) {
								connected = true;
								break;
							}
						}
					}
					Point p = new Point();
					p.x = ((Integer) ViewUtil.getStructuralFeatureValue(
							(View) ep.getModel(), NotationPackage.eINSTANCE
									.getLocation_X())).intValue();
					p.y = ((Integer) ViewUtil.getStructuralFeatureValue(
							(View) ep.getModel(), NotationPackage.eINSTANCE
									.getLocation_Y())).intValue();
					Point tp = p.getCopy();
					Point centerPoint = ep.getFigure().getBounds().getCenter();
					int delta = sp.x - centerPoint.x;
					tp.x = tp.x + delta;
					c = new ChangeBoundsCommand(transactionDomain, (Node) ep
							.getModel(), tp, ep.getFigure().getBounds().width,
							-1);
					getCommandStack().execute(c);
					ep.getFigure().setLocation(new Point(tp.x, tp.y));
				}
			}
		}
	}
	

	/**
	 * Return height of text of th enode
	 * 
	 * @param node
	 * @return
	 */
	public static Dimension getTextDimension(String text) {
		if (text != null){
			Font f = DiagramConstants.DEFAULT_FONT;
			Dimension d = FigureUtilities.getTextExtents(text, f);

			if (d != null)
				return d;
		}
		return null;
	}
	
	private void anyObliqueLinks(ActivityDetailDiagramEditPart dep,
			List recentlyAddedChildren) {
		List children = dep.getChildren();
		for (Iterator iterator = children.iterator(); iterator.hasNext();) {
			IGraphicalEditPart part = (IGraphicalEditPart) iterator.next();
			if(part instanceof RoleTaskCompositeEditPart){
				List grandChildren = ((RoleTaskCompositeEditPart)part).getChildren();
				for (Iterator iterator2 = grandChildren.iterator(); iterator2
						.hasNext();) {
					ShapeNodeEditPart child = (ShapeNodeEditPart) iterator2
							.next();
					if (child instanceof TaskNodeEditPart) {
						Point p = child.getFigure().getBounds().getCenter();
						List connected = child.getTargetConnections();
						if (!connected.isEmpty()) {
							AbstractGraphicalEditPart linkedPart = (AbstractGraphicalEditPart) ((ConnectionNodeEditPart) connected
									.get(0)).getSource();
							Point pt = linkedPart.getFigure().getBounds()
									.getCenter();
							if (p.x != pt.x) {
								if (!recentlyAddedChildren.contains(part)) {
									recentlyAddedChildren.add(part);
								}
							}
						}
						connected = child.getSourceConnections();
						if (!connected.isEmpty()) {
							AbstractGraphicalEditPart linkedPart = (AbstractGraphicalEditPart) ((ConnectionNodeEditPart)connected
									.get(0)).getSource();
							Point ps = linkedPart.getFigure().getBounds()
									.getCenter();
							if (p.x != ps.x) {
								if (!recentlyAddedChildren.contains(part)) {
									recentlyAddedChildren.add(part);
								}
							}
						}
					}
				}
			}
		}
		
	}
}