//------------------------------------------------------------------------------
// Copyright (c) 2005, 2008 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.library;
import java.util.Collection;
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.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.util.InternalEList;
import org.eclipse.epf.library.configuration.ConfigurationData;
import org.eclipse.epf.library.configuration.ConfigurationHelper;
import org.eclipse.epf.library.configuration.DefaultElementRealizer;
import org.eclipse.epf.library.configuration.ElementRealizer;
import org.eclipse.epf.library.configuration.SupportingElementData;
import org.eclipse.epf.library.edit.configuration.PracticeSubgroupItemProvider;
import org.eclipse.epf.library.edit.process.ActivityWrapperItemProvider;
import org.eclipse.epf.library.edit.realization.IRealizationManager;
import org.eclipse.epf.library.edit.uma.MethodElementExt.MethodConfigurationExt;
import org.eclipse.epf.library.edit.util.LibraryEditUtil;
import org.eclipse.epf.library.edit.util.MethodConfigurationPropUtil;
import org.eclipse.epf.library.edit.util.MethodElementPropUtil;
import org.eclipse.epf.library.edit.util.MethodElementPropertyHelper;
import org.eclipse.epf.library.edit.util.PropUtil;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.library.layout.BrowsingLayoutSettings;
import org.eclipse.epf.library.layout.HtmlBuilder;
import org.eclipse.epf.library.layout.IElementLayout;
import org.eclipse.epf.library.layout.elements.AbstractElementLayout;
import org.eclipse.epf.library.layout.elements.AbstractProcessElementLayout;
import org.eclipse.epf.library.layout.elements.ElementLayoutExtender;
import org.eclipse.epf.library.layout.elements.SummaryPageLayout;
import org.eclipse.epf.library.persistence.ILibraryResourceSet;
import org.eclipse.epf.library.realization.RealizationManagerFactory;
import org.eclipse.epf.library.util.LibraryUtil;
import org.eclipse.epf.library.util.ResourceHelper;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.BreakdownElement;
import org.eclipse.epf.uma.ContentCategory;
import org.eclipse.epf.uma.CustomCategory;
import org.eclipse.epf.uma.MethodConfiguration;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodElementProperty;
import org.eclipse.epf.uma.MethodLibrary;
import org.eclipse.epf.uma.MethodPackage;
import org.eclipse.epf.uma.MethodPlugin;
import org.eclipse.epf.uma.Process;
import org.eclipse.epf.uma.ProcessComponent;
import org.eclipse.epf.uma.ProcessPackage;
import org.eclipse.epf.uma.UmaPackage;
import org.eclipse.epf.uma.ecore.impl.MultiResourceEObject;
import org.eclipse.epf.uma.ecore.util.OppositeFeature;
import org.eclipse.epf.uma.util.Scope;
import org.eclipse.swt.SWT;
import org.eclipse.ui.IPerspectiveDescriptor;
import org.eclipse.ui.IPerspectiveListener;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
/**
* Delegate class used in ConfigurationHelper
*
* @author Weiping Lu
* @since 1.5
*/
public class ConfigHelperDelegate {
private boolean generateHtmlMode = false;
private boolean publishingMode = false;
private boolean authoringPerspective = false;
private MethodConfiguration config;
private boolean loadForBrowsingNeeded = true;
private boolean autoSyncedByBrowsing = false;
private Map<MethodElement, Set<CustomCategory>> dynamicCustomCategoriesMap;
public ConfigHelperDelegate() {
LibraryService.getInstance().addListener(libServiceListener);
IRealizationManager mgr = RealizationManagerFactory.getInstance().newRealizationManager(null);
LibraryEditUtil.getInstance().setDefaultRealizationManager(mgr);
}
protected boolean hasDynamicElements(CustomCategory cc) {
MethodElementProperty prop = MethodElementPropertyHelper.getProperty(
cc,
MethodElementPropertyHelper.CUSTOM_CATEGORY__INCLUDED_ELEMENTS);
return prop != null;
}
public void buildDynamicCustomCategoriesMap(MethodConfiguration config) {
try {
if (config == null) {
return;
}
ConfigurationHelper.getDelegate().loadUserDefinedType();
dynamicCustomCategoriesMap = new HashMap<MethodElement, Set<CustomCategory>>();
ElementRealizer realizer = DefaultElementRealizer.newElementRealizer(config);
Set<CustomCategory> set = new HashSet<CustomCategory>();
MethodElementPropUtil propUtil = MethodElementPropUtil.getMethodElementPropUtil();
for (MethodPlugin plugin : config.getMethodPluginSelection()) {
for (CustomCategory cc : TngUtil.getAllCustomCategories(plugin)) {
cc = (CustomCategory) ConfigurationHelper.getCalculatedElement(cc, realizer);
if (cc != null && hasDynamicElements(cc)) {
set.add(cc);
}
}
}
for (CustomCategory cc : set) {
for (MethodElement element : (List<MethodElement>) ConfigurationHelper
.calc0nFeatureValue(cc, UmaPackage.eINSTANCE
.getCustomCategory_CategorizedElements(), realizer)) {
Set<CustomCategory> ccSet = dynamicCustomCategoriesMap.get(element);
if (ccSet == null) {
ccSet = new HashSet<CustomCategory>();
dynamicCustomCategoriesMap.put(element, ccSet);
}
ccSet.add(cc);
}
}
} catch (Throwable e) {
LibraryPlugin.getDefault().getLogger().logError(e);
}
}
public void clearDynamicCustomCategoriesMap() {
dynamicCustomCategoriesMap = null;
}
public Set<CustomCategory> getDynamicCustomCategories(MethodElement element) {
return dynamicCustomCategoriesMap == null ? null : dynamicCustomCategoriesMap.get(element);
}
/**
* Test if pkg is a system package of plugin
* @param plugin
* @param pkg
* @return
*/
public boolean isSystemPackage(MethodPlugin plugin, MethodPackage pkg) {
return TngUtil.getAllSystemPackages(plugin).contains(pkg);
}
public void loadOppositeFeatures(ILibraryResourceSet resouceSet,
List<OppositeFeature> oppositeFeatures, MethodElement element) {
Set<String> GUIDs = new HashSet<String>();
GUIDs.add(element.getGuid());
resouceSet.loadOppositeFeatures(oppositeFeatures, GUIDs);
}
public boolean isOwnerSelected(MethodElement element,
MethodConfiguration config, boolean checkSubtracted) {
if (config instanceof Scope) {
return ((Scope)config).inScope(element);
}
MethodLibrary library = LibraryServiceUtil.getMethodLibrary(config);
ILibraryManager libraryManager = library == null? null : LibraryService.getInstance().getLibraryManager(library);
if (libraryManager != null) {
return LibraryService.getInstance()
.getConfigurationManager(config)
.getConfigurationData()
.isOwnerSelected(element, checkSubtracted);
}
if (element == null) {
return false;
}
if (config == null || ConfigurationHelper.isDescriptionElement(element)) {
return true;
}
// since UMA 1.0.4, configuration can have added categories
// and subtracted categories. The order of filtering is:
// 1. any element in the subtracted categories should be excluded
// 2. any element in the added categories should be included
// 3. any element not in the selected package or plugin should be excluded.
if ( checkSubtracted ) {
// first check subtracted elements
List subtractedCategories = config.getSubtractedCategory();
if ( subtractedCategories.size() > 0 ) {
for ( Iterator it = subtractedCategories.iterator(); it.hasNext(); ) {
ContentCategory cc = (ContentCategory)it.next();
if ( cc == element ) {
return false;
}
// need to check all content category types and sub-categories
// we need to have an efficient algorithm for this checking.
// for now, only check the custom category's categorised elements
// TODO. Jinhua Xi, 11/27/2006
if ( cc instanceof CustomCategory ) {
if ( ((CustomCategory)cc).getCategorizedElements().contains(element) ) {
return false;
}
} else {
// TODO, not implemented yet
System.out.println("TODO, isOwnerSelected: not implemented yet"); //$NON-NLS-1$
}
}
}
}
// then check added categories
// TODO
// elements beyond configuration scope should be always visible
if ((element instanceof MethodLibrary)
|| (element instanceof MethodConfiguration)) {
return true;
} else if (element instanceof MethodPlugin) {
List plugins = config.getMethodPluginSelection();
return (plugins != null) && plugins.contains(element);
} else {
// if the ownerprocess can't show, can't accept
if (element instanceof Activity) {
Activity base = (Activity) ((Activity) element)
.getVariabilityBasedOnElement();
if (base != null && base != element) {
MethodElement owningProc = TngUtil.getOwningProcess(base);
if ( owningProc != null && owningProc != element
&& !ConfigurationHelper.inConfig(owningProc, config, checkSubtracted)) {
return false;
}
}
}
EObject pkg = LibraryUtil.getSelectable(element);
// accept global package if the plugin is in the configuration
if (pkg instanceof MethodPackage
&& ConfigurationHelper.isGlobalPackage((MethodPackage) pkg)) {
MethodPlugin plugin = LibraryUtil.getMethodPlugin(pkg);
return ConfigurationHelper.inConfig(plugin, config, checkSubtracted);
}
List pkgs = config.getMethodPackageSelection();
if (pkgs == null) {
return false;
}
// per Phong's request, for ProcessPackage, check the
// ProcessComponent parent instead
if (pkg instanceof ProcessPackage) {
while ((pkg != null) && !(pkg instanceof ProcessComponent)
&& !pkgs.contains(pkg)) {
pkg = pkg.eContainer();
}
}
// if package not selected, return false
if ((pkg == null) || !pkgs.contains(pkg)) {
return false;
}
return true;
}
}
public void loadOppositeFeatures(Map map, List oppositeFeatures, Set deletedGUIDs) {
int max = oppositeFeatures.size() - 1;
if (max < 0) {
return;
}
Collection elements = new HashSet(map.values());
HashSet loadedElements = new HashSet();
while (!elements.isEmpty()) {
for (Iterator iter = elements.iterator(); iter.hasNext();) {
Object obj = iter.next();
if (obj instanceof MethodElement) {
MethodElement element = (MethodElement) obj;
MultiResourceEObject mrEObject = ((MultiResourceEObject) element);
for (int i = max; i > -1; i--) {
OppositeFeature oppositeFeature = ((OppositeFeature) oppositeFeatures
.get(i));
EStructuralFeature eFeature = oppositeFeature.getTargetFeature();
if (eFeature.getContainerClass().isInstance(element)) {
if (eFeature.isMany()) {
InternalEList list = (InternalEList) element
.eGet(eFeature);
if (!list.isEmpty()) {
boolean resolve = false;
check_resolve: for (Iterator iterator = list
.basicIterator(); iterator
.hasNext();) {
InternalEObject e = (InternalEObject) iterator
.next();
if (e.eIsProxy()) {
String guid = e.eProxyURI()
.fragment();
if (deletedGUIDs.contains(guid)) {
resolve = true;
break check_resolve;
}
}
}
if (resolve) {
Collection<Object> deletedElements = new HashSet<Object>();
for (Iterator iterator = list
.iterator(); iterator.hasNext();) {
Object o = iterator.next();
if(o instanceof MethodElement && deletedGUIDs.contains(((MethodElement) o).getGuid())) {
deletedElements.add(o);
}
}
for (Object e : deletedElements) {
if(oppositeFeature.isMany()) {
mrEObject.oppositeAdd(oppositeFeature, e);
}
else {
mrEObject.getOppositeFeatureMap().put(oppositeFeature, e);
}
}
}
}
} else {
Object value = element.eGet(eFeature, false);
if (value instanceof InternalEObject) {
InternalEObject e = (InternalEObject) value;
if (e.eIsProxy()) {
String guid = e.eProxyURI().fragment();
if (deletedGUIDs.contains(guid)) {
Object o = element.eGet(eFeature);
if(oppositeFeature.isMany()) {
mrEObject.oppositeAdd(oppositeFeature, o);
}
else {
mrEObject.getOppositeFeatureMap().put(oppositeFeature, o);
}
}
}
}
}
}
}
}
}
// gets the newly loaded elements to load their opposite features
//
loadedElements.addAll(elements);
elements = new HashSet(map.values());
elements.removeAll(loadedElements);
}
}
public String generateHtml(Object raw_element, HtmlBuilder htmlBuilder) {
ResourceHelper.birt_publishing = false;
loadForBrowsing(raw_element);
IElementLayout layout = null;
String file_url = "about:blank"; //$NON-NLS-1$
Object element = LibraryUtil.unwrap(raw_element);
try {
setGenerateHtmlMode(true);
if ( raw_element instanceof ActivityWrapperItemProvider ) {
ActivityWrapperItemProvider wrapper = (ActivityWrapperItemProvider)raw_element;
Object proc = wrapper.getTopItem();
if ( element instanceof MethodElement && proc instanceof org.eclipse.epf.uma.Process ) {
String path = AbstractProcessElementLayout.getPath(wrapper);
//System.out.println(topItem);
layout = htmlBuilder.getLayoutManager()
.createLayout((MethodElement)element,
(org.eclipse.epf.uma.Process)proc, path);
file_url = htmlBuilder.generateHtml(layout);
}
} else if (raw_element instanceof PracticeSubgroupItemProvider) {
PracticeSubgroupItemProvider provider = (PracticeSubgroupItemProvider) raw_element;
layout = new SummaryPageLayout(htmlBuilder.getLayoutManager(),
provider.getPractice(), provider.getPrefix(),
provider.getText(null), (List) provider.getChildren(null),
provider.getText(null));
((SummaryPageLayout) layout).setHtmlBuilder(htmlBuilder);
file_url = htmlBuilder.generateHtml(layout);
} else if (element instanceof MethodElement) {
file_url = htmlBuilder.generateHtml((MethodElement)element);
}
} finally {
setGenerateHtmlMode(false);
}
if ( file_url == null ) {
file_url = "about:blank"; //$NON-NLS-1$
}
// on linux, the file path need to be specified as file, otherwise it will be treated as url
// and casuign encoding/decoding issue
// Linux: Configuration names containing accented characters cannot be browsed.
else {
if (!SWT.getPlatform().equals("win32") && !file_url.startsWith("file://") && //$NON-NLS-1$ //$NON-NLS-2$
!file_url.equals("about:blank")) //$NON-NLS-1$
{
file_url = "file://" + file_url; //$NON-NLS-1$
}
// Bug 201335 - Refresh does not work correctly for process pages in browsing mode
// need to append the query string
if ( layout instanceof AbstractProcessElementLayout ) {
file_url += ((AbstractProcessElementLayout)layout).getQueryString();
}
}
ResourceHelper.birt_publishing = true;
return file_url;
}
//Should be overriden by sub classes
public ElementLayoutExtender newElementLayoutExtender(AbstractElementLayout layout) {
return null;
}
public void configViewRefreshNotified() {
}
public void debugDump(String msg) {
System.out.println("LD> " + getClass() + ".debugDump: " + msg); //$NON-NLS-1$//$NON-NLS-2$
}
public boolean isPublishingMode() {
return publishingMode;
}
public void setPublishingMode(boolean publishingMode) {
this.publishingMode = publishingMode;
}
public boolean isAuthoringPerspective() {
return authoringPerspective;
}
public void setAuthoringPerspective(boolean authoringPerspective) {
this.authoringPerspective = authoringPerspective;
}
public boolean isAuthoringMode() {
return isAuthoringPerspective();
}
private boolean supportingInAuthoringMode = false;
public boolean isSupportingInAuthoringMode() {
return supportingInAuthoringMode;
}
public void setSupportingInAuthoringMode(boolean supportingInAuthoringMode) {
this.supportingInAuthoringMode = supportingInAuthoringMode;
}
private IPerspectiveListener perspectiveListener;
private void addPerspectiveListener() {
if (perspectiveListener != null) {
return;
}
IWorkbenchWindow window = LibraryUtil.getActiveWorkbenchWindow();
if (window != null) {
perspectiveListener = new IPerspectiveListener() {
public void perspectiveActivated(IWorkbenchPage page,
IPerspectiveDescriptor desc) {
handleConfigOrPersepctiveChange();
}
public void perspectiveChanged(IWorkbenchPage page,
IPerspectiveDescriptor desc, String id) {
handleConfigOrPersepctiveChange();
}
};
window.addPerspectiveListener(perspectiveListener);
}
}
private ILibraryServiceListener libServiceListener = new LibraryServiceListener() {
public void configurationSet(MethodConfiguration newConfig) {
addPerspectiveListener();
if (config == newConfig) {
return;
}
handleConfigOrPersepctiveChange();
config = newConfig;
}
};
protected void loadForBrowsing(Object raw_element) {
if (!loadForBrowsingNeeded) {
return;
}
MethodConfiguration config = LibraryService.getInstance()
.getCurrentMethodConfiguration();
if (config != null && ! BrowsingLayoutSettings.INSTANCE.isIgnoreDynamicParents()) {
buildDynamicCustomCategoriesMap(config);
}
if (raw_element instanceof BreakdownElement
|| raw_element instanceof ActivityWrapperItemProvider) {
if (config == null) {
LibraryUtil.loadAll(LibraryService.getInstance()
.getCurrentMethodLibrary());
} else {
LibraryUtil.loadAllPlugins(config);
IRealizationManager mgr = getRealizationManager(config);
if (mgr != null) {
mgr.updateAllProcesseModels();
setAutoSyncedByBrowsing(true);
}
}
}
loadForBrowsingNeeded = false;
}
public IRealizationManager getRealizationManager(MethodConfiguration config) {
if (config == null || config instanceof Scope) {
return null;
}
IConfigurationManager configMgr = LibraryService.getInstance().getConfigurationManager(config);
return configMgr == null ? null : configMgr.getRealizationManager();
}
private void handleConfigOrPersepctiveChange() {
loadForBrowsingNeeded = true;
ConfigurationHelper.getDelegate().loadUserDefinedType();
clearDynamicCustomCategoriesMap();
}
//Check to see if a process can be converted to a config-free process
//To be overridden by sub-class
public boolean canBeConfigFree(Process proc) {
return true;
}
protected boolean isLoadForBrowsingNeeded() {
return loadForBrowsingNeeded;
}
public void setLoadForBrowsingNeeded(boolean loadForBrowsingNeeded) {
this.loadForBrowsingNeeded = loadForBrowsingNeeded;
}
public boolean isAutoSyncedByBrowsing() {
return autoSyncedByBrowsing;
}
public void setAutoSyncedByBrowsing(boolean autoSyncedByBrowsing) {
this.autoSyncedByBrowsing = autoSyncedByBrowsing;
}
public ConfigurationData getConfigurationData(MethodConfiguration config) {
if (config == null) {
return null;
}
IConfigurationManager configMgr = LibraryService.getInstance().getConfigurationManager(config);
ConfigurationData configData = configMgr == null ? null : configMgr.getConfigurationData();
if (configData == null) {
LibraryPlugin.getDefault().getLogger().logError("getConfigurationData() == null for: " + config.getName());//$NON-NLS-1$
}
return configData;
}
public SupportingElementData getSupportingElementData(MethodConfiguration config) {
if (config == null) {
return null;
}
IConfigurationManager configMgr = LibraryService.getInstance().getConfigurationManager(config);
return configMgr == null ? null : configMgr.getSupportingElementData();
}
//Make closure if conig stores any making closure info
//Return true if processed otherwise false
public boolean makeClosure(MethodConfiguration config) {
return false;
}
public void loadUserDefinedType() {
}
public boolean additionShowConfigSelectMenu(IWorkbenchPage activePage) {
return false;
}
public boolean filterOutEmptyCategories() {
if (isAuthoringMode()) {
return false;
}
if (isPublishingMode()) {
//Publishing logic does its own filter out, ok to return false here
return false;
}
return true;
}
public void fixupLoadCheckPackages(MethodLibrary lib) {
if (lib == null) {
return;
}
Map<MethodPlugin, Set<MethodPackage>> map = new HashMap<MethodPlugin, Set<MethodPackage>>();
for (MethodConfiguration config : lib.getPredefinedConfigurations()) {
fixupLoadCheckPackages(map, config);
}
}
public void fixupLoadCheckPackages(MethodConfiguration config) {
fixupLoadCheckPackages(null, config);
}
private void fixupLoadCheckPackages(
Map<MethodPlugin, Set<MethodPackage>> map,
MethodConfiguration config) {
MethodConfigurationPropUtil propUtil = MethodConfigurationPropUtil.getMethodConfigurationPropUtil();
MethodConfigurationExt ext = propUtil.getMethocConfigurationExt(config);
if (ext == null || ext.isLoadCheckPackagesCalled()) {
return;
}
ext.setLoadCheckPackagesCalled(true);
if (! needFixupLoadCheckPackages(config)) {
return;
}
if (map == null) {
map = new HashMap<MethodPlugin, Set<MethodPackage>>();
}
Set<MethodPackage> selectedPkgs = new HashSet<MethodPackage>(config.getMethodPackageSelection());
Set<MethodPackage> toAddCheckPkgs = new HashSet<MethodPackage>();
for (MethodPlugin plugin : config.getMethodPluginSelection()) {
Set<MethodPackage> loadCheckPkgs = map.get(plugin);
if (loadCheckPkgs == null) {
loadCheckPkgs = new HashSet<MethodPackage>();
map.put(plugin, loadCheckPkgs);
}
collectLoadCheckPkgs(plugin.getMethodPackages(), loadCheckPkgs);
toAddCheckPkgs.addAll(loadCheckPkgs);
}
Set<MethodPackage> doneSet = propUtil.getDoneLoadCheckPkgs(config);
toAddCheckPkgs.removeAll(doneSet);
Set<MethodPackage> handkedSet = new HashSet<MethodPackage>();
for (MethodPackage pkg : toAddCheckPkgs) {
if (handkedSet.add(pkg)) {
if (checkParentPackage(handkedSet, config, selectedPkgs, pkg,
toAddCheckPkgs)) {
addToConfig(config, selectedPkgs, pkg);
}
}
}
}
public boolean needFixupLoadCheckPackages(MethodConfiguration config) {
return config != null;
}
private void addToConfig(MethodConfiguration config,
Set<MethodPackage> selectedPkgs, MethodPackage pkg) {
config.getMethodPackageSelection().add(pkg);
selectedPkgs.add(pkg);
}
private boolean checkParentPackage(Set<MethodPackage> handkedSet, MethodConfiguration config, Set<MethodPackage> selectedPkgs, MethodPackage pkg, Set<MethodPackage> toAddCheckPkgs) {
EObject container = pkg.eContainer();
if (! (container instanceof MethodPackage)) {
return false;
}
MethodPackage parentPkg = (MethodPackage) container;
if (selectedPkgs.contains(parentPkg)) {
return true;
}
if (! toAddCheckPkgs.contains(parentPkg)) {
return false;
}
if (handkedSet.add(parentPkg)) {
if (checkParentPackage(handkedSet, config, selectedPkgs, parentPkg, toAddCheckPkgs)) {
addToConfig(config, selectedPkgs, parentPkg);
}
}
return false;
}
private void collectLoadCheckPkgs(List<MethodPackage> pkgList, Set<MethodPackage> loadCheckPkgs) {
PropUtil propUtil = PropUtil.getPropUtil();
for (MethodPackage pkg : pkgList) {
Boolean b = propUtil.getBooleanValue(pkg, PropUtil.Pkg_loadCheck);
if (b != null && b.booleanValue()) {
loadCheckPkgs.add(pkg);
}
collectLoadCheckPkgs(pkg.getChildPackages(), loadCheckPkgs);
}
}
public boolean isGenerateHtmlMode() {
return generateHtmlMode;
}
public void setGenerateHtmlMode(boolean generateHtmlMode) {
this.generateHtmlMode = generateHtmlMode;
}
public boolean browseOrPublishMode() {
return isPublishingMode() || isGenerateHtmlMode();
}
}