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