public static boolean setHidden(PictogramElement pe, boolean hidden) {
   if (hidden) {
     pe.eSetDeliver(false);
     Graphiti.getPeService()
         .setPropertyValue(pe, GraphitiConstants.IS_HIDDEN, Boolean.TRUE.toString());
     pe.setVisible(false);
     pe.eSetDeliver(true);
   } else {
     pe.eSetDeliver(false);
     Graphiti.getPeService().removeProperty(pe, GraphitiConstants.IS_HIDDEN);
     pe.setVisible(true);
     pe.eSetDeliver(true);
   }
   return false;
 }
 @Override
 public PictogramElement add(IAddContext context) {
   PictogramElement pe = super.add(context);
   // make sure everyone knows that this PE is a custom task
   Graphiti.getPeService().setPropertyValue(pe, CUSTOM_TASK_ID, getId());
   return pe;
 }
 public static void setHorizontal(ContainerShape container, boolean isHorizontal) {
   Graphiti.getPeService()
       .setPropertyValue(
           container, GraphitiConstants.IS_HORIZONTAL_PROPERTY, Boolean.toString(isHorizontal));
   BPMNShape bs = BusinessObjectUtil.getFirstElementOfType(container, BPMNShape.class);
   if (bs != null) bs.setIsHorizontal(isHorizontal);
 }
  /**
   * Returns the modelObject ID string from the given Graphiti context.
   *
   * @param context
   * @return - ID string for this modelObject.
   */
  public static String getId(IContext context) {
    Object id = null;

    /**
     * IAddContext can also mean that a file is dragged, therefore we have to check if we are really
     * dragging a customTask
     */
    if (context instanceof IAddContext
        && ((IAddContext) context).getNewObject() instanceof EObject) {
      EObject object = (EObject) ((IAddContext) context).getNewObject();
      TargetRuntime rt = TargetRuntime.getCurrentRuntime();
      for (CustomTaskDescriptor ct : rt.getCustomTasks()) {
        id = ct.getFeatureContainer().getId(object);
        if (id != null) {
          context.putProperty(CUSTOM_TASK_ID, id);
          return (String) id;
        }
      }
    }

    if (context instanceof IPictogramElementContext) {
      PictogramElement pe = ((IPictogramElementContext) context).getPictogramElement();
      id = Graphiti.getPeService().getPropertyValue(pe, CUSTOM_TASK_ID);
    } else {
      id = context.getProperty(CUSTOM_TASK_ID);
    }
    return (String) id;
  }
  @Override
  protected ContainerShape createPictogramElement(IAddContext context, IRectangle bounds) {

    T addedGateway = getBusinessObject(context);
    IGaService gaService = Graphiti.getGaService();
    IPeService peService = Graphiti.getPeService();

    int x = bounds.getX();
    int y = bounds.getY();
    int width = bounds.getWidth();
    int height = bounds.getHeight();

    // Create a container for the gateway-symbol
    final ContainerShape newShape =
        peService.createContainerShape(context.getTargetContainer(), true);
    final Rectangle gatewayRect = gaService.createInvisibleRectangle(newShape);
    gaService.setLocationAndSize(gatewayRect, x, y, width, height);

    Shape gatewayShape = peService.createShape(newShape, false);
    Polygon gateway = GraphicsUtil.createGateway(gatewayShape, width, height);
    StyleUtil.applyStyle(gateway, addedGateway);
    gaService.setLocationAndSize(gateway, 0, 0, width, height);

    return newShape;
  }
  @Override
  public PictogramElement add(IAddContext context) {
    IPeService peService = Graphiti.getPeService();
    IGaService gaService = Graphiti.getGaService();

    BaseElement element = (BaseElement) context.getNewObject();
    IAddConnectionContext addConContext = (IAddConnectionContext) context;

    Connection connection = peService.createFreeFormConnection(getDiagram());

    Object importProp = context.getProperty(DIImport.IMPORT_PROPERTY);
    if (importProp != null && (Boolean) importProp) {
      connection.setStart(addConContext.getSourceAnchor());
      connection.setEnd(addConContext.getTargetAnchor());
    } else {
      ContainerShape sourceContainer =
          (ContainerShape) addConContext.getSourceAnchor().eContainer();
      ContainerShape targetContainer =
          (ContainerShape) addConContext.getTargetAnchor().eContainer();
      Tuple<FixPointAnchor, FixPointAnchor> anchors =
          AnchorUtil.getSourceAndTargetBoundaryAnchors(
              sourceContainer, targetContainer, connection);

      connection.setStart(anchors.getFirst());
      connection.setEnd(anchors.getSecond());
    }

    if (ModelUtil.hasName(element)) {
      ConnectionDecorator labelDecorator =
          Graphiti.getPeService().createConnectionDecorator(connection, true, 0.5, true);
      Text text = gaService.createText(labelDecorator, ModelUtil.getName(element));
      peService.setPropertyValue(
          labelDecorator, UpdateBaseElementNameFeature.TEXT_ELEMENT, Boolean.toString(true));
      text.setStyle(StyleUtil.getStyleForText(getDiagram()));
    }

    Polyline connectionLine = gaService.createPolyline(connection);
    connectionLine.setForeground(manageColor(StyleUtil.CLASS_FOREGROUND));

    decorateConnectionLine(connectionLine);

    createDIEdge(connection, element);
    createConnectionDecorators(connection);
    hook(addConContext, connection, element);

    return connection;
  }
 public static GraphicsAlgorithm[] getClickArea(PictogramElement element) {
   Iterator<PictogramElement> iterator =
       Graphiti.getPeService().getPictogramElementChildren(element).iterator();
   GraphicsAlgorithm[] algorithms = new GraphicsAlgorithm[2];
   algorithms[0] = iterator.next().getGraphicsAlgorithm();
   algorithms[1] = iterator.next().getGraphicsAlgorithm();
   return algorithms;
 }
