/** @generated */
@Override
protected void handleNotificationEvent(Notification notification) {
super.handleNotificationEvent(notification);
if (notification.getNotifier() instanceof de.uni_mannheim.informatik.swt.models.plm.PLM.Feature
&& ((EStructuralFeature) notification.getFeature()).getName().equals("expressed")) {
IGraphicalEditPart parent = (IGraphicalEditPart) getParent();
de.uni_mannheim.informatik.swt.models.plm.PLM.Element self =
(de.uni_mannheim.informatik.swt.models.plm.PLM.Element) resolveSemanticElement();
// Check is visible
if (parent.resolveSemanticElement()
instanceof de.uni_mannheim.informatik.swt.models.plm.PLM.Context) {
de.uni_mannheim.informatik.swt.models.plm.PLM.Context container =
(de.uni_mannheim.informatik.swt.models.plm.PLM.Context) parent.resolveSemanticElement();
if ((container.getOrigin().equalsIgnoreCase("computed") && self.isExpressed())
|| (container.getOrigin().equalsIgnoreCase("expressed") && !self.isExpressed())) {
getNotationView().setVisible(false);
}
} else {
getNotationView().setVisible(true);
}
de.uni_mannheim.informatik.swt.models.plm.PLM.Feature f =
(de.uni_mannheim.informatik.swt.models.plm.PLM.Feature) resolveSemanticElement();
if (f.isExpressed()) {
((org.eclipse.gmf.runtime.notation.Shape) this.getNotationView()).setItalic(false);
((org.eclipse.gmf.runtime.notation.Shape) this.getNotationView()).setFontColor(0);
} else {
((org.eclipse.gmf.runtime.notation.Shape) this.getNotationView()).setItalic(true);
((org.eclipse.gmf.runtime.notation.Shape) this.getNotationView())
.setFontColor(FigureUtilities.colorToInteger(DiagramColorConstants.diagramGray));
}
}
}
/** @generated */
protected void handleNotificationEvent(Notification event) {
Object feature = event.getFeature();
if (NotationPackage.eINSTANCE.getFontStyle_FontColor().equals(feature)) {
Integer c = (Integer) event.getNewValue();
setFontColor(DiagramColorRegistry.getInstance().getColor(c));
} else if (NotationPackage.eINSTANCE.getFontStyle_Underline().equals(feature)) {
refreshUnderline();
} else if (NotationPackage.eINSTANCE.getFontStyle_StrikeThrough().equals(feature)) {
refreshStrikeThrough();
} else 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)) {
refreshFont();
} else {
if (getParser() != null
&& getParser().isAffectingEvent(event, getParserOptions().intValue())) {
refreshLabel();
}
if (getParser() instanceof ISemanticParser) {
ISemanticParser modelParser = (ISemanticParser) getParser();
if (modelParser.areSemanticElementsAffected(null, event)) {
removeSemanticListeners();
if (resolveSemanticElement() != null) {
addSemanticListeners();
}
refreshLabel();
}
}
}
super.handleNotificationEvent(event);
}
@Override
public void notifyChanged(Notification notification) {
if (notification.getFeatureID(Diagram.class) == NotationPackage.DIAGRAM__NAME
&& notification.getNotifier() == diagram) {
setPartName(diagram.getName());
}
}
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;
}
/**
* Checks only if removed object was an Ensemble, if true, closes all open Ensemble Editors.
*
* <p>Checking remove event and correct classes is done by the NotificationFilter
*/
@Override
protected void handleNotification(TransactionalEditingDomain domain, Notification notification) {
if (notification.getOldValue() instanceof Ensemble) {
final Ensemble oldEnsemble = (Ensemble) notification.getOldValue();
Display.getDefault()
.asyncExec(
new Runnable() {
@Override
public void run() {
IWorkbenchPage page = getActivePage();
Ensemble ens = oldEnsemble;
if (page != null) {
IEditorReference[] editors =
page.findEditors(
new EnsembleEditorInput(ens),
EnsembleEditor.ID,
IWorkbenchPage.MATCH_ID | IWorkbenchPage.MATCH_INPUT);
page.closeEditors(editors, false);
}
}
});
}
}
/**
* 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;
}
@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);
}
}
@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;
}
@Override
public void notifyChanged(Notification notification) {
super.notifyChanged(notification);
if (this.object == notification.getNotifier() && this.feature == notification.getFeature()) {
button.setSelection((Boolean) object.eGet(feature));
}
}
@Override
public void processNotifications(TemporalEdgeManager manager, List<Notification> notifications) {
for (Notification notification : notifications) {
Object feature = notification.getFeature();
// Temporal changes
//
if (TemporalPackage.Literals.TEMPORAL_MEMBER__START_TIME == feature
|| TemporalPackage.Literals.TEMPORAL_MEMBER__DURATION == feature
|| TemporalPackage.Literals.TEMPORAL_MEMBER__END_TIME == feature) {
EActivity eActivity =
(EActivity) ((TemporalMember) notification.getNotifier()).getPlanElement();
removeActivityEdges(manager, eActivity);
addActivityEdges(manager, eActivity);
}
// Hierarchy changes
//
if (PlanPackage.Literals.EPLAN_PARENT__CHILDREN == feature
|| PlanPackage.Literals.EACTIVITY__CHILDREN == feature) {
for (EActivity activity : EMFUtils.getAddedObjects(notification, EActivity.class)) {
addActivityEdges(manager, activity);
}
for (EActivity activity : EMFUtils.getRemovedObjects(notification, EActivity.class)) {
removeActivityEdges(manager, activity);
}
}
}
}
/**
* 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}
*
* @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} */
@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);
}
/**
* 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(DocumentRoot.class)) {
case RulesPackage.DOCUMENT_ROOT__ACTION:
case RulesPackage.DOCUMENT_ROOT__ACTIONS:
case RulesPackage.DOCUMENT_ROOT__CHANNEL:
case RulesPackage.DOCUMENT_ROOT__CHANNELS:
case RulesPackage.DOCUMENT_ROOT__CONTAINER:
case RulesPackage.DOCUMENT_ROOT__GLOBALS:
case RulesPackage.DOCUMENT_ROOT__IMPLEMENTATION_RULES:
case RulesPackage.DOCUMENT_ROOT__INPUTS:
case RulesPackage.DOCUMENT_ROOT__LISTENER:
case RulesPackage.DOCUMENT_ROOT__LISTENERS:
case RulesPackage.DOCUMENT_ROOT__LOGGER:
case RulesPackage.DOCUMENT_ROOT__LOGGERS:
case RulesPackage.DOCUMENT_ROOT__MANIFEST:
case RulesPackage.DOCUMENT_ROOT__MAPPING:
case RulesPackage.DOCUMENT_ROOT__OUTPUTS:
case RulesPackage.DOCUMENT_ROOT__PROPERTIES:
case RulesPackage.DOCUMENT_ROOT__PROPERTY:
case RulesPackage.DOCUMENT_ROOT__RESOURCE:
case RulesPackage.DOCUMENT_ROOT__RESOURCES:
fireNotifyChanged(
new ViewerNotification(notification, notification.getNotifier(), true, false));
return;
}
super.notifyChanged(notification);
}
/** @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));
}
}
}
}
}
}
@Override
public void notifyChanged(final Notification msg) {
switch (msg.getFeatureID(SdrPackage.class)) {
case SdrPackage.SDR_ROOT__LOAD_STATUS:
// The value is the changed load status which will go to null during loading
// once loading is finished the status will change to reflect that of the SDRROOT.
if (msg.getNewValue() != null) {
Job refreshExternalSettingProviderJob =
new Job("Refresh External Settings Providers") {
@Override
protected IStatus run(IProgressMonitor monitor) {
CoreModel.getDefault()
.getProjectDescriptionManager()
.updateExternalSettingsProviders(
new String[] {ExternalSettingProvider.ID}, monitor);
return Status.OK_STATUS;
}
};
refreshExternalSettingProviderJob.setSystem(true); // hide from progress monitor
refreshExternalSettingProviderJob.setUser(false);
refreshExternalSettingProviderJob.schedule(1000);
}
break;
default:
break;
}
}
/**
* 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);
}
/** @generated */
protected void handleNotificationEvent(Notification event) {
if (event.getNotifier() == getModel()
&& EcorePackage.eINSTANCE.getEModelElement_EAnnotations().equals(event.getFeature())) {
handleMajorSemanticChange();
} else {
super.handleNotificationEvent(event);
}
}
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);
}
}
/*
* (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;
}
}
}
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);
}
}
private boolean isDTableElementStyleAttributeChange(Notification notification) {
boolean isStyleFeature =
notification.getFeature() == TablePackage.Literals.DTABLE_ELEMENT_STYLE__BACKGROUND_COLOR
|| notification.getFeature()
== TablePackage.Literals.DTABLE_ELEMENT_STYLE__FOREGROUND_COLOR
|| notification.getFeature() == TablePackage.Literals.DTABLE_ELEMENT_STYLE__LABEL_FORMAT
|| notification.getFeature() == TablePackage.Literals.DTABLE_ELEMENT_STYLE__LABEL_SIZE;
return isStyleFeature && notification.getNotifier() instanceof DTableElementStyle;
}
protected void handleNotification(Resource resource, Notification msg) {
switch (msg.getFeatureID(Resource.class)) {
case Resource.RESOURCE__IS_LOADED:
if (msg.getNewBooleanValue()) {
handleResourceLoaded(resource);
}
break;
}
}
/** @generated NOT */
protected void handleNotificationEvent(Notification notification) {
Object feature = notification.getFeature();
if (RobmodPackage.eINSTANCE.getPort_External().equals(feature)) {
if (notification.getNewBooleanValue()) {
primaryShape.setVisible(false);
} else {
primaryShape.setVisible(true);
}
} else super.handleNotificationEvent(notification);
}
@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;
}
}
}
@Override
public void notifyChanged(Notification notification) {
super.notifyChanged(notification);
if (!doRecord(notification)) return;
if (notification.getNotifier() instanceof EObject) {
recordObjectModification((EObject) notification.getNotifier());
}
}
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);
}
}
/**
* {@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();
}
}
@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();
}
}
/** {@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();
}
}
}
