@Override
  protected void postMoveShape(final IMoveShapeContext context) {
    super.postMoveShape(context);
    PictogramElement containerShape = context.getPictogramElement();
    Activity activity = BusinessObjectUtil.getFirstElementOfType(containerShape, Activity.class);
    GraphicsUtil.sendToFront(context.getShape());

    new AbstractBoundaryEventOperation() {
      @Override
      protected void doWorkInternal(ContainerShape container) {
        GraphicsAlgorithm ga = container.getGraphicsAlgorithm();

        MoveShapeContext newContext = new MoveShapeContext(container);
        newContext.setDeltaX(context.getDeltaX());
        newContext.setDeltaY(context.getDeltaY());
        newContext.setSourceContainer(context.getSourceContainer());
        newContext.setTargetContainer(context.getTargetContainer());
        newContext.setTargetConnection(context.getTargetConnection());
        newContext.setLocation(ga.getX(), ga.getY());
        newContext.putProperty(ACTIVITY_MOVE_PROPERTY, true);

        IMoveShapeFeature moveFeature = getFeatureProvider().getMoveShapeFeature(newContext);
        if (moveFeature.canMoveShape(newContext)) {
          moveFeature.moveShape(newContext);
        }
      }
    }.doWork(activity, getDiagram());

    if (containerShape.eContainer() instanceof ContainerShape) {
      PictogramElement pe = (PictogramElement) containerShape.eContainer();
      if (BusinessObjectUtil.containsElementOfType(pe, SubProcess.class)) {
        layoutPictogramElement(pe);
      }
    }
  }
  public void paste(IPasteContext context) {
    // we already verified, that we paste directly in the diagram
    KickstartProcessMemoryModel model =
        ModelHandler.getKickstartProcessModel(EcoreUtil.getURI(getDiagram()));
    List<FlowElement> copyList = model.getClipboard();

    for (FlowElement element : copyList) {
      FlowElement clone = CloneUtil.clone(element, getDiagram());

      AddContext addContext = new AddContext(new AreaContext(), clone);
      IAddFeature addFeature = getFeatureProvider().getAddFeature(addContext);
      PictogramElement pictogram =
          getFeatureProvider().getPictogramElementForBusinessObject(element);
      addContext.setLocation(
          pictogram.getGraphicsAlgorithm().getX() + PASTE_OFFSET,
          pictogram.getGraphicsAlgorithm().getY() + PASTE_OFFSET);
      addContext.setSize(
          pictogram.getGraphicsAlgorithm().getWidth(),
          pictogram.getGraphicsAlgorithm().getHeight());
      addContext.setTargetContainer(getDiagram());
      if (addFeature.canAdd(addContext)) {
        addFeature.add(addContext);
      }
    }
  }
  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);
            }
          }
        }
      }
    }
  }
    private void calculate() {
      int minX = Integer.MAX_VALUE;
      int minY = Integer.MAX_VALUE;
      minWidth = 0;
      minHeight = 0;

      for (PictogramElement pe : FeatureSupport.getContainerChildren(containerShape)) {
        GraphicsAlgorithm ga = pe.getGraphicsAlgorithm();
        if (ga != null) {
          int x = ga.getX();
          int y = ga.getY();
          if (x < minX) minX = x;
          if (y < minY) minY = y;
        }
      }

      shiftX = minX;
      shiftY = minY;

      for (PictogramElement pe : FeatureSupport.getContainerChildren(containerShape)) {
        GraphicsAlgorithm ga = pe.getGraphicsAlgorithm();
        if (ga != null) {
          int w = ga.getX() - minX + ga.getWidth();
          int h = ga.getY() - minY + ga.getHeight();
          if (w > minWidth) minWidth = w;
          if (h > minHeight) minHeight = h;
        }
      }
      if (minWidth <= 0) minWidth = GraphicsUtil.TASK_DEFAULT_WIDTH;
      if (minHeight <= 0) minHeight = GraphicsUtil.TASK_DEFAULT_HEIGHT;
    }
 public boolean canLayout(ILayoutContext context) {
   // return true, if pictogram element is linked to an EClass
   PictogramElement pe = context.getPictogramElement();
   if (!(pe instanceof ContainerShape)) return false;
   EList<EObject> businessObjects = pe.getLink().getBusinessObjects();
   return businessObjects.size() == 1 && businessObjects.get(0) instanceof EClass;
 }
  public static void updateDIShape(PictogramElement element) {

    PictogramLink link = element.getLink();
    if (link == null) {
      return;
    }

    BPMNShape bpmnShape = BusinessObjectUtil.getFirstElementOfType(element, BPMNShape.class);
    if (bpmnShape == null) {
      return;
    }

    ILocation loc = Graphiti.getLayoutService().getLocationRelativeToDiagram((Shape) element);
    Bounds bounds = bpmnShape.getBounds();

    bounds.setX(loc.getX());
    bounds.setY(loc.getY());

    GraphicsAlgorithm graphicsAlgorithm = element.getGraphicsAlgorithm();
    IDimension size = Graphiti.getGaService().calculateSize(graphicsAlgorithm);
    bounds.setHeight(size.getHeight());
    bounds.setWidth(size.getWidth());

    if (element instanceof ContainerShape) {
      EList<Shape> children = ((ContainerShape) element).getChildren();
      for (Shape shape : children) {
        if (shape instanceof ContainerShape) {
          updateDIShape(shape);
        }
      }
    }
  }
  public void execute(ICustomContext context) {
    if (context.getPictogramElements() == null) return;

    for (final PictogramElement pictogramElement : context.getPictogramElements()) {
      if (getBusinessObjectForPictogramElement(pictogramElement) == null) continue;
      final Object boObject = getBusinessObjectForPictogramElement(pictogramElement);
      if (boObject instanceof SequenceFlow == true) {
        final SequenceFlow sequenceFlow = (SequenceFlow) boObject;

        getDiagram().getPictogramLinks().remove(pictogramElement.getLink());
        getDiagram().getConnections().remove(pictogramElement);
        if (sequenceFlow.getSourceRef() != null) {
          sequenceFlow.getSourceRef().getOutgoing().remove(sequenceFlow);
        }
        if (sequenceFlow.getTargetRef() != null) {
          sequenceFlow.getTargetRef().getIncoming().remove(sequenceFlow);
        }

        List<Process> processes =
            ModelHandler.getModel(EcoreUtil.getURI(getDiagram())).getProcesses();
        for (Process process : processes) {
          process.getFlowElements().remove(sequenceFlow);
          removeFlow(sequenceFlow, process.getFlowElements());
        }
      }
    }
  }
  /** {@inheritDoc} */
  @Override
  public void paste(IPasteContext context) {
    // already verified, that pasting is allowed just directly in the diagram
    PictogramElement[] pes = context.getPictogramElements();
    Diagram diagram = (Diagram) pes[0];

    // get the PictogramElements from the clipboard and the linked business object.
    Object[] objects = getFromClipboard();
    for (Object object : objects) {
      PictogramElement pictogramElement = (PictogramElement) object;
      rootCon boRef = (rootCon) getBusinessObjectForPictogramElement(pictogramElement);
      rootCon bo = EcoreUtil.copy(boRef);
      addBusinessObjectToContainer(bo, pictogramElement);

      // create a new AddContext for the creation of a new shape.
      AddContext ac = new AddContext(new AddContext(), bo);
      ac.setLocation(0, 0); // for simplicity paste at (0, 0)
      ac.setTargetContainer(diagram); // paste on diagram
      // copy all properties from the shape (e.g. ALIAS etc.)
      for (Property prop : pictogramElement.getProperties()) {
        ac.putProperty(prop.getKey(), prop.getValue());
      }
      getFeatureProvider().addIfPossible(ac);
    }
  }
