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;
    }
Пример #2
0
  public static void setContainerChildrenVisible(
      IFeatureProvider fp, ContainerShape container, boolean visible) {
    List<PictogramElement> list = new ArrayList<PictogramElement>();
    list.addAll(container.getChildren());
    for (PictogramElement pe : list) {
      if (ShapeDecoratorUtil.isActivityBorder(pe)) continue;

      if (ShapeDecoratorUtil.isEventSubProcessDecorator(pe)) {
        pe.setVisible(!visible);
      } else pe.setVisible(visible);

      if (visible) FeatureSupport.updateLabel(fp, pe, null);
      if (pe instanceof AnchorContainer) {
        AnchorContainer ac = (AnchorContainer) pe;
        for (Anchor a : ac.getAnchors()) {
          for (Connection c : a.getOutgoingConnections()) {
            c.setVisible(visible);
            if (visible) FeatureSupport.updateLabel(fp, c, null);
            for (ConnectionDecorator decorator : c.getConnectionDecorators()) {
              decorator.setVisible(visible);
            }
          }
        }
      }
    }
  }
Пример #3
0
  @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();
        }
      }
    }
  }
Пример #4
0
  public static boolean updateConnection(IFeatureProvider fp, Connection connection) {
    boolean layoutChanged = false;

    LayoutContext layoutContext = new LayoutContext(connection);
    ILayoutFeature layoutFeature = fp.getLayoutFeature(layoutContext);
    if (layoutFeature != null) {
      layoutFeature.layout(layoutContext);
      layoutChanged = layoutFeature.hasDoneChanges();
    }

    boolean updateChanged = false;
    UpdateContext updateContext = new UpdateContext(connection);
    IUpdateFeature updateFeature = fp.getUpdateFeature(updateContext);
    if (updateFeature != null && updateFeature.updateNeeded(updateContext).toBoolean()) {
      updateFeature.update(updateContext);
      updateChanged = updateFeature.hasDoneChanges();
    }

    if (layoutChanged) FeatureSupport.updateLabel(fp, connection, null);

    // also update any Connections that are connected to this Connection
    //		for (Shape shape : AnchorUtil.getConnectionPoints(connection)) {
    //			updateConnections(fp, shape);
    //		}
    return layoutChanged || updateChanged;
  }
Пример #5
0
 @Override
 public boolean canExecute(ICustomContext context) {
   PictogramElement[] pes = context.getPictogramElements();
   if (pes != null && pes.length == 1) {
     BaseElement be = BusinessObjectUtil.getFirstBaseElement(pes[0]);
     return FeatureSupport.isElementExpanded(be);
   }
   return false;
 }
Пример #6
0
  @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);
          }
        }
      }
    }
  }
Пример #8
0
 /**
  * Gets the owner {@link PictogramElement} of a Label from a given IContext object. Label shapes
  * are added by Feature Containers using a {@link
  * org.eclipse.bpmn2.modeler.core.features.MultiAddFeature} - the first Add Feature in the Multi
  * Add creates the graphical element that represents the shape or connection, and a subsequent Add
  * Feature contributes the Label.
  *
  * <p>A Label and its owning PictogramElement are ultimately linked to each other by way of the
  * PictogramElement link list; the owner has a link to the ContainerShape of the Label and the
  * Label has a link to the owning shape or connection.
  *
  * @param context a Graphiti context object
  * @return the PictogramElement that owns a Label if it has one, or null.
  */
 public static PictogramElement getLabelOwner(IContext context) {
   List<PictogramElement> pes =
       (List<PictogramElement>) context.getProperty(GraphitiConstants.PICTOGRAM_ELEMENTS);
   if (pes != null && pes.size() > 0) {
     return getLabelOwner(pes.get(pes.size() - 1));
   }
   PictogramElement pe =
       (PictogramElement) context.getProperty(GraphitiConstants.PICTOGRAM_ELEMENT);
   if (pe != null) return pe;
   if (context instanceof IPictogramElementContext)
     return FeatureSupport.getLabelOwner(
         ((IPictogramElementContext) context).getPictogramElement());
   return null;
 }
