/*****************************************************************************
* Copyright (c) 2014 CEA LIST.
*
*
* 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:
* Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - Initial API and implementation
*
*****************************************************************************/
package org.eclipse.gmf.tooling.runtime.linklf;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.draw2d.AbstractPointListShape;
import org.eclipse.draw2d.ConnectionAnchor;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.PositionConstants;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.PointList;
import org.eclipse.draw2d.geometry.PrecisionPoint;
import org.eclipse.draw2d.geometry.PrecisionRectangle;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.gef.commands.Command;
import org.eclipse.gef.commands.CompoundCommand;
import org.eclipse.gef.editparts.AbstractConnectionEditPart;
import org.eclipse.gmf.runtime.common.core.command.CommandResult;
import org.eclipse.gmf.runtime.common.core.command.ICommand;
import org.eclipse.gmf.runtime.diagram.ui.commands.ICommandProxy;
import org.eclipse.gmf.runtime.diagram.ui.editparts.INodeEditPart;
import org.eclipse.gmf.runtime.draw2d.ui.figures.PolylineConnectionEx;
import org.eclipse.gmf.runtime.emf.commands.core.command.AbstractTransactionalCommand;
import org.eclipse.gmf.runtime.gef.ui.figures.NodeFigure;
import org.eclipse.gmf.runtime.notation.Edge;
import org.eclipse.gmf.runtime.notation.IdentityAnchor;
import org.eclipse.gmf.runtime.notation.NotationFactory;
import org.eclipse.gmf.runtime.notation.View;
/**
*
* This class provides command to fix the anchors during a resize.
* The methods are not static to allow to overriding
*
*/
public class FixAnchorHelper {
/**
* the editing domain used for the command
*/
protected final TransactionalEditingDomain domain;
/**
*
* Constructor.
*
* @param domain
* the editing domain to use, it must not be <code>null</code>
*/
public FixAnchorHelper(final TransactionalEditingDomain domain) {
Assert.isNotNull(domain);
this.domain = domain;
}
/**
*
* @param node
* the resized node
* @param move
* the move direction
* @param sizeDelta
* the delta of the size
* @param moveDirection
* the direction for the resize/move
* @return
* the command to fix the anchor or <code>null</code> if we can't fix it
*/
public Command getFixIdentityAnchorCommand(final INodeEditPart node, final Point move, final Dimension sizeDelta, int moveDirection) {
final CompoundCommand cc = new CompoundCommand("Fix All Anchors Command"); //$NON-NLS-1$
//1. we calculate the new bounds;
final IFigure nodeFigure = node.getFigure();
final PrecisionRectangle oldBounds = new PrecisionRectangle(nodeFigure.getBounds());
//we translate the coordinates to absolute
nodeFigure.translateToAbsolute(oldBounds);
final PrecisionRectangle newBounds = oldBounds.getPreciseCopy();
newBounds.translate(move.preciseX(), move.preciseY());
newBounds.resize(sizeDelta.preciseWidth(), sizeDelta.preciseHeight());
//2. we iterate on the target anchor
for(final Object targetConnection : node.getTargetConnections()) {
if(targetConnection instanceof AbstractConnectionEditPart) {
final Command tmp = getFixAnchorCommand(node, oldBounds, newBounds, (AbstractConnectionEditPart)targetConnection, move, sizeDelta, false);
if(tmp != null) {
cc.add(tmp);
}
}
}
//. we iterate on the source anchor
for(final Object sourceConnection : node.getSourceConnections()) {
if(sourceConnection instanceof AbstractConnectionEditPart) {
final Command tmp = getFixAnchorCommand(node, oldBounds, newBounds, (AbstractConnectionEditPart)sourceConnection, move, sizeDelta, true);
if(tmp != null) {
cc.add(tmp);
}
}
}
if(cc.isEmpty()) {
return null;
}
return cc;
}
/**
*
* @param edgeEP
* the edge edit part
* @param sourcePoint
* if <code>true</code> we return the source point and if false we return the end point
* @return
* the real point to fix
*/
protected Point getRealAnchorPoint(final AbstractConnectionEditPart edgeEP, final boolean sourcePoint) {
final IFigure figure = edgeEP.getFigure();
Point point = null;
if(figure instanceof AbstractPointListShape) {
if(sourcePoint) {
point = ((AbstractPointListShape)figure).getStart().getCopy();
} else {
point = ((AbstractPointListShape)figure).getEnd().getCopy();
}
}
figure.translateToAbsolute(point);
return point;
}
/**
*
* @param edgeEP
* the edge edit part
* @param sourcePoint
* if <code>true</code> we return the source point and if false we return the end point
* @param nodeEP
* the node edit part
* @param p
* the real anchor point in absolute coordinate
* @return
* the anchor representing the point to fix
*/
protected IdentityAnchor getIdentityAnchor(final AbstractConnectionEditPart edgeEP, final boolean sourcePoint, final INodeEditPart nodeEP, final Point p) {
final View view = (View)edgeEP.getAdapter(View.class);
IdentityAnchor anchor = null;
if(view instanceof Edge) {
final Object tmpAnchor;
if(sourcePoint) {
tmpAnchor = ((Edge)view).getSourceAnchor();
} else {
tmpAnchor = ((Edge)view).getTargetAnchor();
}
if(tmpAnchor instanceof IdentityAnchor) {
anchor = (IdentityAnchor)tmpAnchor;
}
if(anchor == null) {
ConnectionAnchor connectionAnchor = null;
if(nodeEP.getFigure() instanceof NodeFigure) {
NodeFigure nodeFigure = (NodeFigure)nodeEP.getFigure();
if(sourcePoint) {
connectionAnchor = nodeFigure.getSourceConnectionAnchorAt(p);
} else {
connectionAnchor = nodeFigure.getTargetConnectionAnchorAt(p);
}
if(connectionAnchor != null) {
final String id = nodeEP.mapConnectionAnchorToTerminal(connectionAnchor);
anchor = NotationFactory.eINSTANCE.createIdentityAnchor();
anchor.setId(id);
}
}
}
}
return anchor;
}
/**
*
* @param nodeEditPart
* the resized edit part
* @param oldNodeBounds
* the old bounds for this edit part
* @param newNodeBounds
* the new bounds for this edit part
* @param targetConnectionEP
* the edit part of the connection for which we want fix anchor
* @param move
* the move
* @param sizeDelta
* the delta of the resize
* @param fixSource
* if <code>true</code> we are fixing the source anchor if <code>false</code> we are fixing the target anchor
* @return
*/
public Command getFixAnchorCommand(final INodeEditPart nodeEditPart, final PrecisionRectangle oldNodeBounds, final PrecisionRectangle newNodeBounds, final AbstractConnectionEditPart targetConnectionEP, final Point move, final Dimension sizeDelta, final boolean fixSource) {
final Point realAnchorPoint = getRealAnchorPoint(targetConnectionEP, fixSource);
final IFigure fig = nodeEditPart.getFigure();
if(fig instanceof NodeFigure) {
final NodeFigure nodeFigure = (NodeFigure)fig;
final IdentityAnchor editedAnchor = getIdentityAnchor(targetConnectionEP, fixSource, nodeEditPart, realAnchorPoint);
if(realAnchorPoint != null && editedAnchor != null) {
final View view = (View)targetConnectionEP.getAdapter(View.class);
if(view instanceof Edge) {
//1. get the real side on which start/end the manipulated anchor
final int anchorSide = getSideOfConnectionPoint(nodeFigure, targetConnectionEP, fixSource);
//2. determine the new values
double newX = -1;
double newY = -1;
switch(anchorSide) {
case PositionConstants.NORTH:
newY = 0;
break;
case PositionConstants.WEST:
newX = 0;
break;
case PositionConstants.EAST:
newX = 1;
break;
case PositionConstants.SOUTH:
newY = 1;
break;
default:
// other case not yet manager because they are resize dependant!
break;
}
PrecisionPoint newRealAnchorPoint = new PrecisionPoint(realAnchorPoint);
newRealAnchorPoint.setPreciseLocation(newRealAnchorPoint.x() - oldNodeBounds.preciseX(), newRealAnchorPoint.y() - oldNodeBounds.preciseY());
PrecisionPoint newLocation = newRealAnchorPoint.getPreciseCopy();
newLocation.setPreciseX(newLocation.preciseX() - move.preciseX());
newLocation.setPreciseY(newLocation.preciseY() - move.preciseY());
if(newX == -1) {
newX = newLocation.preciseX() / newNodeBounds.preciseWidth();
}
if(newY == -1) {
newY = newLocation.preciseY() / newNodeBounds.preciseHeight();
}
if(newX <= 1 && newX >= 0 && newY <= 1 && newY >= 0) {
final String newIdValue = IdentityAnchorHelper.createNewAnchorIdValue(newX, newY);
final ICommand cmd = new AbstractTransactionalCommand(this.domain, "Fix Anchor Location", null) { //$NON-NLS-1$
@Override
protected CommandResult doExecuteWithResult(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
editedAnchor.setId(newIdValue);
if(editedAnchor.eContainer() == null) {
if(fixSource) {
((Edge)view).setSourceAnchor(editedAnchor);
} else {
((Edge)view).setTargetAnchor(editedAnchor);
}
}
return CommandResult.newOKCommandResult(editedAnchor);
}
};
return new ICommandProxy(cmd);
}
}
}
}
return null;
}
/**
*
* @param nodeFigure
* the node figure
* @param edgeEP
* the connection edit part
* @param fixingSource
* if <code>true</code> we are fixing the source anchor and if <code>false</code> we are fixing the target anchor
* @return
* the direction of the manipulated anchor (according to {@link PositionConstants}
*/
protected final int getSideOfConnectionPoint(final IFigure nodeFigure, final AbstractConnectionEditPart edgeEP, final boolean fixingSource) {
int side = -1;
final IFigure figure = edgeEP.getFigure();
if(figure instanceof PolylineConnectionEx) {
final PolylineConnectionEx connection = (PolylineConnectionEx)figure;
final Rectangle bounds = nodeFigure.getBounds().getCopy();
nodeFigure.translateToAbsolute(bounds);
final Point pt;
if(fixingSource) {
pt = connection.getStart();
} else {
pt = connection.getEnd();
}
figure.translateToAbsolute(pt);
Rectangle includedRect = bounds.getCopy();
while(includedRect.contains(pt)) {
includedRect.shrink(1, 1);
}
side = includedRect.getPosition(pt);
//if the anchor side is a corner, we determine its side using another point
if(side == PositionConstants.NORTH_WEST || side == PositionConstants.NORTH_EAST || side == PositionConstants.SOUTH_EAST || side == PositionConstants.SOUTH_WEST) {
final Point previousPoint;
final PointList list = connection.getPoints();
if(list.size() > 1) {
if(fixingSource) {
previousPoint = list.getPoint(1);
} else {
previousPoint = list.getPoint(list.size() - 2);
}
nodeFigure.translateToAbsolute(previousPoint.getCopy());
while(includedRect.contains(previousPoint)) {
includedRect.shrink(1, 1);
}
side = includedRect.getPosition(previousPoint);
}
}
}
return side;
}
}
