| //------------------------------------------------------------------------------ |
| // 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(); |
| |
| } |
| |
| } |
| } |