Esempio n. 8
0
 /**
  * If the given AnchorContainer has graphiti connections from / to itself, this method delete all
  * these connections as well the business objects (net.sf.orcc.df.Connection) linked
  *
  * @param fp The current FeatureProvider instance
  * @param ac An anchor container, typically an Instance or a NetworkPort shape
  */
 public static void deleteConnections(final IFeatureProvider fp, final AnchorContainer ac) {
   // Make a copy of all connections, because we will delete them entirely
   final List<org.eclipse.graphiti.mm.pictograms.Connection> connections =
       Graphiti.getPeService().getAllConnections(ac);
   for (final org.eclipse.graphiti.mm.pictograms.Connection connection : connections) {
     deleteConnection(fp, connection);
   }
 }
  /**
   * Set this modelObject's ID in the given Graphiti context.
   *
   * @param context - if this is a IPictogramElementContext, set the property in the contained
   *     PictogramElement's list of properties; otherwise set the Context's property
   * @param id - ID of this Custom Task
   */
  public static void setId(IContext context, String id) {

    if (context instanceof IPictogramElementContext) {
      PictogramElement pe = ((IPictogramElementContext) context).getPictogramElement();
      Graphiti.getPeService().setPropertyValue(pe, CUSTOM_TASK_ID, id);
    } else {
      context.putProperty(CUSTOM_TASK_ID, id);
    }
  }
  @Override
  protected void hook(
      Activity activity, ContainerShape container, IAddContext context, int width, int height) {
    super.hook(activity, container, context, width, height);
    Graphiti.getPeService().setPropertyValue(container, TRIGGERED_BY_EVENT, "false");

    IPeService peService = Graphiti.getPeService();
    IGaService gaService = Graphiti.getGaService();

    Shape textShape = peService.createShape(container, false);
    Text text = gaService.createDefaultText(textShape, activity.getName());
    gaService.setLocationAndSize(text, 5, 5, width - 10, 15);
    text.setStyle(StyleUtil.getStyleForText(getDiagram()));
    text.setHorizontalAlignment(Orientation.ALIGNMENT_CENTER);
    text.setVerticalAlignment(Orientation.ALIGNMENT_CENTER);
    text.getFont().setBold(true);
    link(textShape, activity);
  }
