plugins/org.eclipse.bpel.ui.noEmbeddedEditors/src/org/eclipse/bpel/ui/editparts/FlowEditPart.java - bpel/org.eclipse.bpel - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 2012 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.bpel.ui.editparts;

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

 import org.eclipse.bpel.model.Activity;
 import org.eclipse.bpel.model.Flow;
 import org.eclipse.bpel.model.Links;
 import org.eclipse.bpel.ui.BPELEditor;
 import org.eclipse.bpel.ui.BPELUIPlugin;
 import org.eclipse.bpel.ui.IBPELUIConstants;
 import org.eclipse.bpel.ui.commands.CompoundCommand;
 import org.eclipse.bpel.ui.commands.SetConstraintCommand;
 import org.eclipse.bpel.ui.editparts.borders.DrawerBorder;
 import org.eclipse.bpel.ui.editparts.borders.FlowBorder;
 import org.eclipse.bpel.ui.editparts.figures.GradientFigure;
 import org.eclipse.bpel.ui.editparts.policies.FlowHighlightEditPolicy;
 import org.eclipse.bpel.ui.editparts.policies.FlowResizeEditPolicy;
 import org.eclipse.bpel.ui.editparts.policies.FlowXYLayoutEditPolicy;
 import org.eclipse.bpel.ui.editparts.util.BPELDecorationLayout;
 import org.eclipse.bpel.ui.editparts.util.GraphAnimation;
 import org.eclipse.bpel.ui.util.BatchedMultiObjectAdapter;
 import org.eclipse.bpel.ui.util.FlowXYLayout;
 import org.eclipse.bpel.ui.util.ModelHelper;
 import org.eclipse.bpel.ui.util.NonclippingXYLayout;
 import org.eclipse.bpel.ui.util.RowColumnLayout;
 import org.eclipse.bpel.ui.util.marker.BPELEditPartMarkerDecorator;
 import org.eclipse.draw2d.IFigure;
 import org.eclipse.draw2d.Label;
 import org.eclipse.draw2d.LayoutManager;
 import org.eclipse.draw2d.PositionConstants;
 import org.eclipse.draw2d.geometry.Dimension;
 import org.eclipse.draw2d.geometry.Insets;
 import org.eclipse.draw2d.geometry.Point;
 import org.eclipse.draw2d.geometry.Rectangle;
 import org.eclipse.draw2d.graph.DirectedGraph;
 import org.eclipse.draw2d.graph.DirectedGraphLayout;
 import org.eclipse.draw2d.graph.Edge;
 import org.eclipse.draw2d.graph.Node;
 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.common.notify.Notifier;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.util.EContentAdapter;
 import org.eclipse.gef.EditPart;
 import org.eclipse.gef.EditPolicy;
 import org.eclipse.gef.GraphicalEditPart;
 import org.eclipse.gef.commands.CommandStackListener;

 public class FlowEditPart extends CollapsableEditPart {

 	private FlowBorder flowBorder;

 	private EContentAdapter flowContentAdapter;

 	private BatchedMultiObjectAdapter flowBatchedAdapter;

 	protected boolean smoothLayout = false;

 	protected FlowHighlightEditPolicy flowHighlightEditPolicy;

 	@Override
 	protected void addAllAdapters() {
 		super.addAllAdapters();
 		Links links = ((Flow) getActivity()).getLinks();
 		if (links != null) {
 			adapter.addToObject(links);
 		}
 	}

 	// TODO: this looks strange.. what is it really doing??
 	CommandStackListener stackListener = new CommandStackListener() {
 		public void commandStackChanged(EventObject event) {
 			if (!isSmoothLayout())
 				return;

 			setSmoothLayout(false);

 			if (!GraphAnimation.captureLayout(getFigure()))
 				return;

 			while (GraphAnimation.step())
 				getFigure().getUpdateManager().performUpdate();
 			GraphAnimation.end();

 		}
 	};

 	class FlowDecorationLayout extends BPELDecorationLayout {
 		@Override
 		protected Point calculateLocation(int locationHint, IFigure container,
 				Dimension childDimension) {
 			Rectangle area = container.getClientArea();
 			switch (locationHint) {
 				case PositionConstants.CENTER:
 					// Center
 					return new Point(area.x + area.width / 2
 							- childDimension.width / 2, area.y + area.height
 							/ 2 - childDimension.height / 2);
 				case PositionConstants.TOP:
 					// Top Center
 					return new Point(area.x + area.width / 2
 							- childDimension.width / 2, area.y
 							+ FlowBorder.LINE_WIDTH);
 				case PositionConstants.BOTTOM:
 					// Bottom Center
 					return new Point(area.x + area.width / 2
 							- childDimension.width / 2, area.y + area.height
 							- childDimension.height - FlowBorder.LINE_WIDTH);
 				case PositionConstants.LEFT: {
 					// Center Left
 					int x = area.x + DrawerBorder.DRAWER_WIDTH;
 					int y = area.y;
 					if (isCollapsed()) {
 						y += container.getBounds().height / 2;
 					} else {
 						y += area.height / 2 - childDimension.width / 2;
 					}
 					return new Point(x, y);
 				}
 				case PositionConstants.RIGHT: {
 					// Center Right
 					int x = area.x + area.width - DrawerBorder.DRAWER_WIDTH
 							- childDimension.width;
 					int y = area.y;
 					if (isCollapsed()) {
 						y += container.getBounds().height / 2;
 					} else {
 						y += area.height / 2 - childDimension.width / 2;
 					}
 					return new Point(x, y);
 				}
 				case PositionConstants.TOP | PositionConstants.LEFT: {
 					// Top Left
 					int x = area.x + DrawerBorder.DRAWER_WIDTH;
 					int y = area.y;
 					if (isCollapsed()) {
 						y += image.getBounds().height / 2;
 					}
 					return new Point(x, y);
 				}
 				case PositionConstants.TOP | PositionConstants.RIGHT: {
 					// Top Right
 					int x = area.x + area.width - DrawerBorder.DRAWER_WIDTH
 							- childDimension.width;
 					int y = area.y;
 					if (isCollapsed()) {
 						y += image.getBounds().height / 2;
 					}
 					return new Point(x, y);
 				}
 				case PositionConstants.BOTTOM | PositionConstants.LEFT: {
 					// Bottom Left
 					int x = area.x + DrawerBorder.DRAWER_WIDTH;
 					int y = area.y + area.height
 							- (image.getBounds().height / 2);
 					return new Point(x, y);
 				}
 				case PositionConstants.BOTTOM | PositionConstants.RIGHT: {
 					// Bottom Right
 					int x = area.x + area.width - DrawerBorder.DRAWER_WIDTH
 							- childDimension.width;
 					int y = area.y + area.height
 							- (image.getBounds().height / 2);
 					return new Point(x, y);
 				}
 				default:
 					return new Point(area.x, area.y);
 			}
 		}
 	}

 	public FlowEditPart() {
 		super();

 		// in order to create a batched EContentAdapter we
 		// basically delegate the notifications to a real
 		// batched adapter
 		flowContentAdapter = new EContentAdapter() {
 			@Override
 			public void notifyChanged(Notification n) {
 				switch (n.getEventType()) {
 					case Notification.ADD_MANY:
 					case Notification.REMOVE_MANY:
 					case Notification.ADD:
 					case Notification.REMOVE:
 					case Notification.SET:
 					case Notification.UNSET:
 					case Notification.MOVE:
 						flowBatchedAdapter.notifyChanged(n);
 				}
 				super.notifyChanged(n);
 			}
 		};
 		// do not add this adapter to model objects - it is called
 		// from the flow content adapter
 		flowBatchedAdapter = new BatchedMultiObjectAdapter() {
 			protected boolean refreshLayout = false;

 			@Override
 			public void finish() {
 				if (refreshLayout) {
 					if (getAutoLayout())
 						doAutoLayout(false);
 				}
 				refreshLayout = false;
 			}

 			@Override
 			public void notify(Notification n) {
 				if (isActive()) {
 					refreshLayout = true;
 				}
 			}
 		};
 	}

 	@Override
 	protected void addChildVisual(EditPart childEditPart, int index) {
 		IFigure child = ((GraphicalEditPart) childEditPart).getFigure();
 		getContentPane().add(child,
 				getFigure().getLayoutManager().getConstraint(child), index);
 		// Bugzilla 319215
 		// addChildVisual() is also called by reorderChild() to rearrange the order of children.
 		// This causes auto layout to reference a child object with a model that has no parent.
 		// The right place to auto arrange Flow children if no *.bpelex exists yet, is in
 		// BPELEditor.arrangeEditParts() after the model is loaded
 //		if (getShowFreeformFlow() && getAutoLayout())
 //			doAutoLayout(false);
 	}

 	protected void setFlowEditPolicies() {
 		installEditPolicy(EditPolicy.LAYOUT_ROLE, new FlowXYLayoutEditPolicy());
 		flowHighlightEditPolicy = new FlowHighlightEditPolicy(!collapsed) {
 			@Override
 			protected int getDrawerInset() {
 				return DrawerBorder.DRAWER_WIDTH;
 			}

 			@Override
 			protected int getNorthInset() {
 				if (isCollapsed()) {
 					return 2;
 				} else {
 					return 2;
 				}
 			}

 			@Override
 			protected int getSouthInset() {
 				return 0;
 			}

 			@Override
 			protected int getEastInset() {
 				return DrawerBorder.DRAWER_WIDTH;
 			}

 			@Override
 			protected int getWestInset() {
 				return DrawerBorder.DRAWER_WIDTH + 2;
 			}
 		};
 		installEditPolicy(EditPolicy.SELECTION_FEEDBACK_ROLE,
 				flowHighlightEditPolicy);
 	}

 	@Override
 	protected void createEditPolicies() {
 		super.createEditPolicies();
 		// installEditPolicy(EditPolicy.NODE_ROLE, null);
 		setFlowEditPolicies();
 		installEditPolicy("childFlowResize", new FlowResizeEditPolicy()); //$NON-NLS-1$
 	}

 	@Override
 	public Label getLabelFigure() {
 		if (isCollapsed())
 			return super.getLabelFigure();
 		return null;
 	}

 	@Override
 	public void setCollapsed(boolean collapsed) {
 		if (collapsed != this.collapsed) {
 			if (flowHighlightEditPolicy != null) {
 				flowHighlightEditPolicy.setResizable(!collapsed);
 			}
 		}
 		super.setCollapsed(collapsed);
 	}

 	@Override
 	protected IFigure createFigure() {
 		createEditPolicies(); // reset the edit policies based on flow display
 								// mode
 		initializeLabels();

 		editPartMarkerDecorator = new BPELEditPartMarkerDecorator(
 				(EObject) getModel(), new FlowDecorationLayout());
 		editPartMarkerDecorator
 				.addMarkerMotionListener(getMarkerMotionListener());

 		IFigure figure = new GradientFigure(getModel());
 		if (collapsed) {
 			addCollapsedContents(figure);
 		} else {
 			configureExpandedFigure(figure);
 		}
 		this.contentFigure = figure;

 		return editPartMarkerDecorator.createFigure(figure);
 	}

 	@Override
 	protected void configureExpandedFigure(IFigure figure) {
 		LayoutManager layout;

 		if (!getShowFreeformFlow()) {
 			layout = new RowColumnLayout();
 		} else {
 			FlowXYLayout xylayout = new FlowXYLayout(this);
 			Dimension d = ModelHelper.getSize(getFlow());
 			if (d.height != 0 && d.width != 0)
 				xylayout.setSize(d);
 			layout = xylayout;
 		}

 		figure.setLayoutManager(layout);

 		if (!(figure.getBorder() instanceof FlowBorder)) {
 			flowBorder = new FlowBorder(figure);
 			figure.setBorder(this.flowBorder);
 			this.flowBorder.setEditPart(this);
 		}
 		figure.addMouseMotionListener(getMouseMotionListener());
 		this.flowBorder.setEditPart(this);
 	}

 	protected Flow getFlow() {
 		return (Flow) getModel();
 	}

 	@Override
 	protected boolean isCollapsable() {
 		return true;
 	}

 	@Override
 	public void deactivate() {
 		if (!isActive())
 			return;
 		super.deactivate();
 		((Notifier) getModel()).eAdapters().remove(flowContentAdapter);

 		getViewer().getEditDomain().getCommandStack()
 				.removeCommandStackListener(stackListener);
 	}

 	private boolean getShowFreeformFlow() {
 		return BPELUIPlugin.INSTANCE.getPreferenceStore().getBoolean(
 				IBPELUIConstants.PREF_SHOW_FREEFORM_FLOW);
 	}

 	private boolean getAutoLayout() {
 		return BPELUIPlugin.INSTANCE.getPreferenceStore().getBoolean(
 				IBPELUIConstants.PREF_AUTO_FLOW_LAYOUT);
 	}

 	@Override
 	public IFigure getContentPane() {
 		return contentFigure;
 	}

 	public boolean isShowFreeform() {
 		return (getContentPane().getLayoutManager() instanceof NonclippingXYLayout);
 	}

 	@Override
 	public void regenerateVisuals() {
 		if (collapsed) {
 			addCollapsedContents(this.contentFigure);
 		} else {
 			configureExpandedFigure(this.contentFigure);
 		}
 		setFlowEditPolicies();
 		// This is necessary because..we may have replaced the border!
 		refreshDrawerImages();

 		if (getShowFreeformFlow() && getAutoLayout())
 			doAutoLayout(false);
 	}

 	public DirectedGraph computeAutoLayoutGraph(Map partsToNodes) {
 		DirectedGraph graph = new DirectedGraph();
 		graph.setDefaultPadding(new Insets(8, 8, 10, 8));
 		Node top = new Node(null);
 		graph.nodes.add(top);
 		top.width = top.height = 0;
 		top.setPadding(new Insets(-8, 0, 0, 0));

 		List nodesWithoutPreds = new ArrayList();

 		for (Iterator it = getChildren().iterator(); it.hasNext();) {
 			Object object = it.next();
 			if (object instanceof BPELEditPart) {
 				BPELEditPart editPart = (BPELEditPart) object;
 				Node n = new Node(editPart);
 				n.width = editPart.getFigure().getPreferredSize().width;
 				n.height = editPart.getFigure().getPreferredSize().height;
 				n.sortValue = getFigure().getBounds().x;
 				graph.nodes.add(n);
 				partsToNodes.put(editPart, n);
 				nodesWithoutPreds.add(n);
 				// TODO: pre-sort node list based on x-coords of existing
 				// constraints?
 			} else {
 				// System.out.println(object);
 			}
 		}
 		for (Iterator it = getChildren().iterator(); it.hasNext();) {
 			Object object = it.next();
 			if (object instanceof BPELEditPart) {
 				Node target = (Node) partsToNodes.get(object);
 				if (target == null)
 					continue;

 				for (Iterator it2 = ((BPELEditPart) object)
 						.getTargetConnections().iterator(); it2.hasNext();) {
 					Object object2 = it2.next();
 					if (object2 instanceof LinkEditPart) {
 						LinkEditPart link = (LinkEditPart) object2;
 						Node source = (Node) partsToNodes.get(link.getSource());
 						if (source != null) {
 							graph.edges.add(new Edge(source, target));
 							nodesWithoutPreds.remove(target);
 						}
 					}
 				}
 			}
 		}
 		for (Iterator it = nodesWithoutPreds.iterator(); it.hasNext();) {
 			graph.edges.add(new Edge(top, (Node) it.next()));
 		}

 		new DirectedGraphLayout().visit(graph);

 		return graph;
 	}

 	public void doImmediateAutoLayout() {
 		Map<BPELEditPart, Node> partsToNodes = new HashMap<BPELEditPart, Node>();
 		if (BPELUIPlugin.INSTANCE.getPreferenceStore().getBoolean(
 				IBPELUIConstants.PREF_USE_ANIMATION)) {
 			setSmoothLayout(true);
 		}
 		computeAutoLayoutGraph(partsToNodes);

 		for (Iterator it = getChildren().iterator(); it.hasNext();) {
 			Object object = it.next();
 			if (object instanceof BPELEditPart) {
 				BPELEditPart editPart = (BPELEditPart) object;

 				Node n = partsToNodes.get(editPart);
 				Point loc = new Point(n.x, n.y);
 				// TODO: I think this is wrong
 				// getFigure().translateToRelative(loc);

 				ModelHelper.setLocation((Activity) editPart.getModel(), loc);
 			}
 		}
 	}

 	public void doAutoLayout() {
 		doAutoLayout(true);
 	}

 	public void doAutoLayout(boolean withCommand) {
 		Map<BPELEditPart, Node> partsToNodes = new HashMap<BPELEditPart, Node>();
 		this.getFigure().invalidateTree();
 		if (BPELUIPlugin.INSTANCE.getPreferenceStore().getBoolean(
 				IBPELUIConstants.PREF_USE_ANIMATION)) {
 			setSmoothLayout(true);
 		}
 		computeAutoLayoutGraph(partsToNodes);

 		CompoundCommand cmd = new CompoundCommand();
 		cmd.setLabel(IBPELUIConstants.CMD_AUTO_ARRANGE);

 		BPELEditor bpelEditor = ModelHelper.getBPELEditor(getModel());

 		for (Iterator it = getChildren().iterator(); it.hasNext();) {
 			Object object = it.next();
 			if (object instanceof BPELEditPart) {
 				BPELEditPart editPart = (BPELEditPart) object;

 				Node n = partsToNodes.get(editPart);
 				Point loc = new Point(n.x, n.y);
 				// TODO: I think this is wrong
 				// getFigure().translateToRelative(loc);

 				SetConstraintCommand cmd2 = new SetConstraintCommand(
 						(Activity) editPart.getModel(), loc, null);
 				if (withCommand) {
 					cmd.add(cmd2);
 				} else {
 					cmd2.execute();
 				}
 			}
 		}
 		if (withCommand) {
 			regenerateVisuals();
 			bpelEditor.getCommandStack().execute(cmd);
 		}
 	}

 	@Override
 	protected void handleModelChanged() {
 		// The size of the flow may have changed. Rebuild the edit part.

 		// move this line to top of function, must call refreshChildren() to
 		// make sure the gef is in sync with model before we regenerate visuals
 		// and do an autolayout
 		refreshChildren();

 		super.handleModelChanged();
 		regenerateVisuals();
 	}

 	@Override
 	public void activate() {
 		super.activate();
 		((Notifier) getModel()).eAdapters().add(flowContentAdapter);

 		getViewer().getEditDomain().getCommandStack().addCommandStackListener(
 				stackListener);
 	}

 	public boolean isSmoothLayout() {
 		return smoothLayout;
 	}

 	public void setSmoothLayout(boolean smoothLayout) {
 		this.smoothLayout = smoothLayout;
 	}

 	/* a couple of utility classes for use in the cycle detection code */

 	/** represents an edge connection for an editpart * */

 	private class EditPartEdge {
 		private EditPartNode source, dest;

 		public EditPartEdge(EditPartNode source, EditPartNode dest) {
 			this.source = source;
 			this.dest = dest;
 		}

 		public EditPartNode getDest() {
 			return dest;
 		}

 		public EditPartNode getSource() {
 			return source;
 		}
 	}

 	/**
 	 * represents an node in a graph The main feature is a visit function which
 	 * marks the visited node and returns false if cycle detected
 	 */

 	private class EditPartNode {
 		public static final int VISITING = 1, VISITED = 2, NOTVISITED = 0;

 		private EditPart part;

 		private List edges = new ArrayList();

 		public int visited = NOTVISITED;

 		public EditPartNode(EditPart part) {
 			this.part = part;
 		}

 		public EditPart getPart() {
 			return part;
 		}

 		public int getVisited() {
 			return visited;
 		}

 		public void addEdge(EditPartEdge edge) {
 			edges.add(edge);
 		}

 		/** returns false if cycle detected * */
 		public boolean visit() {
 			EditPartEdge e;
 			if (visited == VISITING) {
 				return false;
 			}
 			if (visited == VISITED)
 				return true;
 			visited = VISITING;
 			for (Iterator it = edges.iterator(); it.hasNext();) {
 				e = (EditPartEdge) it.next();
 				// if (e.getSource() == this)
 				if (e.getDest().visit() == false)
 					return false;
 			}
 			visited = VISITED;
 			return true;
 		}
 	}

 	/**
 	 * checks if a new connection joining sourceNode and potentialDest will
 	 * result in a cycle *
 	 */

 	public boolean detectImpendingCycle(EditPart sourceNode,
 			EditPart potentialDest) {
 		List<EditPartNode> nodes = new ArrayList<EditPartNode>();

 		Map<BPELEditPart, EditPartNode> partsToNodes = new HashMap<BPELEditPart, EditPartNode>();

 		// strategy: we'll build up a separate parallel graph that we can
 		// traverse to detect cycles.
 		// We are essentially duplicating the Flow's
 		// graph structure, but this is easiest since we don't have a way of
 		// "simulating a link between
 		// for the proposed link, and we don't want to pollute the editparts
 		// extraneous methods and fields
 		// just for cycle detection logic, this will have to do for now.

 		for (Iterator it = getChildren().iterator(); it.hasNext();) {
 			Object object = it.next();
 			if (object instanceof BPELEditPart) {
 				BPELEditPart editPart = (BPELEditPart) object;
 				EditPartNode n = new EditPartNode(editPart);
 				nodes.add(n);
 				partsToNodes.put(editPart, n);
 			}
 		}

 		for (Iterator it = getChildren().iterator(); it.hasNext();) {
 			Object object = it.next();
 			if (object instanceof BPELEditPart) {
 				EditPartNode source = partsToNodes.get(object);
 				if (source == null)
 					continue;

 				for (Iterator it2 = ((BPELEditPart) object)
 						.getSourceConnections().iterator(); it2.hasNext();) {
 					Object targetObject = it2.next();
 					if (targetObject instanceof LinkEditPart) {
 						LinkEditPart linkEditPart = (LinkEditPart) targetObject;
 						EditPartNode target = partsToNodes
 								.get(linkEditPart.getTarget());
 						if (target != null) {
 							source.addEdge(new EditPartEdge(source, target));
 						}
 					}
 				}
 			}
 		}

 		// add the proposed edge
 		EditPartNode source = partsToNodes.get(sourceNode);
 		if (source != null) {
 			EditPartNode target = partsToNodes
 					.get(potentialDest);
 			if (target != null) {
 				source.addEdge(new EditPartEdge(source, target));
 			}
 		}

 		/* visit each node checking if a cycle will result */
 		for (Iterator<EditPartNode> it = nodes.iterator(); it.hasNext();) {
 			EditPartNode v = it.next();
 			if (v.getVisited() == EditPartNode.NOTVISITED)
 				if (v.visit() == false)
 					return false;
 		}

 		return true;
 	}

 	public void switchLayout(boolean horizontal) {
 		// Actually does nothing
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2005, 2012 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.bpel.ui.editparts;

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

	import org.eclipse.bpel.model.Activity;
	import org.eclipse.bpel.model.Flow;
	import org.eclipse.bpel.model.Links;
	import org.eclipse.bpel.ui.BPELEditor;
	import org.eclipse.bpel.ui.BPELUIPlugin;
	import org.eclipse.bpel.ui.IBPELUIConstants;
	import org.eclipse.bpel.ui.commands.CompoundCommand;
	import org.eclipse.bpel.ui.commands.SetConstraintCommand;
	import org.eclipse.bpel.ui.editparts.borders.DrawerBorder;
	import org.eclipse.bpel.ui.editparts.borders.FlowBorder;
	import org.eclipse.bpel.ui.editparts.figures.GradientFigure;
	import org.eclipse.bpel.ui.editparts.policies.FlowHighlightEditPolicy;
	import org.eclipse.bpel.ui.editparts.policies.FlowResizeEditPolicy;
	import org.eclipse.bpel.ui.editparts.policies.FlowXYLayoutEditPolicy;
	import org.eclipse.bpel.ui.editparts.util.BPELDecorationLayout;
	import org.eclipse.bpel.ui.editparts.util.GraphAnimation;
	import org.eclipse.bpel.ui.util.BatchedMultiObjectAdapter;
	import org.eclipse.bpel.ui.util.FlowXYLayout;
	import org.eclipse.bpel.ui.util.ModelHelper;
	import org.eclipse.bpel.ui.util.NonclippingXYLayout;
	import org.eclipse.bpel.ui.util.RowColumnLayout;
	import org.eclipse.bpel.ui.util.marker.BPELEditPartMarkerDecorator;
	import org.eclipse.draw2d.IFigure;
	import org.eclipse.draw2d.Label;
	import org.eclipse.draw2d.LayoutManager;
	import org.eclipse.draw2d.PositionConstants;
	import org.eclipse.draw2d.geometry.Dimension;
	import org.eclipse.draw2d.geometry.Insets;
	import org.eclipse.draw2d.geometry.Point;
	import org.eclipse.draw2d.geometry.Rectangle;
	import org.eclipse.draw2d.graph.DirectedGraph;
	import org.eclipse.draw2d.graph.DirectedGraphLayout;
	import org.eclipse.draw2d.graph.Edge;
	import org.eclipse.draw2d.graph.Node;
	import org.eclipse.emf.common.notify.Notification;
	import org.eclipse.emf.common.notify.Notifier;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.ecore.util.EContentAdapter;
	import org.eclipse.gef.EditPart;
	import org.eclipse.gef.EditPolicy;
	import org.eclipse.gef.GraphicalEditPart;
	import org.eclipse.gef.commands.CommandStackListener;

	public class FlowEditPart extends CollapsableEditPart {

	private FlowBorder flowBorder;

	private EContentAdapter flowContentAdapter;

	private BatchedMultiObjectAdapter flowBatchedAdapter;

	protected boolean smoothLayout = false;

	protected FlowHighlightEditPolicy flowHighlightEditPolicy;

	@Override
	protected void addAllAdapters() {
	super.addAllAdapters();
	Links links = ((Flow) getActivity()).getLinks();
	if (links != null) {
	adapter.addToObject(links);
	}
	}

	// TODO: this looks strange.. what is it really doing??
	CommandStackListener stackListener = new CommandStackListener() {
	public void commandStackChanged(EventObject event) {
	if (!isSmoothLayout())
	return;

	setSmoothLayout(false);

	if (!GraphAnimation.captureLayout(getFigure()))
	return;

	while (GraphAnimation.step())
	getFigure().getUpdateManager().performUpdate();
	GraphAnimation.end();

	}
	};

	class FlowDecorationLayout extends BPELDecorationLayout {
	@Override
	protected Point calculateLocation(int locationHint, IFigure container,
	Dimension childDimension) {
	Rectangle area = container.getClientArea();
	switch (locationHint) {
	case PositionConstants.CENTER:
	// Center
	return new Point(area.x + area.width / 2
	- childDimension.width / 2, area.y + area.height
	/ 2 - childDimension.height / 2);
	case PositionConstants.TOP:
	// Top Center
	return new Point(area.x + area.width / 2
	- childDimension.width / 2, area.y
	+ FlowBorder.LINE_WIDTH);
	case PositionConstants.BOTTOM:
	// Bottom Center
	return new Point(area.x + area.width / 2
	- childDimension.width / 2, area.y + area.height
	- childDimension.height - FlowBorder.LINE_WIDTH);
	case PositionConstants.LEFT: {
	// Center Left
	int x = area.x + DrawerBorder.DRAWER_WIDTH;
	int y = area.y;
	if (isCollapsed()) {
	y += container.getBounds().height / 2;
	} else {
	y += area.height / 2 - childDimension.width / 2;
	}
	return new Point(x, y);
	}
	case PositionConstants.RIGHT: {
	// Center Right
	int x = area.x + area.width - DrawerBorder.DRAWER_WIDTH
	- childDimension.width;
	int y = area.y;
	if (isCollapsed()) {
	y += container.getBounds().height / 2;
	} else {
	y += area.height / 2 - childDimension.width / 2;
	}
	return new Point(x, y);
	}
	case PositionConstants.TOP \| PositionConstants.LEFT: {
	// Top Left
	int x = area.x + DrawerBorder.DRAWER_WIDTH;
	int y = area.y;
	if (isCollapsed()) {
	y += image.getBounds().height / 2;
	}
	return new Point(x, y);
	}
	case PositionConstants.TOP \| PositionConstants.RIGHT: {
	// Top Right
	int x = area.x + area.width - DrawerBorder.DRAWER_WIDTH
	- childDimension.width;
	int y = area.y;
	if (isCollapsed()) {
	y += image.getBounds().height / 2;
	}
	return new Point(x, y);
	}
	case PositionConstants.BOTTOM \| PositionConstants.LEFT: {
	// Bottom Left
	int x = area.x + DrawerBorder.DRAWER_WIDTH;
	int y = area.y + area.height
	- (image.getBounds().height / 2);
	return new Point(x, y);
	}
	case PositionConstants.BOTTOM \| PositionConstants.RIGHT: {
	// Bottom Right
	int x = area.x + area.width - DrawerBorder.DRAWER_WIDTH
	- childDimension.width;
	int y = area.y + area.height
	- (image.getBounds().height / 2);
	return new Point(x, y);
	}
	default:
	return new Point(area.x, area.y);
	}
	}
	}

	public FlowEditPart() {
	super();

	// in order to create a batched EContentAdapter we
	// basically delegate the notifications to a real
	// batched adapter
	flowContentAdapter = new EContentAdapter() {
	@Override
	public void notifyChanged(Notification n) {
	switch (n.getEventType()) {
	case Notification.ADD_MANY:
	case Notification.REMOVE_MANY:
	case Notification.ADD:
	case Notification.REMOVE:
	case Notification.SET:
	case Notification.UNSET:
	case Notification.MOVE:
	flowBatchedAdapter.notifyChanged(n);
	}
	super.notifyChanged(n);
	}
	};
	// do not add this adapter to model objects - it is called
	// from the flow content adapter
	flowBatchedAdapter = new BatchedMultiObjectAdapter() {
	protected boolean refreshLayout = false;

	@Override
	public void finish() {
	if (refreshLayout) {
	if (getAutoLayout())
	doAutoLayout(false);
	}
	refreshLayout = false;
	}

	@Override
	public void notify(Notification n) {
	if (isActive()) {
	refreshLayout = true;
	}
	}
	};
	}

	@Override
	protected void addChildVisual(EditPart childEditPart, int index) {
	IFigure child = ((GraphicalEditPart) childEditPart).getFigure();
	getContentPane().add(child,
	getFigure().getLayoutManager().getConstraint(child), index);
	// Bugzilla 319215
	// addChildVisual() is also called by reorderChild() to rearrange the order of children.
	// This causes auto layout to reference a child object with a model that has no parent.
	// The right place to auto arrange Flow children if no *.bpelex exists yet, is in
	// BPELEditor.arrangeEditParts() after the model is loaded
	// if (getShowFreeformFlow() && getAutoLayout())
	// doAutoLayout(false);
	}

	protected void setFlowEditPolicies() {
	installEditPolicy(EditPolicy.LAYOUT_ROLE, new FlowXYLayoutEditPolicy());
	flowHighlightEditPolicy = new FlowHighlightEditPolicy(!collapsed) {
	@Override
	protected int getDrawerInset() {
	return DrawerBorder.DRAWER_WIDTH;
	}

	@Override
	protected int getNorthInset() {
	if (isCollapsed()) {
	return 2;
	} else {
	return 2;
	}
	}

	@Override
	protected int getSouthInset() {
	return 0;
	}

	@Override
	protected int getEastInset() {
	return DrawerBorder.DRAWER_WIDTH;
	}

	@Override
	protected int getWestInset() {
	return DrawerBorder.DRAWER_WIDTH + 2;
	}
	};
	installEditPolicy(EditPolicy.SELECTION_FEEDBACK_ROLE,
	flowHighlightEditPolicy);
	}

	@Override
	protected void createEditPolicies() {
	super.createEditPolicies();
	// installEditPolicy(EditPolicy.NODE_ROLE, null);
	setFlowEditPolicies();
	installEditPolicy("childFlowResize", new FlowResizeEditPolicy()); //$NON-NLS-1$
	}

	@Override
	public Label getLabelFigure() {
	if (isCollapsed())
	return super.getLabelFigure();
	return null;
	}

	@Override
	public void setCollapsed(boolean collapsed) {
	if (collapsed != this.collapsed) {
	if (flowHighlightEditPolicy != null) {
	flowHighlightEditPolicy.setResizable(!collapsed);
	}
	}
	super.setCollapsed(collapsed);
	}

	@Override
	protected IFigure createFigure() {
	createEditPolicies(); // reset the edit policies based on flow display
	// mode
	initializeLabels();

	editPartMarkerDecorator = new BPELEditPartMarkerDecorator(
	(EObject) getModel(), new FlowDecorationLayout());
	editPartMarkerDecorator
	.addMarkerMotionListener(getMarkerMotionListener());

	IFigure figure = new GradientFigure(getModel());
	if (collapsed) {
	addCollapsedContents(figure);
	} else {
	configureExpandedFigure(figure);
	}
	this.contentFigure = figure;

	return editPartMarkerDecorator.createFigure(figure);
	}

	@Override
	protected void configureExpandedFigure(IFigure figure) {
	LayoutManager layout;

	if (!getShowFreeformFlow()) {
	layout = new RowColumnLayout();
	} else {
	FlowXYLayout xylayout = new FlowXYLayout(this);
	Dimension d = ModelHelper.getSize(getFlow());
	if (d.height != 0 && d.width != 0)
	xylayout.setSize(d);
	layout = xylayout;
	}

	figure.setLayoutManager(layout);

	if (!(figure.getBorder() instanceof FlowBorder)) {
	flowBorder = new FlowBorder(figure);
	figure.setBorder(this.flowBorder);
	this.flowBorder.setEditPart(this);
	}
	figure.addMouseMotionListener(getMouseMotionListener());
	this.flowBorder.setEditPart(this);
	}

	protected Flow getFlow() {
	return (Flow) getModel();
	}

	@Override
	protected boolean isCollapsable() {
	return true;
	}

	@Override
	public void deactivate() {
	if (!isActive())
	return;
	super.deactivate();
	((Notifier) getModel()).eAdapters().remove(flowContentAdapter);

	getViewer().getEditDomain().getCommandStack()
	.removeCommandStackListener(stackListener);
	}

	private boolean getShowFreeformFlow() {
	return BPELUIPlugin.INSTANCE.getPreferenceStore().getBoolean(
	IBPELUIConstants.PREF_SHOW_FREEFORM_FLOW);
	}

	private boolean getAutoLayout() {
	return BPELUIPlugin.INSTANCE.getPreferenceStore().getBoolean(
	IBPELUIConstants.PREF_AUTO_FLOW_LAYOUT);
	}

	@Override
	public IFigure getContentPane() {
	return contentFigure;
	}

	public boolean isShowFreeform() {
	return (getContentPane().getLayoutManager() instanceof NonclippingXYLayout);
	}

	@Override
	public void regenerateVisuals() {
	if (collapsed) {
	addCollapsedContents(this.contentFigure);
	} else {
	configureExpandedFigure(this.contentFigure);
	}
	setFlowEditPolicies();
	// This is necessary because..we may have replaced the border!
	refreshDrawerImages();

	if (getShowFreeformFlow() && getAutoLayout())
	doAutoLayout(false);
	}

	public DirectedGraph computeAutoLayoutGraph(Map partsToNodes) {
	DirectedGraph graph = new DirectedGraph();
	graph.setDefaultPadding(new Insets(8, 8, 10, 8));
	Node top = new Node(null);
	graph.nodes.add(top);
	top.width = top.height = 0;
	top.setPadding(new Insets(-8, 0, 0, 0));

	List nodesWithoutPreds = new ArrayList();

	for (Iterator it = getChildren().iterator(); it.hasNext();) {
	Object object = it.next();
	if (object instanceof BPELEditPart) {
	BPELEditPart editPart = (BPELEditPart) object;
	Node n = new Node(editPart);
	n.width = editPart.getFigure().getPreferredSize().width;
	n.height = editPart.getFigure().getPreferredSize().height;
	n.sortValue = getFigure().getBounds().x;
	graph.nodes.add(n);
	partsToNodes.put(editPart, n);
	nodesWithoutPreds.add(n);
	// TODO: pre-sort node list based on x-coords of existing
	// constraints?
	} else {
	// System.out.println(object);
	}
	}
	for (Iterator it = getChildren().iterator(); it.hasNext();) {
	Object object = it.next();
	if (object instanceof BPELEditPart) {
	Node target = (Node) partsToNodes.get(object);
	if (target == null)
	continue;

	for (Iterator it2 = ((BPELEditPart) object)
	.getTargetConnections().iterator(); it2.hasNext();) {
	Object object2 = it2.next();
	if (object2 instanceof LinkEditPart) {
	LinkEditPart link = (LinkEditPart) object2;
	Node source = (Node) partsToNodes.get(link.getSource());
	if (source != null) {
	graph.edges.add(new Edge(source, target));
	nodesWithoutPreds.remove(target);
	}
	}
	}
	}
	}
	for (Iterator it = nodesWithoutPreds.iterator(); it.hasNext();) {
	graph.edges.add(new Edge(top, (Node) it.next()));
	}

	new DirectedGraphLayout().visit(graph);

	return graph;
	}

	public void doImmediateAutoLayout() {
	Map<BPELEditPart, Node> partsToNodes = new HashMap<BPELEditPart, Node>();
	if (BPELUIPlugin.INSTANCE.getPreferenceStore().getBoolean(
	IBPELUIConstants.PREF_USE_ANIMATION)) {
	setSmoothLayout(true);
	}
	computeAutoLayoutGraph(partsToNodes);

	for (Iterator it = getChildren().iterator(); it.hasNext();) {
	Object object = it.next();
	if (object instanceof BPELEditPart) {
	BPELEditPart editPart = (BPELEditPart) object;

	Node n = partsToNodes.get(editPart);
	Point loc = new Point(n.x, n.y);
	// TODO: I think this is wrong
	// getFigure().translateToRelative(loc);

	ModelHelper.setLocation((Activity) editPart.getModel(), loc);
	}
	}
	}

	public void doAutoLayout() {
	doAutoLayout(true);
	}

	public void doAutoLayout(boolean withCommand) {
	Map<BPELEditPart, Node> partsToNodes = new HashMap<BPELEditPart, Node>();
	this.getFigure().invalidateTree();
	if (BPELUIPlugin.INSTANCE.getPreferenceStore().getBoolean(
	IBPELUIConstants.PREF_USE_ANIMATION)) {
	setSmoothLayout(true);
	}
	computeAutoLayoutGraph(partsToNodes);

	CompoundCommand cmd = new CompoundCommand();
	cmd.setLabel(IBPELUIConstants.CMD_AUTO_ARRANGE);

	BPELEditor bpelEditor = ModelHelper.getBPELEditor(getModel());

	for (Iterator it = getChildren().iterator(); it.hasNext();) {
	Object object = it.next();
	if (object instanceof BPELEditPart) {
	BPELEditPart editPart = (BPELEditPart) object;

	Node n = partsToNodes.get(editPart);
	Point loc = new Point(n.x, n.y);
	// TODO: I think this is wrong
	// getFigure().translateToRelative(loc);

	SetConstraintCommand cmd2 = new SetConstraintCommand(
	(Activity) editPart.getModel(), loc, null);
	if (withCommand) {
	cmd.add(cmd2);
	} else {
	cmd2.execute();
	}
	}
	}
	if (withCommand) {
	regenerateVisuals();
	bpelEditor.getCommandStack().execute(cmd);
	}
	}

	@Override
	protected void handleModelChanged() {
	// The size of the flow may have changed. Rebuild the edit part.

	// move this line to top of function, must call refreshChildren() to
	// make sure the gef is in sync with model before we regenerate visuals
	// and do an autolayout
	refreshChildren();

	super.handleModelChanged();
	regenerateVisuals();
	}

	@Override
	public void activate() {
	super.activate();
	((Notifier) getModel()).eAdapters().add(flowContentAdapter);

	getViewer().getEditDomain().getCommandStack().addCommandStackListener(
	stackListener);
	}

	public boolean isSmoothLayout() {
	return smoothLayout;
	}

	public void setSmoothLayout(boolean smoothLayout) {
	this.smoothLayout = smoothLayout;
	}

	/* a couple of utility classes for use in the cycle detection code */

	/** represents an edge connection for an editpart * */

	private class EditPartEdge {
	private EditPartNode source, dest;

	public EditPartEdge(EditPartNode source, EditPartNode dest) {
	this.source = source;
	this.dest = dest;
	}

	public EditPartNode getDest() {
	return dest;
	}

	public EditPartNode getSource() {
	return source;
	}
	}

	/**
	* represents an node in a graph The main feature is a visit function which
	* marks the visited node and returns false if cycle detected
	*/

	private class EditPartNode {
	public static final int VISITING = 1, VISITED = 2, NOTVISITED = 0;

	private EditPart part;

	private List edges = new ArrayList();

	public int visited = NOTVISITED;

	public EditPartNode(EditPart part) {
	this.part = part;
	}

	public EditPart getPart() {
	return part;
	}

	public int getVisited() {
	return visited;
	}

	public void addEdge(EditPartEdge edge) {
	edges.add(edge);
	}

	/** returns false if cycle detected * */
	public boolean visit() {
	EditPartEdge e;
	if (visited == VISITING) {
	return false;
	}
	if (visited == VISITED)
	return true;
	visited = VISITING;
	for (Iterator it = edges.iterator(); it.hasNext();) {
	e = (EditPartEdge) it.next();
	// if (e.getSource() == this)
	if (e.getDest().visit() == false)
	return false;
	}
	visited = VISITED;
	return true;
	}
	}

	/**
	* checks if a new connection joining sourceNode and potentialDest will
	* result in a cycle *
	*/

	public boolean detectImpendingCycle(EditPart sourceNode,
	EditPart potentialDest) {
	List<EditPartNode> nodes = new ArrayList<EditPartNode>();

	Map<BPELEditPart, EditPartNode> partsToNodes = new HashMap<BPELEditPart, EditPartNode>();

	// strategy: we'll build up a separate parallel graph that we can
	// traverse to detect cycles.
	// We are essentially duplicating the Flow's
	// graph structure, but this is easiest since we don't have a way of
	// "simulating a link between
	// for the proposed link, and we don't want to pollute the editparts
	// extraneous methods and fields
	// just for cycle detection logic, this will have to do for now.

	for (Iterator it = getChildren().iterator(); it.hasNext();) {
	Object object = it.next();
	if (object instanceof BPELEditPart) {
	BPELEditPart editPart = (BPELEditPart) object;
	EditPartNode n = new EditPartNode(editPart);
	nodes.add(n);
	partsToNodes.put(editPart, n);
	}
	}

	for (Iterator it = getChildren().iterator(); it.hasNext();) {
	Object object = it.next();
	if (object instanceof BPELEditPart) {
	EditPartNode source = partsToNodes.get(object);
	if (source == null)
	continue;

	for (Iterator it2 = ((BPELEditPart) object)
	.getSourceConnections().iterator(); it2.hasNext();) {
	Object targetObject = it2.next();
	if (targetObject instanceof LinkEditPart) {
	LinkEditPart linkEditPart = (LinkEditPart) targetObject;
	EditPartNode target = partsToNodes
	.get(linkEditPart.getTarget());
	if (target != null) {
	source.addEdge(new EditPartEdge(source, target));
	}
	}
	}
	}
	}

	// add the proposed edge
	EditPartNode source = partsToNodes.get(sourceNode);
	if (source != null) {
	EditPartNode target = partsToNodes
	.get(potentialDest);
	if (target != null) {
	source.addEdge(new EditPartEdge(source, target));
	}
	}

	/* visit each node checking if a cycle will result */
	for (Iterator<EditPartNode> it = nodes.iterator(); it.hasNext();) {
	EditPartNode v = it.next();
	if (v.getVisited() == EditPartNode.NOTVISITED)
	if (v.visit() == false)
	return false;
	}

	return true;
	}

	public void switchLayout(boolean horizontal) {
	// Actually does nothing
	}
	}