//------------------------------------------------------------------------------
// 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.authoring.ui.editors;

import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.command.UnexecutableCommand;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.impl.NotificationImpl;
import org.eclipse.emf.common.ui.viewer.IViewerProvider;
import org.eclipse.emf.common.util.AbstractTreeIterator;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.edit.command.CommandParameter;
import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
import org.eclipse.emf.edit.domain.IEditingDomainProvider;
import org.eclipse.emf.edit.provider.DelegatingWrapperItemProvider;
import org.eclipse.emf.edit.provider.IChangeNotifier;
import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
import org.eclipse.emf.edit.provider.ViewerNotification;
import org.eclipse.emf.edit.ui.action.CommandActionHandler;
import org.eclipse.emf.edit.ui.action.CopyAction;
import org.eclipse.emf.edit.ui.action.CutAction;
import org.eclipse.emf.edit.ui.action.DeleteAction;
import org.eclipse.emf.edit.ui.action.PasteAction;
import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider;
import org.eclipse.epf.authoring.ui.AuthoringUIPlugin;
import org.eclipse.epf.authoring.ui.AuthoringUIResources;
import org.eclipse.epf.authoring.ui.actions.IModifyingAction;
import org.eclipse.epf.authoring.ui.actions.IWorkbenchPartAction;
import org.eclipse.epf.authoring.ui.actions.IndentAction;
import org.eclipse.epf.authoring.ui.actions.MethodLibraryActionBarContributor;
import org.eclipse.epf.authoring.ui.actions.MoveDownAction;
import org.eclipse.epf.authoring.ui.actions.MoveUpAction;
import org.eclipse.epf.authoring.ui.actions.OutdentAction;
import org.eclipse.epf.authoring.ui.actions.ProcessAutoSynchronizeAction;
import org.eclipse.epf.authoring.ui.actions.SynchronizationAction;
import org.eclipse.epf.authoring.ui.actions.UpdateSuppressionFromBaseAction;
import org.eclipse.epf.authoring.ui.dialogs.DialogHelper;
import org.eclipse.epf.authoring.ui.dialogs.UserDefinedDiagramDialog;
import org.eclipse.epf.authoring.ui.forms.ProcessBreakdownStructureFormPage;
import org.eclipse.epf.authoring.ui.properties.EPFPropertySheetPage;
import org.eclipse.epf.authoring.ui.views.LibraryView;
import org.eclipse.epf.authoring.ui.views.ProcessViewer;
import org.eclipse.epf.authoring.ui.views.ViewHelper;
import org.eclipse.epf.diagram.ad.ADImages;
import org.eclipse.epf.diagram.add.ADDImages;
import org.eclipse.epf.diagram.core.part.DiagramEditorInput;
import org.eclipse.epf.diagram.core.part.util.DiagramEditorUtil;
import org.eclipse.epf.diagram.core.services.DiagramManager;
import org.eclipse.epf.diagram.model.util.GraphicalDataHelper;
import org.eclipse.epf.diagram.model.util.GraphicalDataManager;
import org.eclipse.epf.diagram.ui.service.DiagramEditorHelper;
import org.eclipse.epf.diagram.wpdd.part.WPDDImages;
import org.eclipse.epf.library.LibraryService;
import org.eclipse.epf.library.configuration.ActivityDeepCopyConfigurator;
import org.eclipse.epf.library.edit.IFilter;
import org.eclipse.epf.library.edit.LibraryEditResources;
import org.eclipse.epf.library.edit.TngAdapterFactory;
import org.eclipse.epf.library.edit.command.IActionManager;
import org.eclipse.epf.library.edit.command.IResourceAwareCommand;
import org.eclipse.epf.library.edit.command.ResourceAwarePasteFromClipboardCommand;
import org.eclipse.epf.library.edit.process.ActivityWrapperItemProvider;
import org.eclipse.epf.library.edit.process.BreakdownElementWrapperItemProvider;
import org.eclipse.epf.library.edit.process.IBSItemProvider;
import org.eclipse.epf.library.edit.process.command.ActivityDropCommand;
import org.eclipse.epf.library.edit.process.command.ContributeToActivityCommand;
import org.eclipse.epf.library.edit.process.command.LocallyReplaceAndDeepCopyCommand;
import org.eclipse.epf.library.edit.process.command.ReplaceActivityCommand;
import org.eclipse.epf.library.edit.ui.IActionTypeProvider;
import org.eclipse.epf.library.edit.ui.UserInteractionHelper;
import org.eclipse.epf.library.edit.util.DiagramOptions;
import org.eclipse.epf.library.edit.util.ExposedAdapterFactory;
import org.eclipse.epf.library.edit.util.IDiagramManager;
import org.eclipse.epf.library.edit.util.ProcessUtil;
import org.eclipse.epf.library.edit.util.Suppression;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.library.edit.util.Suppression.SuppressionCommand;
import org.eclipse.epf.library.edit.validation.DependencyChecker;
import org.eclipse.epf.library.ui.actions.LibraryLockingOperationRunner;
import org.eclipse.epf.library.ui.actions.ProcessDeleteAction;
import org.eclipse.epf.persistence.FileManager;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.BreakdownElement;
import org.eclipse.epf.uma.Descriptor;
import org.eclipse.epf.uma.Diagram;
import org.eclipse.epf.uma.MethodConfiguration;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.Milestone;
import org.eclipse.epf.uma.Process;
import org.eclipse.epf.uma.ProcessComponent;
import org.eclipse.epf.uma.TaskDescriptor;
import org.eclipse.epf.uma.VariabilityElement;
import org.eclipse.epf.uma.VariabilityType;
import org.eclipse.epf.uma.edit.domain.TraceableAdapterFactoryEditingDomain;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.AbstractTreeViewer;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.dialogs.ListSelectionDialog;
import org.eclipse.ui.forms.editor.IFormPage;

/**
 * Action bar contribtutor for process editor
 * 
 * @author Phong Nguyen Le
 * @sine 1.2
 */
