@Override
  public PictogramElement add(IAddContext context) {
    final NamespaceDeclaration namespaceDeclaration = (NamespaceDeclaration) context.getNewObject();

    final Diagram targetDiagram = (Diagram) context.getTargetContainer();

    // CONTAINER SHAPE WITH ROUNDED RECTANGLE
    IPeCreateService peCreateService = Graphiti.getPeCreateService();
    ContainerShape containerShape = peCreateService.createContainerShape(targetDiagram, true);

    // define a default size for the shape
    int width = 100;
    int height = 50;
    IGaService gaService = Graphiti.getGaService();
    RoundedRectangle roundedRectangle; // need to access it later

    // create and set graphics algorithm
    roundedRectangle = gaService.createRoundedRectangle(containerShape, 5, 5);
    roundedRectangle.setForeground(manageColor(IColorConstant.BLACK));
    roundedRectangle.setBackground(manageColor(IColorConstant.WHITE));
    roundedRectangle.setLineWidth(2);
    gaService.setLocationAndSize(roundedRectangle, context.getX(), context.getY(), width, height);

    // create link and wire it
    link(containerShape, namespaceDeclaration);

    // create shape for text
    Shape shape = peCreateService.createShape(containerShape, false);

    // create and set text graphics algorithm
    Text text = gaService.createText(shape, namespaceDeclaration.getName());
    text.setForeground(manageColor(IColorConstant.BLACK));
    text.setHorizontalAlignment(Orientation.ALIGNMENT_CENTER);
    // vertical alignment has as default value "center"
    text.setFont(gaService.manageDefaultFont(getDiagram(), false, true));
    gaService.setLocationAndSize(text, 0, 0, width, 20);

    // create link and wire it
    link(shape, namespaceDeclaration);

    return containerShape;
  }
 @Override
 protected void decorateContainerRect(RoundedRectangle containerRect) {
   containerRect.setLineWidth(2);
 }
  // Adds a User Application figure to the target object
  @Override
  public PictogramElement add(final IAddContext context) {

    TDeploymentArtifact addedClass = (TDeploymentArtifact) context.getNewObject();

    ContainerShape targetDiagram = (ContainerShape) context.getTargetContainer();
    Object[] targetDiagrams = targetDiagram.getChildren().toArray();
    int ySD = 0;
    int interdist = 0;
    for (int i = 0; i < targetDiagrams.length; i++) {
      Object o = getBusinessObjectForPictogramElement((Shape) targetDiagrams[i]);
      if (o instanceof UserApplication) interdist = 3;
    }
    for (int i = 0; i < targetDiagrams.length; i++) {
      Object o = getBusinessObjectForPictogramElement((Shape) targetDiagrams[i]);
      if (((Shape) targetDiagrams[i]).getGraphicsAlgorithm() instanceof Rectangle
          || (o instanceof SoftwareDependency)) {
        if (((Shape) targetDiagrams[i]).getGraphicsAlgorithm() instanceof Rectangle) {
          ySD = ((Shape) targetDiagrams[i]).getGraphicsAlgorithm().getY();
        }
        ((Shape) targetDiagrams[i])
            .getGraphicsAlgorithm()
            .setY(((Shape) targetDiagrams[i]).getGraphicsAlgorithm().getY() + 20 + interdist);
      }
    }
    // CONTAINER SHAPE WITH ROUNDED RECTANGLE
    IPeCreateService peCreateService = Graphiti.getPeCreateService();
    ContainerShape containerShape = peCreateService.createContainerShape(targetDiagram, true);
    final int width = StyleUtil.SOFT_DEPENDENCY_WIDTH;
    final int height = 20;
    IGaService gaService = Graphiti.getGaService();
    RoundedRectangle roundedRectangle;
    {
      // create and set graphics algorithm
      int x = (StyleUtil.APP_COMPONENT_WIDTH - width) / 2;
      roundedRectangle = gaService.createRoundedRectangle(containerShape, 5, 5);
      roundedRectangle.setForeground(manageColor(E_CLASS_FOREGROUND));
      roundedRectangle.setBackground(manageColor(E_CLASS_BACKGROUND));
      roundedRectangle.setLineWidth(2);
      gaService.setLocationAndSize(roundedRectangle, x, ySD - 10 + interdist, width, height);
      if (addedClass.eResource() == null) {
        getDiagram().eResource().getContents().add(addedClass);
      }
      // create link and wire it
      link(containerShape, addedClass);
    }
    // SHAPE WITH LINE
    {
      // create shape for line
      Shape shape = peCreateService.createShape(containerShape, false);
      // create and set graphics algorithm
      Polyline polyline = gaService.createPolyline(shape, new int[] {0, 20, width, 20});
      polyline.setForeground(manageColor(E_CLASS_FOREGROUND));
      polyline.setLineWidth(2);
    }
    // SHAPE WITH TEXT
    {
      // create shape for text
      Shape shape = peCreateService.createShape(containerShape, false);
      // create and set text graphics algorithm
      Text text = gaService.createText(shape, addedClass.getName());
      text.setForeground(manageColor(E_CLASS_TEXT_FOREGROUND));
      text.setHorizontalAlignment(Orientation.ALIGNMENT_CENTER);
      // vertical alignment has as default value "center"
      text.setFont(gaService.manageDefaultFont(getDiagram(), false, true));
      gaService.setLocationAndSize(text, 0, 0, width, 20);
      // create link and wire it
      link(shape, addedClass);
    }
    return containerShape;
  }
  @Override
  public PictogramElement add(IAddContext context) {
    final Task addedTask = (Task) context.getNewObject();
    final ContainerShape parent = context.getTargetContainer();

    // CONTAINER SHAPE WITH ROUNDED RECTANGLE
    final IPeCreateService peCreateService = Graphiti.getPeCreateService();
    final ContainerShape containerShape = peCreateService.createContainerShape(parent, true);
    final IGaService gaService = Graphiti.getGaService();

    DiagramBaseShape baseShape = DiagramBaseShape.ACTIVITY;

    if (ExtensionUtil.isCustomServiceTask(addedTask)) {
      final ServiceTask serviceTask = (ServiceTask) addedTask;
      final List<CustomServiceTask> customServiceTasks =
          ExtensionUtil.getCustomServiceTasks(ActivitiUiUtil.getProjectFromDiagram(getDiagram()));

      CustomServiceTask targetTask = null;

      for (final CustomServiceTask customServiceTask : customServiceTasks) {
        if (customServiceTask.getId().equals(ExtensionUtil.getCustomServiceTaskId(serviceTask))) {
          targetTask = customServiceTask;
          break;
        }
      }

      if (!DiagramBaseShape.ACTIVITY.equals(targetTask.getDiagramBaseShape())) {
        baseShape = targetTask.getDiagramBaseShape();
      }
    }

    int width = 0;
    int height = 0;
    GraphicsAlgorithm algorithm = null;

    switch (baseShape) {
      case ACTIVITY:
        // check whether the context has a size (e.g. from a create feature)
        // otherwise define a default size for the shape
        width = context.getWidth() <= 0 ? 105 : context.getWidth();
        height = context.getHeight() <= 0 ? 55 : context.getHeight();

        RoundedRectangle roundedRectangle; // need to access it later
        {
          // create invisible outer rectangle expanded by
          // the width needed for the anchor
          final Rectangle invisibleRectangle = gaService.createInvisibleRectangle(containerShape);
          gaService.setLocationAndSize(
              invisibleRectangle, context.getX(), context.getY(), width, height);

          // create and set visible rectangle inside invisible rectangle
          roundedRectangle = gaService.createRoundedRectangle(invisibleRectangle, 20, 20);
          algorithm = roundedRectangle;
          roundedRectangle.setParentGraphicsAlgorithm(invisibleRectangle);
          roundedRectangle.setStyle(StyleUtil.getStyleForTask(getDiagram()));
          gaService.setLocationAndSize(roundedRectangle, 0, 0, width, height);

          // create link and wire it
          link(containerShape, addedTask);
        }
        break;
      case GATEWAY:
        // check whether the context has a size (e.g. from a create feature)
        // otherwise define a default size for the shape
        width = context.getWidth() <= 0 ? 60 : context.getWidth();
        height = context.getHeight() <= 0 ? 60 : context.getHeight();

        Polygon polygon;
        {
          int xy[] = new int[] {0, 30, 30, 0, 60, 30, 30, 60, 0, 30};

          final Polygon invisiblePolygon = gaService.createPolygon(containerShape, xy);
          invisiblePolygon.setFilled(false);
          invisiblePolygon.setLineVisible(false);
          gaService.setLocationAndSize(
              invisiblePolygon, context.getX(), context.getY(), width, height);

          // create and set visible circle inside invisible circle
          polygon = gaService.createPolygon(invisiblePolygon, xy);
          algorithm = polygon;
          polygon.setParentGraphicsAlgorithm(invisiblePolygon);
          polygon.setStyle(StyleUtil.getStyleForTask(getDiagram()));
          gaService.setLocationAndSize(polygon, 0, 0, width, height);

          // create link and wire it
          link(containerShape, addedTask);
        }
        break;
      case EVENT:
        // check whether the context has a size (e.g. from a create feature)
        // otherwise define a default size for the shape
        width = context.getWidth() <= 0 ? 55 : context.getWidth();
        height = context.getHeight() <= 0 ? 55 : context.getHeight();

        Ellipse circle;
        {
          final Ellipse invisibleCircle = gaService.createEllipse(containerShape);
          invisibleCircle.setFilled(false);
          invisibleCircle.setLineVisible(false);
          gaService.setLocationAndSize(
              invisibleCircle, context.getX(), context.getY(), width, height);

          // create and set visible circle inside invisible circle
          circle = gaService.createEllipse(invisibleCircle);
          circle.setParentGraphicsAlgorithm(invisibleCircle);
          circle.setStyle(StyleUtil.getStyleForTask(getDiagram()));
          gaService.setLocationAndSize(circle, 0, 0, width, height);

          // create link and wire it
          link(containerShape, addedTask);
        }
        break;
    }

    // SHAPE WITH TEXT
    {
      // create shape for text
      final Shape shape = peCreateService.createShape(containerShape, false);

      // create and set text graphics algorithm
      final MultiText text =
          gaService.createDefaultMultiText(getDiagram(), shape, addedTask.getName());
      text.setStyle(StyleUtil.getStyleForTask(getDiagram()));
      text.setHorizontalAlignment(Orientation.ALIGNMENT_CENTER);
      text.setVerticalAlignment(Orientation.ALIGNMENT_CENTER);
      if (OSUtil.getOperatingSystem() == OSEnum.Mac) {
        text.setFont(gaService.manageFont(getDiagram(), text.getFont().getName(), 11));
      }

      switch (baseShape) {
        case ACTIVITY:
          gaService.setLocationAndSize(text, 0, 20, width, height - 25);
          break;
        case GATEWAY:
          gaService.setLocationAndSize(text, 0, height + 5, width, 40);
          break;
        case EVENT:
          gaService.setLocationAndSize(text, 0, height + 5, width, 40);
          break;
      }

      // create link and wire it
      link(shape, addedTask);

      // provide information to support direct-editing directly
      // after object creation (must be activated additionally)
      final IDirectEditingInfo directEditingInfo = getFeatureProvider().getDirectEditingInfo();
      // set container shape for direct editing after object creation
      directEditingInfo.setMainPictogramElement(containerShape);
      // set shape and graphics algorithm where the editor for
      // direct editing shall be opened after object creation
      directEditingInfo.setPictogramElement(shape);
      directEditingInfo.setGraphicsAlgorithm(text);
    }

    {
      final Shape shape = peCreateService.createShape(containerShape, false);
      final Image image = gaService.createImage(shape, getIcon(addedTask));

      switch (baseShape) {
        case ACTIVITY:
          gaService.setLocationAndSize(image, 5, 5, IMAGE_SIZE, IMAGE_SIZE);
          break;
        case GATEWAY:
          gaService.setLocationAndSize(
              image, (width - IMAGE_SIZE) / 2, (height - IMAGE_SIZE) / 2, IMAGE_SIZE, IMAGE_SIZE);
          break;
        case EVENT:
          gaService.setLocationAndSize(
              image, (width - IMAGE_SIZE) / 2, (height - IMAGE_SIZE) / 2, IMAGE_SIZE, IMAGE_SIZE);
          break;
      }
    }

    // add a chopbox anchor to the shape
    peCreateService.createChopboxAnchor(containerShape);

    // create an additional box relative anchor at middle-right
    final BoxRelativeAnchor boxAnchor = peCreateService.createBoxRelativeAnchor(containerShape);
    boxAnchor.setRelativeWidth(1.0);
    boxAnchor.setRelativeHeight(0.51);
    boxAnchor.setReferencedGraphicsAlgorithm(algorithm);
    final Ellipse ellipse = ActivitiUiUtil.createInvisibleEllipse(boxAnchor, gaService);
    gaService.setLocationAndSize(ellipse, 0, 0, 0, 0);
    layoutPictogramElement(containerShape);

    return containerShape;
  }