org.eclipse.gmf.runtime.diagram.core/src/org/eclipse/gmf/runtime/diagram/core/util/ViewRefactorHelper.java - gmf-runtime/org.eclipse.gmf-runtime - Git at Google

 /******************************************************************************
  * Copyright (c) 2005, 2009 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.gmf.runtime.diagram.core.util;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

 import org.eclipse.emf.common.util.EMap;
 import org.eclipse.emf.ecore.EAnnotation;
 import org.eclipse.emf.ecore.EAttribute;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EReference;
 import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.emf.ecore.EcorePackage;
 import org.eclipse.gmf.runtime.diagram.core.preferences.PreferencesHint;
 import org.eclipse.gmf.runtime.diagram.core.services.ViewService;
 import org.eclipse.gmf.runtime.emf.core.util.EMFCoreUtil;
 import org.eclipse.gmf.runtime.emf.core.util.EObjectAdapter;
 import org.eclipse.gmf.runtime.emf.type.core.commands.DestroyElementCommand;
 import org.eclipse.gmf.runtime.notation.Diagram;
 import org.eclipse.gmf.runtime.notation.Edge;
 import org.eclipse.gmf.runtime.notation.FilteringStyle;
 import org.eclipse.gmf.runtime.notation.Guide;
 import org.eclipse.gmf.runtime.notation.Node;
 import org.eclipse.gmf.runtime.notation.NotationPackage;
 import org.eclipse.gmf.runtime.notation.SortingStyle;
 import org.eclipse.gmf.runtime.notation.Style;
 import org.eclipse.gmf.runtime.notation.View;

 /**
  * A helper class to perform notational refactoring based on a semantic refactoring.
  * The helper provides a typical or generic implementation of the refactoring operation
  * based on the Notation metamodel. However, if the notations being refactoring use other
  * extended notation metamodels, the implementation of this helper class might need to
  * be extended. This can be achieved by directly subclassing this helper class.
  *
  * @author melaasar - Maged Elaasar
  */
 public class ViewRefactorHelper {

 	private PreferencesHint preferencesHint;

 	/**
 	 * Constructs a new <code>ViewRefactorHelper</code> with a given preferences hint
 	 */
 	public ViewRefactorHelper() {
 		this(PreferencesHint.USE_DEFAULTS);
 	}

 	/**
 	 * Constructs a new <code>ViewRefactorHelper</code> with a given preferences hint
 	 *
 	 * @param preferencesHint The preferences hint to be used to perform refactoring
 	 */
 	public ViewRefactorHelper(PreferencesHint preferencesHint) {
 		this.preferencesHint = preferencesHint;
 	}

 	/**
 	 * Returns the preferences hint
 	 *
 	 * @return The preferences hint
 	 */
 	public PreferencesHint getPreferencesHint() {
 		return preferencesHint;
 	}

 	/**
 	 * Refactors the notations associated with the old element to make them
 	 * consistent with the new element.
 	 *
 	 * @param oldElement The semantic element being refactored
 	 * @param newElement The semantic element that replaces the refactored one
 	 */
 	public void refactor(EObject oldElement, EObject newElement) {

 		// refactor views
 		Collection views = getReferencingViews(oldElement);
 		for (Iterator i = views.iterator(); i.hasNext();) {
 			View oldView = (View) i.next();
 			if (oldView instanceof Node) {
 				refactorNode((Node)oldView, newElement);
 			} else if (oldView instanceof Edge) {
 				refactorEdge((Edge)oldView, newElement);
 			} else if (oldView instanceof Diagram) {
 				refactorDiagram((Diagram)oldView, newElement);
 			}
 			DestroyElementCommand.destroy(oldView);
 		}

 		// refactor filtering styles
 		Collection filterStyles = EMFCoreUtil.getReferencers(oldElement, new EReference[]{NotationPackage.eINSTANCE.getFilteringStyle_FilteredObjects()});
 		for (Iterator i = filterStyles.iterator(); i.hasNext();) {
 			List filteredObjects = ((FilteringStyle) i.next()).getFilteredObjects();
 			if (!filteredObjects.contains(oldElement))
 				filteredObjects.add(filteredObjects.indexOf(oldElement), newElement);
 			filteredObjects.remove(oldElement);
 		}

 		// refactor sorting styles
 		Collection sortingStyles = EMFCoreUtil.getReferencers(oldElement, new EReference[]{NotationPackage.eINSTANCE.getSortingStyle_SortedObjects()});
 		for (Iterator i = sortingStyles.iterator(); i.hasNext();) {
 			List sortingObjects = ((SortingStyle) i.next()).getSortedObjects();
 			if (!sortingObjects.contains(oldElement))
 				sortingObjects.add(sortingObjects.indexOf(oldElement), newElement);
 			sortingObjects.remove(oldElement);
 		}
 	}

 	/**
 	 * Refactors an old node to a new one with the given new element
 	 *
 	 * @param oldNode The old node being refactored
 	 * @param newElement The replacing new element
 	 * @return A new refactored node
 	 */
 	protected Node refactorNode(Node oldNode, EObject newElement) {
 		if (oldNode.eContainingFeature() == NotationPackage.eINSTANCE.getView_PersistedChildren()) {
 			Node newNode = createNode(oldNode, newElement);

 			if (newNode != null) {
 				copyNodeFeatures(oldNode, newNode);
 				View container = (View) oldNode.eContainer();
 				container.getPersistedChildren().move(container.getPersistedChildren().indexOf(oldNode), newNode);
 				refactorGuides(oldNode, newNode);
 				return newNode;
 			}
 		}
 		return null;
 	}

 	/**
 	 * Refactors an old edge to a new one with the given new element
 	 *
 	 * @param oldEdge The old edge being refactored
 	 * @param newElement The replacing new element
 	 * @return A new refactored edge
 	 */
 	protected Edge refactorEdge(Edge oldEdge, EObject newElement) {
 		if (oldEdge.eContainingFeature() == NotationPackage.eINSTANCE.getDiagram_PersistedEdges()) {
 			Edge newEdge = createEdge(oldEdge, newElement);

 			if (newEdge != null) {
 				copyEdgeFeatures(oldEdge, newEdge);
 				Diagram container = (Diagram)oldEdge.eContainer();
 				container.getPersistedEdges().move(container.getPersistedEdges().indexOf(oldEdge), newEdge);
 				return newEdge;
 			}
 		}
 		return null;
 	}

 	/**
 	 * Refactors an old diagram to a new one with the given new element
 	 *
 	 * @param oldDiagram The old diagram being refactored
 	 * @param newElement The replacing new element
 	 * @return A new refactored diagram
 	 */
 	protected Diagram refactorDiagram(Diagram oldDiagram, EObject newElement) {
 		if (oldDiagram.eContainingFeature() == EcorePackage.eINSTANCE.getEAnnotation_Contents()) {
 			Diagram newDiagram = createDiagram(oldDiagram, newElement);

 			if (newDiagram != null) {
 				copyDiagramFeatures(oldDiagram, newDiagram);
 				EAnnotation container = (EAnnotation) oldDiagram.eContainer();
 				container.getContents().add(container.getContents().indexOf(oldDiagram), newDiagram);
 				refactorDiagramLinks(oldDiagram, newDiagram);
 				return newDiagram;
 			}
 		}
 		return null;
 	}

 	protected void refactorDiagramLinks(Diagram oldDiagram, Diagram newDiagram) {
 		Collection links = EMFCoreUtil.getReferencers(oldDiagram, new EReference[]{NotationPackage.eINSTANCE.getView_Element()});
 		for (Iterator i = links.iterator(); i.hasNext();) {
 			View view = (View) i.next();
 			view.setElement(newDiagram);
 		}
 	}

 	/**
 	 * Copies the notational features of the old node to the new node
 	 *
 	 * @param oldNode The old node to copy features from
 	 * @param newNode The new node to copy features to
 	 */
 	protected void copyNodeFeatures(Node oldNode, Node newNode) {
 		if (oldNode.eIsSet(NotationPackage.eINSTANCE.getNode_LayoutConstraint())) {
 			newNode.setLayoutConstraint(oldNode.getLayoutConstraint());
 		}
 		copyViewFeatures(oldNode, newNode);
 	}

 	/**
 	 * Copies the notational features of the old edge to the new edge
 	 *
 	 * @param oldEdge The old edge to copy features from
 	 * @param newEdge The new edge to copy features to
 	 */
 	protected void copyEdgeFeatures(Edge oldEdge, Edge newEdge) {
 		newEdge.setBendpoints(oldEdge.getBendpoints());
 		newEdge.setSourceAnchor(oldEdge.getSourceAnchor());
 		newEdge.setTargetAnchor(oldEdge.getTargetAnchor());
 		copyViewFeatures(oldEdge, newEdge);
 	}

 	/**
 	 * Copies the notational features of the old diagram to the new diagram
 	 *
 	 * @param oldDiagram The old diagram to copy features from
 	 * @param newDiagram The new diagram to copy features to
 	 */
 	protected void copyDiagramFeatures(Diagram oldDiagram, Diagram newDiagram) {
 		newDiagram.setName(oldDiagram.getName());
 		if (oldDiagram.eIsSet(NotationPackage.eINSTANCE.getDiagram_PersistedEdges())) {
 			newDiagram.getPersistedEdges().addAll(oldDiagram.getPersistedEdges());
 		}
 		copyViewFeatures(oldDiagram, newDiagram);
 	}

 	/**
 	 * Copies the notational features of the old view to the new view
 	 *
 	 * @param oldView The old view to copy features from
 	 * @param newView The new view to copy features to
 	 */
 	protected void copyViewFeatures(View oldView, View newView) {
 		copyViewAppearance(oldView, newView, new ArrayList());
 		if (oldView.eIsSet(NotationPackage.eINSTANCE.getView_SourceEdges())) {
 			newView.getSourceEdges().addAll(oldView.getSourceEdges());
 		}
 		if (oldView.eIsSet(NotationPackage.eINSTANCE.getView_TargetEdges())) {
 			newView.getTargetEdges().addAll(oldView.getTargetEdges());
 		}
 		copyViewChildren(oldView, newView);
 	}

 	/**
 	 * Copies the appearance of the old view to the new view.  Typically this means copying the visibility
 	 * and the styles of the root and it's children.
 	 *
 	 * @param oldView The old view to copy style features from
 	 * @param newView The new view to copy style features to
 	 * @param excludeStyles the <code>List</code> of <code>Style.eClass</code> types to exclude
 	 * from the copy operation.
 	 */
 	public void copyViewAppearance(View oldView, View newView, final List excludeStyles) {
 		newView.setVisible(oldView.isVisible());
 		copyViewStyles(oldView, newView, excludeStyles);
 		copyViewAppearanceProperties(oldView, newView, excludeStyles);

 		for (Iterator j = new ArrayList(oldView.getPersistedChildren()).iterator(); j.hasNext();) {
 			Node oldChildNode = (Node) j.next();
 			if (oldView.getElement() == oldChildNode.getElement() && oldChildNode.getType() != null) {
 				Node newChildNode = (Node) ViewUtil.getChildBySemanticHint(newView, oldChildNode.getType());
 				if (newChildNode != null) {
 					copyViewAppearance(oldChildNode, newChildNode, excludeStyles);
 				}
 			}
 		}
 	}

 	private void copyViewAppearanceProperties(View oldView, View newView, final List excludeStyles) {
 		for (EAttribute attribute : oldView.eClass().getEAllAttributes()) {
 			EClass containingEClass = attribute.getEContainingClass();
 			if (NotationPackage.Literals.STYLE.isSuperTypeOf(containingEClass) && !excludeStyles.contains(containingEClass)) {
 				EObject newViewStyle = newView.getStyle(containingEClass);
 				if (newViewStyle != null) {
 					if (!oldView.eIsSet(attribute)) {
 						if (newViewStyle.eIsSet(attribute)) {
 							newViewStyle.eUnset(attribute);
 						}
 					} else {
 						newViewStyle.eSet(attribute, oldView.eGet(attribute));
 					}
 				}
 			}
 		}
 	}

 	/**
 	 * Copies the style features of the old view to the new view
 	 *
 	 * @param oldView The old view to copy style features from
 	 * @param newView The new view to copy style features to
 	 */
 	protected void copyViewStyles(View oldView, View newView) {
 		copyViewStyles(oldView, newView, new ArrayList());
 	}

 	/**
 	 * Copies all styles feature from the old view to the new view
 	 *
 	 * @param oldView The old view to copy style features from
 	 * @param newView The new view to copy style features to
 	 * @param excludeStyles the <code>List</code> of <code>Style.eClass</code> types to exclude
 	 * from the copy operation.
 	 */
 	protected void copyViewStyles(View oldView, View newView, List excludeStyles) {
 		if (oldView.eIsSet(NotationPackage.eINSTANCE.getView_Styles())) {
 			for (Style oldStyle : (List<Style>) oldView.getStyles()) {
 				copyViewStyle(oldView, newView, oldStyle, excludeStyles);
 			}
 		}
 	}

 	/**
 	 * Copies the given style features of the old view to the new view
 	 *
 	 * @param oldView The old view to copy style features from
 	 * @param newView The new view to copy style features to
 	 * @param oldStyle The old style to copy
 	 * @param excludeStyles the list of <code>Style.eClass</code> types to exclude
 	 */
 	protected void copyViewStyle(View oldView, View newView, Style oldStyle, List excludeStyles) {
 		// since the same structural feature may appear in styles with different eClass(s)
 		// we really need to get the new style that has the feature; which could be of different
 		// eClass than the source style

 		Map<EClass, Style> eClassMap = new HashMap<EClass, Style>();
 		for (EStructuralFeature feature : oldStyle.eClass().getEAllStructuralFeatures()) {
 			Style newStyle;

 			EClass containingStyleEClass = feature.getEContainingClass();
 			if (excludeStyles.contains(containingStyleEClass))
 				continue;

 			if (eClassMap.containsKey(feature.getEContainingClass())) {
 				newStyle = (Style) eClassMap.get(feature.getEContainingClass());
 			} else {
 				eClassMap.put(feature.getEContainingClass(), newStyle = newView.getStyle(feature.getEContainingClass()));
 			}
 			if (newStyle != null) {
 				if (!oldStyle.eIsSet(feature)) {
 					if (!newStyle.eIsSet(feature)) {
 						// both features are null; nothing to do
 						continue;
 					} else {
 						// new style's feature is set and must be cleared
 						newStyle.eUnset(feature);
 					}
 				} else {
 					newStyle.eSet(feature, oldStyle.eGet(feature));
 				}
 			}
 		}
 	}

 	/**
 	 * Copies the notational properties of the old view children to the new view children
 	 *
 	 * @param oldView The old view to copy children notational features from
 	 * @param newView The new view to copy children notational features to
 	 */
 	protected void copyViewChildren(View oldView, View newView) {
 		for (Iterator j = new ArrayList(oldView.getPersistedChildren()).iterator(); j.hasNext();) {
 			Node oldChildNode = (Node) j.next();
 			copyViewChild(oldView, newView, oldChildNode);
 		}
 	}

 	/**
 	 * If the child view has the same element as the parent and also has a type, it is considered a subview
 	 * and therefore only its properties are copied to matching subviews (if any) of the new parent.
 	 * Otherwise, the default behavior is for the child view to be moved to the new parent
 	 *
 	 * @param oldView The old view to copy children notational features from
 	 * @param newView The new view to copy children notational features to
 	 * @param oldChildNode A child node of the old view
 	 */
 	protected void copyViewChild(View oldView, View newView, Node oldChildNode) {
 		if (oldView.getElement() == oldChildNode.getElement() && oldChildNode.getType() != null) {
 			Node newChildNode = (Node) ViewUtil.getChildBySemanticHint(newView, oldChildNode.getType());
 			if (newChildNode != null) {
 				copyNodeFeatures(oldChildNode, newChildNode);
 			}
 		} else
 			newView.getPersistedChildren().add(oldChildNode);
 	}

 	/**
 	 * Refactors the diagram guides to reference the new node instead of the old one
 	 *
 	 * @param oldNode The old node being refactored
 	 * @param newNode The replacing new node
 	 */
 	protected final void refactorGuides(Node oldNode, Node newNode) {
 		Collection guides = EMFCoreUtil.getReferencers(oldNode, new EReference[]{NotationPackage.eINSTANCE.getNodeEntry_Key()});
 		for (Iterator i = guides.iterator(); i.hasNext();) {
 			EMap nodeMap =  ((Guide) ((EObject) i.next()).eContainer()).getNodeMap();
 			nodeMap.put(newNode, nodeMap.get(oldNode));
 			nodeMap.remove(oldNode);
 		}
 	}

 	/**
 	 * A utility to get all the views of the given element to be refactored. The implementation
 	 * of method delegated to a reverse look up map to get those views. Override if you have
 	 * a more efficient way of getting those view or to cover more or less views.
 	 *
 	 * @param element The element referenced by views to be refactored
 	 * @return A collection of views that reference the given element to refactor
 	 */
 	protected Collection getReferencingViews(EObject element) {
 		Collection views = EMFCoreUtil.getReferencers(element, new EReference[]{NotationPackage.eINSTANCE.getView_Element()});

 		// remove subviews since they will be refactored with their parent
 		for (Iterator i = views.iterator(); i.hasNext();) {
 			View view = (View) i.next();

 			EObject parent = null;
 			while ((parent = view.eContainer()) instanceof View) {
 				if (views.contains(parent)) {
 					i.remove();
 					break;
 				}
 				view = (View) parent;
 			}
 		}
 		return views;
 	}

 	/**
 	 * A utility to create a new node for the given new element that would replace the given old node.
 	 * The method uses default parameters to create the new node for the element. Override and change
 	 * this method if you think this is not the proper way to create a node of this new element.
 	 *
 	 * @param oldNode The old node being refactored
 	 * @param newElement The new element to create a node on
 	 * @return A new node that references the given new element
 	 */
 	protected Node createNode(Node oldNode, EObject newElement) {
 		return ViewService.getInstance().createNode(
 			new EObjectAdapter(newElement),
 			(View)oldNode.eContainer(),
 			getNewViewType(oldNode, newElement),
 			ViewUtil.APPEND,
 			preferencesHint);
 	}

 	/**
 	 * A utility to create a new edge for the given new element that would replace the given old edge.
 	 * The method uses default parameters to create the new edge for the element. Override and change
 	 * this method if you think this is not the proper way to create a edge of this new element.
 	 *
 	 * @param oldEdge The old edge being refactored
 	 * @param newElement The new element to create a edge on
 	 * @return A new edge that references the given new element
 	 */
 	protected Edge createEdge(Edge oldEdge, EObject newElement) {
 		Edge edge = (Edge) ViewService.getInstance().createEdge(
 			new EObjectAdapter(newElement),
 			oldEdge.getDiagram(),
 			getNewViewType(oldEdge, newElement),
 			ViewUtil.APPEND,
 			preferencesHint);
 		if (edge != null) {
 			edge.setSource(oldEdge.getSource());
 			edge.setTarget(oldEdge.getTarget());
 		}
 		return edge;
 	}

 	/**
 	 * A utility to create a new diagram for the given new element that would replace the given old diagram.
 	 * The method uses default parameters to create the new diagram for the element. Override and change
 	 * this method if you think this is not the proper way to create a diagram of this new element.
 	 *
 	 * @param oldDiagram The old diagram being refactored
 	 * @param newElement The new element to create a diagram on
 	 * @return A new diagram that references the given new element
 	 */
 	protected Diagram createDiagram(Diagram oldDiagram, EObject newElement) {
 		return ViewService.getInstance().createDiagram(
 			new EObjectAdapter(newElement),
 			getNewViewType(oldDiagram, newElement),
 			preferencesHint);
 	}

 	/**
 	 * Returns the type of the new view that replaces the old one
 	 *
 	 * @param oldView The old view being replaced
 	 * @param newElement The new element of the new view
 	 * @return The type of the new view
 	 */
 	protected String getNewViewType(View oldView, EObject newElement) {
 		return oldView.getType();
 	}

 }
	/******************************************************************************
	* Copyright (c) 2005, 2009 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.gmf.runtime.diagram.core.util;

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;

	import org.eclipse.emf.common.util.EMap;
	import org.eclipse.emf.ecore.EAnnotation;
	import org.eclipse.emf.ecore.EAttribute;
	import org.eclipse.emf.ecore.EClass;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.ecore.EReference;
	import org.eclipse.emf.ecore.EStructuralFeature;
	import org.eclipse.emf.ecore.EcorePackage;
	import org.eclipse.gmf.runtime.diagram.core.preferences.PreferencesHint;
	import org.eclipse.gmf.runtime.diagram.core.services.ViewService;
	import org.eclipse.gmf.runtime.emf.core.util.EMFCoreUtil;
	import org.eclipse.gmf.runtime.emf.core.util.EObjectAdapter;
	import org.eclipse.gmf.runtime.emf.type.core.commands.DestroyElementCommand;
	import org.eclipse.gmf.runtime.notation.Diagram;
	import org.eclipse.gmf.runtime.notation.Edge;
	import org.eclipse.gmf.runtime.notation.FilteringStyle;
	import org.eclipse.gmf.runtime.notation.Guide;
	import org.eclipse.gmf.runtime.notation.Node;
	import org.eclipse.gmf.runtime.notation.NotationPackage;
	import org.eclipse.gmf.runtime.notation.SortingStyle;
	import org.eclipse.gmf.runtime.notation.Style;
	import org.eclipse.gmf.runtime.notation.View;

	/**
	* A helper class to perform notational refactoring based on a semantic refactoring.
	* The helper provides a typical or generic implementation of the refactoring operation
	* based on the Notation metamodel. However, if the notations being refactoring use other
	* extended notation metamodels, the implementation of this helper class might need to
	* be extended. This can be achieved by directly subclassing this helper class.
	*
	* @author melaasar - Maged Elaasar
	*/
	public class ViewRefactorHelper {

	private PreferencesHint preferencesHint;

	/**
	* Constructs a new <code>ViewRefactorHelper</code> with a given preferences hint
	*/
	public ViewRefactorHelper() {
	this(PreferencesHint.USE_DEFAULTS);
	}

	/**
	* Constructs a new <code>ViewRefactorHelper</code> with a given preferences hint
	*
	* @param preferencesHint The preferences hint to be used to perform refactoring
	*/
	public ViewRefactorHelper(PreferencesHint preferencesHint) {
	this.preferencesHint = preferencesHint;
	}

	/**
	* Returns the preferences hint
	*
	* @return The preferences hint
	*/
	public PreferencesHint getPreferencesHint() {
	return preferencesHint;
	}

	/**
	* Refactors the notations associated with the old element to make them
	* consistent with the new element.
	*
	* @param oldElement The semantic element being refactored
	* @param newElement The semantic element that replaces the refactored one
	*/
	public void refactor(EObject oldElement, EObject newElement) {

	// refactor views
	Collection views = getReferencingViews(oldElement);
	for (Iterator i = views.iterator(); i.hasNext();) {
	View oldView = (View) i.next();
	if (oldView instanceof Node) {
	refactorNode((Node)oldView, newElement);
	} else if (oldView instanceof Edge) {
	refactorEdge((Edge)oldView, newElement);
	} else if (oldView instanceof Diagram) {
	refactorDiagram((Diagram)oldView, newElement);
	}
	DestroyElementCommand.destroy(oldView);
	}

	// refactor filtering styles
	Collection filterStyles = EMFCoreUtil.getReferencers(oldElement, new EReference[]{NotationPackage.eINSTANCE.getFilteringStyle_FilteredObjects()});
	for (Iterator i = filterStyles.iterator(); i.hasNext();) {
	List filteredObjects = ((FilteringStyle) i.next()).getFilteredObjects();
	if (!filteredObjects.contains(oldElement))
	filteredObjects.add(filteredObjects.indexOf(oldElement), newElement);
	filteredObjects.remove(oldElement);
	}

	// refactor sorting styles
	Collection sortingStyles = EMFCoreUtil.getReferencers(oldElement, new EReference[]{NotationPackage.eINSTANCE.getSortingStyle_SortedObjects()});
	for (Iterator i = sortingStyles.iterator(); i.hasNext();) {
	List sortingObjects = ((SortingStyle) i.next()).getSortedObjects();
	if (!sortingObjects.contains(oldElement))
	sortingObjects.add(sortingObjects.indexOf(oldElement), newElement);
	sortingObjects.remove(oldElement);
	}
	}

	/**
	* Refactors an old node to a new one with the given new element
	*
	* @param oldNode The old node being refactored
	* @param newElement The replacing new element
	* @return A new refactored node
	*/
	protected Node refactorNode(Node oldNode, EObject newElement) {
	if (oldNode.eContainingFeature() == NotationPackage.eINSTANCE.getView_PersistedChildren()) {
	Node newNode = createNode(oldNode, newElement);

	if (newNode != null) {
	copyNodeFeatures(oldNode, newNode);
	View container = (View) oldNode.eContainer();
	container.getPersistedChildren().move(container.getPersistedChildren().indexOf(oldNode), newNode);
	refactorGuides(oldNode, newNode);
	return newNode;
	}
	}
	return null;
	}

	/**
	* Refactors an old edge to a new one with the given new element
	*
	* @param oldEdge The old edge being refactored
	* @param newElement The replacing new element
	* @return A new refactored edge
	*/
	protected Edge refactorEdge(Edge oldEdge, EObject newElement) {
	if (oldEdge.eContainingFeature() == NotationPackage.eINSTANCE.getDiagram_PersistedEdges()) {
	Edge newEdge = createEdge(oldEdge, newElement);

	if (newEdge != null) {
	copyEdgeFeatures(oldEdge, newEdge);
	Diagram container = (Diagram)oldEdge.eContainer();
	container.getPersistedEdges().move(container.getPersistedEdges().indexOf(oldEdge), newEdge);
	return newEdge;
	}
	}
	return null;
	}

	/**
	* Refactors an old diagram to a new one with the given new element
	*
	* @param oldDiagram The old diagram being refactored
	* @param newElement The replacing new element
	* @return A new refactored diagram
	*/
	protected Diagram refactorDiagram(Diagram oldDiagram, EObject newElement) {
	if (oldDiagram.eContainingFeature() == EcorePackage.eINSTANCE.getEAnnotation_Contents()) {
	Diagram newDiagram = createDiagram(oldDiagram, newElement);

	if (newDiagram != null) {
	copyDiagramFeatures(oldDiagram, newDiagram);
	EAnnotation container = (EAnnotation) oldDiagram.eContainer();
	container.getContents().add(container.getContents().indexOf(oldDiagram), newDiagram);
	refactorDiagramLinks(oldDiagram, newDiagram);
	return newDiagram;
	}
	}
	return null;
	}

	protected void refactorDiagramLinks(Diagram oldDiagram, Diagram newDiagram) {
	Collection links = EMFCoreUtil.getReferencers(oldDiagram, new EReference[]{NotationPackage.eINSTANCE.getView_Element()});
	for (Iterator i = links.iterator(); i.hasNext();) {
	View view = (View) i.next();
	view.setElement(newDiagram);
	}
	}

	/**
	* Copies the notational features of the old node to the new node
	*
	* @param oldNode The old node to copy features from
	* @param newNode The new node to copy features to
	*/
	protected void copyNodeFeatures(Node oldNode, Node newNode) {
	if (oldNode.eIsSet(NotationPackage.eINSTANCE.getNode_LayoutConstraint())) {
	newNode.setLayoutConstraint(oldNode.getLayoutConstraint());
	}
	copyViewFeatures(oldNode, newNode);
	}

	/**
	* Copies the notational features of the old edge to the new edge
	*
	* @param oldEdge The old edge to copy features from
	* @param newEdge The new edge to copy features to
	*/
	protected void copyEdgeFeatures(Edge oldEdge, Edge newEdge) {
	newEdge.setBendpoints(oldEdge.getBendpoints());
	newEdge.setSourceAnchor(oldEdge.getSourceAnchor());
	newEdge.setTargetAnchor(oldEdge.getTargetAnchor());
	copyViewFeatures(oldEdge, newEdge);
	}

	/**
	* Copies the notational features of the old diagram to the new diagram
	*
	* @param oldDiagram The old diagram to copy features from
	* @param newDiagram The new diagram to copy features to
	*/
	protected void copyDiagramFeatures(Diagram oldDiagram, Diagram newDiagram) {
	newDiagram.setName(oldDiagram.getName());
	if (oldDiagram.eIsSet(NotationPackage.eINSTANCE.getDiagram_PersistedEdges())) {
	newDiagram.getPersistedEdges().addAll(oldDiagram.getPersistedEdges());
	}
	copyViewFeatures(oldDiagram, newDiagram);
	}

	/**
	* Copies the notational features of the old view to the new view
	*
	* @param oldView The old view to copy features from
	* @param newView The new view to copy features to
	*/
	protected void copyViewFeatures(View oldView, View newView) {
	copyViewAppearance(oldView, newView, new ArrayList());
	if (oldView.eIsSet(NotationPackage.eINSTANCE.getView_SourceEdges())) {
	newView.getSourceEdges().addAll(oldView.getSourceEdges());
	}
	if (oldView.eIsSet(NotationPackage.eINSTANCE.getView_TargetEdges())) {
	newView.getTargetEdges().addAll(oldView.getTargetEdges());
	}
	copyViewChildren(oldView, newView);
	}

	/**
	* Copies the appearance of the old view to the new view. Typically this means copying the visibility
	* and the styles of the root and it's children.
	*
	* @param oldView The old view to copy style features from
	* @param newView The new view to copy style features to
	* @param excludeStyles the <code>List</code> of <code>Style.eClass</code> types to exclude
	* from the copy operation.
	*/
	public void copyViewAppearance(View oldView, View newView, final List excludeStyles) {
	newView.setVisible(oldView.isVisible());
	copyViewStyles(oldView, newView, excludeStyles);
	copyViewAppearanceProperties(oldView, newView, excludeStyles);

	for (Iterator j = new ArrayList(oldView.getPersistedChildren()).iterator(); j.hasNext();) {
	Node oldChildNode = (Node) j.next();
	if (oldView.getElement() == oldChildNode.getElement() && oldChildNode.getType() != null) {
	Node newChildNode = (Node) ViewUtil.getChildBySemanticHint(newView, oldChildNode.getType());
	if (newChildNode != null) {
	copyViewAppearance(oldChildNode, newChildNode, excludeStyles);
	}
	}
	}
	}

	private void copyViewAppearanceProperties(View oldView, View newView, final List excludeStyles) {
	for (EAttribute attribute : oldView.eClass().getEAllAttributes()) {
	EClass containingEClass = attribute.getEContainingClass();
	if (NotationPackage.Literals.STYLE.isSuperTypeOf(containingEClass) && !excludeStyles.contains(containingEClass)) {
	EObject newViewStyle = newView.getStyle(containingEClass);
	if (newViewStyle != null) {
	if (!oldView.eIsSet(attribute)) {
	if (newViewStyle.eIsSet(attribute)) {
	newViewStyle.eUnset(attribute);
	}
	} else {
	newViewStyle.eSet(attribute, oldView.eGet(attribute));
	}
	}
	}
	}
	}

	/**
	* Copies the style features of the old view to the new view
	*
	* @param oldView The old view to copy style features from
	* @param newView The new view to copy style features to
	*/
	protected void copyViewStyles(View oldView, View newView) {
	copyViewStyles(oldView, newView, new ArrayList());
	}

	/**
	* Copies all styles feature from the old view to the new view
	*
	* @param oldView The old view to copy style features from
	* @param newView The new view to copy style features to
	* @param excludeStyles the <code>List</code> of <code>Style.eClass</code> types to exclude
	* from the copy operation.
	*/
	protected void copyViewStyles(View oldView, View newView, List excludeStyles) {
	if (oldView.eIsSet(NotationPackage.eINSTANCE.getView_Styles())) {
	for (Style oldStyle : (List<Style>) oldView.getStyles()) {
	copyViewStyle(oldView, newView, oldStyle, excludeStyles);
	}
	}
	}

	/**
	* Copies the given style features of the old view to the new view
	*
	* @param oldView The old view to copy style features from
	* @param newView The new view to copy style features to
	* @param oldStyle The old style to copy
	* @param excludeStyles the list of <code>Style.eClass</code> types to exclude
	*/
	protected void copyViewStyle(View oldView, View newView, Style oldStyle, List excludeStyles) {
	// since the same structural feature may appear in styles with different eClass(s)
	// we really need to get the new style that has the feature; which could be of different
	// eClass than the source style

	Map<EClass, Style> eClassMap = new HashMap<EClass, Style>();
	for (EStructuralFeature feature : oldStyle.eClass().getEAllStructuralFeatures()) {
	Style newStyle;

	EClass containingStyleEClass = feature.getEContainingClass();
	if (excludeStyles.contains(containingStyleEClass))
	continue;

	if (eClassMap.containsKey(feature.getEContainingClass())) {
	newStyle = (Style) eClassMap.get(feature.getEContainingClass());
	} else {
	eClassMap.put(feature.getEContainingClass(), newStyle = newView.getStyle(feature.getEContainingClass()));
	}
	if (newStyle != null) {
	if (!oldStyle.eIsSet(feature)) {
	if (!newStyle.eIsSet(feature)) {
	// both features are null; nothing to do
	continue;
	} else {
	// new style's feature is set and must be cleared
	newStyle.eUnset(feature);
	}
	} else {
	newStyle.eSet(feature, oldStyle.eGet(feature));
	}
	}
	}
	}

	/**
	* Copies the notational properties of the old view children to the new view children
	*
	* @param oldView The old view to copy children notational features from
	* @param newView The new view to copy children notational features to
	*/
	protected void copyViewChildren(View oldView, View newView) {
	for (Iterator j = new ArrayList(oldView.getPersistedChildren()).iterator(); j.hasNext();) {
	Node oldChildNode = (Node) j.next();
	copyViewChild(oldView, newView, oldChildNode);
	}
	}

	/**
	* If the child view has the same element as the parent and also has a type, it is considered a subview
	* and therefore only its properties are copied to matching subviews (if any) of the new parent.
	* Otherwise, the default behavior is for the child view to be moved to the new parent
	*
	* @param oldView The old view to copy children notational features from
	* @param newView The new view to copy children notational features to
	* @param oldChildNode A child node of the old view
	*/
	protected void copyViewChild(View oldView, View newView, Node oldChildNode) {
	if (oldView.getElement() == oldChildNode.getElement() && oldChildNode.getType() != null) {
	Node newChildNode = (Node) ViewUtil.getChildBySemanticHint(newView, oldChildNode.getType());
	if (newChildNode != null) {
	copyNodeFeatures(oldChildNode, newChildNode);
	}
	} else
	newView.getPersistedChildren().add(oldChildNode);
	}

	/**
	* Refactors the diagram guides to reference the new node instead of the old one
	*
	* @param oldNode The old node being refactored
	* @param newNode The replacing new node
	*/
	protected final void refactorGuides(Node oldNode, Node newNode) {
	Collection guides = EMFCoreUtil.getReferencers(oldNode, new EReference[]{NotationPackage.eINSTANCE.getNodeEntry_Key()});
	for (Iterator i = guides.iterator(); i.hasNext();) {
	EMap nodeMap = ((Guide) ((EObject) i.next()).eContainer()).getNodeMap();
	nodeMap.put(newNode, nodeMap.get(oldNode));
	nodeMap.remove(oldNode);
	}
	}

	/**
	* A utility to get all the views of the given element to be refactored. The implementation
	* of method delegated to a reverse look up map to get those views. Override if you have
	* a more efficient way of getting those view or to cover more or less views.
	*
	* @param element The element referenced by views to be refactored
	* @return A collection of views that reference the given element to refactor
	*/
	protected Collection getReferencingViews(EObject element) {
	Collection views = EMFCoreUtil.getReferencers(element, new EReference[]{NotationPackage.eINSTANCE.getView_Element()});

	// remove subviews since they will be refactored with their parent
	for (Iterator i = views.iterator(); i.hasNext();) {
	View view = (View) i.next();

	EObject parent = null;
	while ((parent = view.eContainer()) instanceof View) {
	if (views.contains(parent)) {
	i.remove();
	break;
	}
	view = (View) parent;
	}
	}
	return views;
	}

	/**
	* A utility to create a new node for the given new element that would replace the given old node.
	* The method uses default parameters to create the new node for the element. Override and change
	* this method if you think this is not the proper way to create a node of this new element.
	*
	* @param oldNode The old node being refactored
	* @param newElement The new element to create a node on
	* @return A new node that references the given new element
	*/
	protected Node createNode(Node oldNode, EObject newElement) {
	return ViewService.getInstance().createNode(
	new EObjectAdapter(newElement),
	(View)oldNode.eContainer(),
	getNewViewType(oldNode, newElement),
	ViewUtil.APPEND,
	preferencesHint);
	}

	/**
	* A utility to create a new edge for the given new element that would replace the given old edge.
	* The method uses default parameters to create the new edge for the element. Override and change
	* this method if you think this is not the proper way to create a edge of this new element.
	*
	* @param oldEdge The old edge being refactored
	* @param newElement The new element to create a edge on
	* @return A new edge that references the given new element
	*/
	protected Edge createEdge(Edge oldEdge, EObject newElement) {
	Edge edge = (Edge) ViewService.getInstance().createEdge(
	new EObjectAdapter(newElement),
	oldEdge.getDiagram(),
	getNewViewType(oldEdge, newElement),
	ViewUtil.APPEND,
	preferencesHint);
	if (edge != null) {
	edge.setSource(oldEdge.getSource());
	edge.setTarget(oldEdge.getTarget());
	}
	return edge;
	}

	/**
	* A utility to create a new diagram for the given new element that would replace the given old diagram.
	* The method uses default parameters to create the new diagram for the element. Override and change
	* this method if you think this is not the proper way to create a diagram of this new element.
	*
	* @param oldDiagram The old diagram being refactored
	* @param newElement The new element to create a diagram on
	* @return A new diagram that references the given new element
	*/
	protected Diagram createDiagram(Diagram oldDiagram, EObject newElement) {
	return ViewService.getInstance().createDiagram(
	new EObjectAdapter(newElement),
	getNewViewType(oldDiagram, newElement),
	preferencesHint);
	}

	/**
	* Returns the type of the new view that replaces the old one
	*
	* @param oldView The old view being replaced
	* @param newElement The new element of the new view
	* @return The type of the new view
	*/
	protected String getNewViewType(View oldView, EObject newElement) {
	return oldView.getType();
	}

	}