public class ProcessEditorActionBarContributor extends
		MethodLibraryActionBarContributor {
	protected Collection<IAction> registeredActions = new ArrayList<IAction>();

	protected boolean locked;

	protected IAction rollupAction = new Action(
			AuthoringUIResources.ProcessEditor_Action_RollUp) {

		public void run() {
			boolean wasRolledUp = bsItemProvider.isRolledUp();
			bsItemProvider.setRolledUp(!bsItemProvider.isRolledUp());
			((IChangeNotifier) bsItemProvider)
					.fireNotifyChanged(new ViewerNotification(
							new ENotificationImpl(
									(InternalEObject) selectedActivity,
									Notification.ADD, null, null, null, false),
							selectedActivity, true, false));

			if (bsItemProvider instanceof DelegatingWrapperItemProvider) {
				// Refreshing for green activities during rollup
				DelegatingWrapperItemProvider provider = (DelegatingWrapperItemProvider) bsItemProvider;
				provider.fireNotifyChanged(new ViewerNotification(
						new NotificationImpl(Notification.SET, provider,
								provider), provider, true, false));
			}
			if (wasRolledUp) {
				ProcessViewer viewer = (ProcessViewer) ((ProcessEditor) activeEditor).currentViewer;
				viewer.expandToLevel(selectedActivity,
						AbstractTreeViewer.ALL_LEVELS);

				// eventhough we switched off creating new activities in
				// WBS,
				// user can still create thru AD. Hence we need to update
				// IDs
				// afterwards
				doRefresh();
			}
		}

	};

	protected MoveUpAction moveUpAction = new MoveUpAction() {
		@Override
		protected boolean accept(IStructuredSelection selection) {
			if(!isEditingAllowed()) {
				return false;
			}
			return super.accept(selection);
		}		
	};

	protected MoveDownAction moveDownAction = new MoveDownAction() {
		@Override
		protected boolean accept(IStructuredSelection selection) {
			if(!isEditingAllowed()) {
				return false;
			}
			return super.accept(selection);
		}
	};

	private IAction preferenceAction = new Action(
			AuthoringUIResources.ProcessEditor_Action_Preferences) {
		public void run() {
			// open process preference page
			org.eclipse.ui.dialogs.PreferencesUtil
					.createPreferenceDialogOn(
							getActiveEditor().getEditorSite().getShell(),
							"org.eclipse.epf.authoring.ui.preferences.ProcessEditorPreferencePage", //$NON-NLS-1$
							null, null).open();
		}
	};

	protected IAction openBaseActivity = new Action(
			AuthoringUIResources.ProcessEditor_Action_OpenBaseActivity) {
		public void run() {
			VariabilityElement base = selectedActivity
					.getVariabilityBasedOnElement();
			Process proc = TngUtil.getOwningProcess((BreakdownElement) base);
			try {
				int id = ((ProcessEditor) activeEditor).getActivePage();
				ISelection selection = new StructuredSelection(base);

				IEditorInput input = new MethodElementEditorInput(
						(MethodElement) proc.eContainer());
				ProcessEditor editor = (ProcessEditor) getPage().openEditor(
						input, ProcessEditor.EDITOR_ID);
				editor.setActivePage(id);
				editor.bsPages[id - 1].getViewer()
						.setSelection(selection, true);
			} catch (PartInitException e) {
				AuthoringUIPlugin.getDefault().getLogger().logError(e);
			}
		}
	};

	protected IAction openWorkflowEditorAction = new Action(
			AuthoringUIResources.ProcessEditor_Action_OpenActivityDiagram) {
		public void run() {
			try {
				try {
					IEditorPart parent = getPage().getActiveEditor();
					IEditorInput input = new GraphicalWorkflowEditor.EditorInput(
							selectedObject, getSuppression());
					IEditorPart part = getPage().openEditor(input,
							ProcessEditor.WORKFLOW_EDITOR_ID);
					if (part instanceof AbstractDiagramEditor) {
						AbstractDiagramEditor editor = (AbstractDiagramEditor) part;
						editor.setParentEditor(parent);
					}
				} catch (PartInitException exception) {
					AuthoringUIPlugin.getDefault().getLogger().logError(
							exception);
				}
			} catch (RuntimeException e) {
				AuthoringUIPlugin.getDefault().getLogger().logError(e);
			}
		}
	};
	
	private class OpenDiagramEditorAction extends Action {

		private int diagramType;

		public OpenDiagramEditorAction(String text, int diagramType) {
			super(text);
			this.diagramType = diagramType;
			setImageDescriptor(getImageDescriptor(diagramType));
			setDisabledImageDescriptor(getDisabledImageDescriptor(diagramType));
		}
		
		private ImageDescriptor getImageDescriptor(int diagramType) {
			switch(diagramType) {
			case IDiagramManager.ACTIVITY_DIAGRAM:
				return ADImages.IMG_DESC_EDITOR;
			case IDiagramManager.ACTIVITY_DETAIL_DIAGRAM:
				return ADDImages.IMG_DESC_EDITOR;
			case IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM:
				return WPDDImages.IMG_DESC_EDITOR;
			}
			return null;
		}
		
		private ImageDescriptor getDisabledImageDescriptor(int diagramType) {
			switch(diagramType) {
			case IDiagramManager.ACTIVITY_DIAGRAM:
				return ADImages.DISABLED_IMG_DESC_EDITOR;
			case IDiagramManager.ACTIVITY_DETAIL_DIAGRAM:
				return ADDImages.DISABLED_IMG_DESC_EDITOR;
			case IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM:
				return WPDDImages.DISABLED_IMG_DESC_EDITOR;
			}
			return null;
		}

		
		@Override
		public void run() {
			DiagramManager mgr = null;
			try {
				if(!ProcessUtil.isInherited(selectedObject)) {
					mgr = DiagramManager.getInstance(getProcess(), this);
					Resource resource = mgr.getResource();
					if(mgr.isNewResource() && !new File(FileManager.toFileString(resource.getURI())).exists()) {
						boolean result = AuthoringUIPlugin
						.getDefault()
						.getMsgDialog()
						.displayConfirmation(AuthoringUIResources.NewDiagramFile_title,
								AuthoringUIResources.promptCreateNewDiagramFile_msg);
						if(result) {
							resource.save(Collections.EMPTY_MAP);

							// still keep the flag resourceIsNew set so editor will be marked dirty
							//
							mgr.setResourceIsNew(true);
						}
						else {
							return;
						}
					}
				}
				openDiagram(diagramType);
			} catch (Exception exception) {
				AuthoringUIPlugin.getDefault().getLogger().logError(
						exception);
			}
			finally {
				if(mgr != null) {
					mgr.removeConsumer(this);
				}
			}
		}
	}
	
	private IAction newActivityDiagramEditor = new OpenDiagramEditorAction(
			AuthoringUIResources.ProcessEditor_Action_OpenActivityDiagram, IDiagramManager.ACTIVITY_DIAGRAM);

	private IAction newActivityDetailDiagramEditor = new OpenDiagramEditorAction(
			AuthoringUIResources.ProcessEditor_Action_OpenActivityDetailDiagram, IDiagramManager.ACTIVITY_DETAIL_DIAGRAM);

	private IAction newWPDiagramEditor = new OpenDiagramEditorAction(
			AuthoringUIResources.ProcessEditor_Action_OpenWorkProductDependencyDiagram,
			IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM);

	// Open workflow detail action
	//
	protected IAction openWorkflowDetailEditorAction = new Action(
			AuthoringUIResources.ProcessEditor_Action_OpenActivityDetailDiagram) {
		public void run() {
			try {
				try {
					IEditorPart parent = getPage().getActiveEditor();
					IEditorInput input = new ActivityDetailDiagramEditor.EditorInput(
							selectedObject, getSuppression());
					IEditorPart part = getPage().openEditor(input,
							ProcessEditor.ACTIVITY_DETAIL_DIAGRAM_EDITOR_ID);
					if (part instanceof AbstractDiagramEditor) {
						AbstractDiagramEditor editor = (AbstractDiagramEditor) part;
						editor.setParentEditor(parent);
					}
				} catch (PartInitException exception) {
					exception.printStackTrace();
				}
			} catch (RuntimeException e) {
				e.printStackTrace();
			}

		}
	};

	protected IAction openWPDependencyEditorAction = new Action(
			AuthoringUIResources.ProcessEditor_Action_OpenWorkProductDependencyDiagram) {
		public void run() {
			try {
				try {
					IEditorPart parent = getPage().getActiveEditor();
					MethodElementEditorInput input = new BreakdownElementEditorInput(
							selectedObject, getSuppression()) {
					};
					IEditorPart part = getPage().openEditor(input,
							ProcessEditor.WPDEPENDENCY_EDITOR_ID);
					if (part instanceof AbstractDiagramEditor) {
						AbstractDiagramEditor editor = (AbstractDiagramEditor) part;
						editor.setParentEditor(parent);
					}
				} catch (PartInitException exception) {
					exception.printStackTrace();
				}
			} catch (RuntimeException e) {
				e.printStackTrace();
			}
		}
	};

	protected IAction replaceAction = new Action(
			AuthoringUIResources.ProcessEditor_Action_Replace) {
		public void run() {
			IResourceAwareCommand cmd = null;
			try {
				cmd = new ReplaceActivityCommand(
						(BreakdownElementWrapperItemProvider) bsItemProvider);
				getActionManager().execute(cmd);
			} catch (Exception e) {
				AuthoringUIPlugin.getDefault().getLogger().logError(e);
			} finally {
				if (cmd != null) {
					try {
						cmd.dispose();
					} catch (Exception e) {
						AuthoringUIPlugin.getDefault().getLogger().logError(e);
					}
				}
			}
		}
	};

	protected IAction localReplacementAndDeepCopy = new Action(
			LibraryEditResources.localReplacementAndDeepCopy_text) {
		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.action.Action#run()
		 */
		public void run() {
			Runnable runnable = new Runnable() {

				public void run() {
					IResourceAwareCommand cmd = null;
					try {
						cmd = new LocallyReplaceAndDeepCopyCommand(
								(BreakdownElementWrapperItemProvider) bsItemProvider);
						getActionManager().execute(cmd);
					} catch (Exception e) {
						AuthoringUIPlugin.getDefault().getLogger().logError(e);
					} finally {
						if (cmd != null) {
							try {
								cmd.dispose();
							} catch (Exception e) {
								AuthoringUIPlugin.getDefault().getLogger()
										.logError(e);
							}
						}
					}
				}

			};

			UserInteractionHelper.runInUI(runnable, getText());
		}
	};

	protected IAction contributeAction = new Action(
			AuthoringUIResources.ProcessEditor_Action_Contribute) {
		public void run() {
			IResourceAwareCommand cmd = null;
			try {
				cmd = new ContributeToActivityCommand(
						(BreakdownElementWrapperItemProvider) bsItemProvider);
				getActionManager().execute(cmd);
				// ProcessUtil.contributeToActivity((BreakdownElementWrapperItemProvider)bsItemProvider,
				// ((ProcessFormEditor)activeEditor).editingDomain.getAdapterFactory());
			} catch (Exception e) {
				AuthoringUIPlugin.getDefault().getLogger().logError(e);
			} finally {
				if (cmd != null) {
					try {
						cmd.dispose();
					} catch (Exception e) {
						AuthoringUIPlugin.getDefault().getLogger().logError(e);
					}
				}
			}
		}
	};

	private class EditorSuppressionCommand extends SuppressionCommand {
		EditorSuppressionCommand(Suppression suppression, List selection,
				boolean suppressed) {
			super(suppression, selection, suppressed);
		}

		private void refresh() {
			if (!getResult().isEmpty()) {
				ProcessEditor editor = (ProcessEditor) getActiveEditor();
				if (isReadOnlyElementAffected()) {
					if (ProcessEditor.hasInherited(selection)) {
						editor.refreshAllProcessEditors();
					} else {
						editor.doRefreshAll(false);
					}
				}
				editor.firePropertyChange(IEditorPart.PROP_DIRTY);

				// Do Diagram Editors refresh
				List<IEditorReference> list = new ArrayList<IEditorReference>();
				for (Iterator iter = selection.iterator(); iter.hasNext();) {
					Object element = iter.next();
					DiagramEditorHelper.closeDiagramEditors(element, list);
					DiagramEditorHelper.refreshParentDiagramEditors(element,
							list, true);
					list.clear();
				}
			}
		}

		/**
		 * @see org.eclipse.epf.library.edit.util.Suppression.SuppressionCommand#didExecute()
		 */
		protected void didExecute() {
			refresh();
		}

		/**
		 * @see org.eclipse.epf.library.edit.util.Suppression.SuppressionCommand#didUndo()
		 */
		protected void didUndo() {
			refresh();
		}

	}

	//TODO: move this action to its own CommandActionHandler class, see IndenAction
	private IAction suppressTaskAction = new Action(
			AuthoringUIResources.ProcessEditor_Action_Suppress_Task) {

		public void run() {
			// check if suppressing the selected elements will cause
			// duplicate descriptors.
			// If so, prompt user to delete the duplicates before
			// continuing.
			//

			final List taskDescriptors = ProcessUtil
					.getTaskDescriptors(selection);
			
			// NO MORE CHECK FOR DUPLICATION OF NAME, PRESENTATION NAME, OR LINKED ELEMENT

			BusyIndicator.showWhile(getActiveEditor().getEditorSite()
					.getShell().getDisplay(), new Runnable() {

				public void run() {
					EditorSuppressionCommand cmd = new EditorSuppressionCommand(
							getSuppression(), taskDescriptors, true);
					cmd.setLabel(getText());
					getActionManager().execute(cmd);
				}
			});

			boolean show = true;
			// update context bar menu after performing suppress
			if (getAdapterFactory() == TngAdapterFactory.INSTANCE
					.getWBS_ComposedAdapterFactory()) {
				for (int i = 0; i < selection.size(); i++) {
					if (!(selection.get(i) instanceof Activity || selection
							.get(i) instanceof ActivityWrapperItemProvider))
						show = false;
				}
			} else
				show = false;

			revealTaskAction.setEnabled(show);
			suppressTaskAction.setEnabled(show);

			// enable synchronize actions correctly
			autoSynchronize.setEnabled(autoSynchronize
					.updateSelection(new StructuredSelection(selection
							.toArray())));
			manualSynchronizeAction.setEnabled(manualSynchronizeAction
					.updateSelection(new StructuredSelection(selection
							.toArray())));
		}
	};

	private IAction suppressAction = new Action(
			AuthoringUIResources.ProcessEditor_Action_Suppress) {

		public void run() {
			// NO MORE CHECK FOR DUPLICATION OF NAME, PRESENTATION NAME, OR LINKED ELEMENT
			
			BusyIndicator.showWhile(getActiveEditor().getEditorSite()
					.getShell().getDisplay(), new Runnable() {

				public void run() {
					// if (getSuppression().suppress(selection)) {
					// if (hasInherited(selection)) {
					// editor.refreshAllProcessEditors();
					// } else {
					// editor.doRefreshAll(false);
					// }
					// }
					// editor.firePropertyChange(PROP_DIRTY);

					EditorSuppressionCommand cmd = new EditorSuppressionCommand(
							getSuppression(), selection, true);
					cmd.setLabel(getText());
					getActionManager().execute(cmd);
				}

			});

			// update context bar menu after performing suppress
			revealAction.setEnabled(getSuppression().canReveal(selection));
			suppressAction.setEnabled(getSuppression().canSuppress(selection));

			// enable synchronize actions correctly
			autoSynchronize.setEnabled(autoSynchronize
					.updateSelection(new StructuredSelection(selection
							.toArray())));
			manualSynchronizeAction.setEnabled(manualSynchronizeAction
					.updateSelection(new StructuredSelection(selection
							.toArray())));
		}
	};

	protected UpdateSuppressionFromBaseAction updateSuppressionFromBaseAction = new UpdateSuppressionFromBaseAction();

	protected IAction revealAction = new Action(
			AuthoringUIResources.ProcessEditor_Action_Reveal) {

		public void run() {
			if (ProcessEditor.canReveal(selection, getAdapterFactory(), getSuppression())) {
				// final ProcessEditor editor = (ProcessEditor)
				// getActiveEditor();

				BusyIndicator.showWhile(getActiveEditor().getEditorSite()
						.getShell().getDisplay(), new Runnable() {

					public void run() {
						// if (getSuppression().reveal(selection)) {
						// if (hasInherited(selection)) {
						// editor.refreshAllProcessEditors();
						// } else {
						// editor.doRefreshAll(false);
						// }
						// }
						// editor.firePropertyChange(PROP_DIRTY);

						EditorSuppressionCommand cmd = new EditorSuppressionCommand(
								getSuppression(), selection, false);
						cmd.setLabel(getText());
						getActionManager().execute(cmd);
					}

				});
				// update context bar menu after performing reveal
				revealAction.setEnabled(getSuppression().canReveal(selection));
				suppressAction.setEnabled(getSuppression().canSuppress(
						selection));
				// enable synchronize actions correctly
				autoSynchronize.setEnabled(autoSynchronize
						.updateSelection(new StructuredSelection(selection
								.toArray())));
				manualSynchronizeAction.setEnabled(manualSynchronizeAction
						.updateSelection(new StructuredSelection(selection
								.toArray())));
			}
		}
	};

	private IAction revealTaskAction = new Action(
			AuthoringUIResources.ProcessEditor_Action_Reveal_Task) {

		public void run() {
			final List taskDescriptors = ProcessUtil
					.getTaskDescriptors(selection);
			if (ProcessEditor.canReveal(taskDescriptors, getAdapterFactory(),
					getSuppression())) {

				BusyIndicator.showWhile(getActiveEditor().getEditorSite()
						.getShell().getDisplay(), new Runnable() {

					public void run() {
						EditorSuppressionCommand cmd = new EditorSuppressionCommand(
								getSuppression(), taskDescriptors, false);
						cmd.setLabel(getText());
						getActionManager().execute(cmd);
					}

				});

				// enable synchronize actions correctly
				autoSynchronize.setEnabled(autoSynchronize
						.updateSelection(new StructuredSelection(selection
								.toArray())));
				manualSynchronizeAction.setEnabled(manualSynchronizeAction
						.updateSelection(new StructuredSelection(selection
								.toArray())));
			}
		}
	};

	protected IBSItemProvider bsItemProvider = null;

	protected Object selectedElement = null;

	protected Activity selectedActivity = null;

	protected BreakdownElement selectedBreakdownElement = null;

	protected List selection;

	protected IAction suppressDiagramAction = new Action(
			AuthoringUIResources.ProcessEditor_Action_Suppress2) {
		public boolean isEnabled() {
			if (!super.isEnabled()) {
				return false;
			}
			return !(bsItemProvider instanceof BreakdownElementWrapperItemProvider && ((BreakdownElementWrapperItemProvider) bsItemProvider)
					.isReadOnly());
		}

		public void run() {
			if (!promptSaveActiveEditor()) {
				return;
			}

			IStructuredContentProvider contentProvider = new ArrayContentProvider();

			ILabelProvider labelProvider = new AdapterFactoryLabelProvider(
					TngUtil.umaItemProviderAdapterFactory) {
				public String getColumnText(Object object, int columnIndex) {
					return GraphicalDataHelper
							.getDiagramTypeText((Diagram) object);
				}
			};

			Collection diagrams = GraphicalDataHelper
					.getDiagrams(selectedActivity);
			ArrayList unsuppressedDiagrams = new ArrayList();
			for (Iterator iter = diagrams.iterator(); iter.hasNext();) {
				Diagram diagram = (Diagram) iter.next();
				if (!diagram.getSuppressed().booleanValue()) {
					unsuppressedDiagrams.add(diagram);
				}
			}

			ListSelectionDialog dlg = new ListSelectionDialog(activeEditor
					.getEditorSite().getShell(), diagrams, contentProvider,
					labelProvider,
					AuthoringUIResources.ProcessEditor_SuppressDialog_Message);
			dlg.setInitialElementSelections(unsuppressedDiagrams);
			dlg
					.setTitle(AuthoringUIResources.ProcessEditor_SuppressDialog_Title);
			dlg.setBlockOnOpen(true);
			dlg.open();

			Object[] diagramsToReveal = dlg.getResult();

			if (diagramsToReveal == null) {
				return;
			}

			boolean changed = true;

			// check if there is really any change
			//
			if (diagramsToReveal.length == unsuppressedDiagrams.size()) {
				for (int i = 0; i < diagramsToReveal.length; i++) {
					if (!unsuppressedDiagrams.contains(diagramsToReveal[i])) {
						changed = false;
						break;
					}
				}
			}

			if (changed) {
				for (Iterator iter = diagrams.iterator(); iter.hasNext();) {
					Diagram diagram = (Diagram) iter.next();
					diagram.setSuppressed(Boolean.TRUE);
				}

				for (int i = 0; i < diagramsToReveal.length; i++) {
					Diagram diagram = (Diagram) diagramsToReveal[i];
					diagram.setSuppressed(Boolean.FALSE);
				}

				// save the editor
				//
				saveActiveEditor();
			}
		}
	};

	private IAction newSuppressDiagramAction = new Action(
			AuthoringUIResources.ProcessEditor_Action_Suppress2) {
		public boolean isEnabled() {
			if (!super.isEnabled()) {
				return false;
			}
			return !(bsItemProvider instanceof BreakdownElementWrapperItemProvider && ((BreakdownElementWrapperItemProvider) bsItemProvider)
					.isReadOnly());
		}

		public void run() {
			if (!promptSaveActiveEditor()) {
				return;
			}

			IStructuredContentProvider contentProvider = new ArrayContentProvider();

			ILabelProvider labelProvider = new AdapterFactoryLabelProvider(
					TngUtil.umaItemProviderAdapterFactory) {
				public String getColumnText(Object object, int columnIndex) {
					// TODO: Change to exact string.
					return DiagramEditorHelper
							.getDiagramTypeString((org.eclipse.gmf.runtime.notation.Diagram) object);
				}
			};

			Collection diagrams = ((ProcessEditor) getActiveEditor())
					.getDiagramEditorHelper().getDiagrams(selectedActivity);
			ArrayList<org.eclipse.gmf.runtime.notation.Diagram> publishDiagrams = new ArrayList<org.eclipse.gmf.runtime.notation.Diagram>();

			for (Iterator iter = diagrams.iterator(); iter.hasNext();) {
				org.eclipse.gmf.runtime.notation.Diagram diagram = (org.eclipse.gmf.runtime.notation.Diagram) iter
						.next();
				switch (DiagramEditorHelper.getDiagramType(diagram)) {
				case IDiagramManager.ACTIVITY_DIAGRAM:
					if (DiagramOptions.isPublishAD(selectedActivity)) {
						publishDiagrams.add(diagram);
					}
					break;
				case IDiagramManager.ACTIVITY_DETAIL_DIAGRAM:
					if (DiagramOptions.isPublishADD(selectedActivity)) {
						publishDiagrams.add(diagram);
					}
					break;
				case IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM:
					if (DiagramOptions.isPublishWPDD(selectedActivity)) {
						publishDiagrams.add(diagram);
					}
					break;
				}
			}

			ListSelectionDialog dlg = new ListSelectionDialog(activeEditor
					.getEditorSite().getShell(), diagrams, contentProvider,
					labelProvider,
					AuthoringUIResources.ProcessEditor_SuppressDialog_Message);
			dlg.setInitialElementSelections(publishDiagrams);
			dlg
					.setTitle(AuthoringUIResources.ProcessEditor_SuppressDialog_Title);
			dlg.setBlockOnOpen(true);
			dlg.open();

			Object[] diagramsToReveal = dlg.getResult();

			if (diagramsToReveal == null) {
				return;
			}

			boolean changed = true;

			// check if there is really any change
			//
			if (diagramsToReveal.length == publishDiagrams.size()) {
				for (int i = 0; i < diagramsToReveal.length; i++) {
					if (!publishDiagrams.contains(diagramsToReveal[i])) {
						changed = false;
						break;
					}
				}
			}

			if (changed) {
				for (Iterator iter = diagrams.iterator(); iter.hasNext();) {
					org.eclipse.gmf.runtime.notation.Diagram diagram = (org.eclipse.gmf.runtime.notation.Diagram) iter
							.next();
					switch (DiagramEditorHelper.getDiagramType(diagram)) {
					case IDiagramManager.ACTIVITY_DIAGRAM:
						DiagramOptions.setPublishAD(selectedActivity, false);
						break;
					case IDiagramManager.ACTIVITY_DETAIL_DIAGRAM:
						DiagramOptions.setPublishADD(selectedActivity, false);
						break;
					case IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM:
						DiagramOptions.setPublishWPDD(selectedActivity, false);
						break;
					}
				}

				for (int i = 0; i < diagramsToReveal.length; i++) {
					org.eclipse.gmf.runtime.notation.Diagram diagram = (org.eclipse.gmf.runtime.notation.Diagram) diagramsToReveal[i];
					switch (DiagramEditorHelper.getDiagramType(diagram)) {
					case IDiagramManager.ACTIVITY_DIAGRAM:
						DiagramOptions.setPublishAD(selectedActivity, true);
						break;
					case IDiagramManager.ACTIVITY_DETAIL_DIAGRAM:
						DiagramOptions.setPublishADD(selectedActivity, true);
						break;
					case IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM:
						DiagramOptions.setPublishWPDD(selectedActivity, true);
						break;
					}
				}
				// save the editor
				//
				saveActiveEditor();
			}
		}
	};

	private IAction newAssignUserDiagram = new Action(
			AuthoringUIResources.ProcessEditor_Action_AssignUserDiagram) {
		/**
		 * @see org.eclipse.jface.action.Action#run()
		 */
		public void run() {
			// TODO: necessary changes UserDefinedDiagramDialog's DiagramInfo.
			UserDefinedDiagramDialog dialog = new UserDefinedDiagramDialog(
					Display.getCurrent().getActiveShell(), activeEditor,
					selectedActivity, getProcess().getDefaultContext(), TngUtil
							.isWrapped(selectedObject));
			dialog.open();
		}
	};

	private IAction diagramPublishNone = new Action(
			AuthoringUIResources.ProcessEditor_Action_SuppressAll) {
		public void run() {
			publishDiagramsForProcess(false);
		}
	};

	private IAction diagramsPublishAll = new Action(
			AuthoringUIResources.ProcessEditor_Action_RevealAll) {
		public void run() {
			publishDiagramsForProcess(true);
		}
	};

	protected IAction suppressAllDiagrams = new Action(
			AuthoringUIResources.ProcessEditor_Action_SuppressAll) {
		public void run() {
			setAllDiagramSuppressed(true);
		}
	};

	protected IAction revealAllDiagrams = new Action(
			AuthoringUIResources.ProcessEditor_Action_RevealAll) {
		public void run() {
			setAllDiagramSuppressed(false);
		}
	};

	protected IAction addAction = new Action(
			AuthoringUIResources.ProcessEditor_Action_Add) {
		public void run() {
			LibraryLockingOperationRunner runner = new LibraryLockingOperationRunner();
			runner.run(new IRunnableWithProgress() {

				public void run(IProgressMonitor monitor)
						throws InvocationTargetException, InterruptedException {
					AdapterFactory adapterFactory = getAdapterFactory();
					if (adapterFactory != null) {
						MethodConfiguration config = LibraryService
								.getInstance().getCurrentMethodConfiguration();
						if (config == null) {
							config = TngUtil.getOwningProcess(
									selectedBreakdownElement)
									.getDefaultContext();
						}
						List selection = DialogHelper.selectElementsFor(
								selectedBreakdownElement, config,
								adapterFactory);

						if (selection == null || selection.isEmpty()) {
							return;
						}

						Object adapter = adapterFactory.adapt(
								selectedBreakdownElement,
								IEditingDomainItemProvider.class);
						if (adapter instanceof IBSItemProvider) {
							IResourceAwareCommand cmd = ((IBSItemProvider) adapter)
									.createDropCommand(
											selectedBreakdownElement, selection);
							getActionManager().execute(cmd);
						}
					}
				}

			});

		}
	};

	protected IAction copyActivityAction = new Action(
			AuthoringUIResources.ProcessEditor_Action_Copy) {
		public void run() {
			MethodConfiguration config = LibraryService.getInstance()
					.getCurrentMethodConfiguration();
			if (config == null) {
				config = TngUtil.getOwningProcess(selectedActivity)
						.getDefaultContext();
			}
			List selection = DialogHelper.selectActivitiesFor(selectedActivity,
					config, IActionTypeProvider.COPY);

			if (selection == null || selection.isEmpty()) {
				return;
			} else {
				for (Iterator itor = selection.iterator(); itor.hasNext();) {
					Object o = itor.next();

					if (o instanceof Activity) {
						Activity act = (Activity) o;

						// Process proc =
						// TngUtil.getOwningProcess(selectedBreakdownElement);
						// if (DependencyChecker.hasCyclicDependency(act, proc))
						// {
						// Object[] args = { selectedActivity.getName(),
						// act.getName() };
						// String message = AuthoringUIResources
						// .bind(
						// AuthoringUIResources.apply_pattern_error_msg,
						// args);
						//
						// String title =
						// AuthoringUIResources.apply_pattern_error_title;
						// AuthoringUIPlugin.getDefault().getMsgDialog()
						// .displayError(title, message, ""); //$NON-NLS-1$
						// itor.remove();
						// }
						// else if (ProcessUtil.hasContributorOrReplacer(act)) {
						// Object[] args = { selectedActivity.getName(),
						// act.getName() };
						// String message = AuthoringUIResources
						// .bind(
						// AuthoringUIResources.activity_variability_error_msg,
						// args);
						//
						// String title =
						// AuthoringUIResources.activity_variability_error_title;
						// AuthoringUIPlugin.getDefault().getMsgDialog()
						// .displayError(title, message, ""); //$NON-NLS-1$
						//
						// itor.remove();
						// return;
						// }

						IStatus status = DependencyChecker
								.checkCircularDependency(act, selectedActivity);
						if (!status.isOK()) {
							String title = AuthoringUIResources.activity_variability_error_title;
							AuthoringUIPlugin.getDefault().getMsgDialog()
									.displayError(title, status.getMessage());
							itor.remove();
						}
					}
					if (selection.isEmpty()) {
						return;
					}
				}
			}

			ActivityDropCommand cmd = new ActivityDropCommand(selectedActivity,
					selection, null, getAdapterFactory());
			IStatus status = cmd.checkCopy();
			if (!status.isOK()) {
				String title = AuthoringUIResources.activity_variability_error_title;
				AuthoringUIPlugin.getDefault().getMsgDialog().displayError(
						title, status.getMessage());
				return;
			}
			cmd.setType(IActionTypeProvider.COPY);
			getActionManager().execute(cmd);
		}
	};

	protected IAction extendActivityAction = new Action(
			AuthoringUIResources.ProcessEditor_Action_Extend) {
		public void run() {
			MethodConfiguration config = LibraryService.getInstance()
					.getCurrentMethodConfiguration();
			if (config == null) {
				config = TngUtil.getOwningProcess(selectedActivity)
						.getDefaultContext();
			}
			List selection = DialogHelper.selectActivitiesFor(selectedActivity,
					config, IActionTypeProvider.EXTEND);

			if (selection == null || selection.isEmpty()) {
				return;
			} else {
				for (Iterator itor = selection.iterator(); itor.hasNext();) {
					Object o = itor.next();

					if (o instanceof Activity) {
						Activity act = (Activity) o;

						// Process proc =
						// TngUtil.getOwningProcess(selectedBreakdownElement);
						// if (DependencyChecker.hasCyclicDependency(act, proc))
						// {
						// Object[] args = { selectedActivity.getName(),
						// act.getName() };
						// String message = AuthoringUIResources
						// .bind(
						// AuthoringUIResources.apply_pattern_error_msg,
						// args);
						//
						// String title =
						// AuthoringUIResources.apply_pattern_error_title;
						// AuthoringUIPlugin.getDefault().getMsgDialog()
						// .displayError(title, message, ""); //$NON-NLS-1$
						// itor.remove();
						// }
						// else if (ProcessUtil.hasContributorOrReplacer(act)) {
						// Object[] args = { selectedActivity.getName(),
						// act.getName() };
						// String message = AuthoringUIResources
						// .bind(
						// AuthoringUIResources.activity_variability_error_msg,
						// args);
						//
						// String title =
						// AuthoringUIResources.activity_variability_error_title;
						// AuthoringUIPlugin.getDefault().getMsgDialog()
						// .displayError(title, message, ""); //$NON-NLS-1$
						//
						// itor.remove();
						// return;
						// }

						/*
						 * IStatus status = DependencyChecker.newCheckAct ?
						 * DependencyChecker.checkCircularDependencyAfterFilterSelection
						 * (act, selectedActivity,
						 * VariabilityType.EXTENDS_LITERAL) :
						 * DependencyChecker.checkCircularDependency(act,
						 * selectedActivity);
						 */
						IStatus status = DependencyChecker.newCheckAct ? DependencyChecker
								.checkCircularForApplyingVariabilityElement(
										selectedActivity, act, true)
								: DependencyChecker.checkCircularDependency(
										act, selectedActivity);
						if (!status.isOK()) {
							String title = AuthoringUIResources.activity_variability_error_title;
							AuthoringUIPlugin.getDefault().getMsgDialog()
									.displayError(title, status);
							itor.remove();
						}
					}
					if (selection.isEmpty()) {
						return;
					}
				}
			}
			ActivityDropCommand cmd = new ActivityDropCommand(selectedActivity,
					selection, null, getAdapterFactory());
			IStatus status = cmd.checkExtend();
			if (!status.isOK()) {
				String title = AuthoringUIResources.activity_variability_error_title;
				AuthoringUIPlugin.getDefault().getMsgDialog().displayError(
						title, status.getMessage());
				return;
			}
			cmd.setType(IActionTypeProvider.EXTEND);
			getActionManager().execute(cmd);
		}
	};

	protected IAction deepCopyActivityAction = new Action(
			AuthoringUIResources.ProcessEditor_action_deepCopy) {
		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.action.Action#run()
		 */
		public void run() {
			LibraryLockingOperationRunner runner = new LibraryLockingOperationRunner();
			runner.run(new IRunnableWithProgress() {

				public void run(IProgressMonitor monitor)
						throws InvocationTargetException, InterruptedException {
					MethodConfiguration config = LibraryService.getInstance()
							.getCurrentMethodConfiguration();
					if (config == null) {
						config = TngUtil.getOwningProcess(selectedActivity)
								.getDefaultContext();
					}
					List selection = DialogHelper.selectActivitiesFor(
							selectedActivity, config,
							IActionTypeProvider.DEEP_COPY);

					if (selection == null || selection.isEmpty()) {
						return;
					} else {
						for (Iterator itor = selection.iterator(); itor
								.hasNext();) {
							Object o = itor.next();

							if (o instanceof Activity) {
								Activity act = (Activity) o;

								// Process proc =
								// TngUtil.getOwningProcess(selectedBreakdownElement);
								// if (ProcessUtil.hasCyclicDependency(act,
								// proc)) {
								// Object[] args = { selectedActivity.getName(),
								// act.getName() };
								// String message = AuthoringUIResources
								// .bind(
								// AuthoringUIResources.apply_pattern_error_msg,
								// args);
								//
								// String title =
								// AuthoringUIResources.apply_pattern_error_title;
								// AuthoringUIPlugin.getDefault().getMsgDialog()
								// .displayError(title, message, "");
								// //$NON-NLS-1$
								// itor.remove();
								// }

								IStatus status = DependencyChecker
										.checkCircularDependency(act,
												selectedActivity);
								if (!status.isOK()) {
									String title = AuthoringUIResources.activity_variability_error_title;
									AuthoringUIPlugin.getDefault()
											.getMsgDialog().displayError(title,
													status.getMessage());
									itor.remove();
								}
							}
							if (selection.isEmpty()) {
								return;
							}
						}
					}

					ActivityDropCommand cmd = new ActivityDropCommand(
							selectedActivity, selection, null,
							getAdapterFactory(),new ActivityDeepCopyConfigurator(config));
					cmd.setType(IActionTypeProvider.DEEP_COPY);
					getActionManager().execute(cmd);

				}
			});
		}
	};

	protected Object selectedObject;

	protected IAction expandAllAction = new Action(
			AuthoringUIResources.ProcessFormEditor_expanAllActionLabel) {
		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.action.Action#run()
		 */
		public void run() {
			Viewer viewer = ((ProcessEditor) activeEditor).currentViewer;
			if (viewer instanceof TreeViewer) {
				((TreeViewer) viewer).expandToLevel(selectedObject,
						AbstractTreeViewer.ALL_LEVELS);
			}
		}
	};

	protected IAction collapseAllAction = new Action(
			AuthoringUIResources.ProcessFormEditor_collapseAllActionLabel) {
		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.jface.action.Action#run()
		 */
		public void run() {
			Viewer viewer = ((ProcessEditor) activeEditor).currentViewer;
			if (viewer instanceof TreeViewer) {
				((TreeViewer) viewer).collapseToLevel(selectedObject,
						AbstractTreeViewer.ALL_LEVELS);
			}
		}
	};

	protected SynchronizationAction manualSynchronizeAction = new SynchronizationAction() {
		public void run() {
			super.run();

			// refresh properties view after synch
			EPFPropertySheetPage page = (EPFPropertySheetPage) ((ProcessEditor) activeEditor)
					.getPropertySheetPage();
			if (page != null) {
				page.refresh();
			}
		}
	};

	protected ProcessAutoSynchronizeAction autoSynchronize = new ProcessAutoSynchronizeAction() {
		private void superRun() {
			super.run();
		}

		/**
		 * @see org.eclipse.epf.authoring.ui.actions.ProcessAutoSynchronizeAction#run()
		 */
		public void run() {
			LibraryLockingOperationRunner runner = new LibraryLockingOperationRunner();
			runner.run(new IRunnableWithProgress() {

				public void run(IProgressMonitor monitor)
						throws InvocationTargetException, InterruptedException {
					if (!AuthoringUIPlugin
							.getDefault()
							.getMsgDialog()
							.displayConfirmation(
									AuthoringUIResources.ProcessEditor_defaultSynchronization,
									AuthoringUIResources.ProcessEditor_confirmAutoSynch)) {
						return;
					}
					// ((SynchronizeCommand)command).setUIContext(getActiveEditor().getSite().getShell());
					superRun();

					// refresh properties view after synch
					EPFPropertySheetPage page = (EPFPropertySheetPage) ((ProcessEditor) activeEditor)
							.getPropertySheetPage();
					if (page != null) {
						page.refresh();
					}
				}
			});

		}
	};

	private IAction showInLibraryView = new Action(
			AuthoringUIResources.ProcessEditor_Action_ShowLinkedElementinLibraryView,
			AuthoringUIPlugin.getDefault().getImageDescriptor(
					"full/etool16/show_linked_element.gif")) { //$NON-NLS-1$   //) 

		public void run() {
			final Object linkedElement = ProcessUtil
					.getAssociatedElement((Descriptor) selectedBreakdownElement);
			if (linkedElement != null) {
				Display.getCurrent().asyncExec(new Runnable() {

					public void run() {
						LibraryView.getView().setSelectionToViewer(
								linkedElement);
					}

				});
			}
		}

	};

	private IAction assignUserDiagram = new Action(
			AuthoringUIResources.ProcessEditor_Action_AssignUserDiagram) {
		/**
		 * @see org.eclipse.jface.action.Action#run()
		 */
		public void run() {
			UserDefinedDiagramDialog dialog = new UserDefinedDiagramDialog(
					Display.getCurrent().getActiveShell(), activeEditor,
					selectedActivity, getProcess().getDefaultContext(), TngUtil
							.isWrapped(selectedObject));

			dialog.open();
		}
	};

	// private IAction activityDetailDiagramInfo = new
	// ActivityDetailDiagramInfoAction(){
	// public Object getObject() {
	// return selectedActivity;
	// }
	// public IWorkbenchPage getPagex() {
	// // TODO Auto-generated method stub
	// return getPage();
	// }
	// };

	private boolean oldLocked;

	private IndentAction indentAction = new IndentAction() {
		public boolean updateSelection(IStructuredSelection selection) {
			if (!isEditingAllowed()) {
				return false;
			}
			return super.updateSelection(selection);
		}
	};

	private OutdentAction outdentAction = new OutdentAction() {
		@Override
		public boolean updateSelection(IStructuredSelection selection) {
			if (!isEditingAllowed()) {
				return false;
			}
			return super.updateSelection(selection);
		}
	};

	public ProcessEditorActionBarContributor() {
		super(AuthoringUIResources.ProcessEditor);

		// don't show validate action
		//
		validateAction = null;

		// set disabled image descriptors
		showInLibraryView.setDisabledImageDescriptor(AuthoringUIPlugin
				.getDefault().getImageDescriptor(
						"full/etool16/show_linked_element_disabled.gif")); //$NON-NLS-1$			
	}

	public ProcessEditorActionBarContributor(String name) {
        super(name);
    }

	protected void openDiagram(int diagramType) {
		try {
			DiagramEditorInput input = new DiagramEditorInput(
					selectedObject, getSuppression(), diagramType);
			DiagramEditorUtil.openDiagramEditor(getPage(), input,
					DiagramEditorHelper.getDiagramPreferencesHint(diagramType),
					new NullProgressMonitor());
		} catch (RuntimeException e) {
			AuthoringUIPlugin.getDefault().getLogger().logError(e);
		}
	}

	protected void registerAction(IAction action) {
		if (action != null && !registeredActions.contains(action)) {
			registeredActions.add(action);
		}
	}

	protected void registerActions() {
		registerAction(autoSynchronize);
		registerAction(manualSynchronizeAction);
		registerAction(updateSuppressionFromBaseAction);
		registerAction(indentAction);
		registerAction(outdentAction);
		registerAction(moveDownAction);
		registerAction(moveUpAction);
	}

	/**
	 * @see org.eclipse.emf.edit.ui.action.EditingDomainActionBarContributor#update()
	 */
	public void update() {
		super.update();

		ISelectionProvider selectionProvider = activeEditor instanceof ISelectionProvider ? (ISelectionProvider) activeEditor
				: activeEditor.getEditorSite().getSelectionProvider();
		ISelection selection = selectionProvider.getSelection();
		IStructuredSelection structuredSelection = selection instanceof IStructuredSelection ? (IStructuredSelection) selection
				: StructuredSelection.EMPTY;

		boolean editingAllowed = isEditingAllowed();
		for (IAction action : registeredActions) {
			if (action instanceof CommandActionHandler) {
				action.setEnabled(((CommandActionHandler) action)
						.updateSelection(structuredSelection));
			}
			else if (action instanceof IModifyingAction) {
				action.setEnabled(editingAllowed);
			}
		}
	}

	/**
	 * @see org.eclipse.emf.edit.ui.action.EditingDomainActionBarContributor#activate()
	 */
	public void activate() {
		manualSynchronizeAction.setProcess(getProcess());
		ISelectionProvider selectionProvider = activeEditor instanceof ISelectionProvider ? (ISelectionProvider) activeEditor
				: activeEditor.getEditorSite().getSelectionProvider();
		for (Iterator iter = registeredActions.iterator(); iter.hasNext();) {
			Object action = (Object) iter.next();
			if (action instanceof IWorkbenchPartAction) {
				((IWorkbenchPartAction) action)
						.setActiveWorkbenchPart(activeEditor);
			}
			if (action instanceof ISelectionChangedListener) {
				selectionProvider
						.addSelectionChangedListener((ISelectionChangedListener) action);
			}
		}
		super.activate();

		// call set Active page explicitly in order to get correct action
		// bars
		setActivePage(activeEditor);
	}

	/**
	 * @see org.eclipse.emf.edit.ui.action.EditingDomainActionBarContributor#deactivate()
	 */
	public void deactivate() {
		super.deactivate();

		ISelectionProvider selectionProvider = activeEditor instanceof ISelectionProvider ? (ISelectionProvider) activeEditor
				: activeEditor.getEditorSite().getSelectionProvider();

		for (Iterator iter = registeredActions.iterator(); iter.hasNext();) {
			Object action = (Object) iter.next();
			if (action instanceof IWorkbenchPartAction) {
				((IWorkbenchPartAction) action).setActiveWorkbenchPart(null);
			}
			if (action instanceof ISelectionChangedListener) {
				selectionProvider
						.removeSelectionChangedListener((ISelectionChangedListener) action);
			}
		}
	}

	/**
	 * @see org.eclipse.epf.authoring.ui.actions.MethodLibraryActionBarContributor#init(org.eclipse.ui.IActionBars)
	 */
	public void init(IActionBars actionBars) {
		super.init(actionBars);
		registerActions();
		contributeToToolBar(actionBars.getToolBarManager());
	}

	protected IActionManager getActionManager() {
		return ((MethodElementEditor) activeEditor).getActionManager();
	}

	protected AdapterFactory getAdapterFactory() {
		return ((ProcessEditor) activeEditor).getAdapterFactory();
	}

	protected void setAllDiagramSuppressed(final boolean suppressed) {
		String title = AuthoringUIResources.processFormEditorSaveDialog_title;
		String message = AuthoringUIResources.processFormEditorSaveDialog_message1;

		if (!AuthoringUIPlugin.getDefault().getMsgDialog().displayConfirmation(
				title, message)) {
			return;
		}

		BusyIndicator.showWhile(activeEditor.getEditorSite().getShell()
				.getDisplay(), new Runnable() {

			public void run() {
				GraphicalDataHelper.setAllDiagramSuppressed(getProcess(),
						suppressed);
				doSaveActiveEditor();
			}

		});
	}

	private void publishDiagramsForProcess(final boolean publish) {
		String title = AuthoringUIResources.processFormEditorSaveDialog_title;
		String message = AuthoringUIResources.processFormEditorSaveDialog_message1;

		if (!AuthoringUIPlugin.getDefault().getMsgDialog().displayConfirmation(
				title, message)) {
			return;
		}

		BusyIndicator.showWhile(activeEditor.getEditorSite().getShell()
				.getDisplay(), new Runnable() {

			public void run() {

				Iterator iterator = new AbstractTreeIterator(getProcess()) {

					/**
					 * Comment for <code>serialVersionUID</code>
					 */
					private static final long serialVersionUID = -618949014476371114L;

					protected Iterator getChildren(Object object) {
						Activity act = (Activity) object;
						ArrayList children = new ArrayList();
						for (Iterator iterator = act.getBreakdownElements()
								.iterator(); iterator.hasNext();) {
							Object element = iterator.next();
							if (element instanceof Activity) {
								children.add(element);
							}
						}
						return children.iterator();
					}

				};
				try {
					while (iterator.hasNext()) {
						Activity activity = (Activity) iterator.next();
						DiagramOptions.setPublishAD(activity, publish);
						DiagramOptions.setPublishADD(activity, publish);
						DiagramOptions.setPublishWPDD(activity, publish);
					}
				} catch (Exception e) {
					AuthoringUIPlugin.getDefault().getLogger().logError(e);
				}
				doSaveActiveEditor();
			}
		});
	}

	private boolean promptSaveActiveEditor() {
		String title = AuthoringUIResources.processFormEditorSaveDialog_title;
		String message = AuthoringUIResources.processFormEditorSaveDialog_message2;
		if (activeEditor.isDirty()) {
			return AuthoringUIPlugin.getDefault().getMsgDialog()
					.displayConfirmation(title, message);
		}
		return true;
	}

	protected void saveActiveEditor() {
		// save the editor
		//
		BusyIndicator.showWhile(activeEditor.getEditorSite().getShell()
				.getDisplay(), new Runnable() {

			public void run() {
				doSaveActiveEditor();
			}

		});
	}

	protected void doSaveActiveEditor() {
		((ProcessEditor) activeEditor).resourcesToSave.add(getProcess()
				.eResource());
		activeEditor.doSave(new NullProgressMonitor());
	}

	protected DeleteAction createDeleteAction() {
		return new ProcessDeleteAction() {
			protected void saveCurrentEditor() {
				if (activeEditor.isDirty()) {
					BusyIndicator.showWhile(activeEditor.getEditorSite()
							.getShell().getDisplay(), new Runnable() {

						public void run() {
							activeEditor.doSave(new NullProgressMonitor());
						}

					});
				}
			}

			public void run() {
				IFormPage activePage = ((ProcessEditor) activeEditor)
						.getActivePageInstance();
				if (activePage != null) {
					String id = activePage.getId();
					if (id == ProcessEditor.WBS_FORM_ID
							|| id == ProcessEditor.TA_FORM_ID
							|| id == ProcessEditor.WPBS_FORM_ID
							|| id == ProcessEditor.CONSOLIDATED_FORM_ID) {
						// for all other pages, disable DELETE
						super.run();
					}
				}
			}
		};
	}

	protected CutAction createCutAction() {
		return new CutAction() {
			public boolean updateSelection(IStructuredSelection selection) {
				return super.updateSelection(ProcessDeleteAction
						.filterSelection(selection));
			}

			@Override
			public Command createCommand(Collection selection) {
				boolean unexecutable = false;
				for (Iterator iter = selection.iterator(); iter.hasNext();) {
					Object element = (Object) iter.next();
					if (element instanceof Activity) {
						unexecutable = true;
					}
				}
				if (unexecutable) {
					return UnexecutableCommand.INSTANCE;
				} else {
					return super.createCommand(selection);
				}
			}
		};
	}

	protected PasteAction createPasteAction() {
		return new PasteAction() {
			public boolean updateSelection(IStructuredSelection selection) {
				return super.updateSelection(ProcessDeleteAction
						.filterSelection(selection));
			}

			/**
			 * Overrided to use ResourceAwarePasteFromClipboardCommand
			 * 
			 * @see org.eclipse.emf.edit.ui.action.PasteAction#createCommand(java.util.Collection)
			 * @see org.eclipse.epf.library.edit.command.ResourceAwarePasteFromClipboardCommand
			 */
			public Command createCommand(Collection selection) {
				if (selection.size() == 1) {
					return new ResourceAwarePasteFromClipboardCommand(domain,
							selection.iterator().next(), null,
							CommandParameter.NO_INDEX);
				} else {
					return UnexecutableCommand.INSTANCE;
				}
			}
		};
	}

	protected CopyAction createCopyAction() {
		return new CopyAction() {

			public void run() {
				if (domain instanceof TraceableAdapterFactoryEditingDomain) {
					((TraceableAdapterFactoryEditingDomain) domain)
							.resetCopyMaps();
				}
				super.run();
			}

		};
	}

	/**
	 * @see org.eclipse.emf.edit.ui.action.EditingDomainActionBarContributor#addGlobalActions(org.eclipse.jface.action.IMenuManager)
	 */
	protected void addGlobalActions(IMenuManager menuManager) {
		super.addGlobalActions(menuManager);
		menuManager.insertAfter("additions", new Separator("fixed-additions")); //$NON-NLS-1$ //$NON-NLS-2$
		// menuManager.insertBefore("fixed-additions",
		// insertNewPhaseAction);
	}

	public void contributeToToolBar(IToolBarManager toolBarManager) {
		super.contributeToToolBar(toolBarManager);

		showInLibraryView
				.setToolTipText(AuthoringUIResources.ProcessEditor_Action_ShowLinkedElementinLibraryView);
		toolBarManager.add(moveUpAction);
		toolBarManager.add(moveDownAction);
		toolBarManager.add(indentAction);
		toolBarManager.add(outdentAction);
		toolBarManager.add(showInLibraryView);
	}

	protected boolean isEditingAllowed() {
		IFormPage activePage = ((ProcessEditor) activeEditor)
				.getActivePageInstance();
		return !(activePage instanceof ProcessBreakdownStructureFormPage && ((ProcessBreakdownStructureFormPage) activePage)
				.basicIsReadOnly());
	}

	/**
	 * @see org.eclipse.jface.action.IMenuListener#menuAboutToShow(org.eclipse.jface.action.IMenuManager)
	 */
	public void menuAboutToShow(IMenuManager menuManager) {
		IFormPage activePage = ((ProcessEditor) activeEditor)
				.getActivePageInstance();
		if (!isEditingAllowed()) {
			menuManager.add(new Separator(
					IWorkbenchActionConstants.MB_ADDITIONS));
			menuManager.add(showInLibraryView);
			if (bsItemProvider != null
			// && ((ITreeItemContentProvider)
			// bsItemProvider).hasChildren(selectedObject)
			) {
				menuManager.add(expandAllAction);
				menuManager.add(collapseAllAction);
			}
			menuManager.add(new Separator());
			refreshViewerAction.setEnabled(refreshViewerAction.isEnabled());
			menuManager.add(refreshViewerAction);
			menuManager.add(showPropertiesViewAction);
			return;
		}

		ISelectionProvider selectionProvider = (ISelectionProvider) activeEditor;

		if (selectedActivity == null
				&& (selectionProvider.getSelection() == null || selectionProvider
						.getSelection().isEmpty())) {
			// fake a selection change event with the process selected if no
			// element is selected yet.
			//
			selectionChanged(new SelectionChangedEvent(selectionProvider,
					new StructuredSelection(getProcess())));
		}
		// disable all new action if it's rolled up
		boolean isRolledUP = bsItemProvider != null
				&& bsItemProvider.isRolledUp();
		super.setEnabled(!isRolledUP);
		super.menuAboutToShow(menuManager);

		// add markers
		//
		menuManager.insertAfter("fixed-additions", new Separator("preference")); //$NON-NLS-1$ //$NON-NLS-2$	
		menuManager.appendToGroup("preference", preferenceAction); //$NON-NLS-1$

		menuManager.insertAfter("fixed-additions", new Separator("open")); //$NON-NLS-1$ //$NON-NLS-2$

		if (bsItemProvider instanceof BreakdownElementWrapperItemProvider
				&& TngUtil.unwrap(bsItemProvider) instanceof Activity) {
			menuManager.insertBefore(IWorkbenchActionConstants.MB_ADDITIONS,
					contributeAction);
			menuManager.insertBefore(IWorkbenchActionConstants.MB_ADDITIONS,
					replaceAction);
			menuManager.insertBefore(IWorkbenchActionConstants.MB_ADDITIONS,
					localReplacementAndDeepCopy);
		}

		if (!isRolledUP) {
			if (createChildActions != null && !createChildActions.isEmpty()) {
				menuManager.insertBefore(
						IWorkbenchActionConstants.MB_ADDITIONS, addAction);
			}
		}

		if (revealAction.isEnabled()) {
			menuManager.insertBefore("fixed-additions", revealAction); //$NON-NLS-1$
		}

		if (suppressAction.isEnabled()) {
			menuManager.insertBefore("fixed-additions", suppressAction); //$NON-NLS-1$
		}
		if (!isRolledUP) {
			if (suppressTaskAction.isEnabled()) {
				menuManager.insertBefore("fixed-additions", suppressTaskAction); //$NON-NLS-1$
			}
			if (revealTaskAction.isEnabled()) {
				menuManager.insertBefore("fixed-additions", revealTaskAction); //$NON-NLS-1$
			}
		}
		if (updateSuppressionFromBaseAction.isEnabled()) {
			menuManager.insertBefore(
					"fixed-additions", updateSuppressionFromBaseAction); //$NON-NLS-1$
		}

		if ((selectedBreakdownElement != null) && (bsItemProvider != null)) {
			menuManager.insertBefore("fixed-additions", moveUpAction); //$NON-NLS-1$
			menuManager.insertBefore("fixed-additions", moveDownAction); //$NON-NLS-1$
		}

		// Indent/outdent
		//
		menuManager.insertBefore("fixed-additions", indentAction); //$NON-NLS-1$				
		menuManager.insertBefore("fixed-additions", outdentAction); //$NON-NLS-1$

		menuManager.appendToGroup("open", showInLibraryView); //$NON-NLS-1$

		if ((selectedActivity != null) && (bsItemProvider != null)) {
			if (bsItemProvider.isRolledUp()) {
				rollupAction
						.setText(AuthoringUIResources.ProcessEditor_Action_RollDown);
			} else {
				rollupAction
						.setText(AuthoringUIResources.ProcessEditor_Action_RollUp);
			}
			menuManager.appendToGroup("open", rollupAction); //$NON-NLS-1$				
		}

		if (selectedObject instanceof Activity) {
			// "Reuse" menu
			//
			MenuManager reuseSubMenu = new MenuManager(
					AuthoringUIResources.ProcessEditor_Action_ApplyPattern);
			reuseSubMenu.add(copyActivityAction);
			reuseSubMenu.add(extendActivityAction);
			reuseSubMenu.add(deepCopyActivityAction);

			menuManager.insertBefore(IWorkbenchActionConstants.MB_ADDITIONS,
					reuseSubMenu);
		}

		if (autoSynchronize.isEnabled()) {
			menuManager.insertBefore(IWorkbenchActionConstants.MB_ADDITIONS,
					autoSynchronize);
		}
		if (manualSynchronizeAction.isEnabled()) {
			menuManager.insertBefore(IWorkbenchActionConstants.MB_ADDITIONS,
					manualSynchronizeAction);
		}

		if (!(selectedElement instanceof Milestone)) {
			// MenuManager diagramSubMenu = new MenuManager(
			// AuthoringUIResources.ProcessEditor_Action_Diagrams);
			if (selectedActivity != null) {
				if (selectedActivity.getVariabilityBasedOnElement() != null) {
					menuManager.appendToGroup("open", openBaseActivity); //$NON-NLS-1$
				}

				// diagramSubMenu.add(openWorkflowEditorAction);
				// diagramSubMenu.add(openWorkflowDetailEditorAction);
				// diagramSubMenu.add(openWPDependencyEditorAction);
				// diagramSubMenu.add(suppressDiagramAction);
				// diagramSubMenu.add(assignUserDiagram);
			}
			// if (selectedActivity == getProcess()) {
			// diagramSubMenu.add(suppressAllDiagrams);
			// diagramSubMenu.add(revealAllDiagrams);
			// }
			// Enable this code if ActivityDetailDiagramInfoDialog is need.
			// if(selectedActivity != null){
			// diagramSubMenu.add(new Separator());
			// diagramSubMenu.add(activityDetailDiagramInfo);
			// }
			// menuManager.appendToGroup("open", diagramSubMenu); //$NON-NLS-1$

			MenuManager newDiagramSubMenu = new MenuManager(
					AuthoringUIResources.ProcessEditor_Action_Diagrams); 
			if (selectedActivity != null) {
				newDiagramSubMenu.add(newActivityDiagramEditor);
				newDiagramSubMenu.add(newActivityDetailDiagramEditor);
				newDiagramSubMenu.add(newWPDiagramEditor);
				newDiagramSubMenu.add(newSuppressDiagramAction);
				newDiagramSubMenu.add(newAssignUserDiagram);

			}

			if (selectedActivity == getProcess()) {
				newDiagramSubMenu.add(diagramsPublishAll);
				newDiagramSubMenu.add(diagramPublishNone);
			}
			menuManager.appendToGroup("open", newDiagramSubMenu); //$NON-NLS-1$
		}

		if (bsItemProvider != null
		// this is an expensive check, removed it
		//
		// && ((ITreeItemContentProvider)
		// bsItemProvider).hasChildren(selectedObject)
		) {
			menuManager.appendToGroup("open", expandAllAction); //$NON-NLS-1$
			menuManager.appendToGroup("open", collapseAllAction); //$NON-NLS-1$
		}
	}

	/**
	 * @return
	 */
	protected Process getProcess() {
		return ((ProcessComponent) ((MethodElementEditorInput) activeEditor
				.getEditorInput()).getMethodElement()).getProcess();
	}

	protected Suppression getSuppression() {
		return ((ProcessEditor) activeEditor).suppression;
	}

	protected void depopulateDynamicMenuItems() {
		// Remove any menu items for old selection.
		//
		if (createChildMenuManager != null) {
			depopulateManager(createChildMenuManager, createChildActions);
		}
		if (createSiblingMenuManager != null) {
			depopulateManager(createSiblingMenuManager, createSiblingActions);
		}
		createChildActions = null;
		createSiblingActions = null;
	}

	/**
	 * Set action state to enabled or disabled
	 * 
	 * @param locked
	 */
	protected void setActionState() {
		if (locked) {
			// disable modifying actions
			pasteAction.setEnabled(false);
			cutAction.setEnabled(false);
			deleteAction.setEnabled(false);
			
			for(IAction action : registeredActions) {
				if(action instanceof IModifyingAction) {
					action.setEnabled(false);
				}
			}
		} else if (!oldLocked) {
			// update state of modifying actions
			//
			IStructuredSelection selection = (IStructuredSelection) selectionProvider
					.getSelection();
			cutAction.setEnabled(cutAction.updateSelection(selection));
			pasteAction.setEnabled(pasteAction.updateSelection(selection));
			deleteAction.setEnabled(deleteAction.updateSelection(selection));
			
			for(IAction action : registeredActions) {
				if(action instanceof IModifyingAction) {
					action.setEnabled(action instanceof CommandActionHandler ? 
							((CommandActionHandler)action).updateSelection(selection) : true);
				}
			}
		}

		boolean enabled = !locked;

		addAction.setEnabled(enabled);
		contributeAction.setEnabled(enabled);

		// state of these actions is set in updateActions()
		//
		// moveDownAction.setEnabled(enabled);
		// moveUpAction.setEnabled(enabled);
		// revealAction.setEnabled(enabled);
		// suppressAction.setEnabled(enabled);
		replaceAction.setEnabled(enabled);
		localReplacementAndDeepCopy.setEnabled(enabled);
		revealAllDiagrams.setEnabled(enabled);
		suppressAllDiagrams.setEnabled(enabled);
		suppressDiagramAction.setEnabled(enabled);
		copyActivityAction.setEnabled(enabled);
		extendActivityAction.setEnabled(enabled);
		deepCopyActivityAction.setEnabled(enabled);
	}

	protected Collection generateCreateChildActions(Collection descriptors,
			ISelection selection) {
		if (locked) {
			return null;
		}
		return super.generateCreateChildActions(descriptors, selection);
	}

	protected Collection generateCreateSiblingActions(Collection descriptors,
			ISelection selection) {
		if (locked) {
			return null;
		}
		return super.generateCreateSiblingActions(descriptors, selection);
	}

	/**
	 * @see org.eclipse.epf.authoring.ui.actions.MethodLibraryActionBarContributor#selectionChanged(org.eclipse.jface.viewers.SelectionChangedEvent)
	 */
	public void selectionChanged(SelectionChangedEvent event) {
		ISelection sel = event.getSelection();
		if (sel instanceof IStructuredSelection) {
			IStructuredSelection structuredSelection = (IStructuredSelection) sel;
			oldLocked = locked;
			locked = ViewHelper.isLocked(structuredSelection);

			selection = ((IStructuredSelection) sel).toList();
			if (selection.size() == 1) {
				selectedObject = ((IStructuredSelection) sel).getFirstElement();
				Object obj = TngUtil.unwrap(selectedObject);
				super.selectionChanged(event);
				selectedElement = obj;
				if (obj instanceof Activity) {
					selectedActivity = (Activity) obj;
				} else {
					// depopulateDynamicMenuItems();
					// bsItemProvider = null;
					selectedActivity = null;
				}
				AdapterFactoryEditingDomain domain = (AdapterFactoryEditingDomain) ((IEditingDomainProvider) activeEditorPart)
						.getEditingDomain();
				Object providerObj = domain.getAdapterFactory().adapt(
						selectedObject, ITreeItemContentProvider.class);
				if (providerObj instanceof IBSItemProvider)
					bsItemProvider = (IBSItemProvider) providerObj;

				if (obj instanceof BreakdownElement) {
					selectedBreakdownElement = (BreakdownElement) obj;
				} else {
					selectedBreakdownElement = null;
				}
			} else {
				depopulateDynamicMenuItems();
				bsItemProvider = null;
				selectedElement = null;
				selectedActivity = null;
				selectedBreakdownElement = null;
				selectedObject = null;
			}

			updateActions();

		} else {
			depopulateDynamicMenuItems();
			bsItemProvider = null;
			selectedElement = null;
			selectedActivity = null;
			selectedBreakdownElement = null;
		}

		// // test code
		// //
		// if(selectedActivity != null) {
		// for (Iterator iter =
		// selectedActivity.eClass().getEAllAttributes().iterator();
		// iter.hasNext();) {
		// EAttribute attrib = (EAttribute) iter.next();
		// if(String.class.isAssignableFrom(attrib.getEAttributeType().getInstanceClass()))
		// {
		// List values =
		// ConfigurationHelper.getStringAttribute(selectedActivity, attrib);
		// System.out.println();
		// System.out.println(attrib.getName() + ": " + values);
		// }
		// }
		// }
	}

	/**
	 * Updates actions including enabling/disabling them based on selection
	 */
	protected void updateActions() {
		showInLibraryView
				.setEnabled(selectedBreakdownElement instanceof Descriptor
						&& ProcessUtil
								.getAssociatedElement((Descriptor) selectedBreakdownElement) != null);

		if (!locked && selection != null && !selection.isEmpty()) {
			if (selection.size() == 1) {				
				Object o = selection.get(0);
				AdapterFactory adapterFactory = getAdapterFactory();
				if(ProcessUtil.isRolledUpDescriptor(o, adapterFactory)) {
					revealAction.setEnabled(false);
					suppressAction.setEnabled(false);
				}
				else {
					if (getSuppression().canReveal(selection)) {
						revealAction.setEnabled(true);
						suppressAction.setEnabled(false);
					} else if (getSuppression().canSuppress(selection)) {
						suppressAction.setEnabled(true);
						revealAction.setEnabled(false);
					} else {
						revealAction.setEnabled(false);
						suppressAction.setEnabled(false);
					}
				}
			} else {
				revealAction.setEnabled(getSuppression().canReveal(selection));
				suppressAction.setEnabled(getSuppression().canSuppress(
						selection));
			}

			// Action Enable/Disable for Suppress Task/Reveal Task context menu
			boolean show = true;
			for (int i = 0; i < selection.size(); i++) {
				if (getAdapterFactory() == TngAdapterFactory.INSTANCE
						.getWBS_ComposedAdapterFactory()) {

					if (!(selection.get(i) instanceof Activity || selection
							.get(i) instanceof ActivityWrapperItemProvider)) {
						show = false;
						break;
					}
				} else
					show = false;
			}
			if (show) {
				List taskDescriptors = ProcessUtil
						.getTaskDescriptors(selection);
				suppressTaskAction.setEnabled(getSuppression().canSuppress(
						taskDescriptors));
				revealTaskAction.setEnabled(getSuppression().canReveal(
						taskDescriptors));
			} else {
				suppressTaskAction.setEnabled(false);
				revealTaskAction.setEnabled(false);
			}

			// boolean hasInherited = false;
			// for (Iterator iter = selection.iterator(); iter.hasNext();) {
			// Object item = iter.next();
			// if (item instanceof BreakdownElementWrapperItemProvider
			// && ((BreakdownElementWrapperItemProvider) item)
			// .isReadOnly()) {
			// hasInherited = true;
			// break;
			// }
			// }
			// updateSuppressionFromBaseAction.setEnabled(hasInherited);
		} else {
			revealAction.setEnabled(false);
			suppressAction.setEnabled(false);
			suppressTaskAction.setEnabled(false);
			revealTaskAction.setEnabled(false);
		}

		// Set Activity Detail Diagram Action enable state.
		if (selectedObject instanceof Activity
				|| selectedObject instanceof ActivityWrapperItemProvider) {
			setActionStateForADD();
			setDiagramsContextMenuState();
		}

		// change action state for locked plugin
		setActionState();
	}

	public void setActivePage(IEditorPart part) {
		if (this.activeEditor != null) {
			int page = ((ProcessEditor) this.activeEditor).getActivePage();
			IActionBars actionBars = this.activeEditor.getEditorSite()
					.getActionBars();

			// TODO - need to get IFormPage and compare on that rather than
			// integer page id. These id will change if we reposition pages.
			if (page == 0) {			
				actionBars.setGlobalActionHandler(ActionFactory.DELETE.getId(),
						null);
				actionBars.setGlobalActionHandler(ActionFactory.CUT.getId(),
						null);
				actionBars.setGlobalActionHandler(ActionFactory.COPY.getId(),
						null);
				actionBars.setGlobalActionHandler(ActionFactory.PASTE.getId(),
						null);
				actionBars.setGlobalActionHandler(ActionFactory.UNDO.getId(),
						null);
				actionBars.setGlobalActionHandler(ActionFactory.REDO.getId(),
						null);
			} else if (page == 4) {
				actionBars.clearGlobalActionHandlers();
			}
			else {
				actionBars.setGlobalActionHandler(ActionFactory.DELETE.getId(),
						deleteAction);
				actionBars.setGlobalActionHandler(ActionFactory.CUT.getId(),
						cutAction);
				actionBars.setGlobalActionHandler(ActionFactory.COPY.getId(),
						copyAction);
				actionBars.setGlobalActionHandler(ActionFactory.PASTE.getId(),
						pasteAction);
				actionBars.setGlobalActionHandler(ActionFactory.UNDO.getId(),
						undoAction);
				actionBars.setGlobalActionHandler(ActionFactory.REDO.getId(),
						redoAction);
			}
			actionBars.updateActionBars();
		}
	}
	
	private void superDoRefresh() {
		super.doRefresh();
	}

	protected void doRefresh() {
		if (activeEditorPart instanceof IViewerProvider) {
			Display display = activeEditorPart.getEditorSite().getShell().getDisplay();
			BusyIndicator.showWhile(display, new Runnable() {

				public void run() {
					// update IDs
					//
					AdapterFactory adapterFactory = getAdapterFactory();
					if (adapterFactory == TngAdapterFactory.INSTANCE
							.getWBS_ComposedAdapterFactory()
							|| adapterFactory == TngAdapterFactory.INSTANCE
									.getProcessComposedAdapterFactory()) {
						Process proc = getProcess();
						ProcessUtil.updateIDs(adapterFactory, proc);
//						long time = System.currentTimeMillis();
						ProcessUtil.refreshPredeccessorLists(adapterFactory, proc);
//						System.out.println("refreshPredeccessorLists() took: " + (System.currentTimeMillis() - time));
					}

					superDoRefresh();
				}
				
			});
		}

	}

	/*
	 * Set Action state for Activity Detail Diagram in Context Menu on selection
	 * of Activity. If an Activity consist atleast one taskdescriptor and its
	 * primary performer in current configuration, then state is enabled else
	 * state is disabled in context menu (process editor).
	 */
	protected void setActionStateForADD() {

		// set ADD Action state false
		openWorkflowDetailEditorAction.setEnabled(false);

		// set AD Action state true always
		openWorkflowEditorAction.setEnabled(true);

		// set WPD Diagram Menu Action state tru always
		openWPDependencyEditorAction.setEnabled(true);

		if (selectedObject != null) {

			if (getSuppression().isSuppressed(selectedObject)) {
				openWorkflowDetailEditorAction.setEnabled(false);
				openWorkflowEditorAction.setEnabled(false);
				openWPDependencyEditorAction.setEnabled(false);
				return;
			}

			Activity activity = null;
			List list = new ArrayList();

			if (selectedObject instanceof Activity) {
				activity = selectedActivity;
			} else if (selectedObject instanceof ActivityWrapperItemProvider) {
				activity = (Activity) ((ActivityWrapperItemProvider) selectedObject)
						.getValue();
			}
			if (activity == null)
				return;

			while (!activity.getVariabilityType().equals(
					VariabilityType.NA)) {

				VariabilityElement ve = activity.getVariabilityBasedOnElement();
				// If Activity is set to local contribution,
				// need to get breakdown elements of local contributed
				// activity + base activity. And base activity breakdown
				// elements
				// are collected after while loop ends)
				// if (VariabilityType.CONTRIBUTES_LITERAL.equals(activity
				// .getVariabilityType())) {
				// list.addAll(activity.getBreakdownElements());
				// }
				list.addAll(activity.getBreakdownElements());

				if ((ve != null) && (ve instanceof Activity)) {
					activity = (Activity) ve;
				} else {
					break;
				}
			}

			// For AD diagram menu option, if Base Activity donot have any
			// AD diagram, donot show AD diagram option in context menu for
			// readonly activity.
			Diagram diagram = GraphicalDataManager.getInstance().getUMADiagram(
					activity, GraphicalDataHelper.ACTIVITY_DIAGRAM, false);
			if (diagram == null
					&& selectedObject instanceof ActivityWrapperItemProvider) {
				openWorkflowEditorAction.setEnabled(false);
			}

			// For WPD diagram menu option, if Base Activity donot have any
			// WPD diagram, donot show WPD diagram option in context menu
			// for readonly activity.
			diagram = GraphicalDataManager.getInstance().getUMADiagram(
					activity,
					GraphicalDataHelper.WORK_PRODUCT_DEPENDENCY_DIAGRAM, false);
			if (diagram == null
					&& selectedObject instanceof ActivityWrapperItemProvider) {
				openWPDependencyEditorAction.setEnabled(false);
			}

			// Collect the breakdown elements to verifty taskdescriptors are
			// not.
			list.addAll(activity.getBreakdownElements());

			// For ADD diagram menu option, if Base Activity donot have any
			// ADD diagram, donot show ADD diagram option in context menu
			// for
			// readonly activity.
			diagram = GraphicalDataManager.getInstance().getUMADiagram(
					activity, GraphicalDataHelper.ACTIVITY_DETAIL_DIAGRAM,
					false);
			if (diagram == null
					&& selectedObject instanceof ActivityWrapperItemProvider) {
				openWorkflowDetailEditorAction.setEnabled(false);
			} else {
				// Iterate through the List, to find taskdescriptor and has
				// primary role within current configuration.
				// then enable the action.
				for (Iterator iterator = list.iterator(); iterator.hasNext();) {
					Object obj = iterator.next();
					if (obj instanceof TaskDescriptor) {
						if (!getSuppression().isSuppressed(obj)) {
							Object e = ((TaskDescriptor) obj)
									.getPerformedPrimarilyBy();
							AdapterFactoryEditingDomain domain = (AdapterFactoryEditingDomain) ((IEditingDomainProvider) activeEditorPart)
									.getEditingDomain();
							AdapterFactory factory = domain.getAdapterFactory();
							if (factory instanceof ExposedAdapterFactory) {
								IFilter filter = ((ExposedAdapterFactory) factory)
										.getFilter();
								if (filter != null && filter.accept(e)
										&& !getSuppression().isSuppressed(e)) {
									openWorkflowDetailEditorAction
											.setEnabled(true);
									break;
								}
							}
						}
					}
				}
			}
		}
	}

	/*
	 * Set Action state for Open Diagram Actions in Context Menu on
	 * selection of Activity. Checking condition to handle if activity suppressed, if activity don't have
	 * any taskdescriptor and primary performer, if base activity don't have diagram. 
	 */
	private void setDiagramsContextMenuState() {

		// set ADD Action state false
		newActivityDetailDiagramEditor.setEnabled(false);

		// set AD Action state true always
		newActivityDiagramEditor.setEnabled(true);

		// set WPD Diagram Menu Action state tru always
		newWPDiagramEditor.setEnabled(true);

		if (selectedObject != null) {

			if (getSuppression().isSuppressed(selectedObject)) {
				newActivityDetailDiagramEditor.setEnabled(false);
				newActivityDiagramEditor.setEnabled(false);
				newWPDiagramEditor.setEnabled(false);
				return;
			}

			Object unwrapped = TngUtil.unwrap(selectedObject);
			if(!(unwrapped instanceof Activity)) {
				return;
			}
			Activity activity = (Activity) unwrapped;
			List list = new ArrayList();
			
			//TODO: check for existing diagrams in immediate base instead of root base
			
			while (!activity.getVariabilityType().equals(
					VariabilityType.NA)) {

				VariabilityElement ve = activity.getVariabilityBasedOnElement();
				list.addAll(activity.getBreakdownElements());

				if ((ve != null) && (ve instanceof Activity)) {
					activity = (Activity) ve;
				} else {
					break;
				}
			}

			org.eclipse.gmf.runtime.notation.Diagram diagram = ((ProcessEditor) getActiveEditor())
					.getDiagramEditorHelper().getDiagram(activity,
							IDiagramManager.ACTIVITY_DIAGRAM);
			if (diagram == null
					&& selectedObject instanceof ActivityWrapperItemProvider) {
				newActivityDiagramEditor.setEnabled(false);
			}

			// For WPD diagram menu option, if Base Activity donot have any
			// WPD diagram, donot show WPD diagram option in context menu
			// for readonly activity.
			diagram = ((ProcessEditor) getActiveEditor())
					.getDiagramEditorHelper().getDiagram(activity,
							IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM);
			if (diagram == null
					&& selectedObject instanceof ActivityWrapperItemProvider) {
				newWPDiagramEditor.setEnabled(false);
			}

			// Collect the breakdown elements to verifty taskdescriptors are
			// not.
			list.addAll(activity.getBreakdownElements());

			// For ADD diagram menu option, if Base Activity donot have any
			// ADD diagram, donot show ADD diagram option in context menu
			// for
			// readonly activity.
			diagram = ((ProcessEditor) getActiveEditor())
					.getDiagramEditorHelper().getDiagram(activity,
							IDiagramManager.ACTIVITY_DETAIL_DIAGRAM);

			if (diagram == null
					&& selectedObject instanceof ActivityWrapperItemProvider) {
				newActivityDetailDiagramEditor.setEnabled(false);
			} else {
				// Iterate through the List, to find taskdescriptor and has
				// primary role within current configuration.
				// then enable the action.
				for (Iterator iterator = list.iterator(); iterator.hasNext();) {
					Object obj = iterator.next();
					if (obj instanceof TaskDescriptor) {
						if (!getSuppression().isSuppressed(obj)) {
							Object e = ((TaskDescriptor) obj)
									.getPerformedPrimarilyBy();
							AdapterFactoryEditingDomain domain = (AdapterFactoryEditingDomain) ((IEditingDomainProvider) activeEditorPart)
									.getEditingDomain();
							AdapterFactory factory = domain.getAdapterFactory();
							if (factory instanceof ExposedAdapterFactory) {
								IFilter filter = ((ExposedAdapterFactory) factory)
										.getFilter();
								if (filter != null && filter.accept(e)
										&& !getSuppression().isSuppressed(e)) {
									newActivityDetailDiagramEditor
											.setEnabled(true);
									break;
								}
							}
						}
					}
				}
			}
		}
	}
}