Esempio n. 11
0
  @Override
  public IContextButtonPadData getContextButtonPad(IPictogramElementContext context) {
    IContextButtonPadData data = super.getContextButtonPad(context);
    PictogramElement pe = context.getPictogramElement();

    // 1. set the generic context buttons
    // note, that we do not add 'remove' (just as an example)
    setGenericContextButtons(data, pe, CONTEXT_BUTTON_DELETE | CONTEXT_BUTTON_UPDATE);

    // 2. set the collapse button
    // simply use a dummy custom feature (senseless example)
    CustomContext cc = new CustomContext(new PictogramElement[] {pe});
    ICustomFeature[] cf = getFeatureProvider().getCustomFeatures(cc);
    for (int i = 0; i < cf.length; i++) {
      ICustomFeature iCustomFeature = cf[i];
      if (iCustomFeature instanceof AcoreCollapseDummyFeature) {
        IContextButtonEntry collapseButton =
            ContextEntryHelper.createCollapseContextButton(true, iCustomFeature, cc);
        data.setCollapseContextButton(collapseButton);
        break;
      }
    }

    // 3. add one domain specific context-button, which offers all
    // available connection-features as drag&drop features...

    // 3.a. create new CreateConnectionContext
    CreateConnectionContext ccc = new CreateConnectionContext();
    ccc.setSourcePictogramElement(pe);
    Anchor anchor = null;
    if (pe instanceof Anchor) {
      anchor = (Anchor) pe;
    } else if (pe instanceof AnchorContainer) {
      // assume, that our shapes always have chopbox anchors
      anchor = Graphiti.getPeService().getChopboxAnchor((AnchorContainer) pe);
    }
    ccc.setSourceAnchor(anchor);

    // 3.b. create context button and add all applicable features
    ContextButtonEntry button = new ContextButtonEntry(null, context);
    button.setText("Create connection"); // $NON-NLS-1$
    button.setIconId(AcoreImageProvider.IMG_EREFERENCE);
    ICreateConnectionFeature[] features = getFeatureProvider().getCreateConnectionFeatures();
    for (ICreateConnectionFeature feature : features) {
      if (feature.isAvailable(ccc) && feature.canStartConnection(ccc)) {
        button.addDragAndDropFeature(feature);
      }
    }

    // 3.c. add context button, if it contains at least one feature
    if (button.getDragAndDropFeatures().size() > 0) {
      data.getDomainSpecificContextButtons().add(button);
    }

    return data;
  }
 protected void addBusinessObjectToContainer(rootCon bo, PictogramElement pe) {
   final rootCon model = modelService.getModel();
   final String alias = Graphiti.getPeService().getPropertyValue(pe, PROPERTY_ALIAS);
   if (bo.eClass() == Test3Package.Literals.NODE && alias == null) {
     model.getNodes().add((node) bo);
   }
   if (bo.eClass() == Test3Package.Literals.BRANCH && alias == null) {
     model.getChildren().add((branch) bo);
   }
 }
Esempio n. 13
0
 public static IDimension getExpandedSize(PictogramElement pe) {
   IDimension size = GraphicsUtil.calculateSize(pe);
   String property = Graphiti.getPeService().getPropertyValue(pe, GraphitiConstants.EXPANDED_SIZE);
   if (property != null) {
     int index = property.indexOf(',');
     int w = Integer.parseInt(property.substring(0, index));
     int h = Integer.parseInt(property.substring(index + 1));
     size.setWidth(w);
     size.setHeight(h);
   }
   return size;
 }
Esempio n. 14
0
 public static Shape getShape(ContainerShape container, String property, String expectedValue) {
   IPeService peService = Graphiti.getPeService();
   Iterator<Shape> iterator = peService.getAllContainedShapes(container).iterator();
   while (iterator.hasNext()) {
     Shape shape = iterator.next();
     String value = peService.getPropertyValue(shape, property);
     if (value != null && value.equals(expectedValue)) {
       return shape;
     }
   }
   return null;
 }
    @Override
    protected PictogramElement addGraphicalRepresentation(IAreaContext context, Object newObject) {

      // create a new AddContext and copy our ID into it.
      IAddContext addContext = new AddContext(context, newObject);
      setId(addContext, getId());

      // create the PE and copy our ID into its properties.
      PictogramElement pe = getFeatureProvider().addIfPossible(addContext);
      Graphiti.getPeService().setPropertyValue(pe, CUSTOM_TASK_ID, id);

      return pe;
    }
