| /******************************************************************************* |
| * Copyright (c) 2005, 2012 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.bpel.ui.commands.util; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.bpel.common.extension.model.Extension; |
| import org.eclipse.bpel.common.extension.model.ExtensionMap; |
| import org.eclipse.bpel.common.extension.model.ExtensionmodelPackage; |
| import org.eclipse.bpel.common.extension.model.impl.ExtensionImpl; |
| import org.eclipse.bpel.common.extension.model.impl.ExtensionMapImpl; |
| import org.eclipse.bpel.common.extension.model.notify.ExtensionModelNotification; |
| import org.eclipse.bpel.ui.BPELEditor; |
| import org.eclipse.bpel.ui.BPELUIPlugin; |
| import org.eclipse.bpel.ui.util.BPELUtil; |
| import org.eclipse.bpel.ui.util.ModelHelper; |
| import org.eclipse.emf.common.notify.Adapter; |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.common.notify.Notifier; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EStructuralFeature; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.resource.ResourceSet; |
| import org.eclipse.emf.ecore.util.EContentAdapter; |
| import org.eclipse.core.runtime.Assert; |
| |
| |
| /** |
| * Records the exact changes made to the model during each 'user change'. This |
| * history information can be used to Undo and Redo user changes automatically. |
| */ |
| public class ModelAutoUndoRecorder implements IAutoUndoRecorder { |
| |
| protected Set<Resource> ignoreResources = new HashSet<Resource>(); |
| |
| protected boolean VERBOSE_DEBUG = false; |
| protected boolean DEBUG = false || VERBOSE_DEBUG; |
| |
| protected Set<Notifier> listenerRootSet = new HashSet<Notifier>(); |
| |
| protected List<Object> currentChangeList = null; |
| |
| /** |
| * IUndoHandler to undo/redo a change to the ExtensionMap (adding, changing or |
| * removing an extension entry). |
| */ |
| class EMapSingleChangeHandler implements IUndoHandler { |
| ExtensionMap fExtensionMap; |
| EObject fExtendedObject, fOldExtension, fNewExtension; |
| |
| /** |
| * @param extensionMap |
| * @param extendedObject |
| * @param oldExtension |
| * @param newExtension |
| */ |
| public EMapSingleChangeHandler(ExtensionMap extensionMap, EObject extendedObject, |
| EObject oldExtension, EObject newExtension) |
| { |
| this.fExtensionMap = extensionMap; this.fExtendedObject = extendedObject; |
| this.fOldExtension = oldExtension; this.fNewExtension = newExtension; |
| } |
| /** |
| * @see org.eclipse.bpel.ui.commands.util.IUndoHandler#undo() |
| */ |
| public void undo() { |
| if (DEBUG) System.out.println("undo single change"); //$NON-NLS-1$ |
| if (fOldExtension == null) { |
| if (fExtensionMap.containsKey(fExtendedObject)) { |
| fExtensionMap.remove(fExtendedObject); |
| } |
| } else { |
| fExtensionMap.put(fExtendedObject, fOldExtension); |
| } |
| } |
| /** |
| * @see org.eclipse.bpel.ui.commands.util.IUndoHandler#redo() |
| */ |
| public void redo() { |
| if (DEBUG) System.out.println("redo single change"); //$NON-NLS-1$ |
| if (fNewExtension == null) { |
| if (fExtensionMap.containsKey(fExtendedObject)) { |
| fExtensionMap.remove(fExtendedObject); |
| } |
| } else { |
| fExtensionMap.put(fExtendedObject, fNewExtension); |
| } |
| } |
| } |
| |
| /** |
| * IUndoHandler to undo/redo a bulk change to the ExtensionMap (i.e. putAll or clear). |
| */ |
| class EMapMultiChangeHandler implements IUndoHandler { |
| ExtensionMap fExtensionMap; |
| Map fOldContents, fNewContents; |
| |
| /** |
| * @param extensionMap |
| * @param oldContents |
| * @param newContents |
| */ |
| public EMapMultiChangeHandler(ExtensionMap extensionMap, Map oldContents, Map newContents) { |
| this.fExtensionMap = extensionMap; |
| this.fOldContents = oldContents; |
| this.fNewContents = newContents; |
| } |
| /** |
| * @see org.eclipse.bpel.ui.commands.util.IUndoHandler#undo() |
| */ |
| public void undo() { |
| if (DEBUG) System.out.println("undo multi-change"); //$NON-NLS-1$ |
| fExtensionMap.clear(); |
| if (fOldContents != null) fExtensionMap.putAll(fOldContents); |
| } |
| |
| /** |
| * @see org.eclipse.bpel.ui.commands.util.IUndoHandler#redo() |
| */ |
| public void redo() { |
| if (DEBUG) System.out.println("redo multi-change"); //$NON-NLS-1$ |
| fExtensionMap.clear(); |
| if (fNewContents != null) { |
| fExtensionMap.putAll(fNewContents); |
| } |
| } |
| } |
| |
| class ModelAutoUndoAdapter extends EContentAdapter { |
| |
| protected ModelAutoUndoRecorder getAutoUndoRecorder() { return ModelAutoUndoRecorder.this; } |
| |
| /** |
| * Handles a containment change by adding and removing the adapter as appropriate. |
| */ |
| @Override |
| protected void handleContainment(Notification notification) { |
| switch (notification.getEventType()) { |
| case Notification.SET: |
| case Notification.UNSET: { |
| Notifier newValue = (Notifier)notification.getNewValue(); |
| if (newValue != null && !newValue.eAdapters().contains(this)) { |
| newValue.eAdapters().add(this); |
| } |
| break; |
| } |
| case Notification.ADD: { |
| Notifier newValue = (Notifier) notification.getNewValue(); |
| if (newValue != null && !newValue.eAdapters().contains(this)) { |
| newValue.eAdapters().add(this); |
| } |
| break; |
| } |
| case Notification.ADD_MANY: { |
| Collection<Notifier> newValues = (Collection<Notifier>) notification.getNewValue(); |
| for(Notifier next : newValues) { |
| if (!next.eAdapters().contains(this)) { |
| next.eAdapters().add(this); |
| } |
| } |
| break; |
| } |
| |
| //if (n.getNotifier() instanceof ResourceSet) return; |
| } |
| |
| } |
| |
| /** |
| * note: super implementation doesn't handle overlapping targets very well |
| * |
| * @see org.eclipse.emf.ecore.util.EContentAdapter#setTarget(org.eclipse.emf.common.notify.Notifier) |
| */ |
| @Override |
| public void setTarget(Notifier aTarget) { |
| this.target = aTarget; |
| |
| List<?> contents = null; |
| |
| if (target instanceof EObject) { |
| contents = ((EObject)aTarget).eContents(); |
| } else if (target instanceof ResourceSet) { |
| contents = ((ResourceSet)target).getResources(); |
| } else if (target instanceof Resource) { |
| contents = ((Resource)target).getContents(); |
| } else { |
| return ; |
| } |
| |
| for (Object next : contents) { |
| Notifier notifier = (Notifier) next ; |
| if (!notifier.eAdapters().contains(this)) { |
| notifier.eAdapters().add(this); |
| } |
| } |
| } |
| |
| /** |
| * @see org.eclipse.emf.ecore.util.EContentAdapter#notifyChanged(org.eclipse.emf.common.notify.Notification) |
| */ |
| |
| @Override |
| public void notifyChanged(Notification n) { |
| switch (n.getEventType()) { |
| case Notification.ADD_MANY: |
| case Notification.REMOVE_MANY: |
| case Notification.ADD: |
| case Notification.REMOVE: |
| case Notification.SET: |
| case Notification.UNSET: |
| case Notification.MOVE: |
| if (!ignoreChange(n)) { |
| recordChange(n); |
| } |
| } |
| super.notifyChanged(n); |
| } |
| |
| } |
| |
| protected ModelAutoUndoAdapter modelAutoUndoAdapter = new ModelAutoUndoAdapter(); |
| |
| protected boolean ignoreChange(Notification n) { |
| Resource res = null; |
| if (n.getNotifier() instanceof ResourceSet) { |
| // don't record resources being added (usually this is due to demand-loading). |
| // TODO: what about resources being deleted? Is this a problem? |
| return true; |
| } |
| if (n.getNotifier() instanceof Resource) { |
| res = (Resource)n.getNotifier(); |
| } else if (n.getNotifier() instanceof EObject) { |
| res = ((EObject)n.getNotifier()).eResource(); |
| } else { |
| // we won't know how to undo this notification anyways, so ignore it. |
| // TODO: this should never occur |
| return true; |
| } |
| if (res != null && ignoreResources.contains(res)) { |
| if (VERBOSE_DEBUG) System.out.println("IGNORING -- "+ //$NON-NLS-1$ |
| (n.isTouch()?"<t> " : "CHG: ")+BPELUtil.debug(n)); //$NON-NLS-1$ //$NON-NLS-2$ |
| return true; |
| } |
| return false; |
| } |
| |
| protected void recordChange(Notification n) { |
| if (currentChangeList == null) { |
| // ignore. |
| //System.out.println("IGNORING!! -- "+ //$NON-NLS-1$ |
| // (n.isTouch()?"<t> " : "CHG: ")+BPELUtil.debug(n)); //$NON-NLS-1$ //$NON-NLS-2$ |
| return; |
| } |
| |
| // hackedy-hack hack. |
| if (n.getNotifier() instanceof Extension) { |
| // ignore (these are an implementation detail of ExtensionMapImpl). |
| return; |
| } |
| if (n.getNotifier() instanceof ExtensionMapImpl) { |
| // ignore "real" events concerning the EXTENSION_MAP__EXTENSIONS list. |
| // record only "semantic" events (tagged with EXTENSION_MAP__EXTENSIONS_KEY). |
| // those represent put() and remove() calls to the extension map. |
| if (n.getFeatureID(ExtensionMap.class) == ExtensionmodelPackage.EXTENSION_MAP__EXTENSIONS) { |
| if (DEBUG) System.out.println("ignoring impl notification: "+BPELUtil.debug(n)); //$NON-NLS-1$ |
| return; |
| } |
| if (n instanceof ExtensionModelNotification) { |
| // A semantic notification just for us. Thanks Sebastian! |
| ExtensionModelNotification emn = (ExtensionModelNotification)n; |
| ExtensionMap extensionMap = (ExtensionMap)n.getNotifier(); |
| // handle put() |
| if (n.getFeatureID(ExtensionMap.class) == ExtensionModelNotification.EXTENSION_MAP_PUT) { |
| EObject object = (EObject)emn.getArg1(); |
| EObject oldExt = (EObject)emn.getArg2(); |
| EObject newExt = extensionMap.get(object); |
| if (DEBUG) System.out.println("record PUT: "+BPELUtil.debugObject(object)+": "+ //$NON-NLS-1$ //$NON-NLS-2$ |
| BPELUtil.debugObject(oldExt)+" ==> "+BPELUtil.debugObject(newExt)); //$NON-NLS-1$ |
| currentChangeList.add(new EMapSingleChangeHandler(extensionMap, object, oldExt, newExt)); |
| } else if (n.getFeatureID(ExtensionMap.class) == ExtensionModelNotification.EXTENSION_MAP_REMOVE) { |
| EObject object = (EObject)emn.getArg1(); |
| EObject oldExt = (EObject)emn.getArg2(); |
| EObject newExt = null; |
| if (DEBUG) System.out.println("record REMOVE: "+BPELUtil.debugObject(object)+": "+ //$NON-NLS-1$ //$NON-NLS-2$ |
| BPELUtil.debugObject(oldExt)+" ==> "+BPELUtil.debugObject(newExt)); //$NON-NLS-1$ |
| currentChangeList.add(new EMapSingleChangeHandler(extensionMap, object, oldExt, newExt)); |
| } else if (n.getFeatureID(ExtensionMap.class) == ExtensionModelNotification.EXTENSION_MAP_PUTALL) { |
| Map oldContents = (Map)emn.getArg1(); |
| Map newContents = new HashMap(extensionMap); |
| if (DEBUG) System.out.println("record PUTALL: "+oldContents.size()+" items ==> "+newContents.size()+" items"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| currentChangeList.add(new EMapMultiChangeHandler(extensionMap, oldContents, newContents)); |
| } else if (n.getFeatureID(ExtensionMap.class) == ExtensionModelNotification.EXTENSION_MAP_CLEAR) { |
| Map oldContents = (Map)emn.getArg1(); |
| Map newContents = Collections.EMPTY_MAP; |
| if (DEBUG) System.out.println("record CLEAR: "+oldContents.size()+" items ==> "+newContents.size()+" items"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| currentChangeList.add(new EMapMultiChangeHandler(extensionMap, oldContents, newContents)); |
| } else { |
| if (DEBUG) System.out.println("WARNING: ModelAutoUndoRecorder.recordChange(): unknown event type from ExtensionMapImpl"); //$NON-NLS-1$ |
| } |
| return; |
| } |
| if (DEBUG) System.out.println("ExtensionMap: "+BPELUtil.debug(n)); //$NON-NLS-1$ |
| } |
| |
| // handle all other notifications. |
| if (DEBUG) System.out.println((n.isTouch()?"<t> " : "CHG: ")+BPELUtil.debug(n)); //$NON-NLS-1$ //$NON-NLS-2$ |
| currentChangeList.add(n); |
| } |
| |
| /** |
| * @param resource |
| */ |
| public void startIgnoringResource(Resource resource) { |
| ignoreResources.add(resource); |
| } |
| /** |
| * @param resource |
| */ |
| |
| public void stopIgnoringResource(Resource resource) { |
| ignoreResources.remove(resource); |
| } |
| |
| /** |
| * @see org.eclipse.bpel.ui.commands.util.IAutoUndoRecorder#startChanges(java.util.List) |
| */ |
| @SuppressWarnings("nls") |
| public void startChanges( List<Object> modelRoots) { |
| if (VERBOSE_DEBUG) { |
| System.out.println("startChanges()"); //$NON-NLS-1$ |
| } |
| if (currentChangeList != null) { |
| throw new IllegalStateException("startChages(): pending current change list"); |
| } |
| currentChangeList = new ArrayList<Object>(); |
| addModelRoots(modelRoots); |
| } |
| |
| /** |
| * @see org.eclipse.bpel.ui.commands.util.IAutoUndoRecorder#finishChanges() |
| */ |
| @SuppressWarnings("nls") |
| public List<Object> finishChanges() { |
| if (currentChangeList == null) { |
| throw new IllegalStateException("Nothing to finish, currentChangeList is committed"); |
| } |
| if (VERBOSE_DEBUG) System.out.println("finishChanges(): "+currentChangeList.size()); //$NON-NLS-1$ |
| List<Object> result = currentChangeList; |
| currentChangeList = null; |
| clearModelRoots(); |
| return result; |
| } |
| |
| protected void addModelRoot(Object root) { |
| // TODO: TEMPORARY HACK!! This is to work around the problems with |
| // duplicate/overlapping adapters when we use non-resource roots. |
| // I don't know what the real solution is for this problem. |
| if (root instanceof EObject) { root = ((EObject)root).eResource(); } |
| |
| if (root instanceof Notifier) { |
| List<Adapter> adapters = ((Notifier)root).eAdapters(); |
| // careful: only add adapter if it hasn't already been added, or duplicate |
| // notifications will be recorded and things will break. |
| if (!adapters.contains(modelAutoUndoAdapter)) { |
| if (VERBOSE_DEBUG) System.out.println(" >>> Add Root: "+root); //$NON-NLS-1$ |
| adapters.add(modelAutoUndoAdapter); |
| listenerRootSet.add((Notifier) root); |
| } else { |
| if (VERBOSE_DEBUG) System.out.println(" >>> Overlapping Root: "+root); //$NON-NLS-1$ |
| } |
| } |
| } |
| |
| /** |
| * @see org.eclipse.bpel.ui.commands.util.IAutoUndoRecorder#addModelRoots(java.util.List) |
| */ |
| public void addModelRoots(List<Object> modelRoots) { |
| boolean gotExtensionMap = false; |
| |
| for(Object root : modelRoots) { |
| addModelRoot(root); |
| // HACK! treat the ExtensionMap as a model root |
| if (!gotExtensionMap) { |
| BPELEditor bpelEditor = ModelHelper.getBPELEditor(root); |
| if (bpelEditor != null) { |
| addModelRoot(bpelEditor.getExtensionMap()); |
| } |
| gotExtensionMap = true; |
| } |
| } |
| } |
| |
| protected void clearModelRoots() { |
| if (VERBOSE_DEBUG) System.out.println(" <<< Clear Model Roots"); //$NON-NLS-1$ |
| |
| for (Notifier notifier : listenerRootSet) { |
| // HACK! |
| while ((notifier instanceof EObject) && ((EObject)notifier).eContainer().eAdapters().contains(modelAutoUndoAdapter)) { |
| notifier = ((EObject)notifier).eContainer(); |
| } |
| notifier.eAdapters().remove(modelAutoUndoAdapter); |
| } |
| listenerRootSet.clear(); |
| } |
| |
| /** |
| * @see org.eclipse.bpel.ui.commands.util.IAutoUndoRecorder#isRecordingChanges() |
| */ |
| public boolean isRecordingChanges() { |
| return (currentChangeList != null); |
| } |
| |
| /** |
| * @see org.eclipse.bpel.ui.commands.util.IAutoUndoRecorder#insertUndoHandler(org.eclipse.bpel.ui.commands.util.IUndoHandler) |
| */ |
| public void insertUndoHandler(IUndoHandler undoHandler) { |
| if (currentChangeList != null) { |
| currentChangeList.add(undoHandler); |
| } else { |
| if (DEBUG) System.out.println("WARNING: insertUndoHandler() while not recording changes!"); //$NON-NLS-1$ |
| } |
| } |
| |
| protected void undoNotification(Notification n) { |
| List list; |
| |
| // hack to work around side-effect ordering problems! |
| if (n.getNotifier() instanceof ExtensionImpl) { |
| if (DEBUG) System.out.println("ignore ExtensionImpl change: "+BPELUtil.debug(n)); //$NON-NLS-1$ |
| return; |
| } |
| |
| if (DEBUG) System.out.println((n.isTouch()? "<t> " : "undo: ")+BPELUtil.debug(n)); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| EStructuralFeature feature = (EStructuralFeature)n.getFeature(); |
| |
| if (n.getNotifier() instanceof EObject) { |
| EObject obj = (EObject)n.getNotifier(); |
| |
| switch (n.getEventType()) { |
| case Notification.ADD_MANY: |
| case Notification.REMOVE_MANY: |
| Assert.isTrue(feature.isMany()); |
| obj.eSet(feature, n.getOldValue()); |
| break; |
| |
| case Notification.ADD: |
| Assert.isTrue(feature.isMany()); |
| list = (List)obj.eGet(feature, true); |
| try { |
| list.remove(n.getPosition()); |
| } catch (ClassCastException e) { |
| // it shouldn't be happening but there |
| // is a bug in the WSDL model |
| if (DEBUG) e.printStackTrace(); |
| } |
| break; |
| |
| case Notification.REMOVE: |
| Assert.isTrue(feature.isMany()); |
| list = (List)obj.eGet(feature, true); |
| if (n.getPosition() == Notification.NO_INDEX) { |
| list.add(n.getOldValue()); |
| } else { |
| list.add(n.getPosition(), n.getOldValue()); |
| } |
| break; |
| |
| case Notification.SET: |
| case Notification.UNSET: |
| if (feature.isMany() && n.getPosition() >= 0) { |
| list = (List)obj.eGet(feature, true); |
| list.set(n.getPosition(), n.getOldValue()); |
| } else if (n.wasSet()) { |
| obj.eSet(feature, n.getOldValue()); |
| } else { |
| obj.eUnset(feature); |
| } |
| break; |
| |
| case Notification.MOVE: |
| Assert.isTrue(feature.isMany()); |
| // TODO: does this even work?! |
| obj.eSet(feature, n.getOldValue()); |
| break; |
| |
| default: throw new IllegalStateException(); |
| } |
| |
| } else { |
| // TODO: adding and removing things from resources ?? |
| System.err.println("undoNotification on non-EObject not implemented yet"); //$NON-NLS-1$ |
| (new Exception()).printStackTrace(System.err); |
| } |
| } |
| |
| // TODO: this stuff should be refactored/moved somewhere else. |
| protected void redoNotification(Notification n) { |
| List<Object> list; |
| if (DEBUG) System.out.println((n.isTouch()? "<t> " : "redo: ")+BPELUtil.debug(n)); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| EStructuralFeature feature = (EStructuralFeature)n.getFeature(); |
| |
| |
| if (n.getNotifier() instanceof EObject) { |
| EObject obj = (EObject)n.getNotifier(); |
| |
| switch (n.getEventType()) { |
| case Notification.ADD_MANY: |
| case Notification.REMOVE_MANY: |
| Assert.isTrue(feature.isMany()); |
| obj.eSet(feature, n.getNewValue()); |
| break; |
| |
| case Notification.ADD: |
| Assert.isTrue(feature.isMany()); |
| list = (List)obj.eGet(feature, true); |
| list.add(n.getPosition(), n.getNewValue()); |
| break; |
| |
| case Notification.REMOVE: |
| Assert.isTrue(feature.isMany()); |
| list = (List)obj.eGet(feature, true); |
| if (n.getPosition() == Notification.NO_INDEX) { |
| list.remove(n.getOldValue()); |
| } else { |
| list.remove(n.getPosition()); |
| } |
| break; |
| |
| case Notification.SET: |
| if (feature.isMany() && n.getPosition() >= 0) { |
| list = (List)obj.eGet(feature, true); |
| list.set(n.getPosition(), n.getNewValue()); |
| } else { |
| obj.eSet(feature, n.getNewValue()); |
| } |
| break; |
| |
| case Notification.UNSET: |
| obj.eUnset(feature); |
| break; |
| |
| case Notification.MOVE: |
| Assert.isTrue(feature.isMany()); |
| // TODO: does this even work?! |
| obj.eSet(feature, n.getNewValue()); |
| break; |
| |
| default: throw new IllegalStateException(); |
| } |
| |
| } else { |
| // TODO: adding and removing things from resources ?? |
| System.err.println("redoNotification on non-EObject not implemented yet"); //$NON-NLS-1$ |
| (new Exception()).printStackTrace(System.err); |
| } |
| } |
| |
| /** |
| * @see org.eclipse.bpel.ui.commands.util.IAutoUndoRecorder#undo(java.util.List) |
| */ |
| public void undo (List<Object> changes) { |
| if (VERBOSE_DEBUG) System.out.println("UNDOING "+changes.size()+" changes"); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| for (int i = changes.size(); --i >= 0; ) { |
| Object change = changes.get(i); |
| if (change instanceof Notification) { |
| try { |
| undoNotification((Notification)change); |
| } catch (RuntimeException e) { |
| BPELUIPlugin.log(e); |
| } |
| } else if (change instanceof IUndoHandler) { |
| ((IUndoHandler)change).undo(); |
| } |
| } |
| } |
| |
| /** |
| * @see org.eclipse.bpel.ui.commands.util.IAutoUndoRecorder#redo(java.util.List) |
| */ |
| public void redo (List<Object> changes) { |
| if (VERBOSE_DEBUG) System.out.println("REDOING "+changes.size()+" changes"); //$NON-NLS-1$ //$NON-NLS-2$ |
| for(Object change : changes) { |
| if (change instanceof Notification) { |
| try { |
| redoNotification((Notification)change); |
| } catch (RuntimeException e) { |
| BPELUIPlugin.log(e); |
| } |
| } else if (change instanceof IUndoHandler) { |
| ((IUndoHandler)change).redo(); |
| } |
| } |
| } |
| |
| /** |
| * @param notifier |
| * @return the undo recorder from the adapter. |
| */ |
| |
| |
| public static IAutoUndoRecorder getFromAdapter (Notifier notifier) { |
| for(Adapter a : notifier.eAdapters()) { |
| if (a instanceof ModelAutoUndoAdapter) { |
| return ((ModelAutoUndoAdapter)a).getAutoUndoRecorder(); |
| } |
| } |
| return null; |
| } |
| } |
