/** {@inheritedDoc} */
 public void notifyChanged(Notification notification) {
   // change the label of the figure managed by the host edit part (managed
   // by the parent edit
   // part in general...)
   // it must be changed only if:
   // - the annotation corresponding to the display of the stereotype
   // changes
   // - the stereotype application list has changed
   final int eventType = notification.getEventType();
   if (eventType == PapyrusStereotypeListener.APPLIED_STEREOTYPE) {
     // a stereotype was applied to the notifier
     // then a new listener should be added to the stereotype application
     getDiagramEventBroker().addNotificationListener((EObject) notification.getNewValue(), this);
     createAppliedStereotypeCompartment((EObject) notification.getNewValue());
   } else if (eventType == PapyrusStereotypeListener.UNAPPLIED_STEREOTYPE) {
     getDiagramEventBroker()
         .removeNotificationListener((EObject) notification.getOldValue(), this);
     removeAppliedStereotypeCompartment((EObject) notification.getNewValue());
   }
   // if element that has changed is a stereotype => refresh the label.
   if (notification.getNotifier() instanceof Node
       && (notification.getEventType() == Notification.ADD)
       && (notification.getNewValue() instanceof EAnnotation)) {
     if (UMLVisualInformationPapyrusConstant.STEREOTYPE_ANNOTATION
         == ((EAnnotation) notification.getNewValue()).getSource()) {
       // stereotype annotation has changed => refresh label display
       refreshDisplay();
     }
   }
 }
 /**
  * Add the following notifications to the list to be processed at the next asynchronous
  * opportunity. Returns true if any of the notifications could remove, add, or change any
  * violations.
  *
  * @param notifications
  * @return boolean
  */
 public final boolean enqueue(List<Notification> notifications) {
   Boolean isPaused = null;
   List<Notification> filtered = new ArrayList<Notification>();
   for (Notification notification : notifications) {
     if (notification.getEventType() == Notification.RESOLVE) {
       continue;
     } else if (notification.getEventType() == ControlNotification.PAUSE) {
       isPaused = true;
       continue;
     } else if (notification.getEventType() == ControlNotification.RESUME) {
       isPaused = false;
       filtered.add(notification);
       continue;
     }
     if (isImportant(notification)) {
       filtered.add(notification);
     }
   }
   if (filtered.isEmpty() && (isPaused == null || !isPaused)) {
     return false;
   }
   synchronized (queueLock) {
     if (isPaused != null) {
       paused = isPaused;
     }
     queuedNotifications.addAll(filtered);
     queueLock.notify();
   }
   return !paused;
 }
 public static Collection<EObject> getAffectedValues(Notification notification, EClass clz) {
   if (notification.isTouch()) {
     return Collections.emptyList();
   }
   switch (notification.getEventType()) {
     case Notification.ADD:
     case Notification.SET:
       if (clz.isInstance(notification.getNewValue())) {
         return Collections.singletonList((EObject) notification.getNewValue());
       }
       return Collections.emptyList();
     case Notification.REMOVE:
     case Notification.UNSET:
       if (clz.isInstance(notification.getOldValue())) {
         return Collections.singletonList((EObject) notification.getOldValue());
       }
     case Notification.ADD_MANY:
       return affectingObjects(notification.getNewValue(), clz);
     case Notification.REMOVE_MANY:
       return affectingObjects(notification.getOldValue(), clz);
     case Notification.MOVE:
       if (notification.getNotifier() instanceof EObject
           && notification.getFeature() instanceof EStructuralFeature) {
         return affectingObjects(
             ((EObject) notification.getNotifier())
                 .eGet((EStructuralFeature) notification.getFeature()),
             clz);
       }
       return Collections.emptyList();
   }
   return Collections.emptyList();
 }
  /**
   * @see
   *     org.eclipse.gmf.runtime.diagram.core.listener.NotificationListener#notifyChanged(org.eclipse.emf.common.notify.Notification)
   * @param notification
   */
  public void notifyChanged(Notification notification) {
    Object feature = notification.getFeature();
    boolean headChanged = false;
    if (NotationPackage.eINSTANCE.getFontStyle_FontHeight().equals(feature)
        || NotationPackage.eINSTANCE.getFontStyle_FontName().equals(feature)
        || NotationPackage.eINSTANCE.getFontStyle_Bold().equals(feature)
        || NotationPackage.eINSTANCE.getFontStyle_Italic().equals(feature)) {
      headChanged = true;
    } else if (notification.getNotifier() instanceof EAnnotation
        && UMLVisualInformationPapyrusConstant.STEREOTYPE_ANNOTATION
            == ((EAnnotation) notification.getNotifier()).getSource()) {
      headChanged = true;
    } else if ((notification.getNotifier() instanceof DynamicEObjectImpl)
        && (hostSemanticElement != null)
        && (hostSemanticElement.getStereotypeApplications().contains(notification.getNotifier()))) {
      headChanged = true;
    } else if (PapyrusStereotypeListener.MODIFIED_STEREOTYPE == notification.getEventType()) {
      headChanged = true;
    } else if (notification instanceof StereotypeCustomNotification) {
      headChanged = true;
    }
    if (headChanged) {
      Display.getDefault()
          .asyncExec(
              new Runnable() {

                public void run() {
                  impactLayout();
                }
              });
    }
  }