Esempio n. 16
0
 public static List<ContainerShape> getParticipantBandContainerShapes(
     ContainerShape containerShape) {
   IPeService peService = Graphiti.getPeService();
   List<ContainerShape> bandShapes = new ArrayList<ContainerShape>();
   Collection<Shape> shapes = peService.getAllContainedShapes(containerShape);
   for (Shape s : shapes) {
     String property = peService.getPropertyValue(s, ChoreographyUtil.PARTICIPANT_BAND);
     if (new Boolean(property)) {
       bandShapes.add((ContainerShape) s);
     }
   }
   return bandShapes;
 }
  // TODO: move this to the adapter registry
  public IFeature getCreateFeatureForPictogramElement(PictogramElement pe) {
    if (pe != null) {
      String id = Graphiti.getPeService().getPropertyValue(pe, ICustomTaskFeature.CUSTOM_TASK_ID);
      if (id != null) {
        for (FeatureContainer container : containers) {
          if (container instanceof CustomTaskFeatureContainer) {
            CustomTaskFeatureContainer ctf = (CustomTaskFeatureContainer) container;
            if (id.equals(ctf.getId())) {
              return ctf.getCreateFeature(this);
            }
          }
        }
      }

      EObject be = Graphiti.getLinkService().getBusinessObjectForLinkedPictogramElement(pe);
      return getCreateFeatureForBusinessObject(be);
    }
    return null;
  }
Esempio n. 18
0
  public static boolean isHorizontal(ContainerShape container) {
    EObject parent = container.eContainer();
    if (parent instanceof PictogramElement) {
      // participant bands are always "vertical" so that
      // the label is drawn horizontally by the LayoutFeature
      if (BusinessObjectUtil.getFirstElementOfType(
              (PictogramElement) parent, ChoreographyActivity.class)
          != null) return false;
    }

    String v =
        Graphiti.getPeService()
            .getPropertyValue(container, GraphitiConstants.IS_HORIZONTAL_PROPERTY);
    if (v == null) {
      BPMNShape bpmnShape =
          DIUtils.findBPMNShape(BusinessObjectUtil.getFirstBaseElement(container));
      if (bpmnShape != null) return bpmnShape.isIsHorizontal();
      return Bpmn2Preferences.getInstance(container).isHorizontalDefault();
    }
    return Boolean.parseBoolean(v);
  }
Esempio n. 19
0
 @Override
 protected void handlePostSelectionChanged(SelectionChangedEvent event) {
   ISelectionProvider parentProvider = getMultiPageEditor().getSite().getSelectionProvider();
   // make sure the selected PictogramElement is still on the same Diagram as the
   // one currently being displayed - this event can happen after a page switch.
   Diagram currentDiagram = bpmn2Editor.getDiagramTypeProvider().getDiagram();
   PictogramElement pe = BusinessObjectUtil.getPictogramElementForSelection(event.getSelection());
   try {
     Diagram peDiagram = Graphiti.getPeService().getDiagramForPictogramElement(pe);
     if (currentDiagram != peDiagram) return;
   } catch (Exception e) {
     // if PictogramElements were deleted, there will be an NPE when searching for
     // the PEs parent diagram
     return;
   }
   if (parentProvider instanceof MultiPageSelectionProvider) {
     SelectionChangedEvent newEvent = getNewEvent(parentProvider, event);
     MultiPageSelectionProvider prov = (MultiPageSelectionProvider) parentProvider;
     prov.firePostSelectionChanged(newEvent);
   }
 }
  @Override
  public PictogramElement add(IAddContext context) {
    IPeService peService = Graphiti.getPeService();

    BaseElement element = (BaseElement) context.getNewObject();
    IAddConnectionContext addConContext = (IAddConnectionContext) context;

    Connection connection = peService.createFreeFormConnection(getDiagram());

    Object importProp = context.getProperty(DIImport.IMPORT_PROPERTY);
    if (importProp != null && (Boolean) importProp) {
      connection.setStart(addConContext.getSourceAnchor());
      connection.setEnd(addConContext.getTargetAnchor());
    } else {
      ContainerShape sourceContainer =
          (ContainerShape) addConContext.getSourceAnchor().eContainer();
      ContainerShape targetContainer =
          (ContainerShape) addConContext.getTargetAnchor().eContainer();
      Tuple<FixPointAnchor, FixPointAnchor> anchors =
          AnchorUtil.getSourceAndTargetBoundaryAnchors(
              sourceContainer, targetContainer, connection);

      connection.setStart(anchors.getFirst());
      connection.setEnd(anchors.getSecond());
    }

    IGaService gaService = Graphiti.getGaService();
    Polyline connectionLine = gaService.createPolyline(connection);
    connectionLine.setForeground(manageColor(StyleUtil.CLASS_FOREGROUND));

    decorateConnectionLine(connectionLine);

    createDIEdge(connection, element);
    createConnectionDecorators(connection);
    hook(addConContext, connection, element);

    return connection;
  }
 protected IPeService getPeService() {
   return Graphiti.getPeService();
 }
