/*****************************************************************************
* Copyright (c) 2013 CEA
*
*
* 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:
* Soyatec - Initial API and implementation
*
*****************************************************************************/
package org.eclipse.papyrus.uml.diagram.sequence.util;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.draw2d.Label;
import org.eclipse.draw2d.MarginBorder;
import org.eclipse.draw2d.OrderedLayout;
import org.eclipse.draw2d.RectangleFigure;
import org.eclipse.draw2d.ToolbarLayout;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.draw2d.geometry.PrecisionPoint;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.command.CompoundCommand;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.edit.command.SetCommand;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.gef.ConnectionEditPart;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.EditPartViewer;
import org.eclipse.gef.GraphicalEditPart;
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.BaseSlidableAnchor;
import org.eclipse.gmf.runtime.notation.Anchor;
import org.eclipse.gmf.runtime.notation.Edge;
import org.eclipse.gmf.runtime.notation.IdentityAnchor;
import org.eclipse.gmf.runtime.notation.LayoutConstraint;
import org.eclipse.gmf.runtime.notation.Location;
import org.eclipse.gmf.runtime.notation.NotationPackage;
import org.eclipse.gmf.runtime.notation.Shape;
import org.eclipse.gmf.runtime.notation.Size;
import org.eclipse.gmf.runtime.notation.View;
import org.eclipse.papyrus.infra.gmfdiag.common.utils.DiagramEditPartsUtil;
import org.eclipse.papyrus.uml.diagram.sequence.edit.parts.CombinedFragmentEditPart;
import org.eclipse.papyrus.uml.diagram.sequence.edit.parts.InteractionUseEditPart;
import org.eclipse.papyrus.uml.diagram.sequence.edit.parts.LifelineEditPart;
import org.eclipse.papyrus.uml.diagram.sequence.edit.parts.MessageFoundEditPart;
import org.eclipse.papyrus.uml.diagram.sequence.edit.parts.MessageLostEditPart;
import org.eclipse.papyrus.uml.diagram.sequence.figures.LifelineFigure;
import org.eclipse.swt.widgets.Display;
import org.eclipse.uml2.uml.CombinedFragment;
import org.eclipse.uml2.uml.InteractionFragment;
import org.eclipse.uml2.uml.InteractionUse;
import org.eclipse.uml2.uml.Lifeline;
/**
* @author Jin Liu (jin.liu@soyatec.com)
*/
public class LifelineHeadUtil {
public static int computeLifelineVerticalPosition(final EditPart parent) {
if (parent instanceof GraphicalEditPart) {
List<?> children = parent.getChildren();
int bottom = -1;
for (Object object : children) {
if (!(object instanceof LifelineEditPart)) {
continue;
}
LifelineEditPart lifeline = (LifelineEditPart) object;
if (SequenceUtil.isCreateMessageEndLifeline(lifeline)) {
continue;
}
LifelineFigure primaryShape = lifeline.getPrimaryShape();
// RectangleFigure figure = primaryShape.getFigureLifelineNameContainerFigure();
// Rectangle r = figure.getBounds().getCopy();
// if (!r.isEmpty()) {
// bottom = Math.max(bottom, r.bottom());
// }
}
if (bottom != -1) {
RectangleFigure figure = new RectangleFigure();
figure.setBorder(new MarginBorder(7));
ToolbarLayout layout = new ToolbarLayout();
layout.setMinorAlignment(OrderedLayout.ALIGN_CENTER);
Label label = new Label("Lifeline");
label.setFont(Display.getDefault().getSystemFont());
figure.add(label);
figure.setLayoutManager(layout);
int height = figure.getPreferredSize().height;
return bottom - height - 1;
}
}
return SequenceUtil.LIFELINE_VERTICAL_OFFSET;
}
public static void updateHead(LifelineEditPart lifeline, int resized) {
if (lifeline == null || resized == 0) {
return;
}
List<LifelineEditPart> toMovedLifelines = new ArrayList<>();
collectLifelines(toMovedLifelines, lifeline);
List<ShapeNodeEditPart> children = LifelineEditPartUtil.getChildShapeNodeEditPart(lifeline);
for (ShapeNodeEditPart child : children) {
collectLifelines(toMovedLifelines, child);
}
EditPart parent = lifeline.getParent();
while (parent instanceof LifelineEditPart) {
parent = parent.getParent();
}
if (!SequenceUtil.isCreateMessageEndLifeline(lifeline)) {
List<?> childrenList = parent.getChildren();
for (Object object : childrenList) {
if (toMovedLifelines.contains(object) || !(object instanceof LifelineEditPart)) {
continue;
}
toMovedLifelines.add((LifelineEditPart) object);
}
}
if (toMovedLifelines.isEmpty()) {
return;
}
CompoundCommand command = new CompoundCommand();
computeUpdateHeadCommand(command, lifeline, false, resized, new ArrayList<EditPart>());
if (command.canExecute()) {
CommandHelper.executeCommandWithoutHistory(lifeline.getEditingDomain(), command, true);
}
}
private static void computeUpdateHeadCommand(CompoundCommand commands, LifelineEditPart lifeline, boolean moveChildren, int moveDelta, List<EditPart> movedEditParts) {
// 1. move children of current lifeline.
if (moveChildren) {
ShapeNodeEditPart nodeToMove = lifeline;
EditPart parent = lifeline.getParent();
while (parent instanceof LifelineEditPart) {
nodeToMove = (ShapeNodeEditPart) parent;
parent = parent.getParent();
}
Command cmd = getVerticalMoveShapeCommand(nodeToMove, moveDelta, false);
commands.appendIfCanExecute(cmd);
} else {
View view = lifeline.getNotationView();
LayoutConstraint constraint = ((Shape) view).getLayoutConstraint();
if (constraint instanceof Size) {
int height = ((Size) constraint).getHeight();
if (height == -1) {
height = lifeline.getFigure().getBounds().height;
}
height += moveDelta;
commands.appendIfCanExecute(SetCommand.create(lifeline.getEditingDomain(), constraint, NotationPackage.eINSTANCE.getSize_Height(), height));
}
}
movedEditParts.add(lifeline);
// 2. move covered CombinedFragment and InteractionUse
EObject elt = lifeline.resolveSemanticElement();
if (elt instanceof Lifeline) {
EList<InteractionFragment> coveredBys = ((Lifeline) elt).getCoveredBys();
EditPartViewer viewer = lifeline.getViewer();
for (InteractionFragment fragment : coveredBys) {
if (!(fragment instanceof CombinedFragment || fragment instanceof InteractionUse)) {
continue;
}
List<View> views = DiagramEditPartsUtil.findViews(fragment, viewer);
if (views.isEmpty()) {
continue;
}
for (View view : views) {
EditPart ep = (EditPart) viewer.getEditPartRegistry().get(view);
if (ep == null) {
continue;
}
if (movedEditParts.contains(ep)) {
continue;
}
EditPart parent = ep.getParent();
boolean parentMoved = false;
while (parent != null) {
if (movedEditParts.contains(parent)) {
parentMoved = true;
break;
}
parent = parent.getParent();
}
if (parentMoved) {
continue;
}
if (ep instanceof CombinedFragmentEditPart || ep instanceof InteractionUseEditPart) {
Command cmd = getVerticalMoveShapeCommand((ShapeNodeEditPart) ep, moveDelta, false);
commands.appendIfCanExecute(cmd);
movedEditParts.add(ep);
List<?> children = ep.getChildren();
for (Object object : children) {
if (movedEditParts.contains(object)) {
continue;
}
}
}
}
}
}
// 3. move Gate if existed.
fillMoveDownMessageEnds(commands, lifeline, moveDelta, movedEditParts);
List<ShapeNodeEditPart> childShapeNodeEditParts = LifelineEditPartUtil.getChildShapeNodeEditPart(lifeline);
for (ShapeNodeEditPart shapeNodeEditPart : childShapeNodeEditParts) {
fillMoveDownMessageEnds(commands, shapeNodeEditPart, moveDelta, movedEditParts);
}
// 4. move children of linked lifelines.
if (SequenceUtil.isCreateMessageEndLifeline(lifeline)) {
return;
}
List<LifelineEditPart> toMovedLifelines = new ArrayList<>();
collectLifelines(toMovedLifelines, lifeline);
List<ShapeNodeEditPart> children = LifelineEditPartUtil.getChildShapeNodeEditPart(lifeline);
for (ShapeNodeEditPart child : children) {
collectLifelines(toMovedLifelines, child);
}
EditPart parent = lifeline.getParent();
while (parent instanceof LifelineEditPart) {
parent = parent.getParent();
}
List<?> childrenList = parent.getChildren();
for (Object object : childrenList) {
if (toMovedLifelines.contains(object) || !(object instanceof LifelineEditPart)) {
continue;
}
toMovedLifelines.add((LifelineEditPart) object);
}
for (LifelineEditPart editPart : toMovedLifelines) {
if (movedEditParts.contains(editPart)) {
continue;
}
computeUpdateHeadCommand(commands, editPart, true, moveDelta, movedEditParts);
}
}
private static void fillMoveDownMessageEnds(CompoundCommand commands, GraphicalEditPart editPart, int moveDelta, List<EditPart> movedEditParts) {
List<?> sourceConnections = editPart.getSourceConnections();
for (Object object : sourceConnections) {
ConnectionEditPart conn = (ConnectionEditPart) object;
if (object instanceof MessageLostEditPart) {
Command command = getMoveAnchorCommand(conn, moveDelta, false);
commands.appendIfCanExecute(command);
}
}
List<?> targetConnections = editPart.getTargetConnections();
for (Object object : targetConnections) {
ConnectionEditPart conn = (ConnectionEditPart) object;
if (conn instanceof MessageFoundEditPart) {
Command command = getMoveAnchorCommand(conn, moveDelta, true);
commands.appendIfCanExecute(command);
}
}
}
private static Command getMoveAnchorCommand(ConnectionEditPart conn, int moveDelta, boolean moveSource) {
EditPart editPart = moveSource ? conn.getSource() : conn.getTarget();
if (!(editPart instanceof IGraphicalEditPart)) {
return null;
}
Object model = conn.getModel();
if (!(model instanceof Edge)) {
return null;
}
Edge edge = (Edge) model;
Anchor anchor = moveSource ? edge.getSourceAnchor() : edge.getTargetAnchor();
if (!(anchor instanceof IdentityAnchor)) {
return null;
}
String terminal = ((IdentityAnchor) anchor).getId();
PrecisionPoint pt = BaseSlidableAnchor.parseTerminalString(terminal);
PrecisionPoint p = null;
if (pt.preciseX() > 1 || pt.preciseY() > 1) {
p = new PrecisionPoint(pt.preciseX(), pt.preciseY() + moveDelta);
} else {
Rectangle bounds = SequenceUtil.getAbsoluteBounds((IGraphicalEditPart) editPart);
PrecisionPoint location = new PrecisionPoint(pt.preciseX() * bounds.preciseWidth() + bounds.preciseX(), pt.preciseY() * bounds.preciseHeight() + bounds.preciseY());
location.translate(0, moveDelta);
Dimension d = location.getDifference(bounds.getTopLeft());
p = new PrecisionPoint(d.preciseWidth() / bounds.width, d.preciseHeight() / bounds.height);
}
StringBuffer s = new StringBuffer(24);
s.append('('); // 1 char
s.append(p.preciseX()); // 10 chars
s.append(','); // 1 char
s.append(p.preciseY()); // 10 chars
s.append(')');
return SetCommand.create(getEditingDomain((GraphicalEditPart) editPart), anchor, NotationPackage.eINSTANCE.getIdentityAnchor_Id(), s.toString());
}
private static void collectLifelines(List<LifelineEditPart> toMovedLifelines, GraphicalEditPart editPart) {
if (editPart == null) {
return;
}
// 1. links from current lifeline
List<?> sourceConnections = editPart.getSourceConnections();
for (Object object : sourceConnections) {
ConnectionEditPart conn = (ConnectionEditPart) object;
LifelineEditPart target = getLifeline(conn.getTarget());
if (target == null || toMovedLifelines.contains(target) || editPart == target) {
continue;
}
toMovedLifelines.add(target);
}
// 2. links to current lifeline.
List<?> targetConnections = editPart.getTargetConnections();
for (Object object : targetConnections) {
ConnectionEditPart conn = (ConnectionEditPart) object;
LifelineEditPart source = getLifeline(conn.getSource());
if (source == null || toMovedLifelines.contains(source) || editPart == source) {
continue;
}
toMovedLifelines.add(source);
}
//
// if (editPart instanceof CustomLifelineEditPart && ((CustomLifelineEditPart) editPart).isInlineMode()) {
// List<?> children = ((CustomLifelineEditPart) editPart).getChildren();
// for (Object object : children) {
// if (object instanceof LifelineEditPart) {
// collectLifelines(toMovedLifelines, (LifelineEditPart) object);
// }
// }
// if (toMovedLifelines.isEmpty()) {
// toMovedLifelines.add((LifelineEditPart) editPart);
// }
// }
}
private static Command getVerticalMoveShapeCommand(GraphicalEditPart shapeEditPart, int moveDelta, boolean increaseHeight) {
if (shapeEditPart == null || moveDelta == 0) {
return null;
}
Object view = shapeEditPart.getModel();
if (!(view instanceof Shape)) {
return null;
}
LayoutConstraint constraint = ((Shape) view).getLayoutConstraint();
if (!(constraint instanceof Location)) {
return null;
}
int y = ((Location) constraint).getY();
int value = y + moveDelta;
Command command = SetCommand.create(getEditingDomain(shapeEditPart), constraint, NotationPackage.eINSTANCE.getLocation_Y(), value);
if (increaseHeight && constraint instanceof Size) {
int height = ((Size) constraint).getHeight();
if (height == -1) {
height = shapeEditPart.getFigure().getBounds().height;
}
height += moveDelta;
command = command.chain(SetCommand.create(getEditingDomain(shapeEditPart), constraint, NotationPackage.eINSTANCE.getSize_Height(), height));
}
return command;
}
private static EditingDomain getEditingDomain(GraphicalEditPart editPart) {
if (editPart instanceof IGraphicalEditPart) {
return ((IGraphicalEditPart) editPart).getEditingDomain();
}
return null;
}
private static LifelineEditPart getLifeline(EditPart editPart) {
if (editPart == null) {
return null;
}
if (editPart instanceof LifelineEditPart) {
return (LifelineEditPart) editPart;
}
return getLifeline(editPart.getParent());
}
}
