| //------------------------------------------------------------------------------ |
| // 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.migration.diagram.ad.services; |
| |
| import java.io.File; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.ecore.EModelElement; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.transaction.Transaction; |
| import org.eclipse.epf.diagram.ad.part.ActivityDiagramEditorPlugin; |
| import org.eclipse.epf.diagram.add.part.ActivityDetailDiagramEditorPlugin; |
| import org.eclipse.epf.diagram.core.bridge.BridgeHelper; |
| import org.eclipse.epf.diagram.core.services.DiagramManager; |
| import org.eclipse.epf.diagram.model.ActivityDetailDiagram; |
| import org.eclipse.epf.diagram.model.ActivityDiagram; |
| import org.eclipse.epf.diagram.model.ModelFactory; |
| import org.eclipse.epf.diagram.model.Node; |
| import org.eclipse.epf.diagram.model.TypedNode; |
| import org.eclipse.epf.diagram.model.WorkProductDependencyDiagram; |
| import org.eclipse.epf.diagram.model.util.GraphicalDataHelper; |
| import org.eclipse.epf.diagram.model.util.GraphicalDataManager; |
| import org.eclipse.epf.diagram.wpdd.part.WPDDiagramEditorPlugin; |
| import org.eclipse.epf.library.configuration.ProcessAuthoringConfigurator; |
| import org.eclipse.epf.library.edit.util.DiagramOptions; |
| import org.eclipse.epf.library.edit.util.IDiagramManager; |
| import org.eclipse.epf.library.edit.util.Suppression; |
| import org.eclipse.epf.library.services.SafeUpdateController; |
| import org.eclipse.epf.migration.diagram.DiagramMigrationPlugin; |
| import org.eclipse.epf.migration.diagram.MigrationExportException; |
| import org.eclipse.epf.migration.diagram.ad.map.IMapConstants; |
| import org.eclipse.epf.migration.diagram.ad.map.MapFactory; |
| import org.eclipse.epf.migration.diagram.ad.map.MapNode; |
| import org.eclipse.epf.migration.diagram.ad.map.MapUtil; |
| import org.eclipse.epf.migration.diagram.addwpd.map.ConnectionFactory; |
| import org.eclipse.epf.migration.diagram.util.MigrationUtil; |
| import org.eclipse.epf.uma.Activity; |
| import org.eclipse.epf.uma.Process; |
| import org.eclipse.gmf.runtime.diagram.core.preferences.PreferencesHint; |
| import org.eclipse.gmf.runtime.diagram.core.services.ViewService; |
| import org.eclipse.gmf.runtime.notation.Bounds; |
| import org.eclipse.gmf.runtime.notation.Diagram; |
| import org.eclipse.gmf.runtime.notation.NotationFactory; |
| import org.eclipse.uml2.uml.UMLFactory; |
| import org.eclipse.uml2.uml.UMLPackage; |
| |
| /** |
| * @author Shashidhar Kannoori |
| * @author Shilpa Toraskar |
| * @author Weiping Lu |
| * @since 1.2 |
| */ |
| |
| public class WorkflowExportService { |
| |
| public static final String DEFAULT_XMI_EXTENSION = ".xmi"; //$NON-NLS-1$ |
| |
| protected boolean debug; |
| |
| public static WorkflowExportService singleton = null; |
| |
| public static WorkflowExportService getInstance() { |
| if (singleton == null) { |
| singleton = new WorkflowExportService(); |
| } |
| return singleton; |
| } |
| |
| /** |
| * Export activity diagram data |
| * @param proc |
| * @param activity |
| * @param fileName |
| * @param targetDir |
| * @return |
| * @throws MigrationExportException |
| */ |
| public boolean export(Process proc, Activity activity, String fileName, |
| File targetDir) throws MigrationExportException { |
| |
| debug = DiagramMigrationPlugin.getDefault().isDebugging(); |
| |
| // construct the export target xml file path |
| Path exportPath = new Path(targetDir.getAbsolutePath()); |
| boolean endWithXmiExt = fileName.toLowerCase().endsWith( |
| DEFAULT_XMI_EXTENSION); |
| |
| String exportXMIPath = (exportPath.append(endWithXmiExt ? fileName |
| : (fileName + DEFAULT_XMI_EXTENSION))).toOSString(); |
| |
| |
| URI uri = URI.createFileURI(exportXMIPath); |
| |
| /* // Create resource set |
| ResourceSet resourceSet = new ResourceSetImpl(); |
| |
| //XMLResourceImpl xmires = new Workflow2XMIResourceImpl(uri); |
| //Resource xmires = new GMFResourceFactory().createResource(uri); |
| Resource xmires = DiagramManager.getInstance(proc) |
| .getEditingDomain().getResourceSet().createResource(uri); |
| |
| resourceSet.getResources().add(xmires);*/ |
| DiagramManager mgr = DiagramManager.getInstance(proc, this); |
| |
| try { |
| Transaction tx = mgr.getEditingDomain().startTransaction(false, |
| Collections.EMPTY_MAP); |
| Resource xmires = mgr.getResource(); |
| tx.commit(); |
| |
| // Create temp map |
| IMapConstants.graphUMLNodeMap.clear(); |
| |
| if (proc == activity) { |
| Map activities = MigrationUtil.getActivities(proc, true); |
| for (Iterator it = activities.values().iterator(); it.hasNext();) { |
| Activity act = (Activity) it.next(); |
| addAD(xmires, proc, act, mgr); |
| addADD(xmires, proc, act, mgr); |
| addWPD(xmires, proc, act, mgr); |
| } |
| } else { |
| addAD(xmires, proc, activity, mgr); |
| addADD(xmires, proc, activity, mgr); |
| addWPD(xmires, proc, activity, mgr); |
| } |
| |
| /* tx.commit();*/ |
| |
| List contents = xmires.getContents(); |
| if (contents != null && ! contents.isEmpty()) { |
| xmires.save(null); |
| } |
| |
| } catch (Exception e) { |
| e.printStackTrace(); |
| throw new MigrationExportException(e); |
| } finally { |
| if(mgr != null) { |
| mgr.removeConsumer(this); |
| } |
| } |
| |
| return true; |
| } |
| |
| private void addDataToResource_WPD(Resource xmiResource, Process proc, |
| Activity umaActivity) { |
| |
| org.eclipse.epf.uma.Diagram d = GraphicalDataManager.getInstance().getUMADiagram(umaActivity, IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM, false); |
| if (d != null) { |
| if (debug) { |
| System.out.println("WPDD->"+proc.getName()+"::"+umaActivity.getName()); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| WorkProductDependencyDiagram wpdDiagram = ModelFactory.eINSTANCE |
| .createWorkProductDependencyDiagram(); |
| addDataToResource_ADDorWPD(proc, umaActivity, xmiResource, |
| wpdDiagram); |
| } |
| } |
| |
| |
| private void addDataToResource_ADD(Resource xmiResource, |
| Process proc, Activity umaActivity) { |
| org.eclipse.epf.uma.Diagram d = GraphicalDataManager.getInstance() |
| .getUMADiagram(umaActivity, |
| IDiagramManager.ACTIVITY_DETAIL_DIAGRAM, false); |
| if (d != null) { |
| if (debug) { |
| System.out.println("ADD->"+proc.getName()+":"+umaActivity.getName()); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| ActivityDetailDiagram addDiagram = ModelFactory.eINSTANCE |
| .createActivityDetailDiagram(); |
| addDataToResource_ADDorWPD(proc, umaActivity, xmiResource, |
| addDiagram); |
| } |
| } |
| |
| private void addDataToResource_ADDorWPD(Process proc, Activity umaActivity, |
| Resource xmiResource, org.eclipse.epf.diagram.model.Diagram addOrWpdDiagram) { |
| Suppression sup = new Suppression(proc); |
| addOrWpdDiagram.setSuppression(sup); |
| String kind = null; |
| PreferencesHint prefHint = null; |
| if (addOrWpdDiagram instanceof ActivityDetailDiagram) { |
| addOrWpdDiagram.setFilter(ProcessAuthoringConfigurator.INSTANCE); |
| kind = DiagramManager.ADD_kind; |
| prefHint = ActivityDetailDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT; |
| } else if (addOrWpdDiagram instanceof WorkProductDependencyDiagram) { |
| kind = DiagramManager.WPD_kind; |
| prefHint = WPDDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT; |
| } else { |
| throw new UnsupportedOperationException(); |
| } |
| addOrWpdDiagram.setObject(umaActivity); |
| addOrWpdDiagram.setLinkedElement(umaActivity); |
| |
| // set suppression/published info for ADD/ WPDD |
| org.eclipse.epf.uma.Diagram umaDiagram = addOrWpdDiagram.getUMADiagram(); |
| if (umaDiagram != null) { |
| if (umaDiagram.getSuppressed().booleanValue()) { |
| if (addOrWpdDiagram instanceof ActivityDetailDiagram){ |
| DiagramOptions.setPublishADD(umaActivity, false); |
| } |
| else if (addOrWpdDiagram instanceof WorkProductDependencyDiagram) { |
| DiagramOptions.setPublishWPDD(umaActivity, false); |
| } |
| } |
| } |
| // get autoLayout flag if diagram is ADD |
| if (addOrWpdDiagram instanceof ActivityDetailDiagram) { |
| boolean value = GraphicalDataHelper |
| .isAutoLayout((ActivityDetailDiagram) addOrWpdDiagram); |
| ((ActivityDetailDiagram) addOrWpdDiagram).setAutoLayout(value); |
| } |
| |
| // Create diagram |
| Diagram diagram = ViewService.createDiagram(addOrWpdDiagram, kind, |
| prefHint); |
| diagram.setElement(addOrWpdDiagram); |
| diagram.setName(umaActivity.getName()); |
| |
| xmiResource.getContents().add(addOrWpdDiagram); |
| xmiResource.getContents().add(diagram); |
| |
| List nodes = new ArrayList(); |
| HashMap map = new HashMap(); |
| |
| |
| List diagramNodes = addOrWpdDiagram.getNodes(); |
| for (Iterator iterator = diagramNodes.iterator(); iterator.hasNext();) { |
| Object obj = iterator.next(); |
| if (obj instanceof Node ) { |
| Node node = (Node) obj; |
| if ((obj instanceof TypedNode) && |
| (((TypedNode)obj).getType() == TypedNode.FREE_TEXT)) { |
| // do special handing for free text node |
| org.eclipse.gmf.runtime.notation.Node text = MapUtil.createText(diagram, (Node) obj); |
| diagram.insertChild(text); |
| } |
| else { |
| // Create Notation nnode |
| org.eclipse.gmf.runtime.notation.Node notationNode = MapUtil.createNotationNode_ADDorWPD(diagram, node); |
| if (notationNode == null) { |
| continue; |
| } |
| diagram.insertChild(notationNode); |
| |
| Bounds bounds = NotationFactory.eINSTANCE.createBounds(); |
| bounds.setHeight(node.getHeight()); |
| bounds.setWidth(node.getWidth()); |
| bounds.setX(node.getLocation().x); |
| bounds.setY(node.getLocation().y); |
| notationNode.setLayoutConstraint(bounds); |
| |
| notationNode.setElement(node); |
| |
| nodes.add(node); |
| map.put(node, notationNode); |
| } |
| } |
| } |
| |
| |
| ConnectionFactory factory = new ConnectionFactory(diagram, map, kind); |
| // Create Outgoing connections |
| for (Iterator iterator = nodes.iterator(); iterator.hasNext();) { |
| Object obj = iterator.next(); |
| if (obj instanceof Node) { |
| factory.outgoingConnections((Node) obj); |
| } |
| } |
| |
| // Create Outgoing connections |
| for (Iterator iterator = nodes.iterator(); iterator.hasNext();) { |
| Object obj = iterator.next(); |
| if (obj instanceof Node) { |
| factory.incomingConnections((Node) obj); |
| } |
| } |
| |
| } |
| |
| |
| /** |
| * |
| * @param resource |
| * @param list |
| * @param process |
| */ |
| private void addDataToResource_AD( Resource xmiResource, Process proc, |
| Activity umaActivity) { |
| |
| org.eclipse.epf.uma.Diagram d = GraphicalDataManager.getInstance() |
| .getUMADiagram(umaActivity, IDiagramManager.ACTIVITY_DIAGRAM, |
| false); |
| if (d == null) { |
| return; |
| } |
| if (debug) { |
| System.out.println("AD->"+proc.getName()+":"+umaActivity.getName()); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| |
| // Create top level UML activity |
| EObject activity = UMLFactory.eINSTANCE.create(UMLPackage.eINSTANCE |
| .getActivity()); |
| if (activity instanceof org.eclipse.uml2.uml.Activity) { |
| ((org.eclipse.uml2.uml.Activity)activity).setName(umaActivity.getName()); |
| } |
| if (activity instanceof EModelElement) { |
| //BridgeHelper.addEAnnotation((EModelElement) activity, ((MethodElement) umaActivity)); |
| // UmaUmlUtil.createEAnnotationForUml((NamedElement) activity, |
| // umaActivity.getGuid()); |
| |
| BridgeHelper.associate((EModelElement) activity, umaActivity); |
| } |
| |
| // Create diagram |
| Diagram diagram = ViewService.createDiagram(activity, DiagramManager.AD_kind, |
| ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT); |
| diagram.setElement(activity); |
| if (activity instanceof org.eclipse.uml2.uml.Activity) { |
| diagram.setName(umaActivity.getName()); |
| } |
| |
| Suppression suppression = new Suppression(proc); |
| |
| ActivityDiagram ad = ModelFactory.eINSTANCE.createActivityDiagram(); |
| ad.setSuppression(suppression); |
| ad.setObject(umaActivity); |
| if (ad.isNew()) { |
| return; |
| } |
| |
| // set suppression/published info for AD |
| org.eclipse.epf.uma.Diagram umaDiagram = ad.getUMADiagram(); |
| if (umaDiagram != null) { |
| if (umaDiagram.getSuppressed().booleanValue()) { |
| DiagramOptions.setPublishAD(umaActivity, false); |
| } |
| } |
| |
| // return (List) ad.getNodes(); |
| |
| // List diagramNodes = getActivityDiagramData(suppression, umaActivity); |
| List diagramNodes = ad.getNodes(); |
| if (diagramNodes == null) { |
| return; |
| } |
| |
| |
| |
| xmiResource.getContents().add(activity); |
| xmiResource.getContents().add(diagram); |
| |
| List mapNodes = new ArrayList(); |
| HashMap mapNodesMap = new HashMap(); |
| |
| // Create UML and notation nodes |
| for (Iterator iterator = diagramNodes.iterator(); iterator.hasNext();) { |
| Object obj = iterator.next(); |
| if (obj instanceof Node ) { |
| if ((obj instanceof TypedNode) && |
| (((TypedNode)obj).getType() == TypedNode.FREE_TEXT)) { |
| // do special handing for free text node |
| org.eclipse.gmf.runtime.notation.Node text = MapUtil.createText(diagram, (Node) obj); |
| } |
| else { |
| MapNode mapNode = MapFactory.getInstance().create((Node) obj); |
| mapNode.setActivity((org.eclipse.uml2.uml.Activity)activity); |
| mapNode.setDiagram(diagram); |
| |
| mapNode.updateResource(); |
| mapNodes.add(mapNode); |
| mapNodesMap.put(mapNode, (Node) obj); |
| } |
| } |
| } |
| |
| // Create Outgoing connections |
| for (Iterator iterator = mapNodes.iterator(); iterator.hasNext();) { |
| Object obj = iterator.next(); |
| if (obj instanceof MapNode) { |
| ((MapNode) obj).outgoingConnections((Node) mapNodesMap.get((MapNode) obj)); |
| } |
| } |
| |
| // Create incoming connections |
| for (Iterator iterator = mapNodes.iterator(); iterator.hasNext();) { |
| Object obj = iterator.next(); |
| if (obj instanceof MapNode) { |
| ((MapNode) obj).incomingConnections((Node) mapNodesMap.get((MapNode) obj)); |
| } |
| } |
| } |
| |
| |
| /** |
| * Return activity diagram data |
| * @param sup |
| * @param activity |
| * @return |
| */ |
| private List getActivityDiagramData(Suppression sup, Activity activity) { |
| ActivityDiagram ad = ModelFactory.eINSTANCE.createActivityDiagram(); |
| ad.setSuppression(sup); |
| ad.setObject(activity); |
| if (ad.isNew()) { |
| return null; |
| } |
| return (List) ad.getNodes(); |
| |
| } |
| |
| private void addAD(final Resource resource, final Process proc, |
| final Activity umaActivity, final DiagramManager mgr) { |
| addToResource(resource, proc, umaActivity, mgr, 0); |
| } |
| |
| private void addADD(final Resource resource, final Process proc, |
| final Activity umaActivity, final DiagramManager mgr) { |
| addToResource(resource, proc, umaActivity, mgr, 1); |
| } |
| |
| private void addWPD(final Resource resource, final Process proc, |
| final Activity umaActivity, final DiagramManager mgr) { |
| addToResource(resource, proc, umaActivity, mgr, 2); |
| } |
| |
| //type: 0=AD, 1=ADD, 2=WPD |
| private void addToResource(final Resource resource, |
| final Process proc, final Activity umaActivity, |
| final DiagramManager mgr, final int type) { |
| SafeUpdateController.syncExec(new Runnable() { |
| public void run() { |
| try { |
| Transaction tx = mgr.getEditingDomain().startTransaction( |
| false, Collections.EMPTY_MAP); |
| |
| if (type == 0) { |
| addDataToResource_AD(resource, proc, umaActivity); |
| } else if (type == 1) { |
| addDataToResource_ADD(resource, proc, umaActivity); |
| } else if (type == 2) { |
| addDataToResource_WPD(resource, proc, umaActivity); |
| } else { |
| assert (false); |
| } |
| |
| tx.commit(); |
| } catch (Exception e) { |
| |
| } |
| } |
| }); |
| } |
| } |