/**
 * Abstract base class for Connection Routers. This is a container for common utility functions
 * related to routing.
 */
public abstract class AbstractConnectionRouter implements IConnectionRouter {

  /** The Constant peService. */
  protected static final IPeService peService = Graphiti.getPeService();

  /** The Constant gaService. */
  protected static final IGaService gaService = Graphiti.getGaService();

  /** The connection routing directions. */
  public enum Direction {
    UP,
    DOWN,
    LEFT,
    RIGHT,
    NONE
  };

  /** The Feature Provider. */
  protected IFeatureProvider fp;

  /**
   * Instantiates a new abstract connection router.
   *
   * @param fp the Feature Provider
   */
  public AbstractConnectionRouter(IFeatureProvider fp) {
    this.fp = fp;
  }

  /* (non-Javadoc)
   * @see org.eclipse.bpmn2.modeler.core.features.IConnectionRouter#route(org.eclipse.graphiti.mm.pictograms.Connection)
   */
  @Override
  public abstract boolean route(Connection connection);

  /* (non-Javadoc)
   * @see org.eclipse.bpmn2.modeler.core.features.IConnectionRouter#dispose()
   */
  @Override
  public abstract void dispose();

  /**
   * Adds the routing info.
   *
   * @param connection the connection
   * @param info the info
   * @return the string
   */
  public static String addRoutingInfo(Connection connection, String info) {
    Assert.isTrue(info != null && !info.isEmpty());
    String newInfo = getRoutingInfo(connection);
    if (!newInfo.isEmpty()) newInfo += ","; // $NON-NLS-1$
    newInfo += info;

    peService.setPropertyValue(connection, ROUTING_INFO, newInfo);
    return newInfo;
  }

  /**
   * Removes the routing info.
   *
   * @param connection the connection
   */
  public static void removeRoutingInfo(Connection connection) {
    removeRoutingInfo(connection, getRoutingInfo(connection));
  }

  /**
   * Removes the routing info.
   *
   * @param connection the connection
   * @param info the info
   * @return the string
   */
  public static String removeRoutingInfo(Connection connection, String info) {
    String newInfo = null;
    if (info != null && !info.isEmpty()) {
      newInfo = getRoutingInfo(connection);
      if (newInfo != null && !newInfo.isEmpty()) {
        String a[] = newInfo.split(","); // $NON-NLS-1$
        String b[] = info.split(","); // $NON-NLS-1$
        for (int i = 0; i < a.length; ++i) {
          for (String sb : b) {
            if (a[i].startsWith(sb)) {
              a[i] = null;
              break;
            }
          }
        }
        newInfo = ""; // $NON-NLS-1$
        for (int i = 0; i < a.length; ++i) {
          if (a[i] != null && !a[i].isEmpty()) {
            if (!newInfo.isEmpty()) newInfo += ","; // $NON-NLS-1$
            newInfo += a[i];
          }
        }
      }
    }
    if (newInfo == null || newInfo.isEmpty()) peService.removeProperty(connection, ROUTING_INFO);
    else peService.setPropertyValue(connection, ROUTING_INFO, newInfo);
    return newInfo;
  }

