@Override
protected void doExecute() {
if (designEditor != null) {
GraphicalViewer graphicalViewer = designEditor.getGraphicalViewer();
if (graphicalViewer != null && graphicalViewer.getEditPartRegistry() != null) {
ScalableFreeformRootEditPart rootEditPart =
(ScalableFreeformRootEditPart)
graphicalViewer.getEditPartRegistry().get(LayerManager.ID);
IFigure gridFigure = ((LayerManager) rootEditPart).getLayer(LayerConstants.GRID_LAYER);
IColorConstant cc =
StyleUtil.getColorConstant(
PreferenceManager.getInstance()
.loadPreferenceAsString(PreferencesConstants.EDITOR_GRID_COLOR));
Diagram diagram = designEditor.getDiagramTypeProvider().getDiagram();
if (cc != null && diagram != null) {
GraphicsAlgorithm ga = diagram.getGraphicsAlgorithm();
if (ga != null) {
ga.setForeground(GraphitiUi.getGaService().manageColor(diagram, cc));
gridFigure.repaint();
gridFigure.revalidate();
designEditor.getDiagramBehavior().refreshContent();
}
}
}
}
}
public static ContainerShape getLastLaneInContainer(ContainerShape root) {
List<PictogramElement> laneShapes = BusinessObjectUtil.getChildElementsOfType(root, Lane.class);
if (!laneShapes.isEmpty()) {
Iterator<PictogramElement> iterator = laneShapes.iterator();
PictogramElement result = iterator.next();
if (result instanceof ContainerShape) {
GraphicsAlgorithm ga = result.getGraphicsAlgorithm();
if (isHorizontal(root)) {
while (iterator.hasNext()) {
PictogramElement currentShape = iterator.next();
if (currentShape instanceof ContainerShape) {
if (currentShape.getGraphicsAlgorithm().getY() > ga.getY()) {
result = currentShape;
}
}
}
} else {
while (iterator.hasNext()) {
PictogramElement currentShape = iterator.next();
if (currentShape instanceof ContainerShape) {
if (currentShape.getGraphicsAlgorithm().getX() > ga.getX()) {
result = currentShape;
}
}
}
}
return (ContainerShape) result;
}
}
return root;
}
private void movePin(Pin pin, IMoveShapeContext context) {
PictogramElement pinShape = getPinShape(pin);
if (pinShape != null) {
GraphicsAlgorithm pinArea = pinShape.getGraphicsAlgorithm();
pinArea.setX(pinArea.getX() + context.getDeltaX());
pinArea.setY(pinArea.getY() + context.getDeltaY());
}
}
@Override
public void execute(ICustomContext context) {
PictogramElement[] pes = context.getPictogramElements();
if (pes != null && pes.length == 1) {
PictogramElement pe0 = pes[0];
Object bo = getBusinessObjectForPictogramElement(pe0);
if (pe0 instanceof ContainerShape && bo instanceof FlowNode) {
ContainerShape containerShape = (ContainerShape) pe0;
FlowNode flowNode = (FlowNode) bo;
try {
BPMNShape bpmnShape = DIUtils.findBPMNShape(flowNode);
if (bpmnShape.isIsExpanded()) {
Bpmn2Preferences preferences = Bpmn2Preferences.getInstance(getDiagram());
ShapeStyle ss = preferences.getShapeStyle("TASKS");
// SubProcess is expanded - resize to standard Task size
// NOTE: children tasks will be set not-visible in LayoutExpandableActivityFeature
bpmnShape.setIsExpanded(false);
GraphicsAlgorithm ga = containerShape.getGraphicsAlgorithm();
ResizeShapeContext resizeContext = new ResizeShapeContext(containerShape);
IResizeShapeFeature resizeFeature =
getFeatureProvider().getResizeShapeFeature(resizeContext);
IDimension oldSize = FeatureSupport.getCollapsedSize(containerShape);
int oldWidth = ga.getWidth();
int oldHeight = ga.getHeight();
FeatureSupport.setExpandedSize(containerShape, oldWidth, oldHeight);
int newWidth = ss.getDefaultWidth();
int newHeight = ss.getDefaultHeight();
if (newWidth < oldSize.getWidth()) oldSize.setWidth(newWidth);
if (newHeight < oldSize.getHeight()) oldSize.setHeight(newHeight);
newWidth = oldSize.getWidth();
newHeight = oldSize.getHeight();
resizeContext.setX(ga.getX() + oldWidth / 2 - newWidth / 2);
resizeContext.setY(ga.getY() + oldHeight / 2 - newHeight / 2);
resizeContext.setWidth(newWidth);
resizeContext.setHeight(newHeight);
resizeFeature.resizeShape(resizeContext);
UpdateContext updateContext = new UpdateContext(containerShape);
IUpdateFeature updateFeature = getFeatureProvider().getUpdateFeature(updateContext);
if (updateFeature.updateNeeded(updateContext).toBoolean())
updateFeature.update(updateContext);
getDiagramEditor().selectPictogramElements(new PictogramElement[] {});
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
protected ActorViewModel.PortKind getIOPortKind(ICreateContext context) {
int x = context.getX(); // , y = context.getY();
GraphicsAlgorithm parentGa = context.getTargetContainer().getGraphicsAlgorithm();
int width = parentGa.getWidth(); // , height = parentShape.getHeight();
if (x < width / 3) {
return ActorViewModel.PortKind.INPUT;
} else if (x > width * 2 / 3) {
return ActorViewModel.PortKind.OUTPUT;
}
return ioKind;
}
private void performMove(Shape labelShape, Point position) {
// always move within the original container
GraphicsAlgorithm labelGraphicsAlgorithm = labelShape.getGraphicsAlgorithm();
if (labelGraphicsAlgorithm != null) {
Graphiti.getGaService()
.setLocation(
labelGraphicsAlgorithm,
position.getX() - labelGraphicsAlgorithm.getWidth() / 2,
position.getY(),
true);
}
}
private void calculate() {
int minX = Integer.MAX_VALUE;
int minY = Integer.MAX_VALUE;
minWidth = 0;
minHeight = 0;
for (PictogramElement pe : FeatureSupport.getContainerChildren(containerShape)) {
GraphicsAlgorithm ga = pe.getGraphicsAlgorithm();
if (ga != null) {
int x = ga.getX();
int y = ga.getY();
if (x < minX) minX = x;
if (y < minY) minY = y;
}
}
shiftX = minX;
shiftY = minY;
for (PictogramElement pe : FeatureSupport.getContainerChildren(containerShape)) {
GraphicsAlgorithm ga = pe.getGraphicsAlgorithm();
if (ga != null) {
int w = ga.getX() - minX + ga.getWidth();
int h = ga.getY() - minY + ga.getHeight();
if (w > minWidth) minWidth = w;
if (h > minHeight) minHeight = h;
}
}
if (minWidth <= 0) minWidth = GraphicsUtil.TASK_DEFAULT_WIDTH;
if (minHeight <= 0) minHeight = GraphicsUtil.TASK_DEFAULT_HEIGHT;
}
private static void updateSPPFigure(SPPRef spp, PictogramElement pe, Color dark, Color bright) {
ContainerShape container = (ContainerShape) pe;
// we clear the figure and rebuild it
GraphicsAlgorithm invisibleRect = pe.getGraphicsAlgorithm();
invisibleRect.getGraphicsAlgorithmChildren().clear();
createSPPFigure(spp, false, container, invisibleRect, dark, bright);
GraphicsAlgorithm ga = container.getChildren().get(0).getGraphicsAlgorithm();
if (ga instanceof Text) {
((Text) ga).setValue(spp.getName());
}
}
public static void updateDIEdge(Diagram diagram, Connection connection, Class clazz) {
try {
ModelHandler modelHandler =
ModelHandlerLocator.getModelHandler(
connection.getLink().getBusinessObjects().get(0).eResource());
EObject be = BusinessObjectUtil.getFirstElementOfType(connection, clazz);
BPMNEdge edge = (BPMNEdge) modelHandler.findDIElement(diagram, (BaseElement) be);
Point point = DcFactory.eINSTANCE.createPoint();
List<Point> waypoint = edge.getWaypoint();
waypoint.clear();
GraphicsAlgorithm graphicsAlgorithm = connection.getStart().getGraphicsAlgorithm();
// FIXME connections must create anchors!!!
if (graphicsAlgorithm != null) {
point.setX(graphicsAlgorithm.getX());
point.setY(graphicsAlgorithm.getY());
} else {
point.setX(connection.getStart().getParent().getGraphicsAlgorithm().getX());
point.setY(connection.getStart().getParent().getGraphicsAlgorithm().getY());
}
waypoint.add(point);
if (connection instanceof FreeFormConnectionImpl) {
FreeFormConnectionImpl freeForm = (FreeFormConnectionImpl) connection;
EList<org.eclipse.graphiti.mm.algorithms.styles.Point> bendpoints =
freeForm.getBendpoints();
for (org.eclipse.graphiti.mm.algorithms.styles.Point bp : bendpoints) {
addBendPoint(freeForm, point);
}
}
point = DcFactory.eINSTANCE.createPoint();
graphicsAlgorithm = connection.getEnd().getGraphicsAlgorithm();
if (graphicsAlgorithm != null) {
point.setX(graphicsAlgorithm.getX());
point.setY(graphicsAlgorithm.getY());
} else {
point.setX(connection.getEnd().getParent().getGraphicsAlgorithm().getX());
point.setY(connection.getEnd().getParent().getGraphicsAlgorithm().getY());
}
waypoint.add(point);
} catch (IOException e) {
Activator.logError(e);
}
}
public static String getToolTip(GraphicsAlgorithm ga) {
if (ga != null) {
for (Property prop : ga.getProperties()) {
if (GraphitiConstants.TOOLTIP_PROPERTY.equals(prop.getKey())) return prop.getValue();
}
}
return null;
}
public static void setToolTip(GraphicsAlgorithm ga, String text) {
if (ga != null) {
Property prop = MmFactory.eINSTANCE.createProperty();
prop.setKey(GraphitiConstants.TOOLTIP_PROPERTY);
prop.setValue(text);
ga.getProperties().add(prop);
}
}
private void resizeLaneWidth(IResizeShapeContext context) {
ContainerShape participantShape = (ContainerShape) context.getShape();
GraphicsAlgorithm ga = participantShape.getGraphicsAlgorithm();
int dHeight = context.getHeight() - ga.getHeight();
int dWidth = context.getWidth() - ga.getWidth();
if ((dWidth != 0 && FeatureSupport.isHorizontal(participantShape))
|| (dHeight != 0 && !FeatureSupport.isHorizontal(participantShape))) {
List<PictogramElement> childrenShapes =
FeatureSupport.getChildsOfBusinessObjectType(participantShape, Lane.class);
for (PictogramElement currentPicElem : childrenShapes) {
if (currentPicElem instanceof ContainerShape) {
ContainerShape currentContainerShape = (ContainerShape) currentPicElem;
GraphicsAlgorithm laneGA = currentContainerShape.getGraphicsAlgorithm();
ResizeShapeContext newContext = new ResizeShapeContext(currentContainerShape);
newContext.setLocation(laneGA.getX(), laneGA.getY());
if (FeatureSupport.isHorizontal(participantShape)) {
newContext.setWidth(laneGA.getWidth() + dWidth);
newContext.setHeight(laneGA.getHeight());
} else {
newContext.setHeight(laneGA.getHeight() + dHeight);
newContext.setWidth(laneGA.getWidth());
}
newContext.putProperty(POOL_RESIZE_PROPERTY, true);
IResizeShapeFeature resizeFeature =
getFeatureProvider().getResizeShapeFeature(newContext);
if (resizeFeature.canResizeShape(newContext)) {
resizeFeature.resizeShape(newContext);
}
}
}
}
}
private void splitBendPoints(
FreeFormConnection startConnection, Connection endConnection, int x, int y) {
List<Point> points = new ArrayList<Point>();
GraphicsAlgorithm startGa = startConnection.getStart().getGraphicsAlgorithm();
if (startGa != null) {
Point p = StylesFactory.eINSTANCE.createPoint();
p.setX(startGa.getX());
p.setY(startGa.getY());
points.add(p);
}
points.addAll(startConnection.getBendpoints());
GraphicsAlgorithm endGa = startConnection.getEnd().getGraphicsAlgorithm();
if (endGa != null) {
Point p = StylesFactory.eINSTANCE.createPoint();
p.setX(endGa.getX());
p.setY(endGa.getY());
points.add(p);
}
Point p0 = null;
int min = -1, minDistance2 = -1;
for (int i = 0; i < points.size(); i++) {
Point p1 = points.get(i);
if (p0 == null) {
p0 = p1;
} else {
int distance2 =
distance2(x, p0.getX(), y, p0.getX()) + distance2(x, p1.getX(), y, p1.getY());
if (min < 0 || distance2 < minDistance2) {
min = i;
minDistance2 = distance2;
}
p0 = p1;
}
}
for (int i = min; i > 0 && i < points.size(); i++) {
Point p = points.get(i);
if (p.eContainer() != null) {
((List<?>) p.eContainer().eGet(p.eContainingFeature())).remove(p);
}
if (endConnection instanceof FreeFormConnection) {
((FreeFormConnection) endConnection).getBendpoints().add(p);
}
}
}
public boolean layout(ILayoutContext context) {
boolean anythingChanged = false;
ContainerShape containerShape = (ContainerShape) context.getPictogramElement();
GraphicsAlgorithm containerGa = containerShape.getGraphicsAlgorithm();
// height
if (containerGa.getHeight() < MIN_HEIGHT) {
containerGa.setHeight(MIN_HEIGHT);
anythingChanged = true;
}
// width
if (containerGa.getWidth() < MIN_WIDTH) {
containerGa.setWidth(MIN_WIDTH);
anythingChanged = true;
}
int containerWidth = containerGa.getWidth();
for (Shape shape : containerShape.getChildren()) {
GraphicsAlgorithm graphicsAlgorithm = shape.getGraphicsAlgorithm();
IGaService gaService = Graphiti.getGaService();
IDimension size = gaService.calculateSize(graphicsAlgorithm);
if (containerWidth != size.getWidth()) {
if (graphicsAlgorithm instanceof Polyline) {
Polyline polyline = (Polyline) graphicsAlgorithm;
Point secondPoint = polyline.getPoints().get(1);
Point newSecondPoint = gaService.createPoint(containerWidth, secondPoint.getY());
polyline.getPoints().set(1, newSecondPoint);
anythingChanged = true;
} else {
gaService.setWidth(graphicsAlgorithm, containerWidth);
anythingChanged = true;
}
}
}
return anythingChanged;
}
protected ContainerShape createNewShape(
ModelHandler mh, ContainerShape oldShape, EClass newType) {
ILayoutService layoutService = Graphiti.getLayoutService();
boolean horz = Bpmn2Preferences.getInstance().isHorizontalDefault();
ILocation loc = layoutService.getLocationRelativeToDiagram(oldShape);
int x = loc.getX();
int y = loc.getY();
int xOffset = 0;
int yOffset = 0;
GraphicsAlgorithm ga = oldShape.getGraphicsAlgorithm();
int width = ga.getWidth();
int height = ga.getHeight();
BPMN2FeatureProvider fp = (BPMN2FeatureProvider) getFeatureProvider();
AbstractCreateFeature createFeature =
(AbstractCreateFeature) fp.getCreateFeatureForBusinessObject(newType.getInstanceClass());
CreateContext createContext = new CreateContext();
createContext.putProperty(AbstractCreateFlowElementFeature.SKIP_ADD_GRAPHICS, true);
createContext.setTargetContainer(oldShape.getContainer());
FlowElement newObject = null;
if (createFeature != null) {
newObject = (FlowElement) createFeature.create(createContext)[0];
} else {
newObject = (FlowElement) mh.create(newType);
}
ContainerShape containerShape = oldShape.getContainer();
if (containerShape != getDiagram()) {
// we are adding a new shape to a control (e.g a SubProcess)
// so we need to adjust the location to be relative to the
// control instead of the diagram
loc = layoutService.getLocationRelativeToDiagram(containerShape);
xOffset = loc.getX();
yOffset = loc.getY();
}
BaseElement oldObject = BusinessObjectUtil.getFirstElementOfType(oldShape, BaseElement.class);
if (oldObject instanceof Lane) {
((Lane) oldObject).getFlowNodeRefs().add((FlowNode) newObject);
}
AddContext ac = new AddContext(new AreaContext(), newObject);
AbstractAddBpmnShapeFeature af =
(AbstractAddBpmnShapeFeature) getFeatureProvider().getAddFeature(ac);
int w = af.getDefaultWidth();
int h = af.getDefaultHeight();
if (horz) {
x += width + 50 + w / 2;
y += height / 2;
boolean done = false;
while (!done) {
done = true;
List<Shape> shapes = getFlowElementChildren(containerShape);
for (Shape s : shapes) {
if (GraphicsUtil.intersects(s, x - w / 2, y - h / 2, w, h)) {
y += 100;
done = false;
break;
}
}
}
} else {
x += width / 2;
y += height + 50 + h / 2;
boolean done = false;
while (!done) {
done = true;
List<Shape> shapes = getFlowElementChildren(containerShape);
for (Shape s : shapes) {
if (GraphicsUtil.intersects(s, x - w / 2, y - h / 2, w, h)) {
x += 100;
done = false;
break;
}
}
}
}
ac.setX(x - xOffset);
ac.setY(y - yOffset);
ac.setTargetContainer(oldShape.getContainer());
return (ContainerShape) getFeatureProvider().addIfPossible(ac);
}
@Override
public void resizeShape(IResizeShapeContext context) {
ResizeShapeContext resizeShapeContext = (ResizeShapeContext) context;
ContainerShape containerShape = (ContainerShape) context.getPictogramElement();
Activity activity = BusinessObjectUtil.getFirstElementOfType(containerShape, Activity.class);
try {
BPMNShape shape =
(BPMNShape)
ModelHandlerLocator.getModelHandler(getDiagram().eResource()).findDIElement(activity);
if (shape.isIsExpanded()) {
// SubProcess is expanded
GraphicsAlgorithm parentGa = containerShape.getGraphicsAlgorithm();
int newWidth = resizeShapeContext.getWidth();
int newHeight = resizeShapeContext.getHeight();
SizeCalculator sizeCalc = new SizeCalculator(containerShape);
int shiftX = sizeCalc.shiftX;
int shiftY = sizeCalc.shiftY;
int minWidth = sizeCalc.minWidth;
int minHeight = sizeCalc.minHeight;
if (shiftX < 0) {
for (PictogramElement pe : FeatureSupport.getContainerChildren(containerShape)) {
GraphicsAlgorithm childGa = pe.getGraphicsAlgorithm();
if (childGa != null) {
int x = childGa.getX() - shiftX + MARGIN;
childGa.setX(x);
}
}
resizeShapeContext.setX(resizeShapeContext.getX() + shiftX - MARGIN);
shiftX = MARGIN;
}
if (shiftY < 0) {
for (PictogramElement pe : FeatureSupport.getContainerChildren(containerShape)) {
GraphicsAlgorithm childGa = pe.getGraphicsAlgorithm();
if (childGa != null) {
int y = childGa.getY() - shiftY + MARGIN;
childGa.setY(y);
}
}
resizeShapeContext.setY(resizeShapeContext.getY() + shiftY - MARGIN);
shiftX = MARGIN;
}
if (shiftX < MARGIN) shiftX = MARGIN;
if (shiftY < MARGIN) shiftY = MARGIN;
minWidth += 2 * MARGIN;
minHeight += 2 * MARGIN;
if (newWidth < minWidth) {
parentGa.setWidth(minWidth);
}
if (newWidth < shiftX + minWidth) {
int shift = shiftX + minWidth - newWidth;
if (shift > shiftX - MARGIN) {
shift = shiftX - MARGIN;
}
if (shift > 0) {
for (PictogramElement pe : FeatureSupport.getContainerChildren(containerShape)) {
GraphicsAlgorithm childGa = pe.getGraphicsAlgorithm();
if (childGa != null) {
int x = childGa.getX() - shift;
childGa.setX(x);
}
}
}
}
if (newHeight < minHeight) {
parentGa.setHeight(minHeight);
}
if (newHeight < shiftY + minHeight) {
int shift = shiftY + minHeight - newHeight;
if (shift > shiftY - MARGIN) {
shift = shiftY - MARGIN;
}
if (shift > 0) {
for (PictogramElement pe : FeatureSupport.getContainerChildren(containerShape)) {
GraphicsAlgorithm childGa = pe.getGraphicsAlgorithm();
if (childGa != null) {
int y = childGa.getY() - shift;
childGa.setY(y);
}
}
}
}
if (resizeShapeContext.getWidth() < minWidth) resizeShapeContext.setWidth(minWidth);
if (resizeShapeContext.getHeight() < minHeight) resizeShapeContext.setHeight(minHeight);
} else {
// SubProcess is collapsed
for (PictogramElement pe : FeatureSupport.getContainerDecorators(containerShape)) {
GraphicsAlgorithm childGa = pe.getGraphicsAlgorithm();
if (childGa != null) {
childGa.setWidth(GraphicsUtil.getActivitySize(getDiagram()).getWidth());
childGa.setHeight(GraphicsUtil.getActivitySize(getDiagram()).getHeight());
}
}
resizeShapeContext.setWidth(GraphicsUtil.getActivitySize(getDiagram()).getWidth());
resizeShapeContext.setHeight(GraphicsUtil.getActivitySize(getDiagram()).getHeight());
}
} catch (Exception e) {
Activator.logError(e);
}
Graphiti.getPeService().sendToBack(containerShape);
super.resizeShape(context);
}
/**
* Gets the owner {@link PictogramElement} of a Label from a given Text {@link GraphicsAlgorithm}.
*
* @param text a GraphicsAlgorithm that contains the Label text.
* @return the PictogramElement that is the owner of the Label shape.
*/
public static PictogramElement getLabelOwner(GraphicsAlgorithm text) {
PictogramElement pe = text.getPictogramElement();
if (isLabelShape(pe)) return getLabelOwner(pe);
return null;
}
public boolean layout(ILayoutContext context) {
boolean anythingChanged = false;
ContainerShape containerShape = (ContainerShape) context.getPictogramElement();
GraphicsAlgorithm containerGa = containerShape.getGraphicsAlgorithm();
// the containerGa is the invisible rectangle
// containing the visible rectangle as its (first and only) child
GraphicsAlgorithm rectangle = containerGa.getGraphicsAlgorithmChildren().get(0);
// height of invisible rectangle
if (containerGa.getHeight() < MIN_HEIGHT) {
containerGa.setHeight(MIN_HEIGHT);
anythingChanged = true;
}
// height of visible rectangle (same as invisible rectangle)
if (rectangle.getHeight() != containerGa.getHeight()) {
rectangle.setHeight(containerGa.getHeight());
anythingChanged = true;
}
// width of invisible rectangle
if (containerGa.getWidth() < MIN_WIDTH) {
containerGa.setWidth(MIN_WIDTH);
anythingChanged = true;
}
// width of visible rectangle (smaller than invisible rectangle)
int rectangleWidth = containerGa.getWidth() - AddNodeFeature.INVISIBLE_RIGHT_SPACE;
if (rectangle.getWidth() != rectangleWidth) {
rectangle.setWidth(rectangleWidth);
anythingChanged = true;
}
// width of text and line (same as visible rectangle)
for (Shape shape : containerShape.getChildren()) {
GraphicsAlgorithm graphicsAlgorithm = shape.getGraphicsAlgorithm();
IGaService gaService = Graphiti.getGaService();
IDimension size = gaService.calculateSize(graphicsAlgorithm);
if (rectangleWidth != size.getWidth()) {
gaService.setWidth(graphicsAlgorithm, rectangleWidth);
anythingChanged = true;
}
}
return anythingChanged;
}
@Override
public void delete(IDeleteContext context) {
ContainerShape laneContainerShape = (ContainerShape) context.getPictogramElement();
ContainerShape parentContainerShape = laneContainerShape.getContainer();
if (parentContainerShape != null) {
boolean before = false;
ContainerShape neighborContainerShape = FeatureSupport.getLaneAfter(laneContainerShape);
if (neighborContainerShape == null) {
neighborContainerShape = FeatureSupport.getLaneBefore(laneContainerShape);
if (neighborContainerShape == null) {
super.delete(context);
return;
} else {
before = true;
}
}
boolean isHorizontal = FeatureSupport.isHorizontal(laneContainerShape);
GraphicsAlgorithm ga = laneContainerShape.getGraphicsAlgorithm();
GraphicsAlgorithm neighborGA = neighborContainerShape.getGraphicsAlgorithm();
ResizeShapeContext newContext = new ResizeShapeContext(neighborContainerShape);
if (!before) {
Graphiti.getGaService().setLocation(neighborGA, ga.getX(), ga.getY());
}
newContext.setLocation(neighborGA.getX(), neighborGA.getY());
if (isHorizontal) {
newContext.setHeight(neighborGA.getHeight() + ga.getHeight());
newContext.setWidth(neighborGA.getWidth());
} else {
newContext.setHeight(neighborGA.getHeight());
newContext.setWidth(neighborGA.getWidth() + ga.getWidth());
}
IResizeShapeFeature resizeFeature = getFeatureProvider().getResizeShapeFeature(newContext);
if (resizeFeature.canResizeShape(newContext)) {
super.delete(context);
resizeFeature.resizeShape(newContext);
return;
}
}
super.delete(context);
}
private void resizeLaneHeight(IResizeShapeContext context) {
ContainerShape participantShape = (ContainerShape) context.getShape();
GraphicsAlgorithm ga = participantShape.getGraphicsAlgorithm();
ContainerShape laneToResize = null;
GraphicsAlgorithm laneToResizeGA = null;
int width = 0;
int height = 0;
int x = 0;
int y = 0;
boolean resizeFirstLane = false;
boolean resize = false;
if (FeatureSupport.isHorizontal(participantShape)) {
int dHeight = context.getHeight() - ga.getHeight();
if (dHeight != 0) {
resize = true;
if (context.getY() != ga.getY()) {
laneToResize = (ContainerShape) FeatureSupport.getFirstLaneInContainer(participantShape);
resizeFirstLane = true;
} else {
laneToResize = (ContainerShape) FeatureSupport.getLastLaneInContainer(participantShape);
}
laneToResizeGA = laneToResize.getGraphicsAlgorithm();
width = laneToResizeGA.getWidth();
height = laneToResizeGA.getHeight() + dHeight;
x = laneToResizeGA.getX();
y = laneToResizeGA.getY();
}
} else {
int dWidth = context.getWidth() - ga.getWidth();
if (dWidth != 0) {
resize = true;
if (context.getX() != ga.getX()) {
laneToResize = (ContainerShape) FeatureSupport.getFirstLaneInContainer(participantShape);
resizeFirstLane = true;
} else {
laneToResize = (ContainerShape) FeatureSupport.getLastLaneInContainer(participantShape);
}
laneToResizeGA = laneToResize.getGraphicsAlgorithm();
width = laneToResizeGA.getWidth() + dWidth;
height = laneToResizeGA.getHeight();
x = laneToResizeGA.getX();
y = laneToResizeGA.getY();
}
}
if (resize) {
ResizeShapeContext newContext = new ResizeShapeContext(laneToResize);
newContext.setLocation(x, y);
newContext.setHeight(height);
newContext.setWidth(width);
newContext.putProperty(POOL_RESIZE_PROPERTY, true);
newContext.putProperty(RESIZE_FIRST_LANE, resizeFirstLane);
IResizeShapeFeature resizeFeature = getFeatureProvider().getResizeShapeFeature(newContext);
if (resizeFeature.canResizeShape(newContext)) {
resizeFeature.resizeShape(newContext);
}
if (FeatureSupport.isHorizontal(participantShape)) {
((ResizeShapeContext) context).setHeight(ga.getHeight());
} else {
((ResizeShapeContext) context).setWidth(ga.getWidth());
}
}
}