//------------------------------------------------------------------------------
// Copyright (c) 2005, 2006 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.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
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.DiagramHelper;
import org.eclipse.epf.diagram.core.services.DiagramManager;
import org.eclipse.epf.diagram.model.util.IAdapterFactoryFilter;
import org.eclipse.epf.diagram.ui.DiagramUIPlugin;
import org.eclipse.epf.diagram.ui.viewer.AbstractDiagramGraphicalViewer;
import org.eclipse.epf.diagram.ui.viewer.NewActivityDetailDiagramViewer;
import org.eclipse.epf.diagram.ui.viewer.NewActivityDiagramViewer;
import org.eclipse.epf.diagram.ui.viewer.NewWPDependencyDiagramViewer;
import org.eclipse.epf.diagram.wpdd.part.WPDDiagramEditorPlugin;
import org.eclipse.epf.library.configuration.ConfigurationHelper;
import org.eclipse.epf.library.edit.IFilter;
import org.eclipse.epf.library.edit.IMethodConfigurationProvider;
import org.eclipse.epf.library.edit.TngAdapterFactory;
import org.eclipse.epf.library.edit.VariabilityInfo;
import org.eclipse.epf.library.edit.process.BSActivityItemProvider;
import org.eclipse.epf.library.edit.process.BreakdownElementWrapperItemProvider;
import org.eclipse.epf.library.edit.process.IBSItemProvider;
import org.eclipse.epf.library.edit.util.ConfigurableComposedAdapterFactory;
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.edit.util.TngUtil;
import org.eclipse.epf.library.layout.ProcessAdapterFactoryFilter;
import org.eclipse.epf.library.layout.diagram.DiagramInfo;
import org.eclipse.epf.library.services.SafeUpdateController;
import org.eclipse.epf.library.util.ResourceHelper;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.BreakdownElement;
import org.eclipse.epf.uma.MethodConfiguration;
import org.eclipse.epf.uma.VariabilityElement;
import org.eclipse.gef.EditPart;
import org.eclipse.gmf.runtime.diagram.core.preferences.PreferencesHint;
import org.eclipse.gmf.runtime.notation.Diagram;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.ImageLoader;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
/**
* Provides service methods for creating diagram images for activity elements
*
* @author Shashidhar Kannoori
* @author Jinhua Xi
* @since 1.0
*/
public class DiagramImageService implements IDiagramImageService {
static boolean debug = DiagramUIPlugin.getDefault().isDebugging();
private Composite parent = null;
private Composite holder = null;
private File pubDir;
private boolean forXMLExport = false;
private static Map<String, Integer> typeMap = new HashMap<String, Integer>();
private DiagramInfo diagramInfo = null;
private boolean publishUncreatedADD = true;
private boolean publishADForActivityExtension = true;
private boolean exist = true;
private MethodConfiguration config = null;
static {
typeMap.put(ResourceHelper.DIAGRAM_TYPE_WORKFLOW, new Integer(
IDiagramManager.ACTIVITY_DIAGRAM));
typeMap.put(ResourceHelper.DIAGRAM_TYPE_ACTIVITY_DETAIL, new Integer(
IDiagramManager.ACTIVITY_DETAIL_DIAGRAM));
typeMap.put(ResourceHelper.DIAGRAM_TYPE_WP_DEPENDENCY, new Integer(
IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM));
}
public static int getIntType(String diagramType) {
Integer type = (Integer) typeMap.get(diagramType);
if (type != null) {
return type.intValue();
}
return -1;
}
public static PreferencesHint getPreferenceHint(String diagramType){
int type = getIntType(diagramType);
switch (type) {
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;
default:
return null;
}
}
public static String getStringType(int type) {
switch(type) {
case IDiagramManager.ACTIVITY_DIAGRAM:
return ResourceHelper.DIAGRAM_TYPE_WORKFLOW;
case IDiagramManager.ACTIVITY_DETAIL_DIAGRAM:
return ResourceHelper.DIAGRAM_TYPE_ACTIVITY_DETAIL;
case IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM:
return ResourceHelper.DIAGRAM_TYPE_WP_DEPENDENCY;
}
return null;
}
Shell shell = null;
private Set<DiagramManager> diagramManagers = new HashSet<DiagramManager>();
// public DiagramImageService() {
// this(null, new File(LibraryService.getInstance().getCurrentMethodLibraryPath()));
// }
public DiagramImageService(File pubDir) {
this(null, pubDir);
}
public DiagramImageService(Composite parent, File pubDir) {
this.parent = parent;
this.pubDir = pubDir;
}
private AbstractDiagramGraphicalViewer getDiagramViewer(int diagramType, Object wrapper) {
// if the shell window is distroyed, recreate it
if ((this.shell != null) && this.shell.isDisposed()) {
this.parent = null;
this.shell = null;
}
getViewerHolder(parent);
switch (diagramType) {
case IDiagramManager.ACTIVITY_DIAGRAM:
return new NewActivityDiagramViewer(holder, wrapper);
case IDiagramManager.ACTIVITY_DETAIL_DIAGRAM:
return new NewActivityDetailDiagramViewer(holder,wrapper);
case IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM:
return new NewWPDependencyDiagramViewer(holder,wrapper);
default:
return null;
}
}
private void getViewerHolder(Composite parent) {
if (parent == null) {
if (shell == null || shell.isDisposed()) {
shell = createShell();
}
shell.open();
parent = shell;
}
if (holder != null) {
holder.dispose();
}
holder = new Composite(parent, SWT.NONE);
holder.setLayoutData(new GridData(1, 1)); // size can't be 0,0
// otherwise the diagram
// will not be painted
holder.setLayout(new GridLayout());
holder.setVisible(false);
}
private Shell createShell() {
Shell shell = null;
Display d = Display.getDefault();
shell = new Shell(d);
GridLayout layout = new GridLayout();
layout.marginHeight = 0;
layout.marginWidth = 0;
shell.setLayout(layout);
shell.setBounds(0, 0, 0, 0);
shell.setVisible(false);
return shell;
}
public void dispose() {
if ((shell != null) && (!shell.isDisposed())) {
shell.close();
shell.dispose();
}
for (DiagramManager mgr : diagramManagers) {
mgr.removeConsumer(this);
}
}
/**
* save the element diagram image and returns the image file url.
*
* @param wrapper
* @param imgPath
* @param diagramType
* @param filter
* IFilter
* @param sup
* Suppression
* @return String the image path relative to the publishing dir
*
* @see org.eclipse.epf.library.layout.diagram.IActivityDiagramService#saveDiagram(java.lang.Object, java.lang.String, java.lang.String, org.eclipse.epf.library.edit.IFilter, org.eclipse.epf.library.edit.util.Suppression)
*/
public DiagramInfo saveDiagram(final Object wrapper, final String imgPath,
final String diagramType, final IFilter filter,
final Suppression sup) {
// initialize the diagramInfo
diagramInfo = null;
// grab the UI thread to avoid thread access error
SafeUpdateController.syncExec(new Runnable() {
public void run() {
__internal_saveDiagram(wrapper, imgPath, diagramType, filter, sup);
}
});
return diagramInfo;
}
private boolean hasUserDefinedDiagram(Activity e, String imgPath, int type)
throws Exception {
// if there is a user defined diagram, use it
org.eclipse.epf.diagram.model.util.DiagramInfo info = new org.eclipse.epf.diagram.model.util.DiagramInfo(
(Activity) e);
switch (type) {
case IDiagramManager.ACTIVITY_DIAGRAM:
if (info.canPublishADImage()) {
return (info.getActivityDiagram() != null)
&& info.canPublishADImage();
}
break;
case IDiagramManager.ACTIVITY_DETAIL_DIAGRAM:
if (info.canPublishADDImage()) {
return (info.getActivityDetailDiagram() != null)
&& info.canPublishADDImage();
}
break;
case IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM:
if (info.canPublishWPDImage()) {
return (info.getWPDDiagram() != null)
&& info.canPublishWPDImage();
}
break;
default:
break;
}
return false;
}
private void __internal_saveDiagram(Object wrapper, final String imgPath,
String diagramType, IFilter filter, Suppression sup) {
if (sup.isSuppressed(wrapper)) {
return;
}
// DiagramInfo diagramInfo = null;
int type = getIntType(diagramType);
if (type < 0) {
return;
}
_internal_generateImage(wrapper, imgPath, type, filter, sup, true, true);
}
/**
* Creates a diagram JPEG for given Activity and
*
* @param wrapper
* @param imgPath
* @param diagramType
* @param filter
* @param sup
* @return
*/
public String generateDiagramImage(final Object wrapper, final String imgPath,
final int diagramType, final IFilter filter,
final Suppression sup, final boolean realizedDiagram){
SafeUpdateController.syncExec(new Runnable() {
public void run() {
_internal_generateImage(wrapper, imgPath, diagramType, filter, sup, false, realizedDiagram);
}
});
return imgPath;
}
/**
* Method to create a diagram viewer and generate image and saves the image.
*
*
* @param wrapper
* @param imgPath
* @param diagramType
* @param filter
* @param sup
* @param calculateDiagramInfo
*/
private void _internal_generateImage(Object wrapper, final String imgPath,
int type, IFilter filter, Suppression sup, boolean calculateDiagramInfo,
boolean realizedDiagram){
exist = true;
Image image = null;
Object o = TngUtil.unwrap(wrapper);
if (!(o instanceof Activity)) {
return;
}
Activity e = (Activity) o;
AbstractDiagramGraphicalViewer viewer = null;
// keep the dirty flag and reset back to avoid make the library dirty
boolean dirtyFlag = e.eResource().isModified();
try {
Object object = canCreateImage(wrapper, imgPath, type, filter, sup);
if(realizedDiagram && object == null){
return;
}else{
wrapper = object;
}
try {
viewer = getDiagramViewer(type, wrapper);
if(config != null){
viewer.setMethodConfiguration(config);
}
EditPart diagramEditPart = viewer.loadDiagram(wrapper, !exist, filter, sup);
if(diagramEditPart == null){
if(debug){
DiagramUIPlugin.getDefault().getLogger().
logError("Publishing: DiagramImageService viewer EditPart is null: "+wrapper); //$NON-NLS-1$
}
return;
}else{
if(diagramEditPart.getChildren().isEmpty())
return;
}
if(calculateDiagramInfo){
diagramInfo = viewer.getDiagramInfo();
}
image = viewer.createDiagramImage();
if (image != null) {
// save the image
File f = new File(pubDir, imgPath);
// make sure the file is created otherwise exception
File parent = f.getParentFile();
if (!parent.exists()) {
parent.mkdirs();
}
if (!f.exists()) {
f.createNewFile();
}
OutputStream os = new FileOutputStream(f);
ImageLoader loader = new ImageLoader();
loader.data = new ImageData[] { image.getImageData() };
loader.save(os, SWT.IMAGE_JPEG);
} else {
DiagramUIPlugin.getDefault().getLogger().logError(
"Failed to create diagram image for" + e); //$NON-NLS-1$
}
if (calculateDiagramInfo && diagramInfo != null && !diagramInfo.isEmpty()) {
diagramInfo.setImageFilePath(imgPath);
}
} catch (RuntimeException e1) {
e1.printStackTrace();
}
// delete the newly created diagram from the library
if (!exist) {
Diagram d = getDiagram(e, type);
if (d != null) {
DiagramHelper.deleteDiagram(d, false);
}
}
} catch (Exception ex) {
DiagramUIPlugin.getDefault().getLogger().logError("Exception"+e); //$NON-NLS-1$
} finally {
try {
// restore the dirty flag
e.eResource().setModified(dirtyFlag);
if (viewer != null) {
viewer.dispose();
}
if (image != null) {
image.dispose();
}
} catch (RuntimeException e1) {
e1.printStackTrace();
}
}
}
private Object canCreateImage(Object wrapper, final String imgPath,
int type, IFilter filter, Suppression suppression){
Object o = TngUtil.unwrap(wrapper);
if (!(o instanceof Activity)) {
return null;
}
try{
//MethodElement e = (MethodElement)o;
Activity e = (Activity) o;
if (hasUserDefinedDiagram((Activity) e, imgPath, type)) {
return null;
}
// Check diagram exists, don't generate for suppressed.
Diagram d = getDiagram(e, type);
// Check publishing options.
exist = (d != null);
if (isForXMLExport()) {
if (exist && canPublishDiagram(d,e)) {
return e;
}
return null;
}
if (exist) {
if(!canPublishDiagram(d,e)) return null;
if (type == IDiagramManager.ACTIVITY_DIAGRAM ) {
// If an extension has its own diagram. Base is replaced or
// contributed.extension diagram shows realized element in undefined
// location. In publishing don't display extension diagram even if it has
// its own diagram if realized elements are coming in through
// variability.
if ( isBreakdownElementsReplaced(e, filter) ) {
return null;
}
// if the object is a wrapper, the diagram is from it's base,
// don't show the AD id the preference is not set
if ( (e != wrapper) && !publishADForActivityExtension ) {
return null;
}
// Check variability and base's variability.
// VariabilityElement calculatedBase = checkVariability(e,
// filter, type);
// if (calculatedBase != null) {
// wrapper = calculatedBase;
// }
} else if ( type == IDiagramManager.ACTIVITY_DETAIL_DIAGRAM) {
if ( (e != wrapper) && !publishUncreatedADD ) {
return null;
}
}
} else {
if ((type == IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM))
return null;
// For Activity Diagram un opened extension publish.
if (type == IDiagramManager.ACTIVITY_DIAGRAM) {
// If option is not checked, don't generate a diagram
if (!publishADForActivityExtension)
return null;
// If extension is modified don't generate it.
if (!e.getBreakdownElements().isEmpty())
return null;
// Check any child is suppressed.
// if any child is suppresed don't generate diagram
if(anyChildrenSuppressed(wrapper, filter, suppression))
return null;
// Check variability and base's variability.
VariabilityElement calculatedBase = checkVariability(e,
filter, type);
if (calculatedBase == null) {
return null;
}
wrapper = calculatedBase;
e = (Activity) calculatedBase;
exist = true;
}
if (publishUncreatedADD == false
&& type == IDiagramManager.ACTIVITY_DETAIL_DIAGRAM) {
boolean contributorexist = false;
// This is need, if contributor has a ADD diagram, base don't
// base should generate ADD in browsing.
MethodConfiguration config = null;
if (filter instanceof ProcessAdapterFactoryFilter) {
config = ((ProcessAdapterFactoryFilter) filter)
.getMethodConfiguration();
}
if (config == null)
return null;
// Get immediate contributors first, and check immediate
// contributors
// have anything extra breakdown elements.
List list = ConfigurationHelper.getContributors(e, config);
if (e instanceof Activity) {
Iterator iterator = list.iterator();
if (iterator != null) {
while (iterator.hasNext()) {
Object act = iterator.next();
if (act != null) {
Diagram dx = getDiagram((Activity)act, type);
if (dx != null) {
contributorexist = true;
break;
}
}
}
}
}
if (!contributorexist)
return null;
}
}
}catch(Exception e){
return null;
}
return wrapper;
}
private boolean canPublishDiagram(Diagram diagram, Activity activity) {
switch (DiagramHelper.getDiagramType(diagram)) {
case IDiagramManager.ACTIVITY_DIAGRAM:
if (DiagramOptions.isPublishAD(activity)) {
return true;
}
break;
case IDiagramManager.ACTIVITY_DETAIL_DIAGRAM:
if (DiagramOptions.isPublishADD(activity)) {
return true;
}
break;
case IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM:
if (DiagramOptions.isPublishWPDD(activity)) {
return true;
}
break;
}
return false;
}
private boolean anyChildrenSuppressed(Object wrapper, IFilter filter, Suppression suppression) {
ITreeItemContentProvider adapter = getAdapter(wrapper, filter);
boolean oldRolledUp = false;
if(adapter instanceof BSActivityItemProvider) {
BSActivityItemProvider itemProvider = (BSActivityItemProvider)adapter;
oldRolledUp = itemProvider.isRolledUp();
itemProvider.basicSetRolledUp(false);
}
else if(adapter instanceof IBSItemProvider){
IBSItemProvider itemProvider = (IBSItemProvider)adapter;
oldRolledUp = itemProvider.isRolledUp();
itemProvider.setRolledUp(false);
}
try {
// filter out the suppressed elements
//
Object element = TngUtil.unwrap(wrapper);
for (Iterator iter = adapter.getChildren(element).iterator(); iter.hasNext();) {
Object child = iter.next();
if(suppression.isSuppressed(child)) {
return true;
}
}
}
finally {
// restore the rolled-up flag
//
if(adapter instanceof IBSItemProvider) {
((IBSItemProvider)adapter).setRolledUp(oldRolledUp);
}
}
return false;
}
/**
* Moved code from getChildren. getAdapter() will return Adapter,
* which will allow us to find itemprovider for the children.
*
* @return
*/
private ITreeItemContentProvider getAdapter(Object wrapper, IFilter filter){
ITreeItemContentProvider adapter = null;
if (wrapper instanceof BreakdownElementWrapperItemProvider) {
adapter = (BreakdownElementWrapperItemProvider)wrapper;
} else {
adapter = (ITreeItemContentProvider) getAdapterFactory(filter).adapt(
wrapper, ITreeItemContentProvider.class);
}
return adapter;
}
AdapterFactory getAdapterFactory(IFilter filter){
AdapterFactory adapterFactory = null;
if (filter == null) {
adapterFactory = TngAdapterFactory.INSTANCE.getWBS_ComposedAdapterFactory();
} else if (filter instanceof IAdapterFactoryFilter) {
adapterFactory = (ConfigurableComposedAdapterFactory) ((IAdapterFactoryFilter) filter)
.getWBSAdapterFactory();
}
return adapterFactory;
}
private VariabilityElement checkVariability(VariabilityElement e, IFilter filter,
int type) {
MethodConfiguration config = null;
if (filter instanceof ProcessAdapterFactoryFilter) {
config = ((ProcessAdapterFactoryFilter) filter)
.getMethodConfiguration();
}
if (config == null)
return null;
// Get immediate contributors first, and check immediate contributors
// have anything extra breakdown elements.
List list = ConfigurationHelper.getContributors(e, config);
for (Iterator iterator = list.iterator(); iterator.hasNext();) {
Object next = iterator.next();
if (next instanceof Activity) {
if (!((Activity) next).getBreakdownElements().isEmpty())
return null;
}
}
// Get all Contributors from parent chain and contributor chain for the
// element e.
VariabilityInfo eInfo = ((ProcessAdapterFactoryFilter) filter)
.getVariabilityInfo((VariabilityElement) e);
List contributors = eInfo.getContributors();
VariabilityElement ve = e.getVariabilityBasedOnElement();
if (ve == null) {
return null;
}
Activity replacer = (Activity) ConfigurationHelper.getReplacer(ve,
config);
if (replacer != null) {
ve = replacer;
Diagram replacerDiagram = getDiagram(replacer, type);
if (replacerDiagram != null) {
return replacer;
} else {
return null;
}
} else {
Diagram baseDiagram = getDiagram((Activity) ve, type);
if (baseDiagram != null) {
// Check first if baseDiagram is suppressed.
if(BridgeHelper.isSuppressed(baseDiagram)) return null;
// Find the contributors of Base
VariabilityInfo veInfo = ((ProcessAdapterFactoryFilter) filter)
.getVariabilityInfo((VariabilityElement) ve);
List veContributors = veInfo.getContributors();
if (contributors.size() != veContributors.size()) {
for (Iterator iterator = contributors.iterator(); iterator
.hasNext();) {
Object next = iterator.next();
if (!veContributors.contains(next)) {
if (!((Activity) next).getBreakdownElements()
.isEmpty()) {
return null;
}
}
}
}
return ve;
}else{
// If no base diagram, check base of base had any diagram.
return checkVariability(ve, filter, type);
}
}
}
public VariabilityElement checkVariability(VariabilityElement e, IFilter filter,
int type, boolean checkUDD) {
MethodConfiguration config = null;
org.eclipse.epf.diagram.model.util.DiagramInfo uddInfo = null;
if (filter instanceof ProcessAdapterFactoryFilter) {
config = ((ProcessAdapterFactoryFilter) filter)
.getMethodConfiguration();
}
if (config == null)
return null;
// Get immediate contributors first, and check immediate contributors
// have anything extra breakdown elements.
List list = ConfigurationHelper.getContributors(e, config);
for (Iterator iterator = list.iterator(); iterator.hasNext();) {
Object next = iterator.next();
if (next instanceof Activity) {
if (!((Activity) next).getBreakdownElements().isEmpty())
return null;
}
}
// Get all Contributors from parent chain and contributor chain for the
// element e.
VariabilityInfo eInfo = ((ProcessAdapterFactoryFilter) filter)
.getVariabilityInfo((VariabilityElement) e);
List contributors = eInfo.getContributors();
VariabilityElement ve = e.getVariabilityBasedOnElement();
if (ve == null) {
return null;
}
Activity replacer = (Activity) ConfigurationHelper.getReplacer(ve,
config);
if (replacer != null) {
ve = replacer;
Diagram replacerDiagram = getDiagram(replacer, type);
if(checkUDD){
uddInfo = new org.eclipse.epf.diagram.model.util.DiagramInfo(replacer);
if(uddInfo.canPublishADImage() && uddInfo.getActivityDiagram() != null){
return replacer;
}
}else{
if (replacerDiagram != null) {
return replacer;
}
}
return null;
} else {
Diagram baseDiagram = null;
if(checkUDD){
uddInfo = new org.eclipse.epf.diagram.model.util.DiagramInfo((Activity)ve);
}else{
baseDiagram = getDiagram((Activity) ve, type);
}
if (baseDiagram != null || (uddInfo != null && uddInfo.canPublishADImage() && uddInfo.getActivityDiagram() != null)) {
// Check first if baseDiagram is suppressed.
// if(BridgeHelper.isSuppressed(baseDiagram)) return null;
// Find the contributors of Base
VariabilityInfo veInfo = ((ProcessAdapterFactoryFilter) filter)
.getVariabilityInfo((VariabilityElement) ve);
List veContributors = veInfo.getContributors();
if (contributors.size() != veContributors.size()) {
for (Iterator iterator = contributors.iterator(); iterator
.hasNext();) {
Object next = iterator.next();
if (!veContributors.contains(next)) {
if (!((Activity) next).getBreakdownElements()
.isEmpty()) {
return null;
}
}
}
}
return ve;
}else{
// If no base diagram, check base of base had any diagram.
return checkVariability(ve, filter, type);
}
}
}
/**
* Set the window's preference attribute for Activity Detail Diagram.
*
*/
public void setPublishedUnCreatedADD(boolean flag) {
this.publishUncreatedADD = flag;
}
/**
* Set the window's preference attribute for Acitivyt Diagram
*
*/
public void setPublishADForActivityExtension(boolean flag){
this.publishADForActivityExtension = flag;
}
// private DiagramGenerator createDiagramImage(DiagramEditPart diagramEP, ImageFileFormat fileFormat)
// throws CoreException {
// CopyToImageUtil util = new CopyToImageUtil();
// DiagramGenerator dGen = util.copyToImage(diagramEP, new Path(pubDir.getPath()), fileFormat, new NullProgressMonitor());
// dGen.createAWTImageForDiagram();
// return dGen;
// }
public Diagram getDiagram(Activity e, int type){
DiagramManager dMgr = getDiagramManager(e);
Diagram diagram = null;
if (dMgr != null) {
try {
List<Diagram> list = dMgr.getDiagrams(e, type);
if (!list.isEmpty()) {
diagram = (Diagram) list.get(0);
}
} catch (Exception ex) {
DiagramUIPlugin.getDefault().getLogger().logError(
"Error in getDiagram()" + ex.getMessage()); //$NON-NLS-1$
}
}
return diagram;
}
private DiagramManager getDiagramManager(Activity e) {
DiagramManager mgr = DiagramManager.getInstance(TngUtil.getOwningProcess(e), this);
diagramManagers .add(mgr);
return mgr;
}
/**
* gets the method configuration
* @return
*/
public MethodConfiguration getConfig() {
return config;
}
/**
* sets the method configuration.
* @param config
*/
public void setConfig(MethodConfiguration config) {
this.config = config;
}
/**
* Checks any breakdownelements of an Activity has a replacer.
*
* @param element
* VariabilityElement the element
* @param config
* MethodConfiguration
* @return VariabilityElement the replacer if there is one and ONLY one,
* null otherwise
*/
private boolean isBreakdownElementsReplaced(Activity activity,
IFilter filter) {
MethodConfiguration config = null;
if (filter instanceof IMethodConfigurationProvider) {
config = ((IMethodConfigurationProvider) filter)
.getMethodConfiguration();
}
if (config == null)
return true;
for (Iterator iter = activity.getBreakdownElements().iterator(); iter
.hasNext();) {
BreakdownElement element = (BreakdownElement) iter.next();
if (element instanceof Activity) {
if(ConfigurationHelper.getReplacer((Activity)element, config) != null)
return true;
}
}
return false;
}
/**
* Method to get a DiagramViewer for given activity.
* Without doing realization and doesn't check for diagram exists or not.
*/
public AbstractDiagramGraphicalViewer getDiagramViewer(final Object wrapper,
final int type, final IFilter filter,
final Suppression sup){
Object o = TngUtil.unwrap(wrapper);
if (!(o instanceof Activity)) {
return null;
}
Activity e = (Activity) o;
AbstractDiagramGraphicalViewer viewer = null;
if (type < 0) {
return null;
}
viewer = getDiagramViewer(type, wrapper);
return viewer;
}
public Activity getRealizedForUnmodified(Object wrapper, IFilter filter,
Suppression suppression){
Activity activity = (Activity)TngUtil.unwrap(wrapper);
if ( activity == null ) {
return null;
}
if (!publishADForActivityExtension)
return null;
// If extension is modified don't generate it.
if (!activity.getBreakdownElements().isEmpty())
return null;
// Check any child is suppressed.
// if any child is suppresed don't generate diagram
if(anyChildrenSuppressed(activity, filter, suppression))
return null;
// Check variability and base's variability.
VariabilityElement calculatedBase = checkVariability(activity,
filter, IDiagramManager.ACTIVITY_DIAGRAM, true);
if (calculatedBase == null) {
return null;
}
wrapper = calculatedBase;
return (Activity)wrapper;
}
/**
* @param pubDir
*/
public void setPubDir(File pubDir) {
this.pubDir = pubDir;
}
private boolean isForXMLExport() {
return forXMLExport;
}
/**
* @param forXMLExport
*/
public void setForXMLExport(boolean forXMLExport) {
this.forXMLExport = forXMLExport;
}
}