Пример #9
0
  public static void updateCategoryValues(IFeatureProvider fp, PictogramElement pe) {

    Resource resource = ObjectPropertyProvider.getResource(pe);
    if (Bpmn2Preferences.getInstance(resource).getPropagateGroupCategories()) {
      // only do this if User Preference is enabled: assign the Group's CategoryValue
      // to the FlowElement represented by the given PictogramElement
      Diagram diagram = fp.getDiagramTypeProvider().getDiagram();
      FlowElement flowElement = BusinessObjectUtil.getFirstElementOfType(pe, FlowElement.class);
      if (flowElement == null) return;
      // remove any previous Category Values from this FlowElement
      flowElement.getCategoryValueRef().clear();

      // find all Groups in this Resource and check if it contains the given FlowElement
      if (pe instanceof ContainerShape) {
        for (Group group : ModelUtil.getAllObjectsOfType(resource, Group.class)) {
          CategoryValue cv = group.getCategoryValueRef();
          if (cv == null) continue;

          for (PictogramElement groupShape :
              Graphiti.getLinkService().getPictogramElements(diagram, group)) {
            if (groupShape instanceof ContainerShape) {
              for (ContainerShape flowElementShape :
                  FeatureSupport.findGroupedShapes((ContainerShape) groupShape)) {
                FlowElement fe =
                    BusinessObjectUtil.getFirstElementOfType(flowElementShape, FlowElement.class);
                if (fe == flowElement) {
                  fe.getCategoryValueRef().add(cv);
                  break;
                }
              }
            }
          }
        }
      } else if (pe instanceof Connection && flowElement instanceof SequenceFlow) {
        SequenceFlow sf = (SequenceFlow) flowElement;
        FlowNode source = sf.getSourceRef();
        FlowNode target = sf.getTargetRef();

        sf.getCategoryValueRef().clear();
        sf.getCategoryValueRef().addAll(source.getCategoryValueRef());
        sf.getCategoryValueRef().addAll(target.getCategoryValueRef());
      }
    }
  }
    @Override
    public Object[] create(ICreateContext context) {
      String state = Selectstate(BPMNToolBehaviorProvider.id_v);
      if (state.compareTo("Working") == 0) {
        SubProcess element = createBusinessObject(context);
        // if (element instanceof Task)
        // System.out.println("selectTaskId()"+selectTaskId());
        String id = selectTaskId();
        element.setId("VA" + id + "-1");
        UpdateTaskId(id);
        if (element != null) {
          changesDone = true;
          try {
            ModelHandler handler = ModelHandler.getInstance(getDiagram());
            if (FeatureSupport.isTargetLane(context) && element instanceof FlowNode) {
              ((FlowNode) element)
                  .getLanes()
                  .add((Lane) getBusinessObjectForPictogramElement(context.getTargetContainer()));
            }
            handler.addFlowElement(
                getBusinessObjectForPictogramElement(context.getTargetContainer()), element);
          } catch (IOException e) {
            Activator.logError(e);
          }
          PictogramElement pe = null;
          pe = addGraphicalRepresentation(context, element);
          return new Object[] {element, pe};
        } else changesDone = false;
        return new Object[] {null};
      } else {
        System.out.println("01102015tttttttttttt");
        JOptionPane.showMessageDialog(
            null,
            "Operation is not allowed because the version of process "
                + BPMNToolBehaviorProvider.id_v
                + " is Stable",
            "Error",
            JOptionPane.ERROR_MESSAGE);

        return new Object[] {null};
      }
    }
Пример #11
0
  /**
   * Gets the owner {@link PictogramElement} of a Label from a given PictogramElement. The given PE
   * may already be the owner of the Label, in which case the given value is returned. See also
   * {@link FeatureSupport#getLabelOwner(IContext)}
   *
   * @param pe a PictogramElement that represents the Label shape. This may be either the Label
   *     shape or its owner.
   * @return the PictogramElement that is the owner of a Label shape.
   */
  public static PictogramElement getLabelOwner(PictogramElement pe) {
    DiagramElement de = BusinessObjectUtil.getFirstElementOfType(pe, DiagramElement.class);
    if (de != null) return pe;
    ContainerShape cs = BusinessObjectUtil.getFirstElementOfType(pe, ContainerShape.class);
    de = BusinessObjectUtil.getFirstElementOfType(cs, DiagramElement.class);
    if (de != null) return cs;

    // Messages attached to MessageFlows do not have a BPMNShape element, their
    // visibility is controlled by a setting on the BPMNEdge for the MessageFlow
    Message msg = BusinessObjectUtil.getFirstElementOfType(cs, Message.class);
    if (msg != null) return cs;
    // If this is the ContainerShape of the MessageFlow Message, then it is the label owner.
    if (pe instanceof ContainerShape) {
      Shape labelShape = BusinessObjectUtil.getFirstElementOfType(pe, Shape.class);
      if (FeatureSupport.isLabelShape(labelShape)) return pe;
    }

    Connection c = BusinessObjectUtil.getFirstElementOfType(pe, Connection.class);
    de = BusinessObjectUtil.getFirstElementOfType(c, DiagramElement.class);
    if (de != null) return c;
    return null;
  }
  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());
      }
    }
  }
    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);
      }
    }
Пример #14
0
 /**
  * Returns a list of all Shapes and any Connections attached to them, that are children or
  * descendants of the given Lane or Pool container. Only Shapes that are NOT Lanes are returned.
  *
  * @param containerShape the Lane or Pool container shape.
  */
 public static List<PictogramElement> getPoolAndLaneDescendants(ContainerShape containerShape) {
   List<PictogramElement> children = new ArrayList<PictogramElement>();
   FeatureSupport.collectChildren(containerShape, children, false);
   return children;
 }
 @Override
 protected void internalMove(IMoveShapeContext context) {
   modifyModelStructure(context);
   FeatureSupport.redraw(context.getSourceContainer());
 }
  @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);
  }
Пример #17
0
 public static void updateCollapsedSize(PictogramElement pe) {
   IDimension size = GraphicsUtil.calculateSize(pe);
   FeatureSupport.setCollapsedSize(pe, size);
 }