示例#9
0
 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());
   }
 }
  public static boolean canApplyTo(PictogramElement element) {
    if (element.getLink() == null || !(element instanceof ContainerShape)) {
      return false;
    }

    EList<EObject> objects = element.getLink().getBusinessObjects();

    for (EObject eObject : objects) {
      if (eObject instanceof Event && !(eObject instanceof BoundaryEvent)) {
        return true;
      }
    }

    return false;
  }
示例#11
0
 private static <T> T getBusinessObjectByClass(PictogramElement pelem, Class<T> class1) {
   PictogramLink link = pelem.getLink();
   if (link == null) return null;
   for (EObject businessObject : link.getBusinessObjects()) {
     if (class1.isAssignableFrom(businessObject.getClass())) return (T) businessObject;
   }
   return null;
 }
 private File getFileDomainObject(IContext context) {
   if (context instanceof ICustomContext) {
     PictogramElement[] pictogramElements = ((ICustomContext) context).getPictogramElements();
     if (pictogramElements.length == 1) {
       PictogramElement pictogramElement = pictogramElements[0];
       Object domainObject = getBusinessObjectForPictogramElement(pictogramElement);
       if (domainObject instanceof File) {
         if (pictogramElement instanceof Shape
             && pictogramElement.eContainer() instanceof ContainerShape
             && pictogramElement.eContainer().eContainer() instanceof ContainerShape) {
           if (getBusinessObjectForPictogramElement(
                   (ContainerShape) pictogramElement.eContainer().eContainer())
               instanceof Folder) {
             return (File) domainObject;
           }
         }
       }
     }
   }
   return null;
 }
  @Override
  public Connection create(ICreateConnectionContext context) {
    Connection newConnection = null;
    // get EClasses which should be connected
    StandardNode source = getStandardNode(context.getSourcePictogramElement());
    StandardNode target = getStandardNode(context.getTargetPictogramElement());

    if (source != null && target != null && target != source) {
      // create new business object

      Link l = createLink(source, target);
      if (l == null) {
        return null;
      }

      // add connection for business object
      AddConnectionContext addContext =
          new AddConnectionContext(context.getSourceAnchor(), context.getTargetAnchor());
      addContext.setNewObject(l);
      newConnection = (Connection) getFeatureProvider().addIfPossible(addContext);

      PictogramElement pes = context.getSourcePictogramElement();
      PictogramElement pet = context.getTargetPictogramElement();

      if (source.getEdge().getChildNode().size() == 0) {
        pet.getGraphicsAlgorithm().setX(pes.getGraphicsAlgorithm().getX());
        pet.getGraphicsAlgorithm()
            .setY(pes.getGraphicsAlgorithm().getY() + pes.getGraphicsAlgorithm().getHeight() + 45);
      }
    }

    return newConnection;
  }
  @Override
  public boolean appliesTo(IWorkbenchPart part, ISelection selection) {

    // should we delegate to the section to determine whether it should be included in this tab?
    if (sectionClass instanceof IBpmn2PropertySection) {
      return ((IBpmn2PropertySection) sectionClass).appliesTo(part, selection);
    }

    // if an input description was specified, check if the selected business object is of this
    // description.
    if (appliesToClass != null) {
      PictogramElement pe = BusinessObjectUtil.getPictogramElementForSelection(selection);
      // this is a special hack to allow selection of connection decorator labels:
      // the connection decorator does not have a business object linked to it,
      // but its parent (the connection) does.
      if (pe.getLink() == null && pe.eContainer() instanceof PictogramElement)
        pe = (PictogramElement) pe.eContainer();

      // check all linked BusinessObjects for a match
      if (pe.getLink() != null) {
        for (EObject eObj : pe.getLink().getBusinessObjects()) {
          if (appliesToClass.isInstance(eObj)) {
            return true;
          }
        }
      }
      return false;
    }
    return true;
  }
 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;
 }
 public static boolean isChoreographyParticipantBand(PictogramElement element) {
   if (element != null) {
     EObject container = element.eContainer();
     if (container instanceof PictogramElement) {
       PictogramElement containerElem = (PictogramElement) container;
       Object bo =
           Graphiti.getLinkService().getBusinessObjectForLinkedPictogramElement(containerElem);
       if (bo instanceof ChoreographyActivity) {
         return true;
       }
     }
   }
   return false;
 }
    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 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;
 }
 public static GraphicsAlgorithm[] getClickArea(PictogramElement element) {
   Collection<PictogramElement> children =
       Graphiti.getPeService().getPictogramElementChildren(element);
   PictogramElement first = children.iterator().next();
   return new GraphicsAlgorithm[] {first.getGraphicsAlgorithm()};
 }
 public static GraphicsAlgorithm getSelectionBorder(PictogramElement element) {
   Collection<PictogramElement> children =
       Graphiti.getPeService().getPictogramElementChildren(element);
   PictogramElement first = children.iterator().next();
   return first.getGraphicsAlgorithm();
 }
  @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);
  }
 public static GraphicsAlgorithm getSelectionBorder(PictogramElement element) {
   Collection<Shape> children =
       Graphiti.getPeService().getAllContainedShapes((ContainerShape) element);
   PictogramElement first = children.iterator().next();
   return first.getGraphicsAlgorithm();
 }