Ejemplo n.º 5
0
  protected void handleResourceContents(Notification msg) {
    Resource.Internal resource = (Resource.Internal) msg.getNotifier();

    // Don't report addition of roots when loading nor removal of roots when unloading
    // because loading and unloading are semantically more significant events
    if (resource.isLoaded() && !resource.isLoading()) {
      switch (msg.getEventType()) {
        case Notification.ADD:
          handleRootAdded(resource, (EObject) msg.getNewValue());
          break;
        case Notification.ADD_MANY:
          for (Object next : (Iterable<?>) msg.getNewValue()) {
            handleRootAdded(resource, (EObject) next);
          }
          break;
        case Notification.REMOVE:
          handleRootRemoved(resource, (EObject) msg.getOldValue());
          break;
        case Notification.REMOVE_MANY:
          for (Object next : (Iterable<?>) msg.getOldValue()) {
            handleRootRemoved(resource, (EObject) next);
          }
          break;
        case Notification.SET:
          handleRootRemoved(resource, (EObject) msg.getOldValue());
          handleRootAdded(resource, (EObject) msg.getNewValue());
          break;
      }
    }
  }
 @Override
 public void notifyChanged(Notification notification) {
   assert getHost() != null;
   if (notification.getEventType() != Notification.SET) return;
   boolean hasChanged = false;
   switch (notification.getFeatureID(GridLayoutRule.class)) {
     case SWTStylesPackage.GRID_LAYOUT_RULE__MAKE_COLUMNS_EQUAL_WIDTH:
       hasChanged =
           !CompareUtils.areEquals(
               notification.getOldBooleanValue(), notification.getNewBooleanValue());
       break;
     case SWTStylesPackage.GRID_LAYOUT_RULE__HORIZONTAL_SPACING:
     case SWTStylesPackage.GRID_LAYOUT_RULE__MARGIN_BOTTOM:
     case SWTStylesPackage.GRID_LAYOUT_RULE__MARGIN_HEIGHT:
     case SWTStylesPackage.GRID_LAYOUT_RULE__MARGIN_LEFT:
     case SWTStylesPackage.GRID_LAYOUT_RULE__MARGIN_RIGHT:
     case SWTStylesPackage.GRID_LAYOUT_RULE__MARGIN_TOP:
     case SWTStylesPackage.GRID_LAYOUT_RULE__MARGIN_WIDTH:
     case SWTStylesPackage.GRID_LAYOUT_RULE__NUM_COLUMNS:
     case SWTStylesPackage.GRID_LAYOUT_RULE__VERTICAL_SPACING:
       hasChanged =
           !CompareUtils.areEquals(notification.getOldIntValue(), notification.getNewIntValue());
       break;
     default:
       super.notifyChanged(notification);
   }
   if (hasChanged && getHost().styleRuleUpdated((StyleRule) notification.getNotifier()))
     reCreateWidgetView();
 }
 public static boolean affects(Notification notification, EClass clz) {
   if (notification.isTouch()) {
     return false;
   }
   switch (notification.getEventType()) {
     case Notification.ADD:
     case Notification.SET:
       return clz.isInstance(notification.getNewValue());
     case Notification.REMOVE:
     case Notification.UNSET:
       return clz.isInstance(notification.getOldValue());
     case Notification.ADD_MANY:
       return affects(notification.getNewValue(), clz);
     case Notification.REMOVE_MANY:
       return affects(notification.getOldValue(), clz);
     case Notification.MOVE:
       if (notification.getNotifier() instanceof EObject
           && notification.getFeature() instanceof EStructuralFeature) {
         return affects(
             ((EObject) notification.getNotifier())
                 .eGet((EStructuralFeature) notification.getFeature()),
             clz);
       }
       return false;
   }
   return false;
 }
