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;
}
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 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();
}
}
}
}
@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 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);
}
}
}
}
}
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);
}
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());
}
}
}