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