Ejemplo n.º 8
0
  @Override
  protected void handleNotificationEvent(Notification notification) {
    super.handleNotificationEvent(notification);
    if ((notification.getEventType() == Notification.SET)
        && (notification.getNotifier() instanceof org.ow2.aspirerfid.ide.bpwme.impl.EBProcImpl)) {

      EBProcImpl epi = (EBProcImpl) notification.getNotifier();
      EAttributeImpl ei = (EAttributeImpl) notification.getFeature();
      MainControl mc = MainControl.getMainControl();

      org.ow2.aspirerfid.commons.apdl.model.EBProc ebproc =
          (org.ow2.aspirerfid.commons.apdl.model.EBProc) mc.getMapObject(epi.hashCode());

      EPCISMasterDataDocumentType doc = MasterDataUtil.getEPCISMasterDataDocument(ebproc);
      VocabularyElementType vocabularyElement = MasterDataUtil.getEBProcVocabularyElement(doc);

      if (ei.getName().equals("id")) {
        ebproc.setId(notification.getNewStringValue());
        MasterDataUtil.setVocabularyElementID(vocabularyElement, notification.getNewStringValue());
      } else if (ei.getName().equals("name")) {
        ebproc.setName(notification.getNewStringValue());
        MasterDataUtil.setVocabularyElementAttribute(
            vocabularyElement,
            "urn:epcglobal:epcis:mda:event_name",
            notification.getNewStringValue());
      } else if (ei.getName().equals("description")) {
        ebproc.setDescription(notification.getNewStringValue());
      } else {
        return;
      }

      mc.saveObject();
    }
  }
Ejemplo n.º 9
0
 public void notifyChanged(final Notification notification) {
   switch (notification.getEventType()) {
     case Notification.REMOVING_ADAPTER:
       return;
     default:
       updatePictogramFigureStates();
   }
 }
 /*
  * (non-Javadoc)
  *
  * @see org.eclipse.emf.common.notify.Adapter#notifyChanged(org.eclipse.emf.common.notify.Notification)
  */
 public void notifyChanged(Notification aNotification) {
   if (aNotification.getFeature()
       == ComponentcorePackage.eINSTANCE.getComponentResource_SourcePath()) {
     if (aNotification.getEventType() == Notification.SET) {
       resource = null;
     }
   }
 }
 protected void highlight(final Notification notification, HighlightingParameters params) {
   int eventType = notification.getEventType();
   if (eventType == ADD || eventType == ADD_MANY) {
     fadeIn(notification.getNewValue(), params);
   } else if (eventType == REMOVE || eventType == REMOVE_MANY) {
     fadeOut(notification.getOldValue(), params);
   }
 }
 public void notifyChanged(Notification msg) {
   if (debug) {
     DebugTrace.print(this, "notifyChanged", "msg=" + msg); // $NON-NLS-1$ //$NON-NLS-2$
   }
   if (msg.getFeatureID(null) == Resource.RESOURCE__IS_MODIFIED
       && msg.getEventType() == org.eclipse.emf.common.notify.Notification.SET) {
     firePropertyChange(msg.getNotifier(), PROP_DIRTY);
   }
 }
  /**
   * @param event the affected event
   * @return returns a {@link List}of {@link Class Interfaces}which contains all implemented <code>
   *     Interfaces</code> of the event and all of its super types.
   */
  public Object getAffectedObject(Notification event) {

    if (isEmpty()) return null; // the affected object is not needed in this case

    Collection<Integer> result = new HashSet<Integer>(16);
    result.add(event.getEventType());

    return result;
  }
 protected boolean isMarkerEvent(Notification notification) {
   int type = notification.getEventType();
   if (type == NOTIFICATION_MARKERS_STALE
       || type == NOTIFICATION_MARKER_ADDED
       || type == NOTIFICATION_MARKER_DELETED) {
     return true;
   }
   return false;
 }
 private void handlePresentationRegistration(Notification notification) {
   if (editingDomain == null) {
     throw new NullPointerException("Presentation registration, but editingDomain not yet set!");
   }
   if (notification.getEventType() == Notification.ADD) {
     ProrPresentationConfiguration config =
         (ProrPresentationConfiguration) notification.getNewValue();
     System.out.println("Registering: " + config);
     ProrUtil.getConfigItemProvider(config, getRootAdapterFactory())
         .registerPresentationConfiguration(config, editingDomain);
   } else if (notification.getEventType() == Notification.REMOVE) {
     ProrPresentationConfiguration config =
         (ProrPresentationConfiguration) notification.getOldValue();
     System.out.println("Unregistering: " + config);
     ProrUtil.getConfigItemProvider(config, getRootAdapterFactory())
         .unregisterPresentationConfiguration(config);
   }
 }
