@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;
 }
Example #18
0
  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());
      }
    }
  }