示例#1
0
  @Override
  public void notifyChanged(Notification notification) {
    EObject notifier = (EObject) notification.getNotifier();
    Object feature = notification.getFeature();

    Interaction interaction =
        EMFModelUtil.getRootContainerOfType(notifier, RamPackage.Literals.INTERACTION);

    // Notification could come from the interaction or an operand.
    if (notifier == specification || interaction == specification) {
      if (feature == RamPackage.Literals.FRAGMENT_CONTAINER__FRAGMENTS) {
        if (notification.getEventType() == Notification.ADD) {
          EObject newValue = (EObject) notification.getNewValue();

          RamSwitch<Object> switcher =
              new RamSwitch<Object>() {
                @Override
                public Object caseExecutionStatement(ExecutionStatement object) {
                  addStatementView(object);
                  return Boolean.TRUE;
                }

                @Override
                public Object caseCombinedFragment(CombinedFragment object) {
                  addCombinedFragment(object);
                  return Boolean.TRUE;
                }

                @Override
                public Object caseAssignmentStatement(AssignmentStatement object) {
                  addAssignmentStatement(object);
                  return Boolean.TRUE;
                };
              };

          switcher.doSwitch(newValue);
        } else if (notification.getEventType() == Notification.REMOVE) {
          EObject oldValue = (EObject) notification.getOldValue();

          RamSwitch<Object> switcher =
              new RamSwitch<Object>() {
                @Override
                public Object caseExecutionStatement(ExecutionStatement object) {
                  removeInteractionFragment(object);
                  return Boolean.TRUE;
                }

                @Override
                public Object caseCombinedFragment(CombinedFragment object) {
                  removeCombinedFragment(object);
                  return Boolean.TRUE;
                }

                @Override
                public Object caseAssignmentStatement(AssignmentStatement object) {
                  removeInteractionFragment(object);
                  return Boolean.TRUE;
                }
              };

          switcher.doSwitch(oldValue);
        }
      } else if (feature == RamPackage.Literals.INTERACTION__LIFELINES) {
        switch (notification.getEventType()) {
          case Notification.ADD:
            Lifeline lifeline = (Lifeline) notification.getNewValue();
            addLifelineView(lifeline);
            break;
          case Notification.REMOVE:
            lifeline = (Lifeline) notification.getOldValue();
            removeLifelineView(lifeline);
            break;
        }
      } else if (feature == RamPackage.Literals.INTERACTION__MESSAGES) {
        switch (notification.getEventType()) {
          case Notification.ADD:
            Message message = (Message) notification.getNewValue();
            addMessageView(message);
            break;
          case Notification.REMOVE:
            message = (Message) notification.getOldValue();
            removeMessageView(message);
            break;
        }
      }
    } else if (notifier == layout) {
      if (feature == RamPackage.Literals.CONTAINER_MAP__VALUE) {
        if (notification.getEventType() == Notification.ADD) {
          ElementMapImpl elementMap = (ElementMapImpl) notification.getNewValue();
          LifelineView lifelineView = lifelines.get(elementMap.getKey());
          lifelineView.setLayoutElement(elementMap.getValue());
        }
      }
    }
  }
示例#2
0
  /**
   * Adds a new view for the given message to this view. A message is represented by a view on each
   * end and a view representing the actual call. The end views are added to the corresponding
   * lifelines. In case an end is a gate and not placed on a lifeline, a {@link GateView} is used
   * instead and added to this view at the left side.
   *
   * @param message the {@link Message} to add
   */
  private void addMessageView(Message message) {
    LifelineView toView = null;
    LifelineView fromView = null;
    RamRectangleComponent sendEventView = null;
    RamRectangleComponent receiveEventView = null;
    MessageEnd sendEvent = message.getSendEvent();
    MessageEnd receiveEvent = message.getReceiveEvent();

    Operation signature = message.getSignature();
    boolean messageViewDefined = false;

    if (signature != null && specifies != signature) {
      Aspect aspect = EMFModelUtil.getRootContainerOfType(signature, RamPackage.Literals.ASPECT);
      /**
       * Make sure that the signature still exists in the aspect. It could have been deleted and
       * would then cause problems here.
       */
      if (aspect != null) {
        messageViewDefined = RAMModelUtil.isMessageViewDefined(aspect, signature);
      }
    }

    if (sendEvent instanceof MessageOccurrenceSpecification) {
      MessageOccurrenceSpecification event = (MessageOccurrenceSpecification) sendEvent;

      fromView = lifelines.get(event.getCovered().get(0));
      int modelIndex = event.getContainer().getFragments().indexOf(sendEvent);

      if (fromView != null) {
        boolean allowMessageCreation = false;
        // Allow creation after sending a message where no return is expected.
        if (signature != null && signature.getReturnType() != null) {
          Type returnType = signature.getReturnType();
          allowMessageCreation =
              message.getMessageSort() != MessageSort.REPLY
                  && !message.isSelfMessage()
                  && (returnType.eClass() == RamPackage.Literals.RVOID
                      || message.getMessageSort() == MessageSort.CREATE_MESSAGE
                      || signature.eContainer() instanceof ImplementationClass
                      // When a message view is defined, there will be no reply, so we need to allow
                      // it.
                      || messageViewDefined);
        }

        sendEventView = fromView.addMessageEnd(event, modelIndex, allowMessageCreation);
      }
    }

    if (receiveEvent instanceof MessageOccurrenceSpecification) {
      MessageOccurrenceSpecification event = (MessageOccurrenceSpecification) receiveEvent;

      toView = lifelines.get(event.getCovered().get(0));
      int modelIndex = event.getContainer().getFragments().indexOf(receiveEvent);

      if (toView != null) {
        if (message.getMessageSort() == MessageSort.CREATE_MESSAGE) {
          receiveEventView = toView;
        } else {
          boolean allowMessageCreation = message.getMessageSort() != MessageSort.DELETE_MESSAGE;
          if (signature != null) {
            // Don't allow message creation if the receiving end is on an implementation class.
            // If it is a self message it cannot be on an implementation class and is allowed.
            allowMessageCreation =
                allowMessageCreation
                    && !(signature.eContainer() instanceof ImplementationClass)
                    && (!messageViewDefined || message.isSelfMessage());
          }

          receiveEventView = toView.addMessageEnd(event, modelIndex, allowMessageCreation);
        }
      }
    }

    if (sendEventView == null) {
      Vector3D oppositePosition = receiveEventView.getPosition(TransformSpace.GLOBAL);
      sendEventView = new GateView(0, oppositePosition.getY(), BOX_WIDTH, BOX_HEIGHT);
      addChild(sendEventView);
    } else if (receiveEventView == null) {
      Vector3D oppositePosition = sendEventView.getPosition(TransformSpace.GLOBAL);
      receiveEventView = new GateView(0, oppositePosition.getY(), BOX_WIDTH, BOX_HEIGHT);
      addChild(receiveEventView);
    }

    MessageCallView messageCallView = new MessageCallView(message, sendEventView, receiveEventView);
    addChild(messageCallView);
    messageCallView.setHandler(HandlerFactoryMessageView.INSTANCE.getMessageHandler());
    messages.put(message, messageCallView);

    layoutMessageView();

    messageCallView.updateLines();
  }