/**
   * This handles model notifications by calling {@link #updateChildren} to update any cached
   * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @generated
   */
  @Override
  public void notifyChanged(Notification notification) {
    updateChildren(notification);

    switch (notification.getFeatureID(ComparativeRiskAssessmentForm.class)) {
      case HazardPackage.COMPARATIVE_RISK_ASSESSMENT_FORM__SEC_TRACKING_NUMBER:
      case HazardPackage.COMPARATIVE_RISK_ASSESSMENT_FORM__CRA_TITLE:
      case HazardPackage.COMPARATIVE_RISK_ASSESSMENT_FORM__SYSTEM:
      case HazardPackage.COMPARATIVE_RISK_ASSESSMENT_FORM__SUMMARY:
      case HazardPackage.COMPARATIVE_RISK_ASSESSMENT_FORM__BASELINE:
      case HazardPackage.COMPARATIVE_RISK_ASSESSMENT_FORM__PROPOSED_CHANGE:
      case HazardPackage.COMPARATIVE_RISK_ASSESSMENT_FORM__DESCRIPTION:
      case HazardPackage.COMPARATIVE_RISK_ASSESSMENT_FORM__ASSESSMENT_SUMMARY:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), false, true));
        return;
      case HazardPackage.COMPARATIVE_RISK_ASSESSMENT_FORM__REFERENCES:
      case HazardPackage.COMPARATIVE_RISK_ASSESSMENT_FORM__RISK_ASSESSMENT:
      case HazardPackage.COMPARATIVE_RISK_ASSESSMENT_FORM__HAZARD_LIST:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), true, false));
        return;
    }
    super.notifyChanged(notification);
  }
 /**
  * {@inheritDoc}
  *
  * @see
  *     org.eclipse.emf.eef.runtime.impl.components.StandardPropertiesEditionComponent#updatePart(org.eclipse.emf.common.notify.Notification)
  */
 public void updatePart(Notification msg) {
   super.updatePart(msg);
   if (editingPart.isVisible()) {
     CommandPropertiesEditionPart basePart = (CommandPropertiesEditionPart) editingPart;
     if (StatemachinePackage.eINSTANCE.getCommand_Name().equals(msg.getFeature())
         && msg.getNotifier().equals(semanticObject)
         && basePart != null
         && isAccessible(StatemachineViewsRepository.Command.Properties.name)) {
       if (msg.getNewValue() != null) {
         basePart.setName(
             EcoreUtil.convertToString(EcorePackage.Literals.ESTRING, msg.getNewValue()));
       } else {
         basePart.setName("");
       }
     }
     if (StatemachinePackage.eINSTANCE.getCommand_Code().equals(msg.getFeature())
         && msg.getNotifier().equals(semanticObject)
         && basePart != null
         && isAccessible(StatemachineViewsRepository.Command.Properties.code)) {
       if (msg.getNewValue() != null) {
         basePart.setCode(
             EcoreUtil.convertToString(EcorePackage.Literals.ESTRING, msg.getNewValue()));
       } else {
         basePart.setCode("");
       }
     }
   }
 }
 /**
  * {@inheritDoc}
  *
  * @see
  *     org.eclipse.emf.eef.runtime.impl.components.StandardPropertiesEditionComponent#updatePart(org.eclipse.emf.common.notify.Notification)
  */
 public void updatePart(Notification msg) {
   super.updatePart(msg);
   if (editingPart.isVisible()) {
     NamespacePropertiesEditionPart namespacePart = (NamespacePropertiesEditionPart) editingPart;
     if (EnvironmentPackage.eINSTANCE.getNamespace_Name().equals(msg.getFeature())
         && msg.getNotifier().equals(semanticObject)
         && namespacePart != null
         && isAccessible(EnvironmentViewsRepository.Namespace.Properties.name)) {
       if (msg.getNewValue() != null) {
         namespacePart.setName(
             EcoreUtil.convertToString(EcorePackage.Literals.ESTRING, msg.getNewValue()));
       } else {
         namespacePart.setName("");
       }
     }
     if (EnvironmentPackage.eINSTANCE.getObeoDSMObject_Description().equals(msg.getFeature())
         && msg.getNotifier().equals(semanticObject)
         && namespacePart != null
         && isAccessible(EnvironmentViewsRepository.Namespace.Properties.description)) {
       if (msg.getNewValue() != null) {
         namespacePart.setDescription(
             EcoreUtil.convertToString(EcorePackage.Literals.ESTRING, msg.getNewValue()));
       } else {
         namespacePart.setDescription("");
       }
     }
   }
 }
 /**
  * {@inheritDoc}
  *
  * @see
  *     org.eclipse.emf.eef.runtime.impl.components.StandardPropertiesEditionComponent#updatePart(org.eclipse.emf.common.notify.Notification)
  */
 public void updatePart(Notification msg) {
   super.updatePart(msg);
   if (editingPart.isVisible()) {
     ConsistencyPropertiesEditionPart basePart = (ConsistencyPropertiesEditionPart) editingPart;
     if (SACMPackage.eINSTANCE.getModelElement_Id().equals(msg.getFeature())
         && msg.getNotifier().equals(semanticObject)
         && basePart != null
         && isAccessible(EvidenceViewsRepository.Consistency.Properties.id)) {
       if (msg.getNewValue() != null) {
         basePart.setId(EcoreUtil.convertToString(SACMPackage.Literals.STRING, msg.getNewValue()));
       } else {
         basePart.setId("");
       }
     }
     if (EvidencePackage.eINSTANCE.getEvidenceElement_Timing().equals(msg.getFeature())
         && isAccessible(EvidenceViewsRepository.Consistency.Properties.timing))
       basePart.updateTiming();
     if (EvidencePackage.eINSTANCE.getEvidenceElement_Custody().equals(msg.getFeature())
         && isAccessible(EvidenceViewsRepository.Consistency.Properties.custody))
       basePart.updateCustody();
     if (EvidencePackage.eINSTANCE.getEvidenceElement_Provenance().equals(msg.getFeature())
         && isAccessible(EvidenceViewsRepository.Consistency.Properties.provenance))
       basePart.updateProvenance();
     if (EvidencePackage.eINSTANCE.getEvidenceElement_Event().equals(msg.getFeature())
         && isAccessible(EvidenceViewsRepository.Consistency.Properties.event))
       basePart.updateEvent();
     if (EvidencePackage.eINSTANCE.getConsistency_Value().equals(msg.getFeature())
         && msg.getNotifier().equals(semanticObject)
         && isAccessible(EvidenceViewsRepository.Consistency.Properties.value))
       basePart.setValue((ConsistencyLevel) msg.getNewValue());
   }
 }