  /**
   * Gets the routing info.
   *
   * @param connection the connection
   * @return the routing info
   */
  public static String getRoutingInfo(Connection connection) {
    String info = peService.getPropertyValue(connection, ROUTING_INFO);
    if (info == null || info.isEmpty()) return ""; // $NON-NLS-1$
    return info;
  }

  /**
   * Sets the routing info.
   *
   * @param connection the connection
   * @param info the info
   * @param value the value
   * @return the string
   */
  public static String setRoutingInfoInt(Connection connection, String info, int value) {
    removeRoutingInfo(connection, info + "="); // $NON-NLS-1$
    return addRoutingInfo(connection, info + "=" + value); // $NON-NLS-1$
  }

  /**
   * Gets the routing info.
   *
   * @param connection the connection
   * @param info the info
   * @return the routing info
   */
  public static int getRoutingInfoInt(Connection connection, String info) {
    String oldInfo = getRoutingInfo(connection);
    String a[] = oldInfo.split(","); // $NON-NLS-1$
    for (String s : a) {
      if (oldInfo.startsWith(info + "=")) { // $NON-NLS-1$
        try {
          String b[] = s.split("="); // $NON-NLS-1$
          return Integer.parseInt(b[1]);
        } catch (Exception e) {
        }
      }
    }
    return -1;
  }

  /**
   * Sets the force routing.
   *
   * @param connection the connection
   * @param force the force
   */
  public static void setForceRouting(Connection connection, boolean force) {
    if (force) addRoutingInfo(connection, ROUTING_INFO_FORCE);
    else removeRoutingInfo(connection, ROUTING_INFO_FORCE);
  }

  /**
   * Force routing.
   *
   * @param connection the connection
   * @return true, if successful
   */
  public static boolean forceRouting(Connection connection) {
    return getRoutingInfo(connection).contains(ROUTING_INFO_FORCE);
  }
}
 public static GraphicsAlgorithm getSelectionBorder(PictogramElement element) {
   Collection<PictogramElement> children =
       Graphiti.getPeService().getPictogramElementChildren(element);
   PictogramElement first = children.iterator().next();
   return first.getGraphicsAlgorithm();
 }
Esempio n. 24
0
 public static GraphicsAlgorithm[] getClickArea(PictogramElement element) {
   Collection<PictogramElement> children =
       Graphiti.getPeService().getPictogramElementChildren(element);
   PictogramElement first = children.iterator().next();
   return new GraphicsAlgorithm[] {first.getGraphicsAlgorithm()};
 }
Esempio n. 25
0
 /**
  * Checks the given PictogramElement to see if it is a Label shape. Label shapes are identified by
  * the LABEL_SHAPE property equal to "true".
  *
  * @param shape the shape to test
  * @return true if the shape is a Label
  */
 public static boolean isLabelShape(PictogramElement shape) {
   if (shape == null) return false;
   return Graphiti.getPeService().getPropertyValue(shape, GraphitiConstants.LABEL_SHAPE) != null;
 }
Esempio n. 26
0
 public static boolean isHidden(PictogramElement pe) {
   if (Graphiti.getPeService().getPropertyValue(pe, GraphitiConstants.IS_HIDDEN) != null)
     return true;
   return false;
 }
 private Shape draw(ContainerShape shape) {
   Shape conditionShape = Graphiti.getPeService().createShape(shape, false);
   GraphicsUtil.createEventImage(conditionShape, ImageProvider.IMG_20_CONDITION);
   return conditionShape;
 }
  @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);
  }
