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(); }
/** * 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); } } }); } }
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; } } }
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; }
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; } } }
/** {@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(); } } }
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 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); } }
/* * @see org.eclipse.gmf.runtime.diagram.ui.editparts.ConnectionEditPart#handleNotificationEvent(org.eclipse.gmf.runtime.diagram.ui.internal.listener.NotificationEvent) */ protected void handleNotificationEvent(Notification notification) { Object feature = notification.getFeature(); if (NotationPackage.eINSTANCE.getView_SourceEdges().equals(feature)) refreshSourceConnections(); else if (NotationPackage.eINSTANCE.getView_TargetEdges().equals(feature)) refreshTargetConnections(); else super.handleNotificationEvent(notification); if (NotationPackage.eINSTANCE.getIdentityAnchor_Id().equals(feature) || notification.getNewValue() instanceof IdentityAnchor || notification.getOldValue() instanceof IdentityAnchor) { anchorChange(); } }
@Override public void notifyChanged(Notification notification) { final Map<URI, Resource> map = getURIResourceMap(); if (map != null && notification.getFeatureID(Resource.class) == Resource.RESOURCE__URI && notification.getNotifier() instanceof Resource) { URI oldOne = (URI) notification.getOldValue(); map.remove(oldOne); if (oldOne != null) { URI oldNormalized = getURIConverter().normalize(oldOne); if (!oldOne.equals(oldNormalized)) map.remove(oldNormalized); } Resource resource = (Resource) notification.getNotifier(); registerURI(resource); } super.notifyChanged(notification); }
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); } }
protected void updateSimpleRefs(Notification notification) { Simple simple = (Simple) notification.getNewValue(); if (simple != null) { // Add Simple Refs associated with new value for (StructValue structValue : getStructValue()) { SimpleRef ref = PrfFactory.eINSTANCE.createSimpleRef(); ref.setRefID(simple.getId()); ref.setValue(PropertiesUtil.getDefaultValue(simple)); SimpleRef oldRef = null; for (SimpleRef sr : structValue.getSimpleRef()) { if (sr.getRefID() != null && sr.getRefID().equals(simple.getId())) { oldRef = sr; break; } } if (oldRef != null) { structValue.getSimpleRef().remove(oldRef); } int index = this.getStruct().getSimple().indexOf(simple); structValue.getSimpleRef().add(index, ref); } } else { // Remove SimpleRefs associated with the oldValue simple = (Simple) notification.getOldValue(); if (simple != null) { for (StructValue structValue : getStructValue()) { Collection<SimpleRef> removeRefs = null; for (SimpleRef ref : structValue.getSimpleRef()) { if (ref.getRefID() != null && simple.getId() != null) { if (ref.getRefID().equals(simple.getId())) { removeRefs = Collections.singletonList(ref); break; } } else if (ref.getRefID() == null && simple.getId() == null) { removeRefs = Collections.singletonList(ref); break; } } if (removeRefs != null) { structValue.getSimpleRef().removeAll(removeRefs); } } } } }
@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) { if (debug) { DebugTrace.print( this, "notifyChanged", "notification=" + notification); // $NON-NLS-1$ //$NON-NLS-2$ } if (!skipEventProcessing) { int eventType = notification.getEventType(); switch (eventType) { case Notification.ADD: { // A method element, typically a method plug-in, has been // added to the managed library without using an editing // command. Object notifier = notification.getNotifier(); Object value = notification.getNewValue(); if ((notifier instanceof MethodLibrary) && (value instanceof MethodPlugin)) { Collection affectedObjects = new ArrayList(); affectedObjects.add(value); notifyListeners(ILibraryChangeListener.OPTION_NEWCHILD, affectedObjects); } break; } case Notification.SET: { Object notifier = notification.getNotifier(); if (notifier != null) { Collection affectedObjects = new ArrayList(); affectedObjects.add(notifier); notifyListeners(ILibraryChangeListener.OPTION_CHANGED, affectedObjects); } break; } case Notification.REMOVE: { // Either a method element has been removed from the // containing element, or a method element reference has // been deleted. Object notifier = notification.getNotifier(); Object oldValue = notification.getOldValue(); Collection affectedObjects = new ArrayList(); if (oldValue instanceof EObject && ((EObject) oldValue).eContainer() == null) { // A method element has been deleted. affectedObjects.add(oldValue); notifyListeners(ILibraryChangeListener.OPTION_DELETED, affectedObjects); } else { // A method element reference has been deleted, notify // the listeners that the containing method element has // changed. affectedObjects.add(notifier); notifyListeners(ILibraryChangeListener.OPTION_CHANGED, affectedObjects); } break; } case Notification.REMOVE_MANY: { // Two or more method elements have been removed from // the containing element, or tw or more method element // reference have been deleted. List oldValue = new ArrayList((Collection) notification.getOldValue()); ArrayList deletedElements = new ArrayList(); ArrayList removedReferences = new ArrayList(); if (!oldValue.isEmpty()) { for (Iterator iter = oldValue.iterator(); iter.hasNext(); ) { Object element = iter.next(); if (element instanceof EObject) { if (((EObject) element).eContainer() == null) { deletedElements.add(element); } else { removedReferences.add(element); } } } } if (!deletedElements.isEmpty()) { // Two or more method elements have been deleted. notifyListeners(ILibraryChangeListener.OPTION_DELETED, deletedElements); } if (!removedReferences.isEmpty()) { // Two or more method element reference has been // deleted. notifyListeners(ILibraryChangeListener.OPTION_CHANGED, removedReferences); } break; } } } }
@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()); } } } }
public void notifyChanged(Notification notification) { super.notifyChanged(notification); /* * We create partOpened / partClosed events based on both MPartWidget * events. * * The initial MPartVisible events are sent early and don't have the * actual implementation included. The MPartWidget events are sent as a * final step of "part is created" and therefore we use it to create * partOpened events. When the part is closed the widget is set to null. */ if (MApplicationPackage.Literals.UI_ELEMENT__WIDGET.equals(notification.getFeature())) { if (notification.getEventType() != Notification.SET) return; if (notification.getOldValue() == notification.getNewValue()) return; // avoid extra notifications Object part = notification.getNotifier(); if (part instanceof MPart) { IWorkbenchPartReference ref = toPartRef((MPart) part); if (ref != null) { boolean isVisible = ((MPart) part).isVisible(); if (isVisible) { if (notification.getNewValue() == null) { /* * not sure if this is the right place to fix bug * 283922 but if there is no widget and * isVisible==true, we must be shutting down, and we * should not send partOpened notifications. */ return; } SaveablesList modelManager = (SaveablesList) ref.getPart(true).getSite().getService(ISaveablesLifecycleListener.class); modelManager.postOpen(ref.getPart(true)); partList.firePartOpened(ref); } } } return; } // Interpret E4 activation events: if (!MApplicationPackage.Literals.ELEMENT_CONTAINER__ACTIVE_CHILD.equals( notification.getFeature())) return; // at this time we only interpreting SET events if (notification.getEventType() != Notification.SET || notification.getEventType() != Notification.CREATE) return; // make sure something actually changed Object oldPart = notification.getOldValue(); Object newPart = notification.getNewValue(); // create 3.x visibility events if ((newPart != oldPart) && (oldPart instanceof MPart) && (newPart instanceof MPart)) changeVisibility((MPart) oldPart, (MPart) newPart); // create 3.x activation events final Object object = e4Context.get(IServiceConstants.ACTIVE_PART); if ((newPart != oldPart) && newPart instanceof MPerspective) { // let legacy Workbench know about perspective activation IWorkbenchPage page = (IWorkbenchPage) e4Context.get(IWorkbenchPage.class.getName()); if (page != null) { String id = ((MPerspective) newPart).getId(); IPerspectiveDescriptor[] descriptors = page.getOpenPerspectives(); for (IPerspectiveDescriptor desc : descriptors) { if (!id.equals(desc.getId())) continue; page.setPerspective(desc); } } } if (object instanceof MPart) { IWorkbenchPartReference ref = toPartRef((MPart) object); if (ref != null) { // set the Focus to the newly active part IWorkbenchPart part = ref.getPart(true); part.setFocus(); // Update the action bars SubActionBars bars = (SubActionBars) ((PartSite) part.getSite()).getActionBars(); bars.partChanged(part); partList.setActivePart(ref); if (ref instanceof IEditorReference) { IEditorReference editorReference = (IEditorReference) ref; partList.setActiveEditor(editorReference); final IEditorPart editor = editorReference.getEditor(true); e4Context.set(ISources.ACTIVE_EDITOR_NAME, editor); e4Context.set(ISources.ACTIVE_EDITOR_ID_NAME, editor.getSite().getId()); e4Context.set(ISources.ACTIVE_EDITOR_INPUT_NAME, editor.getEditorInput()); } } } else { partList.setActiveEditor(null); e4Context.set(ISources.ACTIVE_EDITOR_NAME, null); e4Context.set(ISources.ACTIVE_EDITOR_ID_NAME, null); e4Context.set(ISources.ACTIVE_EDITOR_INPUT_NAME, null); partList.setActivePart(null); } }
@Override public void notifyChanged(final Notification notification) { super.notifyChanged(notification); Object newValue = notification.getNewValue(); Object oldValue = notification.getOldValue(); switch (notification.getEventType()) { case Notification.ADD: if (newValue instanceof DcdComponentInstantiation) { final DcdComponentInstantiation object = (DcdComponentInstantiation) notification.getNewValue(); this.modelMap.add(object); } else if (newValue instanceof DcdConnectInterface) { final DcdConnectInterface object = (DcdConnectInterface) newValue; if (object.getSource() == null || object.getTarget() == null || object.getId() == null) { return; } this.modelMap.add(object); } break; case Notification.ADD_MANY: for (Object obj : ((Collection<?>) newValue)) { if (obj instanceof DcdComponentInstantiation) { final DcdComponentInstantiation object = (DcdComponentInstantiation) obj; this.modelMap.add(object); } else if (newValue instanceof DcdConnectInterface) { final DcdConnectInterface object = (DcdConnectInterface) newValue; if (object.getSource() == null || object.getTarget() == null || object.getId() == null) { return; } this.modelMap.add(object); } } break; case Notification.REMOVE: if (oldValue instanceof DcdComponentInstantiation) { final DcdComponentInstantiation object = (DcdComponentInstantiation) oldValue; this.modelMap.remove(object); } else if (oldValue instanceof DcdComponentPlacement) { final DcdComponentPlacement object = (DcdComponentPlacement) oldValue; for (DcdComponentInstantiation i : object.getComponentInstantiation()) { this.modelMap.remove(i); } } else if (oldValue instanceof DcdConnectInterface) { final DcdConnectInterface object = (DcdConnectInterface) oldValue; this.modelMap.remove(object); } break; case Notification.REMOVE_MANY: for (Object obj : ((Collection<?>) oldValue)) { if (obj instanceof DcdComponentInstantiation) { final DcdComponentInstantiation object = (DcdComponentInstantiation) obj; this.modelMap.remove(object); } else if (oldValue instanceof DcdComponentPlacement) { final DcdComponentPlacement object = (DcdComponentPlacement) oldValue; for (DcdComponentInstantiation i : object.getComponentInstantiation()) { this.modelMap.remove(i); } } else if (obj instanceof DcdConnectInterface) { final DcdConnectInterface object = (DcdConnectInterface) obj; this.modelMap.remove(object); } } break; default: break; } }
/** * Check if profile applications are correctly duplicated on controlled package and that there is * no useless copy left. * * @see * org.eclipse.emf.validation.AbstractModelConstraint#validate(org.eclipse.emf.validation.IValidationContext) * @param ctx validation context * @return validation status */ public IStatus validate(IValidationContext ctx) { try { if (ctx.equals(lastValidatedContext)) { return ctx.createSuccessStatus(); } else { lastValidatedContext = ctx; } EObject eObject = ctx.getTarget(); // detect profile application creation if ((EMFEventType.ADD.equals(ctx.getEventType()) || EMFEventType.ADD_MANY.equals(ctx.getEventType())) && ctx.getFeatureNewValue() instanceof ProfileApplication) { ProfileApplication profileAppl = (ProfileApplication) ctx.getFeatureNewValue(); Package pack = (Package) eObject; boolean res = stereotypeApplicationAdded(pack, profileAppl); if (!res) { return ctx.createFailureStatus(); } } // detect profile application deletion else if (((EMFEventType.REMOVE.equals(ctx.getEventType()) && ctx.getFeatureNewValue() instanceof ProfileApplication) || EMFEventType.REMOVE_MANY.equals(ctx.getEventType()))) { Map<ProfileApplication, Profile> oldAssignement = new HashMap<ProfileApplication, Profile>(ctx.getAllEvents().size()); for (Notification n : ctx.getAllEvents()) { // case when profile is removed from profile application : keep the reference if (ENotificationImpl.SET == n.getEventType() && UMLPackage.eINSTANCE.getProfileApplication_AppliedProfile().equals(n.getFeature()) && n.getNotifier() instanceof ProfileApplication) { Profile profile = (Profile) n.getOldValue(); ProfileApplication profileAppl = (ProfileApplication) n.getNotifier(); oldAssignement.put(profileAppl, profile); } // cases when profile application is removed if (ENotificationImpl.REMOVE == n.getEventType() && n.getOldValue() instanceof ProfileApplication && n.getNotifier() instanceof Package) { ProfileApplication profileAppl = (ProfileApplication) n.getOldValue(); Package pack = (Package) n.getNotifier(); Profile profile = profileAppl.getAppliedProfile(); if (profile == null) { profile = oldAssignement.get(profileAppl); } if (profile != null) { boolean res = stereotypeApplicationRemoved(pack, profileAppl, profile); if (!res) { return ctx.createFailureStatus(); } } } } } return ctx.createSuccessStatus(); } catch (RuntimeException rte) { // avoid throwing uncaught exception which would disable the constraint Activator.getDefault() .getLog() .log( new Status(Status.ERROR, Activator.PLUGIN_ID, Messages.error_during_validation, rte)); // ensure that the constraint's failure does not prevent modification return ctx.createSuccessStatus(); } }
// CHECKSTYLE:OFF @SuppressWarnings("unchecked") private void analyseNotification(Notification notification) { Object notifier = notification.getNotifier(); if (notifier instanceof DTable) { if (notification.getFeature() == TablePackage.Literals.DTABLE__HEADER_COLUMN_WIDTH) { updateHeaderColumnWidth = true; } else if (notification.getFeature() == TablePackage.Literals.DTABLE__COLUMNS) { // The position is incremented by one cause of the header column if (notification.getEventType() == Notification.ADD) { if (notification.getNewValue() instanceof DColumn) { dColumnsToAdd.put((DColumn) notification.getNewValue(), notification.getPosition() + 1); } } else if (notification.getEventType() == Notification.MOVE) { if (notification.getNewValue() instanceof DColumn) { DColumn newValue = (DColumn) notification.getNewValue(); int newPosition = notification.getPosition() + 1; dColumnsToAdd.put(newValue, newPosition); dColumnsToRemove.add(newValue); } } else if (notification.getEventType() == Notification.REMOVE) { if (notification.getOldValue() instanceof DColumn) { dColumnsToRemove.add((DColumn) notification.getOldValue()); } } else if (notification.getEventType() == Notification.REMOVE_MANY && notification.getOldValue() instanceof EList) { for (final EObject oldValue : (EList<EObject>) notification.getOldValue()) { if (oldValue instanceof DTargetColumn) { dColumnsToRemove.add((DColumn) oldValue); } } } } else if (notification.getFeature() == ViewpointPackage.Literals.DSEMANTIC_DECORATOR__TARGET || notification.getFeature() == TablePackage.Literals.LINE_CONTAINER__LINES) { toRefreshInViewerWithUpdateLabels.add(notifier); } } else if (notifier instanceof DLine) { DLine dLine = (DLine) notifier; if (notification.getFeature() == TablePackage.Literals.DLINE__LABEL || notification.getFeature() == TablePackage.Literals.DLINE__CELLS || notification.getFeature() == TablePackage.Literals.DLINE__CURRENT_STYLE) { toUpdateInViewer.add(notifier); } else if (notification.getFeature() == TablePackage.Literals.DLINE__ORDERED_CELLS) { toRefreshInViewerWithUpdateLabels.add(notifier); } else if (notification.getFeature() == TablePackage.Literals.LINE_CONTAINER__LINES) { toRefreshInViewerWithUpdateLabels.add(notifier); // By default created DLine is expand of default value of // DLine.collapsed is false if (!dLine.isCollapsed()) { toExpands.add(dLine); analyseExpansionStateOfCreatedChildren(dLine.getLines()); } } else if (notification.getFeature() == TablePackage.Literals.DLINE__VISIBLE) { launchGlobalRefreshWithoutUpdateLabels = true; } else if (notification.getFeature() == TablePackage.Literals.DLINE__COLLAPSED) { analyseExpansion(dLine); } } else if (notifier instanceof DColumn) { DColumn dColumn = (DColumn) notifier; if (notification.getFeature() == TablePackage.Literals.DCOLUMN__ORDERED_CELLS) { launchGlobalRefreshWithUpdateLabels = true; } else if (notification.getFeature() == TablePackage.Literals.DCOLUMN__LABEL) { dColumnsToUpdateDirectly.add(dColumn); } else if (notification.getFeature() == TablePackage.Literals.DCOLUMN__VISIBLE) { dColumnsToVisibilityChanged.put(dColumn, dColumn.isVisible()); } else if (notification.getFeature() == TablePackage.Literals.DCOLUMN__WIDTH) { dColumnsWidthToUpdate.add(dColumn); } } else if (notification.getFeature() == TablePackage.Literals.DCELL__LABEL || notification.getFeature() == TablePackage.Literals.DCELL__CURRENT_STYLE && notifier instanceof DCell) { DCell dCell = (DCell) notifier; DLine dLine = dCell.getLine(); if (dLine != null) { toUpdateInViewer.add(dLine); } } else if (isDTableElementStyleAttributeChange(notification)) { DTableElementStyle dTableElementStyle = (DTableElementStyle) notifier; EObject eContainer = dTableElementStyle.eContainer(); if (eContainer instanceof DCell) { DCell dCell = (DCell) eContainer; DLine dLine = dCell.getLine(); toUpdateInViewer.add(dLine); } else if (eContainer instanceof DLine) { toUpdateInViewer.add(eContainer); } else if (eContainer instanceof DColumn) { DColumn dColumn = (DColumn) eContainer; toRefreshInViewerWithUpdateLabels.add(dColumn.getTable()); } } else if (notification.getNotifier() instanceof DCellStyle && isRGBValuesChange(notification)) { DCellStyle dCellStyle = (DCellStyle) notification.getNotifier(); EObject dCellStyleContainer = dCellStyle.eContainer(); if (dCellStyleContainer instanceof DCell) { DCell dCell = (DCell) dCellStyleContainer; DLine dLine = dCell.getLine(); if (dLine != null) { toUpdateInViewer.add(dLine); } } } }
@Override public void notifyChanged(Notification notification) { logger.trace("[Source: " + derivedFeature.getName() + "] New notification: " + notification); for (DependentFeaturePath path : featurePaths) { if (notification.getFeature().equals(path.getNavigationFeature())) { logger.trace("Handling notification."); switch (notification.getEventType()) { case Notification.SET: EObject newValue = (EObject) notification.getNewValue(); EObject tempOldValue = (EObject) notification.getOldValue(); if (tempOldValue != null) { tempOldValue.eAdapters().remove(path.getDependantAdapter()); } else { logger.debug("[DerivedFeatureAdapter] oldValue is not set"); } if (newValue != null) { newValue.eAdapters().add(path.getDependantAdapter()); } else { logger.debug("[DerivedFeatureAdapter] new value is not set"); } break; case Notification.ADD: EObject added = (EObject) notification.getNewValue(); added.eAdapters().add(path.getDependantAdapter()); break; case Notification.ADD_MANY: EObject newValueCollection = (EObject) notification.getNewValue(); for (Object newElement : (Collection<?>) newValueCollection) { ((Notifier) newElement).eAdapters().add(path.getDependantAdapter()); } break; case Notification.REMOVE: EObject removed = (EObject) notification.getOldValue(); removed.eAdapters().remove(path.getDependantAdapter()); break; case Notification.REMOVE_MANY: EObject oldValueCollection = (EObject) notification.getOldValue(); for (Object oldElement : (Collection<?>) oldValueCollection) { ((Notifier) oldElement).eAdapters().remove(path.getDependantAdapter()); } break; case Notification.UNSET: EObject unset = (EObject) notification.getOldValue(); unset.eAdapters().remove(path.getDependantAdapter()); break; case Notification.CREATE: case Notification.MOVE: // currently no support for ordering case Notification.RESOLVE: // TODO is it safe to ignore all of them? case Notification.REMOVING_ADAPTER: break; default: logger.debug( "[DerivedFeatureAdapter] Unhandled notification: " + notification.getEventType()); return; // No notification } refreshDerivedFeature(); } } if (localFeatures.contains(notification.getFeature())) { logger.trace("Handling notification."); refreshDerivedFeature(); } }
@Override public void notifyChanged(Notification msg) { switch (msg.getFeatureID(Map.class)) { case ProjectPackage.MAP__ABSTRACT: notifyMapListeners( new MapEvent(map, MapEventType.ABSTRACT, msg.getNewValue(), msg.getOldValue())); break; case ProjectPackage.MAP__COLOR_PALETTE: notifyMapListeners( new MapEvent(map, MapEventType.COLOR_PALETTE, msg.getNewValue(), msg.getOldValue())); break; case ProjectPackage.MAP__COLOUR_SCHEME: notifyMapListeners( new MapEvent(map, MapEventType.COLOUR_SCHEME, msg.getNewValue(), msg.getOldValue())); break; case ProjectPackage.MAP__COMMAND_STACK: notifyMapListeners( new MapEvent(map, MapEventType.MAP_COMMAND, msg.getNewValue(), msg.getOldValue())); break; case ProjectPackage.MAP__EDIT_MANAGER_INTERNAL: notifyMapListeners( new MapEvent(map, MapEventType.EDIT_MANAGER, msg.getNewValue(), msg.getOldValue())); break; case ProjectPackage.MAP__LAYER_FACTORY: notifyMapListeners( new MapEvent(map, MapEventType.LAYER_FACTORY, msg.getNewValue(), msg.getOldValue())); break; case ProjectPackage.MAP__NAME: notifyMapListeners( new MapEvent(map, MapEventType.NAME, msg.getNewValue(), msg.getOldValue())); break; case ProjectPackage.MAP__NAV_COMMAND_STACK: notifyMapListeners( new MapEvent(map, MapEventType.NAV_COMMAND, msg.getNewValue(), msg.getOldValue())); break; case ProjectPackage.MAP__PROJECT_INTERNAL: notifyMapListeners( new MapEvent(map, MapEventType.PROJECT, msg.getNewValue(), msg.getOldValue())); break; case ProjectPackage.MAP__RENDER_MANAGER_INTERNAL: notifyMapListeners( new MapEvent(map, MapEventType.RENDER_MANAGER, msg.getNewValue(), msg.getOldValue())); break; case ProjectPackage.MAP__VIEWPORT_MODEL_INTERNAL: notifyMapListeners( new MapEvent(map, MapEventType.VIEWPORT_MODEL, msg.getNewValue(), msg.getOldValue())); break; default: break; } }
public void notifyChanged(Notification notification) { int type = notification.getEventType(); int featureId = notification.getFeatureID(CoremodelPackage.class); if (notification.getNotifier() instanceof CoreModel) { if (type == Notification.REMOVE) switch (featureId) { case CoremodelPackage.CORE_MODEL__COMPONENTS: if (getCastedVisualModel().getDiagram() != null && notification.getOldValue() == getCastedSemanticModel()) appendToLastAndExecuteCommand(getDeleteComponentCommand()); case CoremodelPackage.CORE_MODEL__STEREOTYPES: if (notification.getOldValue() == getCastedSemanticModel().getStereotype()) { updateStereotypeName(getCastedFigure()); refreshVisuals(); } } return; } if (notification.getNotifier() instanceof Stereotype) { if (type == Notification.SET && featureId == CoremodelPackage.STEREOTYPE__NAME) { updateStereotypeName(getCastedFigure()); refreshVisuals(); } return; } if (notification.getNotifier() instanceof Responsibility) { if (type == Notification.SET && featureId == CoremodelPackage.RESPONSIBILITY__NAME) { updateResponsibilities(getCastedFigure()); refreshVisuals(); } return; } if (notification.getNotifier() instanceof ComponentModel) { switch (type) { case Notification.ADD: if (featureId == CoremodelPackage.COMPONENT_MODEL__FEATURES) { ((Responsibility) notification.getNewValue()).eAdapters().add(this); updateResponsibilities(getCastedFigure()); refreshVisuals(); } break; case Notification.REMOVE: if (featureId == CoremodelPackage.COMPONENT_MODEL__FEATURES) { ((Responsibility) notification.getOldValue()).eAdapters().remove(this); updateResponsibilities(getCastedFigure()); refreshVisuals(); } if (featureId == CoremodelPackage.COMPONENT_MODEL__OWNED_PORTS) notifyChildren(notification); break; case Notification.SET: switch (featureId) { case CoremodelPackage.COMPONENT_MODEL__NAME: getCastedFigure().setText(getCastedSemanticModel().getName()); refreshVisuals(); break; case CoremodelPackage.COMPONENT_MODEL__STEREOTYPE: updateStereotypeName(getCastedFigure()); refreshVisuals(); break; } } return; } // VisualModel featureId = notification.getFeatureID(EditormodelPackage.class); switch (type) { case Notification.ADD: case Notification.REMOVE: if (featureId == EditormodelPackage.VISUAL_MODEL__CHILDREN) refreshVisuals(); break; case Notification.SET: if (featureId == EditormodelPackage.VISUAL_MODEL__DETAIL_LEVEL) { getCastedFigure() .showResponsibilites(notification.getNewIntValue() == VisualModel.HIGH_DETAIL); refreshVisuals(); } break; } super.notifyChanged(notification); }