Example #5
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();
    }
  }
  /**
   * This handles model notifications by calling {@link #updateChildren} to update any cached
   * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @generated
   */
  @Override
  public void notifyChanged(Notification notification) {
    updateChildren(notification);

    switch (notification.getFeatureID(ListFieldMetaData.class)) {
      case RfcPackage.LIST_FIELD_META_DATA__NAME:
      case RfcPackage.LIST_FIELD_META_DATA__TYPE:
      case RfcPackage.LIST_FIELD_META_DATA__BYTE_LENGTH:
      case RfcPackage.LIST_FIELD_META_DATA__UNICODE_BYTE_LENGTH:
      case RfcPackage.LIST_FIELD_META_DATA__DECIMALS:
      case RfcPackage.LIST_FIELD_META_DATA__DEFAULTS:
      case RfcPackage.LIST_FIELD_META_DATA__DESCRIPTION:
      case RfcPackage.LIST_FIELD_META_DATA__IMPORT:
      case RfcPackage.LIST_FIELD_META_DATA__CHANGING:
      case RfcPackage.LIST_FIELD_META_DATA__EXPORT:
      case RfcPackage.LIST_FIELD_META_DATA__EXCEPTION:
      case RfcPackage.LIST_FIELD_META_DATA__OPTIONAL:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), false, true));
        return;
      case RfcPackage.LIST_FIELD_META_DATA__FIELD_META_DATA:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), true, false));
        return;
    }
    super.notifyChanged(notification);
  }
  /** {@inheritDoc} */
  @Override
  public void notifyChanged(final Notification notification) {
    updateChildren(notification);

    switch (notification.getFeatureID(Implementation.class)) {
      case SpdPackage.IMPLEMENTATION__DESCRIPTION:
      case SpdPackage.IMPLEMENTATION__PROPERTY_FILE:
      case SpdPackage.IMPLEMENTATION__CODE:
      case SpdPackage.IMPLEMENTATION__COMPILER:
      case SpdPackage.IMPLEMENTATION__PROGRAMMING_LANGUAGE:
      case SpdPackage.IMPLEMENTATION__HUMAN_LANGUAGE:
      case SpdPackage.IMPLEMENTATION__RUNTIME:
      case SpdPackage.IMPLEMENTATION__AEP_COMPLIANCE:
      case SpdPackage.IMPLEMENTATION__ID:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), false, true));
        return;
      case SpdPackage.IMPLEMENTATION__OS:
      case SpdPackage.IMPLEMENTATION__PROCESSOR:
      case SpdPackage.IMPLEMENTATION__DEPENDENCY:
      case SpdPackage.IMPLEMENTATION__USES_DEVICE:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), true, false));
        return;
      default:
        break;
    }
    super.notifyChanged(notification);
  }