Esempio n. 29
0
 public static GraphicsAlgorithm getSelectionBorder(PictogramElement element) {
   Collection<Shape> children =
       Graphiti.getPeService().getAllContainedShapes((ContainerShape) element);
   PictogramElement first = children.iterator().next();
   return first.getGraphicsAlgorithm();
 }
    private void updateConnectionIfNeeded(DataAssociation association, ItemAwareElement value) {
      DiagramEditor diagramEditor = ModelUtil.getDiagramEditor(association);
      if (diagramEditor == null) return;
      boolean hasDoneChanges = false;
      Diagram diagram = diagramEditor.getDiagramTypeProvider().getDiagram();
      IFeatureProvider fp = diagramEditor.getDiagramTypeProvider().getFeatureProvider();
      Shape taskShape = null;
      EObject container = association.eContainer();
      if (container instanceof Activity || container instanceof Event) {
        for (PictogramElement pe :
            Graphiti.getLinkService().getPictogramElements(diagram, container)) {
          if (pe instanceof Shape
              && BusinessObjectUtil.getFirstElementOfType(pe, BPMNShape.class) != null) {
            taskShape = (Shape) pe;
            break;
          }
        }
      }

      Shape dataShape = null;
      if (value instanceof DataObject
          || value instanceof DataObjectReference
          || value instanceof DataStore
          || value instanceof DataStoreReference
          || value instanceof DataInput
          || value instanceof DataOutput) {
        List<PictogramElement> pes =
            Graphiti.getLinkService().getPictogramElements(diagram, (EObject) value);
        for (PictogramElement p : pes) {
          if (BusinessObjectUtil.getFirstElementOfType(p, BPMNShape.class) != null) {
            dataShape = (Shape) p;
            break;
          }
        }
      }

      Connection connection =
          DataAssociationFeatureContainer.findDataAssociation(diagram, association);
      if (connection != null) {
        // There's an existing DataAssociation connection which needs to
        // either be reconnected or deleted, depending on what the combobox
        // selection is.
        if (dataShape != null) {
          // need to reconnect the DataAssociation
          ReconnectionContext rc = null;
          if (association instanceof DataInputAssociation) {
            Point p = GraphicsUtil.createPoint(connection.getStart());
            Anchor a = AnchorUtil.createAnchor((AnchorContainer) dataShape, p);
            rc = new ReconnectionContext(connection, connection.getStart(), a, null);
            rc.setTargetPictogramElement(dataShape);
            rc.setTargetLocation(Graphiti.getPeService().getLocationRelativeToDiagram(a));
            rc.setReconnectType(ReconnectionContext.RECONNECT_SOURCE);
          } else {
            Point p = GraphicsUtil.createPoint(connection.getEnd());
            Anchor a = AnchorUtil.createAnchor(dataShape, p);
            rc = new ReconnectionContext(connection, a, connection.getEnd(), null);
            rc.setTargetPictogramElement(dataShape);
            rc.setTargetLocation(Graphiti.getPeService().getLocationRelativeToDiagram(a));
            rc.setReconnectType(ReconnectionContext.RECONNECT_TARGET);
          }
          IReconnectionFeature rf = fp.getReconnectionFeature(rc);
          if (rf.canReconnect(rc)) {
            rf.reconnect(rc);
            hasDoneChanges = true;
          }
        } else {
          // need to delete the DataAssociation connection
          DeleteContext dc = new DeleteContext(connection);
          connection.getLink().getBusinessObjects().remove(0);
          IDeleteFeature df = fp.getDeleteFeature(dc);
          df.delete(dc);
        }
      } else if (dataShape != null) {
        // There is no existing DataAssociation connection, but the newly selected source or target
        // is some kind of data object shape, so we need to create a connection between the Activity
        // (or Throw/Catch Event) that owns the DataAssociation, and the new data object shape.
        Point p = GraphicsUtil.createPoint((AnchorContainer) dataShape);
        Anchor ownerAnchor = AnchorUtil.createAnchor(taskShape, p);
        p = GraphicsUtil.createPoint(taskShape);
        Anchor peAnchor = AnchorUtil.createAnchor((AnchorContainer) dataShape, p);
        AddConnectionContext ac = null;
        if (association instanceof DataOutputAssociation) {
          ac = new AddConnectionContext(ownerAnchor, peAnchor);
        } else {
          ac = new AddConnectionContext(peAnchor, ownerAnchor);
        }
        ac.putProperty(GraphitiConstants.BUSINESS_OBJECT, association);
        ac.setNewObject(association);
        IAddFeature af = fp.getAddFeature(ac);
        if (af.canAdd(ac)) {
          PictogramElement pe = af.add(ac);
          if (pe instanceof Connection) {
            connection = (Connection) pe;
            hasDoneChanges = true;
          }
        }
      }
      if (hasDoneChanges) {
        FeatureSupport.updateConnection(
            diagramEditor.getDiagramTypeProvider().getFeatureProvider(), connection);
      }
    }