| //------------------------------------------------------------------------------ |
| // 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.publishing.services; |
| |
| import java.io.File; |
| import java.io.FileOutputStream; |
| import java.io.OutputStreamWriter; |
| import java.io.PrintWriter; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.emf.common.notify.AdapterFactory; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EStructuralFeature; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.emf.edit.provider.ComposedAdapterFactory; |
| import org.eclipse.emf.edit.provider.ITreeItemContentProvider; |
| import org.eclipse.epf.common.serviceability.DebugTrace; |
| import org.eclipse.epf.common.utils.FileUtil; |
| import org.eclipse.epf.common.utils.StrUtil; |
| import org.eclipse.epf.common.utils.Timer; |
| import org.eclipse.epf.library.configuration.ConfigurationFilter; |
| import org.eclipse.epf.library.configuration.ConfigurationHelper; |
| import org.eclipse.epf.library.edit.IFilter; |
| import org.eclipse.epf.library.edit.TngAdapterFactory; |
| import org.eclipse.epf.library.edit.configuration.PracticeSubgroupItemProvider; |
| import org.eclipse.epf.library.edit.process.IBSItemProvider; |
| 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.library.layout.Bookmark; |
| import org.eclipse.epf.library.layout.IElementLayout; |
| import org.eclipse.epf.library.layout.elements.ActivityLayout; |
| import org.eclipse.epf.library.layout.elements.ProcessElementItem; |
| import org.eclipse.epf.library.layout.elements.ProcessLayoutData; |
| import org.eclipse.epf.library.layout.elements.SummaryPageLayout; |
| import org.eclipse.epf.library.layout.util.XmlElement; |
| import org.eclipse.epf.library.util.LibraryUtil; |
| import org.eclipse.epf.publishing.PublishingPlugin; |
| import org.eclipse.epf.publishing.PublishingResources; |
| import org.eclipse.epf.publishing.util.PublishingUtil; |
| import org.eclipse.epf.uma.Activity; |
| import org.eclipse.epf.uma.Artifact; |
| import org.eclipse.epf.uma.ContentCategory; |
| import org.eclipse.epf.uma.DeliveryProcess; |
| import org.eclipse.epf.uma.Descriptor; |
| import org.eclipse.epf.uma.Discipline; |
| import org.eclipse.epf.uma.Guidance; |
| import org.eclipse.epf.uma.MethodElement; |
| import org.eclipse.epf.uma.MethodPackage; |
| import org.eclipse.epf.uma.MethodPlugin; |
| import org.eclipse.epf.uma.Practice; |
| import org.eclipse.epf.uma.Process; |
| import org.eclipse.epf.uma.ProcessElement; |
| import org.eclipse.epf.uma.Role; |
| import org.eclipse.epf.uma.SupportingMaterial; |
| import org.eclipse.epf.uma.Task; |
| import org.eclipse.epf.uma.Tool; |
| import org.eclipse.epf.uma.UmaPackage; |
| import org.eclipse.epf.uma.WorkProduct; |
| import org.eclipse.epf.uma.util.AssociationHelper; |
| |
| /** |
| * Builds the views defined for a method configuration. |
| * |
| * @author Shilpa Toraskar |
| * @author Jinhua Xi |
| * @author Kelvin Low |
| * @since 1.0 |
| */ |
| public class ConfigurationViewBuilder extends AbstractViewBuilder { |
| |
| private static final String PREFIX_Reference_Workflows = "Reference_Workflows"; //$NON-NLS-1$ |
| |
| private static final String PREFIX_Tasks = "Tasks"; //$NON-NLS-1$ |
| |
| private static final String PREFIX_ResponsibleFor_Tasks = "Primarily_Performs"; //$NON-NLS-1$ |
| |
| private static final String PREFIX_ParticipatesIn_Tasks = "Additionally_Performs"; //$NON-NLS-1$ |
| |
| private static final String PREFIX_Performing_Roles = "Performing_Roles"; //$NON-NLS-1$ |
| |
| private static final String PREFIX_Input_Work_Products = "Input_Work_Products"; //$NON-NLS-1$ |
| |
| private static final String PREFIX_Output_Work_Products = "Output_Work_Products"; //$NON-NLS-1$ |
| |
| private static final String PREFIX_Work_Products_Created = "Responsible_For"; //$NON-NLS-1$ |
| |
| private static final String PREFIX_Work_Products_Modified = "Modifies"; //$NON-NLS-1$ |
| |
| private static final String PREFIX_Responsible_Role = "Responsible_Role"; //$NON-NLS-1$ |
| |
| private static final String PREFIX_Containing_Work_Product = "Containing_Work_Product"; //$NON-NLS-1$ |
| |
| private static final String PREFIX_Contained_Work_Products = "Contained_Work_Products"; //$NON-NLS-1$ |
| |
| private static final String PREFIX_Guidances = "Guidance"; //$NON-NLS-1$ |
| |
| private static final String PREFIX_InputTo_Task = "Input_to"; //$NON-NLS-1$ |
| |
| private static final String PREFIX_OutputOf_Task = "Output_from"; //$NON-NLS-1$ |
| |
| private static final String ICON_FOLDER = DefaultNodeIconResources |
| .getIconName("folder"); //$NON-NLS-1$ |
| |
| private static final String NODE_Reference_Workflows = PublishingResources.referenceWorkflowsNode_text; //$NON-NLS-1$ |
| |
| private static final String NODE_Tasks = PublishingResources.taskNode_text; //$NON-NLS-1$ |
| |
| private static final String NODE_ResponsibleFor_Tasks = PublishingResources.primarilyPerformsNode_text; //$NON-NLS-1$ |
| |
| private static final String NODE_ParticipatesIn_Tasks = PublishingResources.additionallyPerformsNode_text; //$NON-NLS-1$ |
| |
| private static final String NODE_Performing_Roles = PublishingResources.performingRolesNode_text; //$NON-NLS-1$ |
| |
| private static final String NODE_Input_Work_Products = PublishingResources.inputWorkProductsNode_text; //$NON-NLS-1$ |
| |
| private static final String NODE_Output_Work_Products = PublishingResources.outputWorkProductsNode_text; //$NON-NLS-1$ |
| |
| private static final String NODE_Work_Products_Created = PublishingResources.responsibleForNode_text; //$NON-NLS-1$ |
| |
| private static final String NODE_Work_Products_Modified = PublishingResources.modifiesNode_text; //$NON-NLS-1$ |
| |
| private static final String NODE_Responsible_Role = PublishingResources.responsibleRoleNode_text; //$NON-NLS-1$ |
| |
| private static final String NODE_Containing_Work_Product = PublishingResources.containingWorkProductNode_text; //$NON-NLS-1$ |
| |
| private static final String NODE_Contained_Work_Products = PublishingResources.containedWorkProductsNode_text; //$NON-NLS-1$ |
| |
| private static final String NODE_Guidances = PublishingResources.guidanceNode_text; //$NON-NLS-1$ |
| |
| private static final String NODE_InputTo_Task = PublishingResources.inputToNode_text; //$NON-NLS-1$ |
| |
| private static final String NODE_OutputOf_Task = PublishingResources.outputFromNode_text; //$NON-NLS-1$ |
| |
| private static final String PROCESS_LAYOUT_DATA_FILE = "/scripts/processElementData.js"; //$NON-NLS-1$ |
| |
| private static final Class ITreeItemContentProviderClass = ITreeItemContentProvider.class; |
| |
| protected static boolean debug = PublishingPlugin.getDefault() |
| .isDebugging(); |
| |
| protected List<Bookmark> bookmarks = new ArrayList<Bookmark>(); |
| |
| protected AdapterFactory adapterFactory; |
| |
| protected IProgressMonitor monitor = null; |
| |
| protected EObjectComparator nameComparator = new EObjectComparator(); |
| |
| /** |
| * Creates a new instance. |
| */ |
| public ConfigurationViewBuilder(ISiteGenerator siteGenerator) { |
| super(siteGenerator); |
| } |
| |
| /** |
| * Build the views defined in the configuration and publish the related |
| * contents. |
| * |
| * @param monitor |
| * IProgressMonitor |
| * @return List a list of Bookmarks for the views |
| */ |
| public List<Bookmark> buildViews(IProgressMonitor monitor) { |
| this.monitor = monitor; |
| |
| // System.out.println("Building views..."); //$NON-NLS-1$ |
| |
| long startTime = 0L; |
| |
| if (config != null) { |
| |
| // already done in PublishManager |
| // // first of all, we need to load the library, |
| // // otherwise, some relationships and opposite features are not |
| // // established |
| // monitor.subTask(PublishingResources.loadLibraryTask_name); |
| // if (profiling) { |
| // startTime = System.currentTimeMillis(); |
| // } |
| // LibraryUtil.loadAll((MethodLibrary) config.eContainer()); |
| // if (profiling) { |
| // DebugTrace.print(this, "buildViews", "LibraryUtil.loadAll: " //$NON-NLS-1$ //$NON-NLS-2$ |
| // + (System.currentTimeMillis() - startTime) |
| // + " ms"); //$NON-NLS-1$ |
| // } |
| |
| // create a filter that does not discard the contributors. |
| // so we get the contributors in to show in the navigation tree |
| IFilter configFilter = new ConfigurationFilter(config, false); |
| adapterFactory = TngAdapterFactory.INSTANCE |
| .getConfigurationView_AdapterFactory(configFilter); |
| |
| if (options != null && options.isPublishProcess()) { |
| makeProcessClosure(); |
| } |
| |
| // publish all the views in the configuration |
| if (profiling) { |
| startTime = System.currentTimeMillis(); |
| } |
| List views = LibraryUtil.getValidViews(config); |
| for (Iterator it = views.iterator(); it.hasNext();) { |
| if (monitor.isCanceled()) { |
| return null; |
| } |
| |
| ContentCategory v = (ContentCategory) it.next(); |
| if (!ConfigurationHelper.canShow(v, config)) { |
| continue; |
| } |
| |
| Object element = LibraryUtil.unwrap(v); |
| Bookmark b = createBookmark(this.monitor, element); |
| |
| if (v == config.getDefaultView()) { |
| super.defaultView = b; |
| } |
| |
| // iterate thru configuration to build the view |
| iterate(v, b); |
| if (b.getChildCount() > 0) { |
| bookmarks.add(b); |
| } |
| } |
| if (profiling) { |
| System.out.println("Time taken to publish bookmarks: " //$NON-NLS-1$ |
| + (System.currentTimeMillis() - startTime) + " ms"); //$NON-NLS-1$ |
| } |
| |
| if (monitor.isCanceled()) { |
| return null; |
| } |
| } |
| |
| if (profiling) { |
| startTime = System.currentTimeMillis(); |
| } |
| publishReferenceElements(); |
| if (profiling) { |
| DebugTrace.print(this, "publishReferenceElements", //$NON-NLS-1$ |
| (System.currentTimeMillis() - startTime) + " ms"); //$NON-NLS-1$ |
| } |
| |
| // copyIconsForNonApplet(); |
| |
| if (monitor.isCanceled()) { |
| return null; |
| } |
| |
| // save published element urls |
| if (profiling) { |
| startTime = System.currentTimeMillis(); |
| } |
| saveElementUrls(); |
| if (profiling) { |
| DebugTrace.print(this, "saveElementUrls", //$NON-NLS-1$ |
| (System.currentTimeMillis() - startTime) + " ms"); //$NON-NLS-1$ |
| } |
| |
| return bookmarks; |
| } |
| |
| /** |
| * The process element closure is generated as follows: |
| * <p> |
| * 1. publish the selected processses, which brings in all the related |
| * process elements |
| * <p> |
| * 2. publish all the referenced process elements from step 1, this brings |
| * in all the directly referenced content elements. make a first level |
| * closure to include the published elements and the referenced elements. |
| * Any direct references to any type of guidances are also in this closure. |
| * <p> |
| * 3. publish all the referened non-ContentCategory content elements from |
| * step 2. based on the first level closure. The purpose of the first level |
| * closure is to allow bring in guidances with valid element link and any |
| * other references such as a Task or Role, being linked with a missing |
| * element link. This again brings in all the direct references |
| * <p> |
| * 4.Make the final closure by including the following elements: |
| * <p> |
| * a. all published elements from step 1,2,3. |
| * <p> |
| * b. all referenced Guidances from step 3 |
| * <p> |
| * c. all Guidances of type Practice, RoadMap, Suporting Material, and Term |
| * Definition, in the configuration |
| * <p> |
| * d. all Content Categories that contains at least one element of type a, |
| * b, or c. and their parent categories |
| * <p> |
| * The selected view is published based on the element closure defined |
| * above. |
| */ |
| private void makeProcessClosure() { |
| monitor.subTask(PublishingResources.buildingProcessClosureTask_name); |
| |
| // publish the selected processes |
| // need to build a closure of all the elements involved in the |
| // processes |
| List<Process> processes = options.getProcesses(); |
| if (processes != null && processes.size() > 0) { |
| for (Iterator<Process> it = processes.iterator(); it.hasNext();) { |
| makeProcessClosure(it.next()); |
| if (monitor.isCanceled()) { |
| return; |
| } |
| } |
| } |
| |
| // make the first level closure to include all the process elements and |
| // it's referenced elements |
| // any thing except Guidances and ContentCategories outside the closure |
| // is filtered |
| getValidator() |
| .addClosureElements(getValidator().getPublishedElements()); |
| getValidator().addClosureElements( |
| getValidator().getReferencedElements()); |
| |
| // now publish all referenced elements, any direct references in the |
| // process elements are |
| // part of the closure |
| // don't publish content categories for now since they might be empty |
| // and discarded later |
| List refs = new ArrayList(getValidator().getReferencedElements()); |
| for (Iterator it = refs.iterator(); it.hasNext();) { |
| MethodElement e = (MethodElement) it.next(); |
| if (!(e instanceof ContentCategory)) { |
| super.publish(monitor, e); |
| |
| // collect process specific layout info with suppression status |
| // this will incldue the diagrams and the supression states of |
| // each item under the current procee |
| if (LibraryUtil.isProcess(e)) { |
| publishProcessLayout((org.eclipse.epf.uma.Process) e); |
| } |
| |
| } |
| } |
| |
| // now, any referenced guidance should be in the closure, |
| // so include them and make the final closure |
| refs.clear(); |
| for (Iterator it = getValidator().getReferencedElements().iterator(); it |
| .hasNext();) { |
| MethodElement e = (MethodElement) it.next(); |
| if (e instanceof Guidance) { |
| refs.add(e); |
| } |
| } |
| |
| if (refs.size() > 0) { |
| getValidator().addClosureElements(refs); |
| } |
| |
| // now all the published elements are the element closure, make the |
| // final closure |
| getValidator().makeElementClosure(config); |
| } |
| |
| private void makeProcessClosure(org.eclipse.epf.uma.Process proc) { |
| |
| if (proc == null) { |
| return; |
| } |
| |
| if (ConfigurationHelper.canShow(proc, config)) { |
| ActivityLayout l = new ActivityLayout(); |
| l.init(getLayoutMgr(), proc, proc, null); |
| l.findAllLinkedElements(); |
| } |
| |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| if (ConfigurationHelper.isExtender(proc)) { |
| org.eclipse.epf.uma.Process baseProc = (org.eclipse.epf.uma.Process) proc |
| .getVariabilityBasedOnElement(); |
| if (ConfigurationHelper.inConfig(baseProc, config)) { |
| makeProcessClosure(baseProc); |
| } |
| } |
| |
| } |
| |
| private void publishReferenceElements() { |
| // now process the referenced elements and publish the contents |
| while (getValidator().getReferencedElements().size() > 0) { |
| MethodElement e = (MethodElement) getValidator() |
| .getReferencedElements().remove(0); |
| |
| try { |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| // references to method plugins and method packages can be |
| // ignored |
| if (e instanceof MethodPlugin || e instanceof MethodPackage) { |
| continue; |
| } |
| |
| long startTime = System.currentTimeMillis(); |
| |
| super.publish(monitor, e); |
| |
| // collect process specific layout info with suppression status |
| // this will incldue the diagrams and the supression states of |
| // each item under the current procee |
| if (LibraryUtil.isProcess(e)) { |
| // long startTime1 = System.currentTimeMillis(); |
| publishProcessLayout((org.eclipse.epf.uma.Process) e); |
| // long endTime1 = System.currentTimeMillis(); |
| // System.out.println("Published process " + e.getName() + |
| // ": " + (endTime1 - startTime1) + " ms"); |
| } |
| |
| long endTime = System.currentTimeMillis(); |
| long timeTaken = endTime - startTime; |
| if (timeTaken >= 5000) { |
| System.out.println("Published " + e.getName() + ": " //$NON-NLS-1$ //$NON-NLS-2$ |
| + timeTaken + " ms"); //$NON-NLS-1$ |
| } |
| |
| } catch (Exception ex) { |
| ex.printStackTrace(); |
| getValidator().logError(e, "Error publishing element", ex); //$NON-NLS-1$ |
| } |
| } |
| } |
| |
| private void publishProcessLayout(final org.eclipse.epf.uma.Process e) { |
| |
| Runnable runnable = new Runnable() { |
| public void run() { |
| try { |
| ActivityLayout layout = new ActivityLayout(); |
| layout.init(getLayoutMgr(), |
| (org.eclipse.epf.uma.Process) e, null, null); |
| ProcessLayoutData pd = new ProcessLayoutData(e.getGuid()); |
| layout.loadLayoutData(pd, true, true, true); |
| printLayoutScript(pd); |
| pd.clear(); |
| } catch (Exception e1) { |
| getValidator() |
| .logError( |
| e, |
| "Error publishing process specific layout data", e1); //$NON-NLS-1$ |
| } |
| |
| } |
| }; |
| |
| Timer timer = new Timer(); |
| try { |
| |
| // run the publishing and check the time, if timeout, terminate it |
| Thread t = new Thread(runnable); |
| t.start(); |
| t.join(TIMEOUT_INTERVAL); |
| if (t.isAlive()) { |
| // wait for the thread to die and log an error |
| timer.stop(); |
| getValidator() |
| .logInfo( |
| e, |
| "publishing process specific layout data takes " + timer.getTime() + " mini seconds already and is still not done yet ..."); //$NON-NLS-1$ //$NON-NLS-2$ |
| timer.start(); |
| t.join(); |
| } |
| } catch (InterruptedException e1) { |
| e1.printStackTrace(); |
| } finally { |
| timer.stop(); |
| getValidator() |
| .logInfo( |
| e, |
| timer.getTotalTime() |
| + " mini seconds publishing process specific layout data"); //$NON-NLS-1$ |
| } |
| |
| } |
| |
| private void printLayoutScript(ProcessLayoutData data) { |
| File outputFile = new File(getLayoutMgr().getPublishDir(), |
| PROCESS_LAYOUT_DATA_FILE); //$NON-NLS-1$ |
| PrintWriter pw = null; |
| try { |
| // create a stream with append enabled |
| FileOutputStream os = new FileOutputStream(outputFile, true); |
| |
| // create a write with utf-8 encoding |
| OutputStreamWriter writer = new OutputStreamWriter(os, "utf-8"); //$NON-NLS-1$ |
| |
| // create a print writer with auto flush |
| pw = new PrintWriter(writer, true); |
| data.print(pw); |
| } catch (Exception e) { |
| getValidator().logError("unable to save process layout data", e); //$NON-NLS-1$ |
| |
| } finally { |
| if (pw != null) { |
| pw.flush(); |
| pw.close(); |
| } |
| } |
| |
| } |
| |
| /** |
| * Iterate thru tuee |
| * |
| * @param obj |
| * @param parent |
| */ |
| private void iterate(Object obj, Bookmark parent) { |
| try { |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| // Get the adapter from the factory. |
| ITreeItemContentProvider treeItemContentProvider = null; |
| if (obj instanceof ITreeItemContentProvider) { |
| treeItemContentProvider = (ITreeItemContentProvider) obj; |
| } else { |
| treeItemContentProvider = (ITreeItemContentProvider) adapterFactory |
| .adapt(obj, ITreeItemContentProvider.class); |
| } |
| |
| // Either delegate the call or return nothing. |
| if (treeItemContentProvider != null) { |
| Collection items = treeItemContentProvider.getChildren(obj); |
| for (Iterator it = items.iterator(); it.hasNext();) { |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| // create bookmark |
| Object itorObj = it.next(); |
| Object element = LibraryUtil.unwrap(itorObj); |
| |
| if ((element instanceof MethodElement)) { |
| MethodElement me = (MethodElement) element; |
| try { |
| if (ConfigurationHelper.canShow(me, config)) { |
| me = ConfigurationHelper |
| .getCalculatedElement(me, |
| getLayoutMgr() |
| .getElementRealizer()); |
| if (me != null) { |
| if (me instanceof Tool) { |
| buildToolSubTree((Tool) me, parent); |
| } else if (me instanceof Discipline) { |
| buildDisciplineSubTree((Discipline) me, |
| parent); |
| } |
| |
| // else if (me instanceof DisciplineGrouping |
| // || me instanceof Domain || me instanceof |
| // WorkProductType |
| // || me instanceof RoleSetGrouping || me |
| // instanceof RoleSet ) |
| else if (me instanceof ContentCategory) { |
| |
| ContentCategory cc = (ContentCategory) me; |
| |
| // if the content category is empty, |
| // don't add to the parent |
| Bookmark b = createBookmark( |
| this.monitor, cc); |
| iterate(itorObj, b); |
| if (options.isPublishEmptyCategories() |
| || b.getChildCount() > 0) { |
| parent.addChild(b); |
| discardEmptyCategory(cc, false); |
| } else { |
| discardEmptyCategory(cc, true); |
| } |
| } else { |
| if (itorObj instanceof PracticeSubgroupItemProvider) { |
| buildPracticeSubgroupTree(obj, parent, |
| (PracticeSubgroupItemProvider) itorObj); |
| } else { |
| Bookmark b = createBookmark(me, parent); |
| if (!buildSubTree(itorObj, me, b)) { |
| iterate(itorObj, b); |
| } |
| } |
| } |
| } |
| } |
| } catch (Exception e) { |
| String message = "Error building navigation tree for " + LibraryUtil.getTypeName(me); //$NON-NLS-1$ |
| getHtmlBuilder().getValidator() |
| .logError(message, e); |
| e.printStackTrace(); |
| } |
| } else { |
| if (itorObj instanceof PracticeSubgroupItemProvider) { |
| buildPracticeSubgroupTree(obj, parent, (PracticeSubgroupItemProvider) itorObj); |
| } else { |
| iterate(itorObj, parent); |
| } |
| } |
| |
| } |
| } |
| } catch (Exception e) { |
| String message = "Error building navigation tree"; //$NON-NLS-1$ |
| getHtmlBuilder().getValidator().logError(message, e); |
| |
| e.printStackTrace(); |
| } |
| } |
| |
| /** |
| * create a bookmark under the specified parent. If no parent is specified, |
| * |
| * @param monitor |
| * @param element |
| * @param parent |
| * @return |
| */ |
| protected Bookmark createBookmark(Object element, Bookmark parent) { |
| Bookmark b = createBookmark(this.monitor, element); |
| if (parent == null) { |
| bookmarks.add(b); |
| } else { |
| parent.addChild(b); |
| } |
| |
| return b; |
| } |
| |
| /** |
| * build the sub tree for the given element. return true if the element is |
| * handled, false otherwise |
| * |
| * @param element |
| * @param bm |
| * @return boolean |
| */ |
| private boolean buildSubTree(Object obj, MethodElement element, Bookmark bm) { |
| boolean isShowRelatedLinks = options.isShowRelatedLinks(); |
| if (element instanceof Task) { |
| if(isShowRelatedLinks) { |
| buildTaskSubTree((Task) element, bm); |
| } else { |
| return true; |
| } |
| } else if (element instanceof Role) { |
| if(isShowRelatedLinks) { |
| buildRoleSubTree((Role) element, bm); |
| } else { |
| return true; |
| } |
| } else if (element instanceof WorkProduct) { |
| if(isShowRelatedLinks) { |
| buildWorkProductSubTree((WorkProduct) element, bm); |
| } else { |
| return true; |
| } |
| } else if (LibraryUtil.isProcess(element)) { |
| buildProcessSubTree(obj, (org.eclipse.epf.uma.Process) element, bm); |
| } else { |
| // System.out.println("Not handled: " + element); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| private void buildItems(List elements, Bookmark bm) { |
| buildItems(elements, bm, false); |
| } |
| |
| private void buildItems(List elements, Bookmark bm, boolean buildSubTree) { |
| for (Iterator it = elements.iterator(); it.hasNext();) { |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| MethodElement element = (MethodElement) it.next(); |
| |
| // filter away the containment child-element if any of the parent(s) |
| // are in the list |
| // 00384619 - Published site: Display of WPs under responsible role |
| // if the container of the element is in the list, ignore it |
| if (ConfigurationHelper.isContainmentElement(element) |
| && ConfigurationHelper.isContainerInList(element, elements, |
| config)) { |
| continue; |
| } |
| |
| buildItem(element, bm, buildSubTree); |
| } |
| } |
| |
| private Bookmark buildItem(MethodElement element, Bookmark parent, |
| boolean buildSubTree) { |
| if (monitor.isCanceled()) { |
| return null; |
| } |
| |
| Bookmark b = null; |
| |
| // make sure the element is showable |
| MethodElement e = ConfigurationHelper.getCalculatedElement(element, |
| getLayoutMgr().getElementRealizer()); |
| if (isVisible(e)) { |
| b = createBookmark(this.monitor, e); |
| if (b == null) { |
| return b; |
| } |
| |
| parent.addChild(b); |
| |
| if (buildSubTree) { |
| if (e instanceof Artifact) { |
| buildContainedArtifactsSubTree((Artifact) e, b, true); |
| } |
| } |
| } |
| |
| return b; |
| } |
| |
| // /** |
| // * create the folder bookmark and it's children. generate the folder summary |
| // * page |
| // * |
| // * @param element |
| // * @param bm |
| // * @param nodeName |
| // * @param items |
| // */ |
| // |
| // private Bookmark createFolderBookmark(MethodElement element, Bookmark bm, |
| // String nodeName, List items, boolean createChildren) { |
| // Bookmark b = null; |
| // if (items.size() > 0) { |
| // IElementLayout l = new SummaryPageLayout(getHtmlBuilder() |
| // .getLayoutManager(), element, nodeName, items); |
| // String url = l.getUrl(); |
| // getHtmlBuilder().generateHtml(l); |
| // b = createBookmark(nodeName, EcoreUtil.generateUUID(), url, |
| // ICON_FOLDER, ICON_FOLDER, null); |
| // bm.addChild(b); |
| // if (createChildren) { |
| // buildItems(items, b); |
| // } |
| // } |
| // |
| // return b; |
| // } |
| |
| Set<String> summaryPagesGenerated = new HashSet<String>(); |
| |
| private Bookmark createFolderBookmark(MethodElement element, Bookmark bm, |
| String prefixName, String nodeName, List items, |
| boolean createChildren) { |
| Bookmark b = null; |
| if (items.size() > 0) { |
| IElementLayout l = new SummaryPageLayout(getHtmlBuilder() |
| .getLayoutManager(), element, prefixName, nodeName, items); |
| String url = l.getUrl(); |
| |
| // don't regenerate the page |
| // 200619 - Summary page html was generated multiple times when publishing |
| if ( !summaryPagesGenerated.contains(url) ) { |
| getHtmlBuilder().generateHtml(l); |
| summaryPagesGenerated.add(url); |
| } |
| |
| b = createBookmark(nodeName, EcoreUtil.generateUUID(), url, |
| ICON_FOLDER, ICON_FOLDER, null); |
| bm.addChild(b); |
| if (createChildren) { |
| buildItems(items, b); |
| } |
| } |
| |
| return b; |
| } |
| |
| private void buildPracticeSubgroupTree(Object providerParent, |
| Bookmark parent, PracticeSubgroupItemProvider provider) { |
| Collection children = provider.getChildren(null); |
| List items = children instanceof List ? (List) children |
| : new ArrayList(children); |
| |
| if (items != null && items.size() > 0) { |
| Practice practice = provider.getPractice(); |
| if (practice == null) { |
| return; |
| } |
| |
| IElementLayout l = new SummaryPageLayout(getHtmlBuilder() |
| .getLayoutManager(), practice, provider.getPrefix(), |
| provider.getText(null), items, provider.getText(null)); |
| |
| String url = l.getUrl(); |
| |
| String imageString = this.getNodeIconName(provider); |
| Bookmark b = createBookmark(provider.getText(null), EcoreUtil |
| .generateUUID(), url, imageString, imageString, null); |
| parent.addChild(b); |
| this.iterate(provider, b); |
| |
| if (!summaryPagesGenerated.contains(url)) { |
| getHtmlBuilder().generateHtml(l); |
| summaryPagesGenerated.add(url); |
| } |
| } |
| |
| } |
| |
| private Bookmark buildDisciplineSubTree(Discipline element, Bookmark parent) { |
| String url = ""; //$NON-NLS-1$ |
| Bookmark b; |
| |
| // need to calculate the realized value of the feature |
| List items_workflow = calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getDiscipline_ReferenceWorkflows()); |
| |
| // Tasks in published site under Disciplines are in |
| // random order |
| // use the adaptor factory to get the childrens |
| // List items_task = ConfigurationHelper.calc0nFeatureValue(element, |
| // UmaPackage.eINSTANCE.getDiscipline_Tasks(), config); |
| List items_task = new ArrayList(); |
| List item_subDisciplies = new ArrayList(); |
| ITreeItemContentProvider treeItemContentProvider = (ITreeItemContentProvider) adapterFactory |
| .adapt(element, ITreeItemContentProvider.class); |
| if (treeItemContentProvider != null) { |
| Collection items = treeItemContentProvider.getChildren(element); |
| for (Iterator it = items.iterator(); it.hasNext();) { |
| if (monitor.isCanceled()) { |
| return null; |
| } |
| |
| // create bookmark |
| Object itorObj = it.next(); |
| Object e = LibraryUtil.unwrap(itorObj); |
| if ((e instanceof Task)) { |
| MethodElement t = ConfigurationHelper.getCalculatedElement( |
| (MethodElement) e, getLayoutMgr() |
| .getElementRealizer()); |
| if (t != null) { |
| items_task.add(t); |
| } |
| } else if (e instanceof Discipline) { |
| MethodElement d = ConfigurationHelper.getCalculatedElement( |
| (MethodElement) e, getLayoutMgr() |
| .getElementRealizer()); |
| if (d != null) { |
| item_subDisciplies.add(d); |
| } |
| |
| } |
| } |
| } |
| |
| if (monitor.isCanceled()) { |
| return null; |
| } |
| |
| // all guidances |
| List items_guidance = new ArrayList(); |
| items_guidance.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_Assets())); |
| items_guidance.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_Checklists())); |
| items_guidance.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_ConceptsAndPapers())); |
| items_guidance.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_Examples())); |
| items_guidance.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_Guidelines())); |
| items_guidance.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_SupportingMaterials())); |
| |
| if (!options.isPublishEmptyCategories() |
| && items_workflow.size() + items_task.size() |
| + items_guidance.size() + item_subDisciplies.size() == 0) { |
| // do nothing, don't show the folder |
| discardEmptyCategory(element, true); |
| return null; |
| } |
| |
| if (monitor.isCanceled()) { |
| return null; |
| } |
| |
| // create the item bookmark |
| // don't set to the parent yet. make sure it's not empty |
| // need to check the sub-disciplines |
| // 150984 - Publishing: Nested discipline is not display in the publish |
| // page |
| // Bookmark bm = createBookmark(element, parent); |
| Bookmark bm = createBookmark(this.monitor, element); |
| |
| // sub-disciplines come first |
| if (item_subDisciplies.size() > 0) { |
| for (Iterator it = item_subDisciplies.iterator(); it.hasNext();) { |
| Discipline d = (Discipline) it.next(); |
| buildDisciplineSubTree(d, bm); |
| } |
| } |
| |
| if (options.isPublishLightWeightTree()) { |
| |
| Collections.sort(items_workflow, nameComparator); |
| //Collections.sort(items_task, nameComparator); |
| Collections.sort(items_guidance, nameComparator); |
| |
| buildItems(items_workflow, bm); |
| buildItems(items_task, bm); |
| buildItems(items_guidance, bm); |
| } else { |
| if (items_workflow.size() > 0) { |
| Bookmark wfFolder = createFolderBookmark(element, bm, |
| PREFIX_Reference_Workflows, NODE_Reference_Workflows, |
| items_workflow, false); |
| |
| // Capability Patterns in treebrowser under |
| // disciplines-reference workflows cannot be expanded |
| for (Iterator it = items_workflow.iterator(); it.hasNext();) { |
| if (monitor.isCanceled()) { |
| return null; |
| } |
| |
| // 179609 - Exception when assign activity as discipline's |
| // referenced workflow |
| // this is a model change, referenced workflow can be |
| // Activity, |
| // old model references Process |
| Activity act = (Activity) it.next(); |
| Bookmark bmWorkflow = buildItem(act, wfFolder, false); |
| buildActivitySubTree(act, act, bmWorkflow); |
| } |
| } |
| |
| if (monitor.isCanceled()) { |
| return null; |
| } |
| |
| if (items_task.size() > 0) { |
| createFolderBookmark(element, bm, PREFIX_Tasks, NODE_Tasks, |
| items_task, true); |
| } |
| |
| if (monitor.isCanceled()) { |
| return null; |
| } |
| |
| if (items_guidance.size() > 0) { |
| createFolderBookmark(element, bm, PREFIX_Guidances, |
| NODE_Guidances, items_guidance, true); |
| } |
| } |
| |
| if (options.isPublishEmptyCategories() || bm.getChildCount() > 0) { |
| parent.addChild(bm); |
| discardEmptyCategory(element, false); |
| } else { |
| discardEmptyCategory(element, true); |
| } |
| |
| return bm; |
| } |
| |
| private void buildActivitySubTree(Object obj, Activity element, Bookmark bm) { |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| List items = new ArrayList(); |
| |
| org.eclipse.epf.uma.Process proc = TngUtil.getOwningProcess(element); |
| ProcessElementItem procItem = new ProcessElementItem(obj, element, |
| element.getGuid()); |
| |
| ComposedAdapterFactory adapterFactory = super.getLayoutMgr() |
| .getWBSAdapterFactory(); |
| Suppression sup = new Suppression(proc); |
| iterateActivity(procItem, bm, adapterFactory, sup); |
| } |
| |
| private void buildToolSubTree(Tool element, Bookmark parent) { |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| List items = calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getTool_ToolMentors()); |
| if (options.isPublishEmptyCategories() || items.size() > 0) { |
| Bookmark b = createBookmark(element, parent); |
| buildItems(items, b); |
| discardEmptyCategory(element, false); |
| } else { |
| discardEmptyCategory(element, true); |
| } |
| } |
| |
| private void buildTaskSubTree(Task element, Bookmark bm) { |
| |
| String url; |
| Bookmark b; |
| |
| List allItems = new ArrayList(); |
| |
| // performing roles |
| List items = new ArrayList(); |
| List rList = (List) calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getTask_PerformedBy()); |
| if (rList != null) { |
| items.addAll(rList); |
| } |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getTask_AdditionallyPerformedBy())); |
| |
| if (items.size() > 0) { |
| if (options.isPublishLightWeightTree()) { |
| Collections.sort(items, nameComparator); |
| allItems.addAll(items); |
| } else { |
| createFolderBookmark(element, bm, PREFIX_Performing_Roles, |
| NODE_Performing_Roles, items, true); |
| } |
| } |
| |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| if (!options.isPublishLightWeightTree()) { |
| // input work products, need a summary page, |
| items = new ArrayList(); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getTask_MandatoryInput())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getTask_OptionalInput())); |
| |
| if (items.size() > 0) { |
| createFolderBookmark(element, bm, PREFIX_Input_Work_Products, |
| NODE_Input_Work_Products, items, true); |
| } |
| |
| if (monitor.isCanceled()) { |
| return; |
| } |
| } |
| |
| // output work products, need a summary page, TODO |
| items = calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getTask_Output()); |
| |
| if (items.size() > 0) { |
| if (options.isPublishLightWeightTree()) { |
| Collections.sort(items, nameComparator); |
| allItems.addAll(items); |
| } else { |
| createFolderBookmark(element, bm, PREFIX_Output_Work_Products, |
| NODE_Output_Work_Products, items, true); |
| } |
| } |
| |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| // all guidances |
| items.clear(); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_Assets())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_Checklists())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_ConceptsAndPapers())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_Examples())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_Guidelines())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_SupportingMaterials())); |
| // Object e = calc01FeatureValue(element, UmaPackage.eINSTANCE |
| // .getTask_Estimate()); |
| // if (e != null) { |
| // items.add(e); |
| // } |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getTask_ToolMentors())); |
| |
| if (items.size() > 0) { |
| if (options.isPublishLightWeightTree()) { |
| Collections.sort(items, nameComparator); |
| allItems.addAll(items); |
| } else { |
| createFolderBookmark(element, bm, PREFIX_Guidances, |
| NODE_Guidances, items, true); |
| } |
| } |
| |
| if (options.isPublishLightWeightTree()) { |
| buildItems(allItems, bm); |
| } |
| |
| } |
| |
| private void buildRoleSubTree(Role element, Bookmark bm) { |
| String url; |
| Bookmark b; |
| |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| List allItems = new ArrayList(); |
| |
| // tasks, // need a general overview page, TODO |
| // List items = AssociationHelper.getPrimaryTasks(element); |
| List items = calc0nFeatureValue(element, |
| AssociationHelper.Role_Primary_Tasks); |
| if (items.size() > 0) { |
| if (options.isPublishLightWeightTree()) { |
| Collections.sort(items, nameComparator); |
| allItems.addAll(items); |
| } else { |
| createFolderBookmark(element, bm, PREFIX_ResponsibleFor_Tasks, |
| NODE_ResponsibleFor_Tasks, items, true); |
| } |
| } |
| |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| if (!options.isPublishLightWeightTree()) { |
| // secondary tasks |
| items = calc0nFeatureValue(element, |
| AssociationHelper.Role_Secondary_Tasks); |
| if (items.size() > 0) { |
| createFolderBookmark(element, bm, PREFIX_ParticipatesIn_Tasks, |
| NODE_ParticipatesIn_Tasks, items, true); |
| } |
| } |
| |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| // responsible for work products, |
| items = calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getRole_ResponsibleFor()); |
| |
| if (items.size() > 0) { |
| if (options.isPublishLightWeightTree()) { |
| Collections.sort(items, nameComparator); |
| allItems.addAll(items); |
| } else { |
| b = createFolderBookmark(element, bm, |
| PREFIX_Work_Products_Created, |
| NODE_Work_Products_Created, items, false); |
| buildItems(items, b, true); |
| } |
| } |
| |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| if (!options.isPublishLightWeightTree()) { |
| // modifies work products, need a summary page, TODO |
| items = calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getRole_Modifies()); |
| if (items.size() > 0) { |
| b = createFolderBookmark(element, bm, |
| PREFIX_Work_Products_Modified, |
| NODE_Work_Products_Modified, items, false); |
| buildItems(items, b, true); |
| } |
| |
| if (monitor.isCanceled()) { |
| return; |
| } |
| } |
| |
| // all guidances |
| items.clear(); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_Assets())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_Checklists())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_ConceptsAndPapers())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_Examples())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_Guidelines())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_SupportingMaterials())); |
| |
| if (items.size() > 0) { |
| if (options.isPublishLightWeightTree()) { |
| Collections.sort(items, nameComparator); |
| allItems.addAll(items); |
| } else { |
| createFolderBookmark(element, bm, PREFIX_Guidances, NODE_Guidances, items, true); |
| } |
| } |
| |
| if (options.isPublishLightWeightTree()) { |
| // light weight tree, no sub folders |
| buildItems(allItems, bm); |
| } |
| } |
| |
| private void buildWorkProductSubTree(WorkProduct element, Bookmark bm) { |
| List items; |
| String url = ""; //$NON-NLS-1$ |
| // Bookmark b; |
| |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| List allItems = new ArrayList(); |
| |
| // performing roles, 0.1 reference element will be realized in buildItem |
| // multiplicity change for opposite features |
| // Role r = AssociationHelper.getResponsibleRole(element); |
| items = calc0nFeatureValue(element, |
| AssociationHelper.WorkProduct_ResponsibleRoles); |
| if (items.size() > 0) { |
| if (options.isPublishLightWeightTree()) { |
| Collections.sort(items, nameComparator); |
| allItems.addAll(items); |
| } else { |
| createFolderBookmark(element, bm, PREFIX_Responsible_Role, |
| NODE_Responsible_Role, items, true); |
| } |
| } |
| |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| // containing work products, need a summary page, TODO |
| if (element instanceof Artifact) { |
| |
| if (!options.isPublishLightWeightTree()) { |
| WorkProduct wp = ((Artifact) element).getContainerArtifact(); |
| // createBookmark(NODE_Containing_Work_Product, |
| // NODE_Containing_Work_Product, url, "", ""); //$NON-NLS-1$ |
| // //$NON-NLS-2$ |
| if (wp != null) { |
| items = new ArrayList(); |
| items.add(wp); |
| createFolderBookmark(element, bm, |
| PREFIX_Containing_Work_Product, |
| NODE_Containing_Work_Product, items, true); |
| } |
| |
| if (monitor.isCanceled()) { |
| return; |
| } |
| } |
| |
| // contained work products, need a summary page, TODO |
| // items = ((Artifact)element).getContainedArtifacts(); |
| items = calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getArtifact_ContainedArtifacts()); |
| |
| // make sure the contained elements does not contain the container, |
| // this is possible due to realization, say, the containing element |
| // contribute to the container |
| items.remove(element); |
| |
| if (items.size() > 0) { |
| if (options.isPublishLightWeightTree()) { |
| Collections.sort(items, nameComparator); |
| allItems.addAll(items); |
| } else { |
| Bookmark b = createFolderBookmark(element, bm, |
| PREFIX_Contained_Work_Products, |
| NODE_Contained_Work_Products, items, false); |
| |
| // for each contained work product, create the nested sub |
| // tree |
| buildItems(items, b, true); |
| } |
| } |
| } |
| |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| if (!options.isPublishLightWeightTree()) { |
| // input to tasks |
| items = new ArrayList(); |
| items.addAll(calc0nFeatureValue(element, |
| AssociationHelper.WorkProduct_MandatoryInputTo_Tasks)); |
| items.addAll(calc0nFeatureValue(element, |
| AssociationHelper.WorkProduct_OptionalInputTo_Tasks)); |
| if (items.size() > 0) { |
| createFolderBookmark(element, bm, PREFIX_InputTo_Task, |
| NODE_InputTo_Task, items, true); |
| } |
| |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| // output from tasks |
| items = calc0nFeatureValue(element, |
| AssociationHelper.WorkProduct_OutputFrom_Tasks); |
| if (items.size() > 0) { |
| createFolderBookmark(element, bm, PREFIX_OutputOf_Task, |
| NODE_OutputOf_Task, items, true); |
| } |
| |
| if (monitor.isCanceled()) { |
| return; |
| } |
| } |
| |
| // all guidances |
| items = new ArrayList(); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_Assets())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_Checklists())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_ConceptsAndPapers())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_Examples())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_Guidelines())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_SupportingMaterials())); |
| // Object e = calc01FeatureValue(element, UmaPackage.eINSTANCE |
| // .getWorkProduct_Estimate()); |
| // if (e != null) { |
| // items.add(e); |
| // } |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getWorkProduct_Reports())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getWorkProduct_Templates())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getWorkProduct_ToolMentors())); |
| |
| if (items.size() > 0) { |
| if (options.isPublishLightWeightTree()) { |
| Collections.sort(items, nameComparator); |
| allItems.addAll(items); |
| } else { |
| createFolderBookmark(element, bm, PREFIX_Guidances, |
| NODE_Guidances, items, true); |
| } |
| } |
| |
| if (options.isPublishLightWeightTree()) { |
| buildItems(allItems, bm); |
| } |
| } |
| |
| private void buildContainedArtifactsSubTree(Artifact element, Bookmark bm, |
| boolean showGuidances) { |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| List items; |
| String url = ""; //$NON-NLS-1$ |
| |
| // contained work products, need a summary page, TODO |
| // items = ((Artifact)element).getContainedArtifacts(); |
| items = calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getArtifact_ContainedArtifacts()); |
| |
| // make sure the contained elements does not contain the container, |
| // this is possible due to realization, say, the containing element |
| // contribute to the container |
| items.remove(element); |
| |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| if (items.size() > 0) { |
| // Bookmark b = createFolderBookmark(element, bm, |
| // NODE_Contained_Work_Products, items, false); |
| |
| // for each contained work product, create the nested sub tree |
| for (Iterator it = items.iterator(); it.hasNext();) { |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| Artifact e = (Artifact) it.next(); |
| buildItem(e, bm, true); |
| } |
| } |
| |
| if (!showGuidances) { |
| return; |
| } |
| |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| // all guidances |
| items = new ArrayList(); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_Assets())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_Checklists())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_ConceptsAndPapers())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_Examples())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_Guidelines())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getContentElement_SupportingMaterials())); |
| // Object e = calc01FeatureValue(element, UmaPackage.eINSTANCE |
| // .getWorkProduct_Estimate()); |
| // if (e != null) { |
| // items.add(e); |
| // } |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getWorkProduct_Reports())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getWorkProduct_Templates())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getWorkProduct_ToolMentors())); |
| |
| if (items.size() > 0) { |
| // createFolderBookmark(element, bm, NODE_Guidances, items, true); |
| buildItems(items, bm); |
| } |
| } |
| |
| /** |
| * iterate the break down structure and build the xml document |
| * |
| * @param parentObj |
| * The object to iterate. It can be a breakdown element, or it's |
| * adaptor |
| * @param parentXml |
| * @param adapterFactory |
| */ |
| private void iterateActivity(ProcessElementItem parentItem, |
| Bookmark parentBm, ComposedAdapterFactory adapterFactory, |
| Suppression sup) { |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| ITreeItemContentProvider provider = null; |
| Object parentObj = parentItem.rawItem; |
| |
| if (parentObj instanceof ITreeItemContentProvider) { |
| provider = (ITreeItemContentProvider) parentObj; |
| } else { |
| provider = (ITreeItemContentProvider) adapterFactory.adapt( |
| parentObj, ITreeItemContentProvider.class); |
| } |
| |
| if (provider != null) { |
| // String displayName = ProcessUtil.getAttribute(parentObj, |
| // IBSItemProvider.COL_PRESENTATION_NAME, provider); |
| // parentXml.setAttribute("DisplayName", displayName); |
| |
| Collection children = provider.getChildren(parentObj); |
| for (Iterator it = children.iterator(); it.hasNext();) { |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| Object rawitem = it.next(); |
| if (sup.isSuppressed(rawitem)) { |
| continue; |
| } |
| |
| MethodElement item = (MethodElement) LibraryUtil |
| .unwrap(rawitem); |
| |
| if (!options.showDescriptorsInNavigationTree |
| && (item instanceof Descriptor)) { |
| continue; |
| } |
| |
| ProcessElementItem elementItem = new ProcessElementItem( |
| rawitem, item, parentItem); |
| |
| Bookmark child = buildItem(elementItem.element, parentBm, false); |
| if (child != null) { |
| // set the query string |
| child.setQueryString(elementItem.getQueryString()); |
| |
| IBSItemProvider adapter = null; |
| if (rawitem instanceof IBSItemProvider) { |
| adapter = (IBSItemProvider) rawitem; |
| } else { |
| adapter = (IBSItemProvider) adapterFactory.adapt(item, |
| ITreeItemContentProvider.class); |
| ; |
| } |
| |
| String displayName = ProcessUtil.getAttribute(item, |
| IBSItemProvider.COL_PRESENTATION_NAME, adapter); |
| child.setPresentationName(displayName); |
| |
| if (item instanceof Activity) { |
| iterateActivity(elementItem, child, adapterFactory, sup); |
| } |
| } |
| } |
| } |
| } |
| |
| private void buildProcessSubTree(Object obj, |
| org.eclipse.epf.uma.Process element, Bookmark bm) { |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| List items = new ArrayList(); |
| |
| ProcessElementItem procItem = new ProcessElementItem(obj, element, |
| element.getGuid()); |
| |
| ComposedAdapterFactory adapterFactory = super.getLayoutMgr() |
| .getWBSAdapterFactory(); |
| Suppression sup = new Suppression(element); |
| iterateActivity(procItem, bm, adapterFactory, sup); |
| |
| String url; |
| Bookmark b; |
| |
| if (monitor.isCanceled()) { |
| return; |
| } |
| |
| // all guidances |
| items = new ArrayList(); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getBreakdownElement_Checklists())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getBreakdownElement_Concepts())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getBreakdownElement_Examples())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getBreakdownElement_Guidelines())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getBreakdownElement_ReusableAssets())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getActivity_Roadmaps())); |
| |
| // need to include supporting materials as well |
| // fix bug: supporting material served as user defined diagram should not |
| // show up in the navigation tree of a published process. |
| org.eclipse.epf.diagram.model.util.DiagramInfo userDiagramInfo = |
| new org.eclipse.epf.diagram.model.util.DiagramInfo(element); |
| List v = calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getBreakdownElement_SupportingMaterials()); |
| for ( Iterator it = v.iterator(); it.hasNext(); ) { |
| SupportingMaterial s = (SupportingMaterial)it.next(); |
| if ( !userDiagramInfo.isDiagram( (SupportingMaterial)s ) ) { |
| items.add(s); |
| } |
| } |
| |
| if (element instanceof DeliveryProcess) { |
| DeliveryProcess dp = (DeliveryProcess) element; |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getDeliveryProcess_CommunicationsMaterials())); |
| items.addAll(calc0nFeatureValue(element, UmaPackage.eINSTANCE |
| .getDeliveryProcess_EducationMaterials())); |
| } |
| |
| if (items.size() > 0) { |
| createFolderBookmark(element, bm, PREFIX_Guidances, NODE_Guidances, |
| items, true); |
| } |
| } |
| |
| /** |
| * dispose the object |
| */ |
| public void dispose() { |
| super.dispose(); |
| |
| adapterFactory = null; |
| nameComparator = null; |
| bookmarks.clear(); |
| elementUrls.clear(); |
| summaryPagesGenerated.clear(); |
| } |
| |
| protected Set elementUrls = new HashSet(); |
| |
| protected void elementPublished(IElementLayout layout, String htmlfile) { |
| // only for process element for now |
| // may cover all method elements later |
| if (layout.getElement() instanceof ProcessElement) { |
| ElementUrl url = new ElementUrl(layout.getElement().getGuid(), |
| layout.getUrl(), layout.getDisplayName()); |
| elementUrls.add(url); |
| } |
| } |
| |
| private void saveElementUrls() { |
| // save published element urls |
| // need to escape the url and text since it will be assigned to a |
| // javascript variable as literal |
| XmlElement xml = new XmlElement("ElementUrls"); //$NON-NLS-1$ |
| for (Iterator it = elementUrls.iterator(); it.hasNext();) { |
| ElementUrl url = (ElementUrl) it.next(); |
| xml.newChild("elementUrl", url.guid) //$NON-NLS-1$ |
| .setAttribute("text", StrUtil.escape(url.text)) //$NON-NLS-1$ |
| .setAttribute("url", StrUtil.escape(url.url)); //$NON-NLS-1$ |
| } |
| |
| // StringBuffer buffer = new StringBuffer(); |
| // buffer.append(XmlHelper.XML_HEADER).append(xml.toXml()); |
| // File f = new File(getLayoutMgr().getPublishDir(), "ElementUrls.xml"); |
| // //$NON-NLS-1$ |
| // FileUtil.writeUTF8File(f.getAbsolutePath(), buffer.toString()); |
| |
| String html = PublishingUtil.getHtml(xml, "xsl/elementUrls.xsl"); //$NON-NLS-1$ |
| File f = new File(getLayoutMgr().getPublishDir(), |
| PROCESS_LAYOUT_DATA_FILE); //$NON-NLS-1$ |
| FileUtil.writeUTF8File(f.getAbsolutePath(), html, true); |
| } |
| |
| /** |
| * data structure to define url of an element |
| * |
| * @author Jinhua Xi |
| * |
| */ |
| public class ElementUrl { |
| |
| String guid; |
| String url; |
| String text; |
| |
| /** |
| * constructor |
| * |
| * @param guid |
| * String the guid of the element |
| * @param url |
| * String the url of the element |
| * @param text |
| * String the text alone with the url |
| */ |
| public ElementUrl(String guid, String url, String text) { |
| this.guid = guid; |
| this.url = url; |
| this.text = text; |
| } |
| } |
| |
| class EObjectComparator implements Comparator { |
| private EStructuralFeature pName = UmaPackage.eINSTANCE |
| .getMethodElement_PresentationName(); |
| private EStructuralFeature name = UmaPackage.eINSTANCE |
| .getNamedElement_Name(); |
| |
| public EObjectComparator() { |
| |
| } |
| |
| public int compare(Object e1, Object e2) { |
| if (e1 instanceof EObject && e2 instanceof EObject) { |
| Object v1 = getValue(e1); |
| Object v2 = getValue(e2); |
| |
| if (v1 == null && v2 == null) { |
| return e1.toString().compareTo(e2.toString()); |
| } else if (v1 == null) { |
| return -1; |
| } else if (v2 == null) { |
| return 1; |
| } else { |
| return v1.toString().compareTo(v2.toString()); |
| } |
| } else { |
| return e1.toString().compareTo(e2.toString()); |
| } |
| } |
| |
| private Object getValue(Object e) { |
| Object v = null; |
| try { |
| v = ((EObject) e).eGet(pName); |
| } catch (Exception ex) { |
| |
| } |
| ; |
| |
| if (v == null || v.toString().length() == 0) { |
| try { |
| v = ((EObject) e).eGet(name); |
| } catch (Exception ex) { |
| |
| } |
| ; |
| } |
| |
| return v; |
| } |
| } |
| } |