Example #8
0
        @Override
        public void notifyChanged(Notification notification) {
          if (notification.getNotifier() instanceof Resource) {
            switch (notification.getFeatureID(Resource.class)) {
              case Resource.RESOURCE__IS_LOADED:
              case Resource.RESOURCE__ERRORS:
              case Resource.RESOURCE__WARNINGS:
                {
                  Resource resource = (Resource) notification.getNotifier();
                  Diagnostic diagnostic = analyzeResourceProblems(resource, null);
                  if (diagnostic.getSeverity() != Diagnostic.OK) {
                    resourceToDiagnosticMap.put(resource, diagnostic);
                  } else {
                    resourceToDiagnosticMap.remove(resource);
                  }

                  if (updateProblemIndication) {
                    getSite()
                        .getShell()
                        .getDisplay()
                        .asyncExec(
                            new Runnable() {
                              @Override
                              public void run() {
                                updateProblemIndication();
                              }
                            });
                  }
                  break;
                }
            }
          } else {
            super.notifyChanged(notification);
          }
        }
  /**
   * @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();
                }
              });
    }
  }
 /**
  * {@inheritDoc}
  *
  * @see
  *     org.eclipse.emf.eef.runtime.impl.components.StandardPropertiesEditionComponent#updatePart(org.eclipse.emf.common.notify.Notification)
  */
 public void updatePart(Notification msg) {
   super.updatePart(msg);
   if (editingPart.isVisible()) {
     DomainClassPropertiesEditionPart domainClassPart =
         (DomainClassPropertiesEditionPart) editingPart;
     if (EnvironmentPackage.eINSTANCE.getType_Name().equals(msg.getFeature())
         && msg.getNotifier().equals(semanticObject)
         && domainClassPart != null
         && isAccessible(GraalViewsRepository.DomainClass.Properties.name)) {
       if (msg.getNewValue() != null) {
         domainClassPart.setName(
             EcoreUtil.convertToString(EcorePackage.Literals.ESTRING, msg.getNewValue()));
       } else {
         domainClassPart.setName("");
       }
     }
     if (EnvironmentPackage.eINSTANCE.getStructuredType_Supertype().equals(msg.getFeature())
         && domainClassPart != null
         && isAccessible(GraalViewsRepository.DomainClass.Properties.superType))
       domainClassPart.setSuperType((EObject) msg.getNewValue());
     if (EnvironmentPackage.eINSTANCE.getObeoDSMObject_Description().equals(msg.getFeature())
         && msg.getNotifier().equals(semanticObject)
         && domainClassPart != null
         && isAccessible(GraalViewsRepository.DomainClass.Properties.description)) {
       if (msg.getNewValue() != null) {
         domainClassPart.setDescription(
             EcoreUtil.convertToString(EcorePackage.Literals.ESTRING, msg.getNewValue()));
       } else {
         domainClassPart.setDescription("");
       }
     }
   }
 }
 /**
  * {@inheritDoc}
  *
  * @see
  *     org.eclipse.emf.eef.runtime.impl.components.StandardPropertiesEditionComponent#updatePart(org.eclipse.emf.common.notify.Notification)
  */
 public void updatePart(Notification msg) {
   super.updatePart(msg);
   if (editingPart.isVisible()) {
     FlowEventPropertiesEditionPart flowEventPart = (FlowEventPropertiesEditionPart) editingPart;
     if (EnvironmentPackage.eINSTANCE.getObeoDSMObject_Description().equals(msg.getFeature())
         && msg.getNotifier().equals(semanticObject)
         && flowEventPart != null
         && isAccessible(FlowViewsRepository.FlowEvent.Properties.description)) {
       if (msg.getNewValue() != null) {
         flowEventPart.setDescription(
             EcoreUtil.convertToString(EcorePackage.Literals.ESTRING, msg.getNewValue()));
       } else {
         flowEventPart.setDescription("");
       }
     }
     if (CinematicPackage.eINSTANCE.getNamedElement_Name().equals(msg.getFeature())
         && msg.getNotifier().equals(semanticObject)
         && flowEventPart != null
         && isAccessible(FlowViewsRepository.FlowEvent.Properties.name)) {
       if (msg.getNewValue() != null) {
         flowEventPart.setName(
             EcoreUtil.convertToString(EcorePackage.Literals.ESTRING, msg.getNewValue()));
       } else {
         flowEventPart.setName("");
       }
     }
     if (FlowPackage.eINSTANCE.getFlowEvent_Binds().equals(msg.getFeature())
         && isAccessible(FlowViewsRepository.FlowEvent.Properties.binds))
       flowEventPart.updateBinds();
   }
 }
 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();
 }
 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;
 }
    /** @generated */
    public void notifyChanged(Notification notification) {
      if (notification.getNotifier() instanceof ResourceSet) {
        super.notifyChanged(notification);
      }
      if (!notification.isTouch() && myModifiedFilter.matches(notification)) {
        if (notification.getNotifier() instanceof Resource) {
          Resource resource = (Resource) notification.getNotifier();
          if (resource.isLoaded()) {
            boolean modified = false;
            for (Iterator /*<org.eclipse.emf.ecore.resource.Resource>*/ it =
                    myInfo.getLoadedResourcesIterator();
                it.hasNext() && !modified; ) {
              Resource nextResource = (Resource) it.next();
              if (nextResource.isLoaded()) {
                modified = nextResource.isModified();
              }
            }
            boolean dirtyStateChanged = false;
            synchronized (myInfo) {
              if (modified != myInfo.fCanBeSaved) {
                myInfo.fCanBeSaved = modified;
                dirtyStateChanged = true;
              }
            }
            if (dirtyStateChanged) {
              fireElementDirtyStateChanged(myInfo.getEditorInput(), modified);

              if (!modified) {
                myInfo.setModificationStamp(computeModificationStamp(myInfo));
              }
            }
          }
        }
      }
    }
 public void notifyChanged(Notification notification) {
   if (notification.getNotifier() == value
       && !(notification.getOldValue() instanceof InsertionAdapter)) {
     // execute if an attribute in the new value has changed
     execute();
   } else if (notification.getNotifier() == object && notification.getNewValue() == value) {
     // if the new value has been added to the object, we can remove this adapter
     object.eAdapters().remove(this);
   }
 }
  @Override
  public void notifyChanged(Notification notification) {
    super.notifyChanged(notification);

    if (!doRecord(notification)) return;

    if (notification.getNotifier() instanceof EObject) {
      recordObjectModification((EObject) notification.getNotifier());
    }
  }
 @Override
 public boolean isImportant(TemporalEdgeManager manager, Notification notification) {
   Object feature = notification.getFeature();
   if (TemporalPackage.Literals.TEMPORAL_MEMBER__START_TIME == feature
       || TemporalPackage.Literals.TEMPORAL_MEMBER__DURATION == feature
       || TemporalPackage.Literals.TEMPORAL_MEMBER__END_TIME == feature) {
     return ((TemporalMember) notification.getNotifier()).getPlanElement() instanceof EActivity;
   } else if (PlanPackage.Literals.EPLAN_PARENT__CHILDREN == feature
       || PlanPackage.Literals.EACTIVITY__CHILDREN == feature) {
     return !EPlanUtils.isTemplatePlanHierarchyElement(notification.getNotifier());
   }
   return false;
 }
 public void notifyChanged(Notification notification) {
   super.notifyChanged(notification);
   if (notification.getFeature() instanceof EAttributeImpl) {
     if (notification.getNotifier() instanceof BoundsImpl) {
       reposition(
           ((BoundsImpl) notification.getNotifier()).getX(),
           ((BoundsImpl) notification.getNotifier()).getY(),
           ((BoundsImpl) notification.getNotifier()).getWidth(),
           ((BoundsImpl) notification.getNotifier()).getHeight());
       FigureCanvas canvas = (FigureCanvas) getViewer().getControl();
       canvas.getViewport().repaint();
     }
   }
 }
  /**
   * This handles model notifications by calling {@link #updateChildren} to update any cached
   * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @generated
   */
  public void notifyChanged(Notification notification) {
    updateChildren(notification);

    switch (notification.getFeatureID(Comment.class)) {
      case UML2Package.COMMENT__BODY:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), false, true));
        return;
      case UML2Package.COMMENT__BODY_EXPRESSION:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), true, false));
        return;
    }
    super.notifyChanged(notification);
  }
  /**
   * This handles model notifications by calling {@link #updateChildren} to update any cached
   * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @generated
   */
  @Override
  public void notifyChanged(Notification notification) {
    updateChildren(notification);

    switch (notification.getFeatureID(BuiltInAtom.class)) {
      case SwrlPackage.BUILT_IN_ATOM__BUILT_IN:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), false, true));
        return;
      case SwrlPackage.BUILT_IN_ATOM__BUILT_IN_ATOM:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), true, false));
        return;
    }
    super.notifyChanged(notification);
  }
  /**
   * This handles model notifications by calling {@link #updateChildren} to update any cached
   * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @generated
   */
  public void notifyChanged(Notification notification) {
    updateChildren(notification);

    switch (notification.getFeatureID(DiagramStyle.class)) {
      case NotationPackage.DIAGRAM_STYLE__DESCRIPTION:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), false, true));
        return;
      case NotationPackage.DIAGRAM_STYLE__HORIZONTAL_GUIDES:
      case NotationPackage.DIAGRAM_STYLE__VERTICAL_GUIDES:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), true, false));
        return;
    }
    super.notifyChanged(notification);
  }
  /**
   * This handles model notifications by calling {@link #updateChildren} to update any cached
   * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
   * <!-- begin-user-doc -->
   * <!--
   * end-user-doc -->
   *
   * @generated
   */
  @Override
  public void notifyChanged(Notification notification) {
    updateChildren(notification);

    switch (notification.getFeatureID(Model.class)) {
      case InteractionsPackage.MODEL__NAME:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), false, true));
        return;
      case InteractionsPackage.MODEL__OWNED_INTERACTIONS:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), true, false));
        return;
    }
    super.notifyChanged(notification);
  }
 /** {@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();
     }
   }
 }
 @Override
 protected boolean affectsViolations(Notification notification) {
   Object feature = notification.getFeature();
   if ((feature == PlanPackage.Literals.EPLAN_PARENT__CHILDREN)
       || (feature == PlanPackage.Literals.EACTIVITY__CHILDREN)) {
     return true;
   }
   if ((feature == TemporalPackage.Literals.TEMPORAL_MEMBER__START_TIME)
       || (feature == TemporalPackage.Literals.TEMPORAL_MEMBER__DURATION)
       || (feature == TemporalPackage.Literals.TEMPORAL_MEMBER__END_TIME)
       || (feature == TemporalPackage.Literals.TEMPORAL_MEMBER__SCHEDULED)) {
     return true;
   }
   if ((feature == ConstraintsPackage.Literals.CONSTRAINTS_MEMBER__PERIODIC_TEMPORAL_CONSTRAINTS)
       || (feature == ConstraintsPackage.Literals.CONSTRAINTS_MEMBER__BINARY_TEMPORAL_CONSTRAINTS)
       || (feature == ConstraintsPackage.Literals.CONSTRAINTS_MEMBER__CHAIN)) {
     return true;
   }
   if (feature == AdvisorPackage.Literals.IWAIVABLE__WAIVER_RATIONALE) {
     return true;
   }
   if (ADParameterUtils.isActivityAttributeOrParameter(notification.getNotifier())) {
     return true;
   }
   return false;
 }
  /**
   * This handles model notifications by calling {@link #updateChildren} to update any cached
   * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @generated
   */
  @Override
  public void notifyChanged(Notification notification) {
    updateChildren(notification);

    switch (notification.getFeatureID(InvokeSaflet2.class)) {
      case Actionpak1Package.INVOKE_SAFLET2__LABEL_TEXT:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), false, true));
        return;
      case Actionpak1Package.INVOKE_SAFLET2__TARGET_SAFLET_PATH:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), true, false));
        return;
    }
    super.notifyChanged(notification);
  }
  /**
   * This handles model notifications by calling {@link #updateChildren} to update any cached
   * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @generated
   */
  @Override
  public void notifyChanged(Notification notification) {
    updateChildren(notification);

    switch (notification.getFeatureID(ConversationNode.class)) {
      case Bpmn2Package.CONVERSATION_NODE__NAME:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), false, true));
        return;
      case Bpmn2Package.CONVERSATION_NODE__CORRELATION_KEYS:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), true, false));
        return;
    }
    super.notifyChanged(notification);
  }
  /**
   * This handles model notifications by calling {@link #updateChildren} to update any cached
   * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @generated
   */
  @Override
  public void notifyChanged(Notification notification) {
    updateChildren(notification);

    switch (notification.getFeatureID(MHandledItem.class)) {
      case MenuPackageImpl.HANDLED_ITEM__WB_COMMAND:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), false, true));
        return;
      case MenuPackageImpl.HANDLED_ITEM__PARAMETERS:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), true, false));
        return;
    }
    super.notifyChanged(notification);
  }
 /**
  * Papyrus codeGen
  *
  * @generated
  */
 protected void handleNotificationEvent(Notification event) {
   /*
    * when a node have external node labels, the methods refreshChildren() remove the EditPart corresponding to the Label from the EditPart
    * Registry. After that, we can't reset the visibility to true (using the Show/Hide Label Action)!
    */
   if (NotationPackage.eINSTANCE.getView_Visible().equals(event.getFeature())) {
     Object notifier = event.getNotifier();
     List<?> modelChildren = ((View) getModel()).getChildren();
     if (!(notifier instanceof Edge)) {
       if (modelChildren.contains(event.getNotifier())) {
         return;
       }
     }
   }
   super.handleNotificationEvent(event);
 }
  /**
   * This handles model notifications by calling {@link #updateChildren} to update any cached
   * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @generated
   */
  @Override
  public void notifyChanged(Notification notification) {
    updateChildren(notification);

    switch (notification.getFeatureID(DisplayUnit.class)) {
      case ConstraintsPackage.DISPLAY_UNIT__ELEMENT_MULTIPLICITY:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), false, true));
        return;
      case ConstraintsPackage.DISPLAY_UNIT__CONSTRAINTS:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), true, false));
        return;
    }
    super.notifyChanged(notification);
  }
  /**
   * This handles model notifications by calling {@link #updateChildren} to update any cached
   * children and by creating a viewer notification, which it passes to {@link #fireNotifyChanged}.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @generated
   */
  @Override
  public void notifyChanged(Notification notification) {
    updateChildren(notification);

    switch (notification.getFeatureID(SimulinkElement.class)) {
      case SimulinkPackage.SIMULINK_ELEMENT__NAME:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), false, true));
        return;
      case SimulinkPackage.SIMULINK_ELEMENT__SIMULINK_REF:
        fireNotifyChanged(
            new ViewerNotification(notification, notification.getNotifier(), true, false));
        return;
    }
    super.notifyChanged(notification);
  }