Ejemplo n.º 16
0
 @Override
 public void notifyChanged(Notification msg) {
   InstanceImpl inst = (InstanceImpl) target;
   if (inst.cachedAdaptedEntity != null) {
     if (msg.getEventType() == Notification.SET
         && msg.getFeature() == DfPackage.Literals.INSTANCE__ENTITY) {
       inst.cachedAdaptedEntity = null;
     }
   }
 }
 /**
  * Construct a RepositoryChangeNotification from the given notification. {@inheritDoc}
  *
  * @see
  *     org.eclipse.emf.common.notify.Adapter#notifyChanged(org.eclipse.emf.common.notify.Notification)
  */
 public void notifyChanged(Notification notification) {
   super.notifyChanged(notification);
   // We don't notify handlers for removing adapter operations neither for Touch notifications
   if ((Notification.REMOVING_ADAPTER != (notification.getEventType()))
       && (!notification.isTouch())) {
     RepositoryChangeNotification newNotification =
         RepositoryChangeNotificationFactoryHolder.getChangeNotificationFactory()
             .createRepositoryChangeNotification(notification);
     this.notificator.notifyHandlers(newNotification);
   }
 }
Ejemplo n.º 18
0
  /* (non-Javadoc)
   * @see org.eclipse.emf.common.notify.impl.AdapterImpl#notifyChanged(org.eclipse.emf.common.notify.Notification)
   */
  @Override
  public void notifyChanged(Notification notification) {
    if (notification != null
        && (notification.getNewValue() instanceof WebSite)
        && notification.getEventType() == Notification.ADD) {
      WebSite webSite = (WebSite) notification.getNewValue();
      qrSource.log("Enriching new WebSite " + webSite.getAdress(), LogService.LOG_INFO);

      // enrich the information objects this website belongs to
      qrSource.enrichInformationObjectsOfWebSite(webSite);
    }
  }
Ejemplo n.º 19
0
  protected void handleResourceSetResources(Notification msg) {
    switch (msg.getEventType()) {
      case Notification.ADD:
        {
          Resource resource = (Resource) msg.getNewValue();
          addAdapter(resource);
          handleResourceAdded(resource);
        }
        break;
      case Notification.ADD_MANY:
        for (Object next : (Iterable<?>) msg.getNewValue()) {
          Resource resource = (Resource) next;
          addAdapter(resource);
          handleResourceAdded(resource);
        }
        break;
      case Notification.REMOVE:
        {
          Resource resource = (Resource) msg.getOldValue();
          try {
            handleResourceRemoved(resource);
          } finally {
            removeAdapter(resource);
          }
          break;
        }
      case Notification.REMOVE_MANY:
        for (Object next : (Iterable<?>) msg.getOldValue()) {
          Resource resource = (Resource) next;
          try {
            handleResourceRemoved(resource);
          } finally {
            removeAdapter(resource);
          }
        }
        break;
      case Notification.SET:
        {
          Resource oldResource = (Resource) msg.getOldValue();
          try {
            handleResourceRemoved(oldResource);
          } finally {
            removeAdapter(oldResource);
          }

          Resource newResource = (Resource) msg.getOldValue();
          addAdapter(newResource);
          handleResourceAdded(newResource);
          break;
        }
    }
  }
