1.5/plugins/org.eclipse.epf.diagram.core/src/org/eclipse/epf/diagram/core/actions/RefreshFromBaseAction.java - epf/org.eclipse.epf.composer - Git at Google

 //------------------------------------------------------------------------------
 // Copyright (c) 2005, 2007 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 implementation
 //------------------------------------------------------------------------------
 /**
  *
  */
 package org.eclipse.epf.diagram.core.actions;

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

 import org.eclipse.emf.ecore.EModelElement;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.resource.ResourceSet;
 import org.eclipse.emf.edit.command.CopyCommand;
 import org.eclipse.emf.edit.domain.EditingDomain;
 import org.eclipse.emf.transaction.util.TransactionUtil;
 import org.eclipse.epf.diagram.core.DiagramCorePlugin;
 import org.eclipse.epf.diagram.core.DiagramCoreResources;
 import org.eclipse.epf.diagram.core.bridge.BridgeHelper;
 import org.eclipse.epf.diagram.core.bridge.DiagramAdapter;
 import org.eclipse.epf.diagram.core.bridge.NodeAdapter;
 import org.eclipse.epf.diagram.core.part.AbstractDiagramEditor;
 import org.eclipse.epf.diagram.core.part.util.DiagramEditorUtil;
 import org.eclipse.epf.diagram.core.services.DiagramHelper;
 import org.eclipse.epf.diagram.core.services.DiagramService;
 import org.eclipse.epf.diagram.model.impl.NodeImpl;
 import org.eclipse.epf.diagram.model.util.TxUtil;
 import org.eclipse.epf.library.edit.util.IDiagramManager;
 import org.eclipse.epf.uma.Activity;
 import org.eclipse.epf.uma.MethodElement;
 import org.eclipse.epf.uma.VariabilityType;
 import org.eclipse.gef.EditPart;
 import org.eclipse.gef.GraphicalViewer;
 import org.eclipse.gef.commands.Command;
 import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart;
 import org.eclipse.gmf.runtime.diagram.ui.services.editpart.EditPartService;
 import org.eclipse.gmf.runtime.notation.Diagram;
 import org.eclipse.gmf.runtime.notation.Edge;
 import org.eclipse.gmf.runtime.notation.Node;
 import org.eclipse.gmf.runtime.notation.View;
 import org.eclipse.jface.action.IAction;
 import org.eclipse.jface.viewers.ISelection;
 import org.eclipse.jface.viewers.IStructuredSelection;
 import org.eclipse.ui.IObjectActionDelegate;
 import org.eclipse.ui.IWorkbenchPart;
 import org.eclipse.uml2.uml.ActivityEdge;
 import org.eclipse.uml2.uml.ActivityNode;
 import org.eclipse.uml2.uml.ObjectNode;
 import org.eclipse.uml2.uml.StructuredActivityNode;

 /**
  * Action to refresh the latest changes from base activity diagram into
  * extend's Activity diagram. Action will keep the existing immediate children's
  * information of extend diagram, only refresh the base diagram's related information.
  *
  * @author Shashidhar Kannoori
  * @author Phong Nguyen Le
  */
 public class RefreshFromBaseAction implements IObjectActionDelegate {

 	private EditPart editPart;
 	private IWorkbenchPart targetPart;
 	/**
 	 *
 	 */
 	public RefreshFromBaseAction() {
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ui.IObjectActionDelegate#setActivePart(org.eclipse.jface.action.IAction, org.eclipse.ui.IWorkbenchPart)
 	 */
 	public void setActivePart(IAction action, IWorkbenchPart targetPart) {
 		this.targetPart = targetPart;
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)
 	 */
 	public void run(IAction action) {
 		refreshFromBaseCommand.execute();
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ui.IActionDelegate#selectionChanged(org.eclipse.jface.action.IAction, org.eclipse.jface.viewers.ISelection)
 	 */
 	public void selectionChanged(IAction action, ISelection selection) {
 		editPart = null;
 		if (selection instanceof IStructuredSelection) {
 			IStructuredSelection structuredSelection = (IStructuredSelection) selection;
 			if (structuredSelection.size() == 1
 					&& structuredSelection.getFirstElement() instanceof EditPart) {
 				editPart = (EditPart) structuredSelection
 						.getFirstElement();
 			}
 		}
 		if(editPart != null){
 			action.setChecked(false);
 			// Check if diagram readonly.
 			if(editPart instanceof DiagramEditPart){
 				if(!((DiagramEditPart)editPart).isEditModeEnabled()){
 					action.setEnabled(false);
 					return;
 				}
 			}

 			// Checked variability
 			Diagram diagram = (Diagram)editPart.getModel();
 			EObject model = diagram.getElement();
 			Activity e = null;
 			if(model instanceof org.eclipse.uml2.uml.Activity){
 				e = (Activity)BridgeHelper.getMethodElement((EModelElement)model);
 			}else if(model instanceof org.eclipse.epf.diagram.model.Diagram){
 				e = (Activity)((org.eclipse.epf.diagram.model.Diagram)model).getLinkedElement();
 			}
 			if(e != null){
 				if(e instanceof Activity){
 					if(((Activity)e).getVariabilityBasedOnElement() == null
 							|| (((Activity)e).getVariabilityBasedOnElement() != null
 							&& ((Activity)e).getVariabilityType() != VariabilityType.EXTENDS)){
 						action.setEnabled(false);
 						return;
 					}
 				}

 			}
 		}else{
 			action.setEnabled(false);
 		}
 	}

 	/**
 	 * Refresh base from previous graphical editor code.
 	 * TODO: handle consumer (set)
 	 *
 	 */
 	private Command refreshFromBaseCommand = new Command(DiagramCoreResources.AbstractDiagramEditorrefreshfrombase) { //$NON-NLS-1$
 		private ArrayList oldContent = new ArrayList();

 		public void execute() {
 			Diagram diagram = (Diagram) editPart.getModel();

 			EditPart parent = editPart.getParent();
 			// back up old diagram content
 			//
 			oldContent.clear();
 			oldContent.addAll(diagram.getPersistedChildren());

 			boolean refreshed = //DiagramHelper.refreshFromBase(diagram);
 				refreshFromBase(diagram);
 			if(!refreshed) return;

 			if (editPart.isActive()) {
 				editPart.deactivate();
 			}
 			//diagram.removeConsumer(this);
 			//createEditPart();
 			editPart = (EditPart)EditPartService.getInstance().createGraphicEditPart(diagram);
 			editPart.setParent(parent);
 			parent.getViewer().setContents(editPart);
 		}

 		public void undo() {
 			Diagram diagram = (Diagram) editPart.getModel();
 			diagram.getChildren().clear();
 			diagram.getChildren().addAll(oldContent);
 			if (editPart.isActive()) {
 				editPart.deactivate();
 			}
 			//diagram.removeConsumer(this);
 			editPart = (EditPart)EditPartService.getInstance().createGraphicEditPart(diagram);
 			getGraphicalViewer().setContents(editPart);
 			editPart.activate();
 		}
 	};

 	private GraphicalViewer getGraphicalViewer(){
 		return (GraphicalViewer)editPart.getRoot().getViewer();
 	}

 	public boolean refreshFromBase(final Diagram diagram) {
 		final boolean[] resultHolder = new boolean[1];
 		try {
 			TxUtil.runInTransaction(diagram, new Runnable() {

 				public void run() {
 					resultHolder[0] = doRefreshFromBase(diagram);
 				}

 			});
 		} catch (Exception e) {
 			DiagramCorePlugin.getDefault().getLogger().logError(e);
 		}
 		return resultHolder[0];
 	}

 	public boolean refreshFromBase(final Diagram diagram, final Activity activity) {
 		final boolean[] resultHolder = new boolean[1];
 		try {
 			TxUtil.runInTransaction(diagram, new Runnable() {

 				public void run() {
 					resultHolder[0] = doRefreshFromBase(diagram, activity);
 				}

 			});
 		} catch (Exception e) {
 			DiagramCorePlugin.getDefault().getLogger().logError(e);
 		}
 		return resultHolder[0];
 	}

 	private static interface IDiagramAssociationHelper {
 		/**
 		 * Gets the {@link MethodElement} that the given {@link Node} represents.
 		 *
 		 * @param node
 		 * @param resourceSet the resource set of the library
 		 * @return
 		 */
 		MethodElement getMethodElement(Node node, ResourceSet resourceSet);

 		/**
 		 * Finds in the given diagram the node that represents the given {@link MethodElement}.
 		 *
 		 * @param diagram
 		 * @param e
 		 * @return
 		 */
 		Node findNode(Diagram diagram, MethodElement e);

 		/**
 		 * Re-associates activity nodes in the base diagram copy with corresponding
 		 * locally contributors or replacers if there is any.
 		 *
 		 * @param activity
 		 * @param copyOfBaseDiagram
 		 */
 		void reassociate(Activity activity, Diagram copyOfBaseDiagram);

 		void addNodeModels(EObject diagramModel, Collection<?> nodeModels);

 		void addEdgeModels(EObject diagramModel, Collection<?> edgeModels);

 		void removeNodeModel(EObject diagramModel, EObject nodeModel);

 		void removeEdgeModel(EObject diagramModel, EObject edgeModel);

 		Collection<?> getNodeModels(EObject element);

 		Collection<?> getEdgeModels(EObject element);
 	}

 	private static final IDiagramAssociationHelper ADAssociationHelper = new IDiagramAssociationHelper() {

 		public Node findNode(Diagram diagram, MethodElement e) {
 			return DiagramHelper.findNode(diagram, e);
 		}

 		public MethodElement getMethodElement(Node node, ResourceSet resourceSet) {
 			EObject umlObject = node.getElement();
 			if (umlObject instanceof StructuredActivityNode
 					|| umlObject instanceof ObjectNode) {
 				MethodElement e = BridgeHelper
 						.getMethodElement((ActivityNode) umlObject);
 				if (e == null && resourceSet != null) {
 					// base diagram is not open, try to get from
 					// annotation
 					//
 					e = BridgeHelper
 							.getMethodElementFromAnnotation(
 									(EModelElement) umlObject, resourceSet);
 				}
 				return e;
 			}
 			return null;
 		}

 		public void reassociate(Activity activity, Diagram copyOfBaseDiagram) {
 			DiagramHelper.reassociate(activity, copyOfBaseDiagram);
 		}

 		public void addEdgeModels(EObject diagramModel, Collection<?> edgeModels) {
 			if(!(diagramModel instanceof org.eclipse.uml2.uml.Activity)) {
 				return;
 			}
 			DiagramAdapter diagramAdapter = BridgeHelper.getDiagramAdapter(diagramModel);
 			boolean oldNotify = false;
 			if(diagramAdapter != null) {
 				oldNotify = diagramAdapter.isNotificationEnabled();
 				diagramAdapter.setNotificationEnabled(false);
 			}
 			try {
 				((org.eclipse.uml2.uml.Activity) diagramModel).getEdges().addAll((Collection<? extends ActivityEdge>) edgeModels);
 			}
 			finally {
 				if(diagramAdapter != null) {
 					diagramAdapter.setNotificationEnabled(oldNotify);
 				}
 			}
 		}

 		public void addNodeModels(EObject diagramModel, Collection<?> nodeModels) {
 			if(!(diagramModel instanceof org.eclipse.uml2.uml.Activity)) {
 				return;
 			}
 			DiagramAdapter diagramAdapter = BridgeHelper.getDiagramAdapter(diagramModel);
 			boolean oldNotify = false;
 			if(diagramAdapter != null) {
 				oldNotify = diagramAdapter.isNotificationEnabled();
 				diagramAdapter.setNotificationEnabled(false);
 			}
 			try {
 				((org.eclipse.uml2.uml.Activity) diagramModel).getNodes().addAll((Collection<? extends ActivityNode>) nodeModels);
 			}
 			finally {
 				if(diagramAdapter != null) {
 					diagramAdapter.setNotificationEnabled(oldNotify);
 				}
 			}
 		}

 		public void removeEdgeModel(EObject diagramModel, EObject edgeModel) {
 			if(!(diagramModel instanceof org.eclipse.uml2.uml.Activity)) {
 				return;
 			}
 			DiagramAdapter diagramAdapter = BridgeHelper.getDiagramAdapter(diagramModel);
 			boolean oldNotify = false;
 			if(diagramAdapter != null) {
 				oldNotify = diagramAdapter.isNotificationEnabled();
 				diagramAdapter.setNotificationEnabled(false);
 			}
 			try {
 				((org.eclipse.uml2.uml.Activity) diagramModel).getEdges().remove(edgeModel);
 			}
 			finally {
 				if(diagramAdapter != null) {
 					diagramAdapter.setNotificationEnabled(oldNotify);
 				}
 			}
 		}

 		public void removeNodeModel(EObject diagramModel, EObject nodeModel) {
 			if(!(diagramModel instanceof org.eclipse.uml2.uml.Activity)) {
 				return;
 			}
 			DiagramAdapter diagramAdapter = BridgeHelper.getDiagramAdapter(diagramModel);
 			boolean oldNotify = false;
 			if(diagramAdapter != null) {
 				oldNotify = diagramAdapter.isNotificationEnabled();
 				diagramAdapter.setNotificationEnabled(false);
 			}
 			try {
 				((org.eclipse.uml2.uml.Activity) diagramModel).getNodes().remove(nodeModel);
 			}
 			finally {
 				if(diagramAdapter != null) {
 					diagramAdapter.setNotificationEnabled(oldNotify);
 				}
 			}
 		}

 		public Collection<?> getEdgeModels(EObject element) {
 			if(element instanceof org.eclipse.uml2.uml.Activity) {
 				return ((org.eclipse.uml2.uml.Activity) element).getEdges();
 			}
 			return Collections.EMPTY_LIST;
 		}

 		public Collection<?> getNodeModels(EObject element) {
 			if(element instanceof org.eclipse.uml2.uml.Activity) {
 				return ((org.eclipse.uml2.uml.Activity) element).getNodes();
 			}
 			return Collections.EMPTY_LIST;
 		}

 	};

 	private static final IDiagramAssociationHelper diagramAssociationHelper = new IDiagramAssociationHelper() {

 		public Node findNode(Diagram diagram, MethodElement e) {
 			return DiagramHelper.findNodeInModelDiagram(diagram, e);
 		}

 		public MethodElement getMethodElement(Node node, ResourceSet resourceSet) {
 			EObject element = node.getElement();
 			return element instanceof org.eclipse.epf.diagram.model.Node?
 					((org.eclipse.epf.diagram.model.Node) element).getLinkedElement() : null;
 		}

 		public void reassociate(Activity activity, Diagram copyOfBaseDiagram) {
 			// TODO Auto-generated method stub

 		}

 		public void addNodeModels(EObject diagramModel, Collection<?> nodeModels) {
 			if(!(diagramModel instanceof org.eclipse.epf.diagram.model.Diagram)) {
 				return;
 			}
 			org.eclipse.epf.diagram.model.Diagram diagram = (org.eclipse.epf.diagram.model.Diagram) diagramModel;
 			boolean oldNotify = ((NodeImpl)diagram).isNotificationEnabled();
 			try {
 				((NodeImpl)diagram).setNotificationEnabled(false);
 				diagram.getNodes().addAll((Collection<? extends org.eclipse.epf.diagram.model.Node>) nodeModels);
 			}
 			finally {
 				((NodeImpl)diagram).setNotificationEnabled(oldNotify);
 			}
 		}

 		public void addEdgeModels(EObject diagramModel, Collection<?> edgeModels) {
 			//
 		}

 		public void removeEdgeModel(EObject diagramModel, EObject edgeModel) {
 		}

 		public void removeNodeModel(EObject diagramModel, EObject nodeModel) {
 			if(!(diagramModel instanceof org.eclipse.epf.diagram.model.Diagram)) {
 				return;
 			}
 			org.eclipse.epf.diagram.model.Diagram diagram = (org.eclipse.epf.diagram.model.Diagram) diagramModel;
 			boolean oldNotify = ((NodeImpl)diagram).isNotificationEnabled();
 			try {
 				((NodeImpl)diagram).setNotificationEnabled(false);
 				diagram.getNodes().remove(nodeModel);
 			}
 			finally {
 				((NodeImpl)diagram).setNotificationEnabled(oldNotify);
 			}
 		}

 		public Collection<?> getEdgeModels(EObject element) {
 			return Collections.EMPTY_LIST;
 		}

 		public Collection<?> getNodeModels(EObject element) {
 			if(element instanceof org.eclipse.epf.diagram.model.Diagram) {
 				return ((org.eclipse.epf.diagram.model.Diagram) element).getNodes();
 			}
 			return Collections.EMPTY_LIST;
 		}

 	};

 	/**
 	 * Checks if the given node is one of the specified nodes or their children.
 	 *
 	 * @param nodes
 	 * @param node
 	 */
 	private static boolean contains(Collection<?> nodes, View node) {
 		if(nodes.contains(node)) {
 			return true;
 		}
 		for (Object child : nodes) {
 			if(child instanceof Node && contains(((Node) child).getChildren(), node)) {
 				return true;
 			}
 		}
 		return false;
 	}

 	private boolean doRefreshFromBase(Diagram diagram) {
 		Activity act = null;
 		EObject model = diagram.getElement();
 		if (model instanceof org.eclipse.uml2.uml.Activity) {
 			act = (Activity) BridgeHelper
 					.getMethodElement((EModelElement) model);
 		} else if (model instanceof org.eclipse.epf.diagram.model.Diagram) {
 			act = (Activity) ((org.eclipse.epf.diagram.model.Diagram) model)
 					.getLinkedElement();
 		}
 		if (act == null)
 			return false;

 		return doRefreshFromBase(diagram, act);

 	}

 	private boolean doRefreshFromBase(Diagram diagram, Activity act) {
 		EObject model = diagram.getElement();
 		Activity base = (Activity) act.getVariabilityBasedOnElement();
 		if (base == null
 				|| act.getVariabilityType() == VariabilityType.LOCAL_REPLACEMENT) {
 			return false;
 		}
 		int type = DiagramHelper.getDiagramType(diagram);
 		DiagramService diagramSvc = new DiagramService();
 		try {
 			Diagram baseDiagram = diagramSvc.getBaseDiagram(act, type);
 			if (baseDiagram == null)
 				return false;

 			Collection<Node> oldNodes = new HashSet<Node>();
 			Collection<Edge> oldEdges = new HashSet<Edge>();
 			Diagram baseCopy = DiagramHelper.copyDiagram(TransactionUtil
 					.getEditingDomain(diagram), baseDiagram);

 			IDiagramAssociationHelper helper = type == IDiagramManager.ACTIVITY_DIAGRAM ? ADAssociationHelper
 					: diagramAssociationHelper;

 			boolean notification = model.eDeliver();
 			try {
 //				model.eSetDeliver(false);
 				ResourceSet resourceSet = base.eResource().getResourceSet();
 				// Collect the base nodes that exist in extend diagram
 				for (Iterator<?> iter = baseDiagram.getChildren().iterator(); iter
 						.hasNext();) {
 					Node baseNode = (Node) iter.next();
 					MethodElement e = helper.getMethodElement(baseNode, resourceSet);
 					if (e != null) {
 						Node node = helper.findNode(diagram, e);
 						if (node != null) {
 							oldNodes.add(node);
 						}
 					}
 				}

 				// Collect old inherited UI nodes && nodes of
 				// contributor/replacer
 				List<?> children = diagram.getChildren();
 				for (Iterator<?> iter = children.iterator(); iter.hasNext();) {
 					Node node = (Node) iter.next();
 					if (BridgeHelper.isInherited(node)) {
 						oldNodes.add(node);
 					} else {
 						MethodElement e = helper.getMethodElement(node, resourceSet);
 						if (e instanceof Activity
 								&& ((Activity) e).getVariabilityBasedOnElement() != null) {
 							// node is of contributor or replacer
 							//
 							oldNodes.add(node);
 						}
 					}
 				}

 				Map<MethodElement, Edge> targetToCustomLinkMap = new HashMap<MethodElement, Edge>();
 				// Collect the edges thats exists in extend diagram
 				for (Iterator<?> iter = diagram.getEdges().iterator(); iter
 						.hasNext();) {
 					Edge edge = (Edge) iter.next();
 					if (contains(oldNodes, edge.getTarget())) {
 						if(contains(oldNodes, edge.getSource())) {
 							oldEdges.add(edge);
 						} else { // must be custom connection
 							MethodElement e = helper.getMethodElement((Node) edge.getTarget(), resourceSet);
 							targetToCustomLinkMap.put(e, edge);
 						}
 					}
 				}

 				// remove the old base nodes and edges that exists in the
 				// extend diagram.
 				for (Node node : oldNodes) {
 					diagram.removeChild(node);
 					helper.removeNodeModel(model, node.getElement());
 				}
 				for (Edge edge : oldEdges) {
 					diagram.removeEdge(edge);
 					helper.removeEdgeModel(model, edge.getElement());
 					edge.setSource(null);
 					edge.setTarget(null);
 				}

 				// replace associated base element with
 				// contributing/replacing
 				// element
 				//
 				helper.reassociate(act, baseCopy);

 				// Mark inherited
 				for (Object obj : baseCopy.getChildren()) {
 					View child = (View) obj;
 					BridgeHelper.markInherited(child);
 					if(child instanceof Node) {
 						MethodElement e = helper.getMethodElement((Node) child, resourceSet);
 						if(e != null) {
 							Edge edge = targetToCustomLinkMap.get(e);
 							if(edge != null) {
 								// update custom edge with new copy of target from base
 								edge.setTarget(child);
 								Object edgeModel = edge.getElement();
 								if(edgeModel instanceof ActivityEdge && child.getElement() instanceof ActivityNode) {
 									ActivityEdge actEdge = (ActivityEdge) edgeModel;
 									// disable notification for node adapter of
 									// the old target so associated work order
 									// will not be removed
 									ActivityNode oldTarget = actEdge.getTarget();
 									NodeAdapter nodeAdapter = BridgeHelper.getNodeAdapter(oldTarget);
 									boolean notify = false;
 									if(nodeAdapter != null) {
 										notify = nodeAdapter.isNotificationEnabled();
 										nodeAdapter.setNotificationEnabled(false);
 									}
 									try {
 										((ActivityEdge) edgeModel).setTarget((ActivityNode) child.getElement());
 									} finally {
 										if(nodeAdapter != null) {
 											nodeAdapter.setNotificationEnabled(notify);
 										}
 									}
 								}
 							}
 						}
 					}
 				}
 				for (Object obj : baseCopy.getEdges()) {
 					BridgeHelper.markInherited((View) obj);
 				}

 				// Add all new nodes and edges from base copy to extend diagram.
 				//
 				diagram.getPersistedChildren().addAll(
 						baseCopy.getChildren());
 				diagram.getPersistedEdges().addAll(
 						baseCopy.getEdges());
 				Collection<?> baseNodeModels = helper.getNodeModels(baseCopy.getElement());
 				if(baseNodeModels != null && !baseNodeModels.isEmpty()) {
 					helper.addNodeModels(model, baseNodeModels);
 				}
 				Collection<?> baseEdgeModels = helper.getEdgeModels(baseCopy
 						.getElement());
 				if (baseEdgeModels != null && !baseEdgeModels.isEmpty()) {
 					helper.addEdgeModels(model, baseEdgeModels);
 				}

 				// TODO: handle the missed links.

 				// ActivityDiagramAdapter adapter =
 				// (ActivityDiagramAdapter)BridgeHelper.getNodeAdapter(umlActivity);
 				// adapter.populateDiagram();
 				// if(targetPart instanceof AbstractDiagramEditor){
 				// DiagramEditorUtil.resetEditor((AbstractDiagramEditor)targetPart);
 				// }
 			} finally {
 				// reset the notification.
 				model.eSetDeliver(notification);
 			}

 			try {
 				if (targetPart instanceof AbstractDiagramEditor) {
 					DiagramEditorUtil
 							.resetEditor((AbstractDiagramEditor) targetPart);
 				}
 				// diagram.eResource().save(null);
 			} catch (Exception e) {

 			}
 		} finally {
 			diagramSvc.dispose();
 		}
 		return true;
 	}

 	public void initialize(){
 		if(targetPart instanceof AbstractDiagramEditor){
 			AbstractDiagramEditor editor = (AbstractDiagramEditor)targetPart;
 			DiagramEditPart part = editor.getDiagramEditPart();

 		}

 	}
 }
	//------------------------------------------------------------------------------
	// Copyright (c) 2005, 2007 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 implementation
	//------------------------------------------------------------------------------
	/**
	*
	*/
	package org.eclipse.epf.diagram.core.actions;

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

	import org.eclipse.emf.ecore.EModelElement;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.ecore.resource.ResourceSet;
	import org.eclipse.emf.edit.command.CopyCommand;
	import org.eclipse.emf.edit.domain.EditingDomain;
	import org.eclipse.emf.transaction.util.TransactionUtil;
	import org.eclipse.epf.diagram.core.DiagramCorePlugin;
	import org.eclipse.epf.diagram.core.DiagramCoreResources;
	import org.eclipse.epf.diagram.core.bridge.BridgeHelper;
	import org.eclipse.epf.diagram.core.bridge.DiagramAdapter;
	import org.eclipse.epf.diagram.core.bridge.NodeAdapter;
	import org.eclipse.epf.diagram.core.part.AbstractDiagramEditor;
	import org.eclipse.epf.diagram.core.part.util.DiagramEditorUtil;
	import org.eclipse.epf.diagram.core.services.DiagramHelper;
	import org.eclipse.epf.diagram.core.services.DiagramService;
	import org.eclipse.epf.diagram.model.impl.NodeImpl;
	import org.eclipse.epf.diagram.model.util.TxUtil;
	import org.eclipse.epf.library.edit.util.IDiagramManager;
	import org.eclipse.epf.uma.Activity;
	import org.eclipse.epf.uma.MethodElement;
	import org.eclipse.epf.uma.VariabilityType;
	import org.eclipse.gef.EditPart;
	import org.eclipse.gef.GraphicalViewer;
	import org.eclipse.gef.commands.Command;
	import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart;
	import org.eclipse.gmf.runtime.diagram.ui.services.editpart.EditPartService;
	import org.eclipse.gmf.runtime.notation.Diagram;
	import org.eclipse.gmf.runtime.notation.Edge;
	import org.eclipse.gmf.runtime.notation.Node;
	import org.eclipse.gmf.runtime.notation.View;
	import org.eclipse.jface.action.IAction;
	import org.eclipse.jface.viewers.ISelection;
	import org.eclipse.jface.viewers.IStructuredSelection;
	import org.eclipse.ui.IObjectActionDelegate;
	import org.eclipse.ui.IWorkbenchPart;
	import org.eclipse.uml2.uml.ActivityEdge;
	import org.eclipse.uml2.uml.ActivityNode;
	import org.eclipse.uml2.uml.ObjectNode;
	import org.eclipse.uml2.uml.StructuredActivityNode;

	/**
	* Action to refresh the latest changes from base activity diagram into
	* extend's Activity diagram. Action will keep the existing immediate children's
	* information of extend diagram, only refresh the base diagram's related information.
	*
	* @author Shashidhar Kannoori
	* @author Phong Nguyen Le
	*/
	public class RefreshFromBaseAction implements IObjectActionDelegate {

	private EditPart editPart;
	private IWorkbenchPart targetPart;
	/**
	*
	*/
	public RefreshFromBaseAction() {
	}

	/* (non-Javadoc)
	* @see org.eclipse.ui.IObjectActionDelegate#setActivePart(org.eclipse.jface.action.IAction, org.eclipse.ui.IWorkbenchPart)
	*/
	public void setActivePart(IAction action, IWorkbenchPart targetPart) {
	this.targetPart = targetPart;
	}

	/* (non-Javadoc)
	* @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)
	*/
	public void run(IAction action) {
	refreshFromBaseCommand.execute();
	}

	/* (non-Javadoc)
	* @see org.eclipse.ui.IActionDelegate#selectionChanged(org.eclipse.jface.action.IAction, org.eclipse.jface.viewers.ISelection)
	*/
	public void selectionChanged(IAction action, ISelection selection) {
	editPart = null;
	if (selection instanceof IStructuredSelection) {
	IStructuredSelection structuredSelection = (IStructuredSelection) selection;
	if (structuredSelection.size() == 1
	&& structuredSelection.getFirstElement() instanceof EditPart) {
	editPart = (EditPart) structuredSelection
	.getFirstElement();
	}
	}
	if(editPart != null){
	action.setChecked(false);
	// Check if diagram readonly.
	if(editPart instanceof DiagramEditPart){
	if(!((DiagramEditPart)editPart).isEditModeEnabled()){
	action.setEnabled(false);
	return;
	}
	}

	// Checked variability
	Diagram diagram = (Diagram)editPart.getModel();
	EObject model = diagram.getElement();
	Activity e = null;
	if(model instanceof org.eclipse.uml2.uml.Activity){
	e = (Activity)BridgeHelper.getMethodElement((EModelElement)model);
	}else if(model instanceof org.eclipse.epf.diagram.model.Diagram){
	e = (Activity)((org.eclipse.epf.diagram.model.Diagram)model).getLinkedElement();
	}
	if(e != null){
	if(e instanceof Activity){
	if(((Activity)e).getVariabilityBasedOnElement() == null
	\|\| (((Activity)e).getVariabilityBasedOnElement() != null
	&& ((Activity)e).getVariabilityType() != VariabilityType.EXTENDS)){
	action.setEnabled(false);
	return;
	}
	}

	}
	}else{
	action.setEnabled(false);
	}
	}

	/**
	* Refresh base from previous graphical editor code.
	* TODO: handle consumer (set)
	*
	*/
	private Command refreshFromBaseCommand = new Command(DiagramCoreResources.AbstractDiagramEditorrefreshfrombase) { //$NON-NLS-1$
	private ArrayList oldContent = new ArrayList();

	public void execute() {
	Diagram diagram = (Diagram) editPart.getModel();

	EditPart parent = editPart.getParent();
	// back up old diagram content
	//
	oldContent.clear();
	oldContent.addAll(diagram.getPersistedChildren());

	boolean refreshed = //DiagramHelper.refreshFromBase(diagram);
	refreshFromBase(diagram);
	if(!refreshed) return;

	if (editPart.isActive()) {
	editPart.deactivate();
	}
	//diagram.removeConsumer(this);
	//createEditPart();
	editPart = (EditPart)EditPartService.getInstance().createGraphicEditPart(diagram);
	editPart.setParent(parent);
	parent.getViewer().setContents(editPart);
	}

	public void undo() {
	Diagram diagram = (Diagram) editPart.getModel();
	diagram.getChildren().clear();
	diagram.getChildren().addAll(oldContent);
	if (editPart.isActive()) {
	editPart.deactivate();
	}
	//diagram.removeConsumer(this);
	editPart = (EditPart)EditPartService.getInstance().createGraphicEditPart(diagram);
	getGraphicalViewer().setContents(editPart);
	editPart.activate();
	}
	};

	private GraphicalViewer getGraphicalViewer(){
	return (GraphicalViewer)editPart.getRoot().getViewer();
	}

	public boolean refreshFromBase(final Diagram diagram) {
	final boolean[] resultHolder = new boolean[1];
	try {
	TxUtil.runInTransaction(diagram, new Runnable() {

	public void run() {
	resultHolder[0] = doRefreshFromBase(diagram);
	}

	});
	} catch (Exception e) {
	DiagramCorePlugin.getDefault().getLogger().logError(e);
	}
	return resultHolder[0];
	}

	public boolean refreshFromBase(final Diagram diagram, final Activity activity) {
	final boolean[] resultHolder = new boolean[1];
	try {
	TxUtil.runInTransaction(diagram, new Runnable() {

	public void run() {
	resultHolder[0] = doRefreshFromBase(diagram, activity);
	}

	});
	} catch (Exception e) {
	DiagramCorePlugin.getDefault().getLogger().logError(e);
	}
	return resultHolder[0];
	}

	private static interface IDiagramAssociationHelper {
	/**
	* Gets the {@link MethodElement} that the given {@link Node} represents.
	*
	* @param node
	* @param resourceSet the resource set of the library
	* @return
	*/
	MethodElement getMethodElement(Node node, ResourceSet resourceSet);

	/**
	* Finds in the given diagram the node that represents the given {@link MethodElement}.
	*
	* @param diagram
	* @param e
	* @return
	*/
	Node findNode(Diagram diagram, MethodElement e);

	/**
	* Re-associates activity nodes in the base diagram copy with corresponding
	* locally contributors or replacers if there is any.
	*
	* @param activity
	* @param copyOfBaseDiagram
	*/
	void reassociate(Activity activity, Diagram copyOfBaseDiagram);

	void addNodeModels(EObject diagramModel, Collection<?> nodeModels);

	void addEdgeModels(EObject diagramModel, Collection<?> edgeModels);

	void removeNodeModel(EObject diagramModel, EObject nodeModel);

	void removeEdgeModel(EObject diagramModel, EObject edgeModel);

	Collection<?> getNodeModels(EObject element);

	Collection<?> getEdgeModels(EObject element);
	}

	private static final IDiagramAssociationHelper ADAssociationHelper = new IDiagramAssociationHelper() {

	public Node findNode(Diagram diagram, MethodElement e) {
	return DiagramHelper.findNode(diagram, e);
	}

	public MethodElement getMethodElement(Node node, ResourceSet resourceSet) {
	EObject umlObject = node.getElement();
	if (umlObject instanceof StructuredActivityNode
	\|\| umlObject instanceof ObjectNode) {
	MethodElement e = BridgeHelper
	.getMethodElement((ActivityNode) umlObject);
	if (e == null && resourceSet != null) {
	// base diagram is not open, try to get from
	// annotation
	//
	e = BridgeHelper
	.getMethodElementFromAnnotation(
	(EModelElement) umlObject, resourceSet);
	}
	return e;
	}
	return null;
	}

	public void reassociate(Activity activity, Diagram copyOfBaseDiagram) {
	DiagramHelper.reassociate(activity, copyOfBaseDiagram);
	}

	public void addEdgeModels(EObject diagramModel, Collection<?> edgeModels) {
	if(!(diagramModel instanceof org.eclipse.uml2.uml.Activity)) {
	return;
	}
	DiagramAdapter diagramAdapter = BridgeHelper.getDiagramAdapter(diagramModel);
	boolean oldNotify = false;
	if(diagramAdapter != null) {
	oldNotify = diagramAdapter.isNotificationEnabled();
	diagramAdapter.setNotificationEnabled(false);
	}
	try {
	((org.eclipse.uml2.uml.Activity) diagramModel).getEdges().addAll((Collection<? extends ActivityEdge>) edgeModels);
	}
	finally {
	if(diagramAdapter != null) {
	diagramAdapter.setNotificationEnabled(oldNotify);
	}
	}
	}

	public void addNodeModels(EObject diagramModel, Collection<?> nodeModels) {
	if(!(diagramModel instanceof org.eclipse.uml2.uml.Activity)) {
	return;
	}
	DiagramAdapter diagramAdapter = BridgeHelper.getDiagramAdapter(diagramModel);
	boolean oldNotify = false;
	if(diagramAdapter != null) {
	oldNotify = diagramAdapter.isNotificationEnabled();
	diagramAdapter.setNotificationEnabled(false);
	}
	try {
	((org.eclipse.uml2.uml.Activity) diagramModel).getNodes().addAll((Collection<? extends ActivityNode>) nodeModels);
	}
	finally {
	if(diagramAdapter != null) {
	diagramAdapter.setNotificationEnabled(oldNotify);
	}
	}
	}

	public void removeEdgeModel(EObject diagramModel, EObject edgeModel) {
	if(!(diagramModel instanceof org.eclipse.uml2.uml.Activity)) {
	return;
	}
	DiagramAdapter diagramAdapter = BridgeHelper.getDiagramAdapter(diagramModel);
	boolean oldNotify = false;
	if(diagramAdapter != null) {
	oldNotify = diagramAdapter.isNotificationEnabled();
	diagramAdapter.setNotificationEnabled(false);
	}
	try {
	((org.eclipse.uml2.uml.Activity) diagramModel).getEdges().remove(edgeModel);
	}
	finally {
	if(diagramAdapter != null) {
	diagramAdapter.setNotificationEnabled(oldNotify);
	}
	}
	}

	public void removeNodeModel(EObject diagramModel, EObject nodeModel) {
	if(!(diagramModel instanceof org.eclipse.uml2.uml.Activity)) {
	return;
	}
	DiagramAdapter diagramAdapter = BridgeHelper.getDiagramAdapter(diagramModel);
	boolean oldNotify = false;
	if(diagramAdapter != null) {
	oldNotify = diagramAdapter.isNotificationEnabled();
	diagramAdapter.setNotificationEnabled(false);
	}
	try {
	((org.eclipse.uml2.uml.Activity) diagramModel).getNodes().remove(nodeModel);
	}
	finally {
	if(diagramAdapter != null) {
	diagramAdapter.setNotificationEnabled(oldNotify);
	}
	}
	}

	public Collection<?> getEdgeModels(EObject element) {
	if(element instanceof org.eclipse.uml2.uml.Activity) {
	return ((org.eclipse.uml2.uml.Activity) element).getEdges();
	}
	return Collections.EMPTY_LIST;
	}

	public Collection<?> getNodeModels(EObject element) {
	if(element instanceof org.eclipse.uml2.uml.Activity) {
	return ((org.eclipse.uml2.uml.Activity) element).getNodes();
	}
	return Collections.EMPTY_LIST;
	}

	};

	private static final IDiagramAssociationHelper diagramAssociationHelper = new IDiagramAssociationHelper() {

	public Node findNode(Diagram diagram, MethodElement e) {
	return DiagramHelper.findNodeInModelDiagram(diagram, e);
	}

	public MethodElement getMethodElement(Node node, ResourceSet resourceSet) {
	EObject element = node.getElement();
	return element instanceof org.eclipse.epf.diagram.model.Node?
	((org.eclipse.epf.diagram.model.Node) element).getLinkedElement() : null;
	}

	public void reassociate(Activity activity, Diagram copyOfBaseDiagram) {
	// TODO Auto-generated method stub

	}

	public void addNodeModels(EObject diagramModel, Collection<?> nodeModels) {
	if(!(diagramModel instanceof org.eclipse.epf.diagram.model.Diagram)) {
	return;
	}
	org.eclipse.epf.diagram.model.Diagram diagram = (org.eclipse.epf.diagram.model.Diagram) diagramModel;
	boolean oldNotify = ((NodeImpl)diagram).isNotificationEnabled();
	try {
	((NodeImpl)diagram).setNotificationEnabled(false);
	diagram.getNodes().addAll((Collection<? extends org.eclipse.epf.diagram.model.Node>) nodeModels);
	}
	finally {
	((NodeImpl)diagram).setNotificationEnabled(oldNotify);
	}
	}

	public void addEdgeModels(EObject diagramModel, Collection<?> edgeModels) {
	//
	}

	public void removeEdgeModel(EObject diagramModel, EObject edgeModel) {
	}

	public void removeNodeModel(EObject diagramModel, EObject nodeModel) {
	if(!(diagramModel instanceof org.eclipse.epf.diagram.model.Diagram)) {
	return;
	}
	org.eclipse.epf.diagram.model.Diagram diagram = (org.eclipse.epf.diagram.model.Diagram) diagramModel;
	boolean oldNotify = ((NodeImpl)diagram).isNotificationEnabled();
	try {
	((NodeImpl)diagram).setNotificationEnabled(false);
	diagram.getNodes().remove(nodeModel);
	}
	finally {
	((NodeImpl)diagram).setNotificationEnabled(oldNotify);
	}
	}

	public Collection<?> getEdgeModels(EObject element) {
	return Collections.EMPTY_LIST;
	}

	public Collection<?> getNodeModels(EObject element) {
	if(element instanceof org.eclipse.epf.diagram.model.Diagram) {
	return ((org.eclipse.epf.diagram.model.Diagram) element).getNodes();
	}
	return Collections.EMPTY_LIST;
	}

	};

	/**
	* Checks if the given node is one of the specified nodes or their children.
	*
	* @param nodes
	* @param node
	*/
	private static boolean contains(Collection<?> nodes, View node) {
	if(nodes.contains(node)) {
	return true;
	}
	for (Object child : nodes) {
	if(child instanceof Node && contains(((Node) child).getChildren(), node)) {
	return true;
	}
	}
	return false;
	}

	private boolean doRefreshFromBase(Diagram diagram) {
	Activity act = null;
	EObject model = diagram.getElement();
	if (model instanceof org.eclipse.uml2.uml.Activity) {
	act = (Activity) BridgeHelper
	.getMethodElement((EModelElement) model);
	} else if (model instanceof org.eclipse.epf.diagram.model.Diagram) {
	act = (Activity) ((org.eclipse.epf.diagram.model.Diagram) model)
	.getLinkedElement();
	}
	if (act == null)
	return false;

	return doRefreshFromBase(diagram, act);

	}

	private boolean doRefreshFromBase(Diagram diagram, Activity act) {
	EObject model = diagram.getElement();
	Activity base = (Activity) act.getVariabilityBasedOnElement();
	if (base == null
	\|\| act.getVariabilityType() == VariabilityType.LOCAL_REPLACEMENT) {
	return false;
	}
	int type = DiagramHelper.getDiagramType(diagram);
	DiagramService diagramSvc = new DiagramService();
	try {
	Diagram baseDiagram = diagramSvc.getBaseDiagram(act, type);
	if (baseDiagram == null)
	return false;

	Collection<Node> oldNodes = new HashSet<Node>();
	Collection<Edge> oldEdges = new HashSet<Edge>();
	Diagram baseCopy = DiagramHelper.copyDiagram(TransactionUtil
	.getEditingDomain(diagram), baseDiagram);

	IDiagramAssociationHelper helper = type == IDiagramManager.ACTIVITY_DIAGRAM ? ADAssociationHelper
	: diagramAssociationHelper;

	boolean notification = model.eDeliver();
	try {
	// model.eSetDeliver(false);
	ResourceSet resourceSet = base.eResource().getResourceSet();
	// Collect the base nodes that exist in extend diagram
	for (Iterator<?> iter = baseDiagram.getChildren().iterator(); iter
	.hasNext();) {
	Node baseNode = (Node) iter.next();
	MethodElement e = helper.getMethodElement(baseNode, resourceSet);
	if (e != null) {
	Node node = helper.findNode(diagram, e);
	if (node != null) {
	oldNodes.add(node);
	}
	}
	}

	// Collect old inherited UI nodes && nodes of
	// contributor/replacer
	List<?> children = diagram.getChildren();
	for (Iterator<?> iter = children.iterator(); iter.hasNext();) {
	Node node = (Node) iter.next();
	if (BridgeHelper.isInherited(node)) {
	oldNodes.add(node);
	} else {
	MethodElement e = helper.getMethodElement(node, resourceSet);
	if (e instanceof Activity
	&& ((Activity) e).getVariabilityBasedOnElement() != null) {
	// node is of contributor or replacer
	//
	oldNodes.add(node);
	}
	}
	}

	Map<MethodElement, Edge> targetToCustomLinkMap = new HashMap<MethodElement, Edge>();
	// Collect the edges thats exists in extend diagram
	for (Iterator<?> iter = diagram.getEdges().iterator(); iter
	.hasNext();) {
	Edge edge = (Edge) iter.next();
	if (contains(oldNodes, edge.getTarget())) {
	if(contains(oldNodes, edge.getSource())) {
	oldEdges.add(edge);
	} else { // must be custom connection
	MethodElement e = helper.getMethodElement((Node) edge.getTarget(), resourceSet);
	targetToCustomLinkMap.put(e, edge);
	}
	}
	}

	// remove the old base nodes and edges that exists in the
	// extend diagram.
	for (Node node : oldNodes) {
	diagram.removeChild(node);
	helper.removeNodeModel(model, node.getElement());
	}
	for (Edge edge : oldEdges) {
	diagram.removeEdge(edge);
	helper.removeEdgeModel(model, edge.getElement());
	edge.setSource(null);
	edge.setTarget(null);
	}

	// replace associated base element with
	// contributing/replacing
	// element
	//
	helper.reassociate(act, baseCopy);

	// Mark inherited
	for (Object obj : baseCopy.getChildren()) {
	View child = (View) obj;
	BridgeHelper.markInherited(child);
	if(child instanceof Node) {
	MethodElement e = helper.getMethodElement((Node) child, resourceSet);
	if(e != null) {
	Edge edge = targetToCustomLinkMap.get(e);
	if(edge != null) {
	// update custom edge with new copy of target from base
	edge.setTarget(child);
	Object edgeModel = edge.getElement();
	if(edgeModel instanceof ActivityEdge && child.getElement() instanceof ActivityNode) {
	ActivityEdge actEdge = (ActivityEdge) edgeModel;
	// disable notification for node adapter of
	// the old target so associated work order
	// will not be removed
	ActivityNode oldTarget = actEdge.getTarget();
	NodeAdapter nodeAdapter = BridgeHelper.getNodeAdapter(oldTarget);
	boolean notify = false;
	if(nodeAdapter != null) {
	notify = nodeAdapter.isNotificationEnabled();
	nodeAdapter.setNotificationEnabled(false);
	}
	try {
	((ActivityEdge) edgeModel).setTarget((ActivityNode) child.getElement());
	} finally {
	if(nodeAdapter != null) {
	nodeAdapter.setNotificationEnabled(notify);
	}
	}
	}
	}
	}
	}
	}
	for (Object obj : baseCopy.getEdges()) {
	BridgeHelper.markInherited((View) obj);
	}

	// Add all new nodes and edges from base copy to extend diagram.
	//
	diagram.getPersistedChildren().addAll(
	baseCopy.getChildren());
	diagram.getPersistedEdges().addAll(
	baseCopy.getEdges());
	Collection<?> baseNodeModels = helper.getNodeModels(baseCopy.getElement());
	if(baseNodeModels != null && !baseNodeModels.isEmpty()) {
	helper.addNodeModels(model, baseNodeModels);
	}
	Collection<?> baseEdgeModels = helper.getEdgeModels(baseCopy
	.getElement());
	if (baseEdgeModels != null && !baseEdgeModels.isEmpty()) {
	helper.addEdgeModels(model, baseEdgeModels);
	}

	// TODO: handle the missed links.

	// ActivityDiagramAdapter adapter =
	// (ActivityDiagramAdapter)BridgeHelper.getNodeAdapter(umlActivity);
	// adapter.populateDiagram();
	// if(targetPart instanceof AbstractDiagramEditor){
	// DiagramEditorUtil.resetEditor((AbstractDiagramEditor)targetPart);
	// }
	} finally {
	// reset the notification.
	model.eSetDeliver(notification);
	}

	try {
	if (targetPart instanceof AbstractDiagramEditor) {
	DiagramEditorUtil
	.resetEditor((AbstractDiagramEditor) targetPart);
	}
	// diagram.eResource().save(null);
	} catch (Exception e) {

	}
	} finally {
	diagramSvc.dispose();
	}
	return true;
	}

	public void initialize(){
	if(targetPart instanceof AbstractDiagramEditor){
	AbstractDiagramEditor editor = (AbstractDiagramEditor)targetPart;
	DiagramEditPart part = editor.getDiagramEditPart();

	}

	}
	}