| //------------------------------------------------------------------------------ |
| // 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.ui.service; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.epf.diagram.ad.part.ActivityDiagramEditorPlugin; |
| import org.eclipse.epf.diagram.add.part.ADDiagramEditor; |
| import org.eclipse.epf.diagram.add.part.ActivityDetailDiagramEditorPlugin; |
| import org.eclipse.epf.diagram.core.part.AbstractDiagramEditor; |
| import org.eclipse.epf.diagram.core.part.DiagramEditorInput; |
| import org.eclipse.epf.diagram.core.part.DiagramEditorInputProxy; |
| import org.eclipse.epf.diagram.core.part.util.DiagramEditorUtil; |
| import org.eclipse.epf.diagram.core.services.DiagramHelper; |
| import org.eclipse.epf.diagram.core.services.DiagramManager; |
| import org.eclipse.epf.diagram.ui.DiagramUIPlugin; |
| import org.eclipse.epf.diagram.wpdd.part.WPDDiagramEditorPlugin; |
| import org.eclipse.epf.library.edit.ICommandListener; |
| import org.eclipse.epf.library.edit.process.BreakdownElementWrapperItemProvider; |
| import org.eclipse.epf.library.edit.util.DiagramOptions; |
| import org.eclipse.epf.library.edit.util.IDiagramManager; |
| import org.eclipse.epf.library.edit.util.ProcessUtil; |
| import org.eclipse.epf.library.edit.util.Suppression; |
| import org.eclipse.epf.library.edit.util.TngUtil; |
| 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.notation.Diagram; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IEditorReference; |
| import org.eclipse.ui.IWorkbenchPage; |
| |
| /** |
| * Helper class for diagram editor. |
| * |
| * @author Shashidhar Kannoori |
| * @author Phong Nguyen Le |
| * @since 1.2 |
| */ |
| public class DiagramEditorHelper { |
| private Map<Process, DiagramManager> processToDiagramManagerMap = new HashMap<Process, DiagramManager>(); |
| |
| public DiagramEditorHelper() { |
| } |
| |
| public DiagramManager getDiagramManager(Process proc) { |
| DiagramManager mgr = processToDiagramManagerMap.get(proc); |
| if(mgr != null && mgr.isDisposed()) { |
| processToDiagramManagerMap.remove(proc); |
| mgr = null; |
| } |
| if(mgr == null) { |
| synchronized (processToDiagramManagerMap) { |
| mgr = processToDiagramManagerMap.get(proc); |
| if(mgr == null) { |
| mgr = DiagramManager.getInstance(proc, this); |
| processToDiagramManagerMap.put(proc, mgr); |
| } |
| } |
| } |
| return mgr; |
| } |
| |
| public void openDiagram(IEditorPart part, int diagramType, Object selectedObject, Suppression suppression) { |
| try { |
| DiagramEditorInput input = new org.eclipse.epf.diagram.core.part.DiagramEditorInput( |
| selectedObject, suppression, diagramType); |
| DiagramEditorUtil.openDiagramEditor(part.getSite().getPage(), input, getDiagramPreferencesHint(diagramType), new NullProgressMonitor()); |
| } catch (RuntimeException e) { |
| DiagramUIPlugin.getDefault().getLogger().logError(e); |
| } |
| } |
| |
| public org.eclipse.gmf.runtime.notation.Diagram getDiagram(Activity activity, int type) { |
| org.eclipse.gmf.runtime.notation.Diagram diagram = null; |
| DiagramManager dMgr = getDiagramManager(TngUtil.getOwningProcess(activity)); |
| if (dMgr != null) { |
| try { |
| List<Diagram> list = dMgr.getDiagrams(activity, type); |
| if (!list.isEmpty()) { |
| diagram = (org.eclipse.gmf.runtime.notation.Diagram) list.get(0); |
| } |
| } catch (Exception e) { |
| DiagramUIPlugin.getDefault().getLogger().logError( |
| "Core error retrieving a diagram in process editor:", e); //$NON-NLS-1$ |
| } |
| } |
| return diagram; |
| } |
| |
| /** |
| * |
| * @param act |
| * @return |
| */ |
| public Collection getDiagrams(Activity act) { |
| |
| DiagramManager mgr = getDiagramManager(TngUtil.getOwningProcess(act)); |
| try{ |
| ArrayList<Diagram> diagrams = new ArrayList<Diagram>(); |
| for (int i = 0; i < DiagramHelper.DIAGRAM_TYPES.length; i++) { |
| List<Diagram> list = mgr.getDiagrams(act, DiagramHelper.DIAGRAM_TYPES[i]); |
| if (!list.isEmpty()) { |
| diagrams.addAll(list); |
| } |
| } |
| return diagrams; |
| }catch(Exception e){ |
| return Collections.EMPTY_LIST; |
| } |
| } |
| |
| public void dispose(){ |
| for (DiagramManager mgr : processToDiagramManagerMap.values()) { |
| try { |
| mgr.removeConsumer(this); |
| } |
| catch(Exception e) { |
| // |
| } |
| } |
| } |
| |
| public static int getDiagramType(Diagram diagram){ |
| return DiagramHelper.getDiagramType(diagram); |
| } |
| |
| public static String getDiagramTypeString(Diagram diagram){ |
| return DiagramHelper.getDiagramTypeString(diagram); |
| } |
| |
| public static PreferencesHint getDiagramPreferencesHint(int diagramType) { |
| switch(diagramType) { |
| case IDiagramManager.ACTIVITY_DIAGRAM: |
| return ActivityDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT; |
| case IDiagramManager.ACTIVITY_DETAIL_DIAGRAM: |
| return ActivityDetailDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT; |
| case IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM: |
| return WPDDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT; |
| } |
| return null; |
| } |
| |
| /** |
| * Close diagram editors |
| * |
| * @param closeElement |
| * @param closeEditorRefs |
| */ |
| public static void closeDiagramEditors(Object closeElement, |
| java.util.List<IEditorReference> closedEditorRefs) { |
| IWorkbenchPage workbenchPage = DiagramUIPlugin.getDefault() |
| .getWorkbench().getActiveWorkbenchWindow() |
| .getActivePage(); |
| if(workbenchPage == null) { |
| return; |
| } |
| IEditorReference[] editorReferences = workbenchPage.getEditorReferences(); |
| if(closedEditorRefs == null) { |
| closedEditorRefs = new ArrayList<IEditorReference>(); |
| } |
| ArrayList<IEditorReference> closeEditorRefs = new ArrayList<IEditorReference>(); |
| for (int i = 0; i < editorReferences.length; i++) { |
| IEditorReference reference = editorReferences[i]; |
| IEditorPart editor = reference.getEditor(true); |
| if (editor != null) { |
| IEditorInput input = editor.getEditorInput(); |
| Object element = null; |
| if (input instanceof DiagramEditorInputProxy) { |
| DiagramEditorInput diagramInput = ((DiagramEditorInputProxy) input).getDiagramEditorInput(); |
| if (diagramInput.getWrapper() != null) { |
| element = diagramInput.getWrapper(); |
| if(element instanceof BreakdownElementWrapperItemProvider){ |
| // close the parent editor too, if opened. |
| Object parent = ((BreakdownElementWrapperItemProvider)element).getParent(element); |
| if(parent instanceof BreakdownElementWrapperItemProvider){ |
| if(element.equals(closeElement)) |
| closeDiagramEditors(parent, closedEditorRefs); |
| } |
| } |
| } else { |
| element = diagramInput.getMethodElement(); |
| } |
| } |
| if (element != null) { |
| if (element.equals(closeElement)) { |
| closeEditorRefs.add(reference); |
| } else { |
| // check whether element is child of closeElement |
| // directly/indirectly |
| if (closeElement instanceof Activity) { |
| Collection collection = new ArrayList(); |
| ProcessUtil.getChildElements( |
| (Activity) closeElement, Activity.class, |
| collection); |
| if (collection.contains(element)) { |
| closeEditorRefs.add(reference); |
| } |
| } |
| } |
| } |
| } |
| } |
| int size = closeEditorRefs.size(); |
| IEditorReference[] references = new IEditorReference[size]; |
| for (int i = 0; i < size; i++) { |
| references[i] = (IEditorReference) closeEditorRefs.get(i); |
| } |
| workbenchPage.closeEditors(references, false); |
| references = null; |
| } |
| |
| /** |
| * Diagram editors of object itself will be closed. And Parent diagram |
| * editors will be refreshed. |
| * |
| */ |
| public static void refreshParentDiagramEditors(Object refreshElement, |
| java.util.List<IEditorReference> openEditorRefs, boolean parentRefresh) { |
| openEditorRefs = new ArrayList<IEditorReference>(); |
| // Now refresh object's parent's diagrams. |
| IWorkbenchPage workbenchPage = DiagramUIPlugin.getDefault() |
| .getWorkbench().getActiveWorkbenchWindow().getActivePage(); |
| IEditorReference[] editorReferences = workbenchPage |
| .getEditorReferences(); |
| for (int i = 0; i < editorReferences.length; i++) { |
| IEditorReference reference = editorReferences[i]; |
| IEditorPart editor = reference.getEditor(true); |
| if (editor != null) { |
| IEditorInput input = editor.getEditorInput(); |
| Object element = null; |
| if (input instanceof DiagramEditorInputProxy) { |
| DiagramEditorInput diagramInput = ((DiagramEditorInputProxy) input) |
| .getDiagramEditorInput(); |
| if (diagramInput.getWrapper() != null) { |
| element = diagramInput.getWrapper(); |
| if(parentRefresh){ |
| if (element instanceof BreakdownElementWrapperItemProvider) { |
| Object parent = ((BreakdownElementWrapperItemProvider) element) |
| .getParent(null); |
| if (parent instanceof BreakdownElementWrapperItemProvider) { |
| if (element.equals(refreshElement)) |
| refreshParentDiagramEditors(parent, |
| openEditorRefs, parentRefresh); |
| } |
| } |
| } |
| } else { |
| element = diagramInput.getMethodElement(); |
| } |
| } |
| if (element != null) { |
| if (element instanceof Activity) { |
| if(!parentRefresh){ |
| if(element == refreshElement){ |
| openEditorRefs.add(reference); |
| } |
| } |
| if (((Activity) element).getBreakdownElements() |
| .contains(refreshElement)) |
| openEditorRefs.add(reference); |
| else if (refreshElement instanceof BreakdownElementWrapperItemProvider) { |
| Object localRefreshElement = refreshElement; |
| while ((localRefreshElement instanceof BreakdownElementWrapperItemProvider) |
| && ((BreakdownElementWrapperItemProvider) localRefreshElement) |
| .getOwner() != null) { |
| if (((BreakdownElementWrapperItemProvider) localRefreshElement) |
| .getOwner().equals(element)) { |
| openEditorRefs.add(reference); |
| } |
| localRefreshElement = ((BreakdownElementWrapperItemProvider) localRefreshElement) |
| .getOwner(); |
| } |
| } |
| if(((Activity) element).getVariabilityBasedOnElement() != null){ |
| Activity base = (Activity)((Activity) element).getVariabilityBasedOnElement(); |
| if (((Activity) base).getBreakdownElements() |
| .contains(refreshElement)) |
| openEditorRefs.add(reference); |
| } |
| } else if (element instanceof BreakdownElementWrapperItemProvider) { |
| Collection c = ((BreakdownElementWrapperItemProvider) element) |
| .getChildren(element); |
| if (c != null && c.contains(refreshElement)) { |
| openEditorRefs.add(reference); |
| } |
| } |
| |
| } |
| } |
| } |
| int size = openEditorRefs.size(); |
| // IEditorReference[] references = new IEditorReference[size]; |
| for (int i = 0; i < size; i++) { |
| IEditorReference reference = (IEditorReference) openEditorRefs |
| .get(i); |
| IEditorPart editor = reference.getEditor(true); |
| if (editor instanceof AbstractDiagramEditor) { |
| ((AbstractDiagramEditor) editor).refreshDiagram(); |
| if(editor instanceof ADDiagramEditor){ |
| ((ADDiagramEditor)editor).runResetLayoutAction(); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Gets list of command listeners that will handle the diagram related changes of the commands of interesses |
| * |
| * @return |
| * @see ICommandListener |
| */ |
| // public static List<ICommandListener> getCommandListeners() { |
| // if (commandListeners == null) { |
| // commandListeners = new ArrayList<ICommandListener>(); |
| // } |
| // |
| // commandListeners.add(new ICommandListener() { |
| // |
| // public void notifyExecuted(Command command) { |
| // // get contributor/replacer of the activity |
| // // |
| // if(true) return; |
| // Activity act = (Activity) command.getResult().iterator().next(); |
| // Activity base = (Activity) act.getVariabilityBasedOnElement(); |
| // DiagramManager dMgr = null; |
| // DiagramManager baseMgr = null; |
| // try { |
| // if (base != null) { |
| // Activity parentAct = act.getSuperActivities(); |
| // dMgr = DiagramManager.getInstance(TngUtil |
| // .getOwningProcess(parentAct)); |
| // Diagram diagram = null; |
| // List<Diagram> diagrams = dMgr.getDiagrams(parentAct, |
| // IDiagramManager.ACTIVITY_DIAGRAM); |
| // if (!diagrams.isEmpty()) { |
| // diagram = diagrams.get(0); |
| // } |
| // if (diagram != null) { |
| // // find existing node for base and link it to the |
| // // contributore/replacer of the activity |
| // Node node = findNode(diagram, base); |
| // if (node != null) { |
| // NodeAdapter adapter = BridgeHelper |
| // .getNodeAdapter(node.getElement()); |
| // if (adapter != null |
| // && adapter.getElement() != act) { |
| // BridgeHelper.associate((EModelElement) node |
| // .getElement(), act); |
| // BridgeHelper |
| // .unmarkInHerited((EModelElement) node |
| // .getElement()); |
| // } |
| // } |
| // } |
| // if (act.getVariabilityType() == VariabilityType.LOCAL_CONTRIBUTION_LITERAL) { |
| // // copy diagrams and their publishing options |
| // baseMgr = DiagramManager |
| // .getInstance(TngUtil.getOwningProcess(base)); |
| // for (int i = 0; i < DiagramHelper.DIAGRAM_TYPES.length; i++) { |
| // int diagramType = DiagramHelper.DIAGRAM_TYPES[i]; |
| // List baseDiagrams = baseMgr.getDiagrams(base, |
| // diagramType); |
| // if (!baseDiagrams.isEmpty() && baseDiagrams.get(0) != null) { |
| // Diagram copy = baseMgr.createDiagram(act, |
| // diagramType, null); |
| // if (isPublishDiagram(base, diagramType)) { |
| // setDiagramOptions(act, diagramType); |
| // } |
| // } |
| // } |
| // } |
| // } |
| // }catch(Exception e){ |
| // |
| // } |
| // finally{ |
| // if(dMgr != null){ |
| // dMgr.release(); |
| // } |
| // if(baseMgr != null){ |
| // dMgr.release(); |
| // } |
| // } |
| // } |
| // |
| // public Class getCommandType() { |
| // return VaryActivityCommand.class; |
| // } |
| // |
| // public void preUndo(Command command) { |
| // // get old contributor/replacer of the activity |
| // // |
| // if(true) return; |
| // Activity act = (Activity) command.getResult().iterator().next(); |
| // VariabilityElement baseAct = act.getVariabilityBasedOnElement(); |
| // if (baseAct != null) { |
| // Activity parentAct = act.getSuperActivities(); |
| // DiagramManager dMgr = DiagramManager.getInstance(TngUtil.getOwningProcess(parentAct)); |
| // Diagram diagram = null; |
| // try { |
| // List diagrams = dMgr.getDiagrams(parentAct, |
| // GraphicalDataHelper.ACTIVITY_DIAGRAM); |
| // diagram = (Diagram) diagrams.get(0); |
| // if (diagram != null) { |
| // // find existing node for the old |
| // // contributore/replacer |
| // // old and relink it to the base activity |
| // Node node = findNode(diagram, act); |
| // if (node != null) { |
| // NodeAdapter adapter = BridgeHelper |
| // .getNodeAdapter(node.getElement()); |
| // if (adapter != null |
| // && adapter.getElement() != baseAct) { |
| // BridgeHelper.associate((EModelElement) node |
| // .getElement(), baseAct); |
| // BridgeHelper |
| // .markInherited((EModelElement) node |
| // .getElement()); |
| // } |
| // } |
| // } |
| // // remove diagrams |
| // |
| // |
| // }catch(Exception e){ |
| // |
| // } |
| // finally { |
| // |
| // } |
| // } |
| // } |
| // |
| // public void preExecute(Command command) { |
| // |
| // } |
| // |
| // }); |
| // |
| // return commandListeners; |
| // } |
| |
| public static void setDiagramOptions(Activity activity , int diagramType){ |
| switch(diagramType){ |
| case IDiagramManager.ACTIVITY_DIAGRAM: |
| DiagramOptions.setPublishAD(activity, false); |
| break; |
| case IDiagramManager.ACTIVITY_DETAIL_DIAGRAM: |
| DiagramOptions.setPublishADD(activity, false); |
| break; |
| case IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM: |
| DiagramOptions.setPublishWPDD(activity, false); |
| break; |
| } |
| } |
| |
| public static boolean isPublishDiagram(Activity activity, int diagramType){ |
| switch(diagramType){ |
| case IDiagramManager.ACTIVITY_DIAGRAM: |
| return DiagramOptions.isPublishAD(activity); |
| case IDiagramManager.ACTIVITY_DETAIL_DIAGRAM: |
| return DiagramOptions.isPublishADD(activity); |
| case IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM: |
| return DiagramOptions.isPublishWPDD(activity); |
| } |
| return false; |
| } |
| } |