Ejemplo n.º 20
0
  @Override
  public void notifyChanged(Notification msg) {
    Object notifier = msg.getNotifier();

    if (!msg.isTouch()) {
      if (notifier instanceof ResourceSet) {
        if (msg.getFeatureID(ResourceSet.class) == ResourceSet.RESOURCE_SET__RESOURCES) {
          handleResourceSetResources(msg);
        }
      } else if (notifier instanceof Resource) {
        switch (msg.getFeatureID(Resource.class)) {
          case Resource.RESOURCE__IS_LOADED:
            switch (msg.getEventType()) {
              case Notification.SET:
              case Notification.UNSET:
                if (msg.getNewBooleanValue()) {
                  handleResourceLoaded((Resource) notifier);
                } else {
                  handleResourceUnloaded((Resource) notifier);
                }
                break;
            }
            break;
          case Resource.RESOURCE__URI:
            switch (msg.getEventType()) {
              case Notification.SET:
              case Notification.UNSET:
                handleResourceURI(
                    (Resource) notifier, (URI) msg.getOldValue(), (URI) msg.getNewValue());
                break;
            }
            break;
          case Resource.RESOURCE__CONTENTS:
            handleResourceContents(msg);
            break;
        }
      }
    }
  }
  public void notifyChanged(Notification notification) {
    int featureId = notification.getFeatureID(target.getClass());
    if (featureId != XSDPackage.XSD_ELEMENT_DECLARATION__SUBSTITUTION_GROUP) {
      return;
    }

    if (notification.getEventType() != Notification.ADD) {
      return;
    }
    if (!(notification.getNewValue() instanceof XSDElementDeclaration)) {
      return;
    }

    XSDElementDeclaration el = (XSDElementDeclaration) notification.getNewValue();
    XSDElementDeclaration e = target;

    while (e != null) {
      synchronized (e) {
        ArrayList<Integer> toremove = new ArrayList();
        for (int i = 0; i < e.getSubstitutionGroup().size(); i++) {
          XSDElementDeclaration se = (XSDElementDeclaration) e.getSubstitutionGroup().get(i);
          if (se == null
              || (Utilities.equals(el.getTargetNamespace(), se.getTargetNamespace())
                  && Utilities.equals(el.getName(), se.getName()))) {
            toremove.add(i);
          }
        }

        // iterate back in reverse order and skip the last element as to keep the latest
        // version of the element
        ArrayList<XSDElementDeclaration> removed = new ArrayList();
        for (int i = toremove.size() - 2; i > -1; i--) {
          XSDElementDeclaration se =
              (XSDElementDeclaration) e.getSubstitutionGroup().remove(toremove.get(i).intValue());
          removed.add(e);
        }

        // set the removed elements sub affiliation to a clone of the actual element
        for (XSDElementDeclaration se : removed) {
          if (se != null && e.equals(se.getSubstitutionGroupAffiliation())) {
            XSDElementDeclaration clone =
                (XSDElementDeclaration) e.cloneConcreteComponent(false, false);
            clone.setTargetNamespace(GML.NAMESPACE);

            se.setSubstitutionGroupAffiliation(clone);
          }
        }
      }
      e = e.getSubstitutionGroupAffiliation();
    }
  }
  protected boolean doRecord(Notification notification) {
    if (!isRecording || isSuspended || notification.isTouch()) return false;

    switch (notification.getEventType()) {
      case Notification.ADD:
      case Notification.ADD_MANY:
      case Notification.MOVE:
      case Notification.REMOVE:
      case Notification.REMOVE_MANY:
      case Notification.SET:
      case Notification.UNSET:
        return true;
      default:
        return false;
    }
  }
Ejemplo n.º 23
0
 protected void handleNotification(ResourceSet rset, Notification msg) {
   switch (msg.getFeatureID(ResourceSet.class)) {
     case ResourceSet.RESOURCE_SET__RESOURCES:
       switch (msg.getEventType()) {
         case Notification.ADD:
           adapt((Resource) msg.getNewValue());
           break;
         case Notification.ADD_MANY:
           for (Object next : (Collection<?>) msg.getNewValue()) {
             adapt((Resource) next);
           }
           break;
       }
       break;
   }
 }
Ejemplo n.º 24
0
 @Override
 public void resourceSetChanged(ResourceSetChangeEvent event) {
   for (Notification notification : event.getNotifications()) {
     if (notification.getNotifier() instanceof EObject
         && notification.getEventType() != Notification.REMOVING_ADAPTER
         && notification.getEventType() != Notification.RESOLVE) {
       EObject eObject = (EObject) notification.getNotifier();
       for (EClass eClass : eObject.eClass().getEAllSuperTypes()) {
         if (SGraphPackage.eINSTANCE == eClass.getEPackage()) {
           validationJob.cancel();
           validationJob.schedule(DELAY);
           return;
         }
       }
     }
   }
 }
  /**
   * {@inheritDoc}
   *
   * @see
   *     org.eclipse.emf.common.notify.impl.AdapterImpl#notifyChanged(org.eclipse.emf.common.notify.Notification)
   */
  @Override
  public void notifyChanged(final Notification msg) {
    final Object notifier = msg.getNotifier();
    if (notifier instanceof DDiagram) {
      final int featureID = msg.getFeatureID(DDiagram.class);
      if (featureID == DiagramPackage.DDIAGRAM__ACTIVATED_LAYERS) {

        switch (msg.getEventType()) {
          case Notification.ADD:
          case Notification.REMOVE:
            computeMappings((DDiagram) notifier, (Layer) msg.getNewValue());
            break;
          default:
            break;
        }
      }
    }
  }
