public class ConnectionLayerClippingStrategy implements IClippingStrategy {

	protected Diagram diagram;
	protected GraphicalViewer graphicalViewer;
	
	public static void applyTo(GraphicalViewer graphicalViewer) {
		ScalableFreeformRootEditPart rootEditPart = (ScalableFreeformRootEditPart) graphicalViewer.getRootEditPart();
		Figure connectionLayer = (Figure) rootEditPart.getLayer(LayerConstants.CONNECTION_LAYER);
		if (connectionLayer.getClippingStrategy()==null) {
			EditPart editPart = graphicalViewer.getContents();
			Diagram diagram = (Diagram)editPart.getModel();
			IClippingStrategy clippingStrategy = new ConnectionLayerClippingStrategy(graphicalViewer, diagram);
			connectionLayer.setClippingStrategy(clippingStrategy);
		}
	}

	public ConnectionLayerClippingStrategy(GraphicalViewer graphicalViewer, Diagram diagram) {
		this.diagram = diagram;
		this.graphicalViewer = graphicalViewer;
	}
	
	@Override
	public Rectangle[] getClip(IFigure childFigure) {
		// search for the Graphiti Connection PictogramElement that represents this childFigure
		// NOTE: there may be a better way to do this, but I wanted to stay away from Graphiti
		// 0.9.2 vs 0.10.0 version differences as much as possible.
		for (Object value : graphicalViewer.getEditPartRegistry().values()) {
			GraphicalEditPart part = (GraphicalEditPart)value;
			if (part.getFigure() == childFigure) {
				Object model = part.getModel();
				if (model instanceof Connection) {
					// This is a Connection PE. In my case the Connection MAY have
					// a ContainerShape attached to a ConnectionDecorator and I need
					// to have the connection clipped within the bounds of the ContainerShape
					// so that it is drawn on top of the Connection instead of underneath it.
					Connection connection = (Connection)model;
					ContainerShape messageShape = findMessageShape(connection);
					if (messageShape!=null) {
						Rectangle inner = getClip(messageShape)[0];
						Rectangle outer = childFigure.getBounds();
						// calculate the clipping rectangles
						return getClip(outer,inner);
					}
				}
			}
		}
		return new Rectangle[] {childFigure.getBounds()};
	}
	
	private Rectangle[] getClip(Rectangle outer, Rectangle inner) {
		if (outer.width > inner.width) {
			if (outer.height > inner.height) {
				Rectangle[] clip = new Rectangle[4];
				clip[0] = new Rectangle(
						outer.x, outer.y,
						outer.width, inner.y - outer.y);
				clip[1] = new Rectangle(
						outer.x, inner.y,
						inner.x - outer.x,
						inner.height
						);
				clip[2] = new Rectangle(
						inner.x + inner.width, inner.y,
						(outer.x + outer.width) - (inner.x + inner.width),
						inner.height
						);
				clip[3] = new Rectangle(
						outer.x, inner.y + inner.height,
						outer.width, (outer.y + outer.height) - (inner.y + inner.height));
				
				return clip;
			}
		}
		return new Rectangle[] {outer};
	}
	
	private Rectangle[] getClip(ContainerShape pe) {
		GraphicsAlgorithm ga = pe.getGraphicsAlgorithm();
		return new Rectangle[] { new Rectangle(ga.getX(), ga.getY(), ga.getWidth(), ga.getHeight()) };
	}

	private ContainerShape findMessageShape(Connection connection) {
		// do some fancy searching stuff here and return a ContainerShape if one is
		// attached to the Connection, or null if not.
	}
}

		ConnectionLayerClippingStrategy.applyTo(getGraphicalViewer());