Ejemplo n.º 26
0
 @Override
 public void notifyChanged(Notification notification) {
   assert getHost() != null;
   if (notification.getEventType() != Notification.SET) return;
   boolean hasChanged = false;
   switch (notification.getFeatureID(IntRule.class)) {
     case CoreStylesPackage.INT_RULE__VALUE:
       hasChanged =
           !CompareUtils.areEquals(notification.getOldIntValue(), notification.getNewIntValue());
       break;
     case CoreStylesPackage.INT_RULE__PROPERTY_NAME:
       reCreateWidgetView();
       return;
     default:
       super.notifyChanged(notification);
   }
   if (hasChanged && getHost().styleRuleUpdated((StyleRule) notification.getNotifier()))
     reCreateWidgetView();
 }
Ejemplo n.º 27
0
  @Override
  protected void eCoreChanged(Notification msg) {
    Object feature = msg.getFeature();

    switch (msg.getEventType()) {
      case Notification.SET:
        // Refresh Icon
        if (feature == IArchimatePackage.Literals.DIAGRAM_MODEL_IMAGE_PROVIDER__IMAGE_PATH
            || feature == ICanvasPackage.Literals.ICONIC__IMAGE_POSITION) {
          ((CanvasStickyFigure) getFigure()).updateImage();
        } else {
          super.eCoreChanged(msg);
        }

        break;

      default:
        super.eCoreChanged(msg);
    }
  }
Ejemplo n.º 28
0
        /**
         * @see
         *     org.eclipse.gmf.runtime.diagram.core.listener.NotificationListener#notifyChanged(org.eclipse.emf.common.notify.Notification)
         * @param notification
         */
        public void notifyChanged(Notification notification) {

          if (notification.getEventType() == Notification.REMOVE) {
            if (notification.getNotifier() instanceof Classifier) {
              IGraphicalEditPart gep =
                  (IGraphicalEditPart) getDecoratorTarget().getAdapter(IGraphicalEditPart.class);
              assert gep != null;
              // we remove the listener on the container (because it's
              // changing
              DiagramEventBroker.getInstance(gep.getEditingDomain())
                  .removeNotificationListener(
                      (EObject) notification.getNotifier(), notificationListener);
            }
          }
          // we update the listeners It's useful when an Element with overlay
          // changes of parent
          deactivate();
          activate();
          refresh();
        }
 /*
  * (non-Javadoc)
  *
  * @see
  * muvitorkit.gef.editparts.AdapterGraphicalEditPart#notifyChanged(org.eclipse
  * .emf.common.notify.Notification)
  */
 @Override
 protected void notifyChanged(Notification notification) {
   final int featureId = notification.getFeatureID(HenshinPackage.class);
   switch (featureId) {
     case HenshinPackage.UNIT__NAME:
       ((SubUnitFigure) getFigure()).setName(getText());
       break;
     case HenshinPackage.PARAMETER_MAPPING:
       final int type = notification.getEventType();
       switch (type) {
         case Notification.ADD:
         case Notification.ADD_MANY:
         case Notification.REMOVE:
         case Notification.REMOVE_MANY:
           refreshSourceConnections();
           refreshTargetConnections();
         case Notification.SET:
           refreshVisuals();
           break;
       }
   }
 }
  /*
   * (non-Javadoc)
   *
   * @see
   * de.tub.tfs.muvitor.gef.editparts.AdapterGraphicalEditPart#notifyChanged
   * (org.eclipse.emf.common.notify.Notification)
   */
  @Override
  protected void notifyChanged(Notification notification) {
    int henshinMsgId = notification.getFeatureID(HenshinPackage.class);
    int msgType = notification.getEventType();

    switch (henshinMsgId) {
      case HenshinPackage.SEQUENTIAL_UNIT__SUB_UNITS:
        getCastedModel().eSetDeliver(false);

        if (msgType == Notification.ADD
            && notification.getNewValue() == getCastedModel().getModel()) {
          getCastedModel().setCounter(getCastedModel().getCounter() + 1);
        }

        getCastedModel().eSetDeliver(true);

        break;

      default:
        break;
    }

    refresh();
  }