//------------------------------------------------------------------------------
// Copyright (c) 2005, 2006 IBM Corporation and others.
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// Contributors:
// IBM Corporation - initial implementation
//------------------------------------------------------------------------------
package org.eclipse.epf.authoring.ui.forms;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
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.AuthoringUIText;
import org.eclipse.epf.authoring.ui.dialogs.ItemsFilterDialog;
import org.eclipse.epf.authoring.ui.editors.MethodElementEditor;
import org.eclipse.epf.authoring.ui.filters.ContentFilter;
import org.eclipse.epf.authoring.ui.filters.WorkProductFilter;
import org.eclipse.epf.authoring.ui.richtext.IMethodRichText;
import org.eclipse.epf.authoring.ui.util.UIHelper;
import org.eclipse.epf.library.edit.IFilter;
import org.eclipse.epf.library.edit.TngAdapterFactory;
import org.eclipse.epf.library.edit.command.IActionManager;
import org.eclipse.epf.library.edit.itemsfilter.FilterConstants;
import org.eclipse.epf.library.edit.itemsfilter.VariabilityBaseElementFilter;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.uma.Artifact;
import org.eclipse.epf.uma.ArtifactDescription;
import org.eclipse.epf.uma.ContentElement;
import org.eclipse.epf.uma.Deliverable;
import org.eclipse.epf.uma.DeliverableDescription;
import org.eclipse.epf.uma.FulfillableElement;
import org.eclipse.epf.uma.Outcome;
import org.eclipse.epf.uma.UmaPackage;
import org.eclipse.epf.uma.VariabilityElement;
import org.eclipse.epf.uma.WorkProduct;
import org.eclipse.epf.uma.util.AssociationHelper;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Table;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorSite;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.forms.editor.FormEditor;
import org.eclipse.ui.forms.widgets.FormToolkit;
import org.eclipse.ui.forms.widgets.Section;

/**
 * The Description page in a Work Product (Artifact, Deliverable and Outcome)
 * editor.
 * 
 * @author Shilpa Toraskar
 * @author Kelvin Low
 * @since 1.0
 */
public class WorkProductDescriptionPage extends DescriptionFormPage {

	private static final String FORM_PAGE_ID = "workProductDescriptionPage"; //$NON-NLS-1$	

	private IMethodRichText ctrl_impact;

	private IMethodRichText ctrl_reason;

	// For Artifact
	private IMethodRichText ctrl_brief_outline;

	private IMethodRichText ctrl_representation_options;

	// For Deliverable
	private IMethodRichText ctrl_external_desc, ctrl_packaging_guidance;

	private IMethodRichText ctrl_representation;

	private IMethodRichText ctrl_notation;

	private WorkProduct workProduct;

	// For slots
	private Button ctrl_slot_button;
	
	private Section slotSection;
	
	private Composite slotComposite;
	
	private String slotSectionDescription;
	
	private Button addSlotButton, removeSlotButton;
	
	private Table ctrl_slot;
	
	private TableViewer slotViewer;

	// slots content provider
	private IStructuredContentProvider slotContentProvider = new AdapterFactoryContentProvider(
			TngAdapterFactory.INSTANCE
					.getNavigatorView_ComposedAdapterFactory()) {
		public Object[] getElements(Object object) {
			List<FulfillableElement> list = new ArrayList<FulfillableElement>();
			list.addAll(workProduct.getFulfills());
			return list.toArray();
		}
	};
	
	protected ILabelProvider slotLabelProvider = new AdapterFactoryLabelProvider(
			TngAdapterFactory.INSTANCE
					.getNavigatorView_ComposedAdapterFactory()) {
		public String getColumnText(Object object, int columnIndex) {
			return TngUtil.getLabelWithPath(object);
		}
	};
	/**
	 * Creates a new instance.
	 */
	public WorkProductDescriptionPage(FormEditor editor) {
		super(editor, FORM_PAGE_ID, AuthoringUIText.DESCRIPTION_PAGE_TITLE);
	}

	/**
	 * @see org.eclipse.epf.authoring.ui.forms.DescriptionFormPage#init(org.eclipse.ui.IEditorSite,
	 *      org.eclipse.ui.IEditorInput)
	 */
	public void init(IEditorSite site, IEditorInput input) {
		super.init(site, input);
		workProduct = (WorkProduct) contentElement;
		purposeOn = true;
		externalIdOn = true;
		if (!(contentElement instanceof Outcome)) {
			notationSectionOn = true;
		}
		tailoringSectionOn = true;
		iconSectionOn = true;
		slotSectionOn = true;
	}

	/**
	 * @see org.eclipse.epf.authoring.ui.forms.DescriptionFormPage#createNotationSectionContent()
	 */
	protected void createNotationSectionContent() {
		super.createNotationSectionContent();

		if (workProduct instanceof Artifact) {
			ctrl_brief_outline = createRichTextEditWithLinkForSection(toolkit,
					notationComposite, AuthoringUIText.BRIEF_OUTLINE_TEXT, 40,
					400, NOTATION_SECTION_ID);
			ctrl_representation = createRichTextEditWithLinkForSection(toolkit,
					notationComposite, AuthoringUIText.REPRESENTATION_TEXT, 40,
					400, NOTATION_SECTION_ID);
			ctrl_notation = createRichTextEditWithLinkForSection(toolkit,
					notationComposite, AuthoringUIText.NOTATION_TEXT, 40, 400,
					NOTATION_SECTION_ID);
		} else if (workProduct instanceof Deliverable) {
			ctrl_external_desc = createRichTextEditWithLinkForSection(toolkit,
					notationComposite,
					AuthoringUIText.EXTERNAL_DESCRIPTION_TEXT, 40, 400,
					NOTATION_SECTION_ID);
			ctrl_packaging_guidance = createRichTextEditWithLinkForSection(
					toolkit, notationComposite,
					AuthoringUIText.PACKAGING_GUIDANCE_TEXT, 40, 400,
					NOTATION_SECTION_ID);
		}
	}

	/**
	 * @see org.eclipse.epf.authoring.ui.forms.DescriptionFormPage#createTailoringSectionContent()
	 */
	protected void createTailoringSectionContent() {
		super.createTailoringSectionContent();
		ctrl_impact = createRichTextEditWithLinkForSection(toolkit,
				tailoringComposite, AuthoringUIText.IMPACT_OF_NOT_HAVING_TEXT,
				40, 400, TAILORING_SECTION_ID);
		ctrl_reason = createRichTextEditWithLinkForSection(toolkit,
				tailoringComposite,
				AuthoringUIText.REASON_FOR_NOT_NEEDING_TEXT, 40, 400,
				TAILORING_SECTION_ID);
		if (workProduct instanceof Artifact) {
			ctrl_representation_options = createRichTextEditWithLinkForSection(
					toolkit, tailoringComposite,
					AuthoringUIText.REPRESENTATION_OPTIONS_TEXT, 40, 400,
					NOTATION_SECTION_ID);
		}
	}

	protected void createEditorContent(FormToolkit toolkit) {
		super.createEditorContent(toolkit);
	}

	/**
	 * Create slot section
	 * 
	 * @param toolkit
	 */
	protected void createSlotSection(FormToolkit toolkit) {

		slotSection = createSection(toolkit, sectionComposite,
				AuthoringUIText.SLOT_SECTION_NAME, this.slotSectionDescription);
		slotComposite = createComposite(toolkit, slotSection);
		slotComposite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		slotComposite.setLayout(new GridLayout(5, false));
		createSlotSectionContent();
		toolkit.paintBordersFor(slotComposite);
	}

	/**
	 * 
	 */
	private void createSlotSectionContent() {
		
		ctrl_slot_button = toolkit.createButton(slotComposite,
				AuthoringUIResources.workproductDescriptionPage_slot_text,
				SWT.CHECK);
		GridData data = new GridData();
		data.horizontalSpan = 5;
		ctrl_slot_button.setLayoutData(data);
		
		createLabel(toolkit, slotComposite,
				AuthoringUIResources.slotsLabel_text, 2);
		ctrl_slot = createTable(toolkit, slotComposite, SWT.MULTI
				| SWT.READ_ONLY, GridData.FILL_HORIZONTAL | GridData.BEGINNING,
				5, 300, 1, 2);
		{
			GridData gridData = new GridData(GridData.FILL_HORIZONTAL
					| GridData.BEGINNING);
			gridData.horizontalSpan = 2;
			gridData.heightHint = 30;
			gridData.widthHint = 300;
			ctrl_slot.setLayoutData(gridData);
		}

		slotViewer = new TableViewer(ctrl_slot);
		slotViewer.setContentProvider(slotContentProvider);
		slotViewer.setLabelProvider(slotLabelProvider);
		slotViewer.setInput(methodElement);

		Composite buttonPane = createComposite(toolkit, slotComposite,
				GridData.HORIZONTAL_ALIGN_END, 1, 1, 1);
		{
			GridData gridData = new GridData(GridData.HORIZONTAL_ALIGN_END);
			buttonPane.setLayoutData(gridData);
		}

		addSlotButton = toolkit.createButton(buttonPane,
				AuthoringUIText.ADD_BUTTON_TEXT, SWT.SIMPLE);
		{
			GridData gridData = new GridData(GridData.FILL_HORIZONTAL);
			gridData.widthHint = BUTTON_WIDTH;
			addSlotButton.setLayoutData(gridData);
		}
		
		removeSlotButton = toolkit.createButton(buttonPane,
				AuthoringUIText.REMOVE_BUTTON_TEXT, SWT.SIMPLE);
		{
			GridData gridData = new GridData(GridData.FILL_HORIZONTAL);
			gridData.widthHint = BUTTON_WIDTH;
			removeSlotButton.setLayoutData(gridData);
		}
		removeSlotButton.setEnabled(false);
	}

	/**
	 * @see org.eclipse.epf.authoring.ui.forms.DescriptionFormPage#addListeners()
	 */
	protected void addListeners() {
		final IActionManager actionMgr = ((MethodElementEditor) getEditor())
				.getActionManager();

		super.addListeners();

		// add all slot related listeners
		
		if (slotSectionOn) {
			addSlotListeners();
		}
		
		
		if (purposeOn) {
			ctrl_purpose.setModalObject(contentElement.getPresentation());
			ctrl_purpose.setModalObjectFeature(UmaPackage.eINSTANCE
					.getWorkProductDescription_Purpose());
			ctrl_purpose.addModifyListener(contentModifyListener);
			ctrl_purpose.addListener(SWT.Deactivate, new Listener() {
				public void handleEvent(Event e) {
					IMethodRichText control = descExpandFlag ? ctrl_expanded
							: ctrl_purpose;
					if (!control.getModified()) {
						return;
					}
					String oldContent = ((org.eclipse.epf.uma.WorkProductDescription) workProduct
							.getPresentation()).getPurpose();
					if (((MethodElementEditor) getEditor()).mustRestoreValue(
							control, oldContent)) {
						return;
					}
					String newContent = control.getText();
					if (!newContent.equals(oldContent)) {
						boolean success = actionMgr.doAction(
								IActionManager.SET, contentElement
										.getPresentation(),
								UmaPackage.eINSTANCE
										.getWorkProductDescription_Purpose(),
								newContent, -1);
						if (success && isVersionSectionOn()) {
							updateChangeDate();
						}
					}
				}
			});
		}


		if (tailoringSectionOn) {
			ctrl_impact.setModalObject(contentElement.getPresentation());
			ctrl_impact.setModalObjectFeature(UmaPackage.eINSTANCE
					.getWorkProductDescription_ImpactOfNotHaving());
			ctrl_impact.addModifyListener(contentModifyListener);
			ctrl_impact.addListener(SWT.Deactivate, new Listener() {
				public void handleEvent(Event e) {
					IMethodRichText control = descExpandFlag ? ctrl_expanded
							: ctrl_impact;
					if (!control.getModified()) {
						return;
					}
					String oldContent = ((org.eclipse.epf.uma.WorkProductDescription) workProduct
							.getPresentation()).getImpactOfNotHaving();
					if (((MethodElementEditor) getEditor()).mustRestoreValue(
							control, oldContent)) {
						return;
					}
					String newContent = control.getText();
					if (!newContent.equals(oldContent)) {
						boolean success = actionMgr
								.doAction(
										IActionManager.SET,
										contentElement.getPresentation(),
										UmaPackage.eINSTANCE
												.getWorkProductDescription_ImpactOfNotHaving(),
										newContent, -1);
						if (success && isVersionSectionOn()) {
							updateChangeDate();
						}
					}
				}
			});

			ctrl_reason.setModalObject(contentElement.getPresentation());
			ctrl_reason.setModalObjectFeature(UmaPackage.eINSTANCE
					.getWorkProductDescription_ReasonsForNotNeeding());
			ctrl_reason.addModifyListener(contentModifyListener);
			ctrl_reason.addListener(SWT.Deactivate, new Listener() {
				public void handleEvent(Event e) {
					IMethodRichText control = descExpandFlag ? ctrl_expanded
							: ctrl_reason;
					if (!control.getModified()) {
						return;
					}
					String oldContent = ((org.eclipse.epf.uma.WorkProductDescription) workProduct
							.getPresentation()).getReasonsForNotNeeding();
					if (((MethodElementEditor) getEditor()).mustRestoreValue(
							control, oldContent)) {
						return;
					}
					String newContent = control.getText();
					if (!newContent.equals(oldContent)) {
						boolean success = actionMgr
								.doAction(
										IActionManager.SET,
										contentElement.getPresentation(),
										UmaPackage.eINSTANCE
												.getWorkProductDescription_ReasonsForNotNeeding(),
										newContent, -1);
						if (success && isVersionSectionOn()) {
							updateChangeDate();
						}
					}
				}
			});

			if (workProduct instanceof Artifact) {
				ctrl_representation_options.setModalObject(contentElement
						.getPresentation());
				ctrl_representation_options
						.setModalObjectFeature(UmaPackage.eINSTANCE
								.getArtifactDescription_RepresentationOptions());
				ctrl_representation_options
						.addModifyListener(contentModifyListener);
				ctrl_representation_options.addListener(SWT.Deactivate,
						new Listener() {
							public void handleEvent(Event e) {
								IMethodRichText control = descExpandFlag ? ctrl_expanded
										: ctrl_representation_options;
								if (!control.getModified()) {
									return;
								}
								String oldContent = ((org.eclipse.epf.uma.ArtifactDescription) workProduct
										.getPresentation())
										.getRepresentationOptions();
								if (((MethodElementEditor) getEditor())
										.mustRestoreValue(control, oldContent)) {
									return;
								}
								String newContent = control.getText();
								if (!newContent.equals(oldContent)) {
									boolean success = actionMgr
											.doAction(
													IActionManager.SET,
													contentElement
															.getPresentation(),
													UmaPackage.eINSTANCE
															.getArtifactDescription_RepresentationOptions(),
													newContent, -1);
									if (success && isVersionSectionOn()) {
										updateChangeDate();
									}
								}
							}
						});
			}
		}

		if (notationSectionOn) {
			if (workProduct instanceof Artifact) {
				ctrl_brief_outline.setModalObject(contentElement
						.getPresentation());
				ctrl_brief_outline.setModalObjectFeature(UmaPackage.eINSTANCE
						.getArtifactDescription_BriefOutline());
				ctrl_brief_outline.addModifyListener(contentModifyListener);
				ctrl_brief_outline.addListener(SWT.Deactivate, new Listener() {
					public void handleEvent(Event e) {
						IMethodRichText control = descExpandFlag ? ctrl_expanded
								: ctrl_brief_outline;
						if (!control.getModified()) {
							return;
						}
						String oldContent = ((org.eclipse.epf.uma.ArtifactDescription) workProduct
								.getPresentation()).getBriefOutline();
						if (((MethodElementEditor) getEditor())
								.mustRestoreValue(control, oldContent)) {
							return;
						}
						String newContent = descExpandFlag ? ctrl_expanded
								.getText() : ctrl_brief_outline.getText();
						if (!newContent.equals(oldContent)) {
							boolean success = actionMgr
									.doAction(
											IActionManager.SET,
											contentElement.getPresentation(),
											UmaPackage.eINSTANCE
													.getArtifactDescription_BriefOutline(),
											newContent, -1);
							if (success && isVersionSectionOn()) {
								updateChangeDate();
							}
						}
					}
				});

				ctrl_representation.setModalObject(contentElement
						.getPresentation());
				ctrl_representation.setModalObjectFeature(UmaPackage.eINSTANCE
						.getArtifactDescription_Representation());
				ctrl_representation.addModifyListener(contentModifyListener);
				ctrl_representation.addListener(SWT.Deactivate, new Listener() {
					public void handleEvent(Event e) {
						IMethodRichText control = descExpandFlag ? ctrl_expanded
								: ctrl_representation;
						if (!control.getModified()) {
							return;
						}
						String oldContent = ((org.eclipse.epf.uma.ArtifactDescription) workProduct
								.getPresentation()).getRepresentation();
						if (((MethodElementEditor) getEditor())
								.mustRestoreValue(control, oldContent)) {
							return;
						}
						String newContent = descExpandFlag ? ctrl_expanded
								.getText() : ctrl_representation.getText();
						if (!newContent.equals(oldContent)) {
							boolean success = actionMgr
									.doAction(
											IActionManager.SET,
											contentElement.getPresentation(),
											UmaPackage.eINSTANCE
													.getArtifactDescription_Representation(),
											newContent, -1);
							if (success && isVersionSectionOn()) {
								updateChangeDate();
							}
						}
					}
				});

				ctrl_notation.setModalObject(contentElement.getPresentation());
				ctrl_notation.setModalObjectFeature(UmaPackage.eINSTANCE
						.getArtifactDescription_Notation());
				ctrl_notation.addModifyListener(contentModifyListener);
				ctrl_notation.addListener(SWT.Deactivate, new Listener() {
					public void handleEvent(Event e) {
						IMethodRichText control = descExpandFlag ? ctrl_expanded
								: ctrl_notation;
						if (!control.getModified()) {
							return;
						}
						String oldContent = ((org.eclipse.epf.uma.ArtifactDescription) workProduct
								.getPresentation()).getNotation();
						if (((MethodElementEditor) getEditor())
								.mustRestoreValue(control, oldContent)) {
							return;
						}
						String newContent = descExpandFlag ? ctrl_expanded
								.getText() : ctrl_notation.getText();
						if (!newContent.equals(oldContent)) {
							boolean success = actionMgr.doAction(
									IActionManager.SET, contentElement
											.getPresentation(),
									UmaPackage.eINSTANCE
											.getArtifactDescription_Notation(),
									newContent, -1);
							if (success && isVersionSectionOn()) {
								updateChangeDate();
							}
						}
					}
				});
			}

			if (workProduct instanceof Deliverable) {
				ctrl_external_desc.setModalObject(contentElement
						.getPresentation());
				ctrl_external_desc.setModalObjectFeature(UmaPackage.eINSTANCE
						.getDeliverableDescription_ExternalDescription());
				ctrl_external_desc.addModifyListener(contentModifyListener);
				ctrl_external_desc.addListener(SWT.Deactivate, new Listener() {
					public void handleEvent(Event e) {
						IMethodRichText control = descExpandFlag ? ctrl_expanded
								: ctrl_external_desc;
						if (!control.getModified()) {
							return;
						}
						String oldContent = ((org.eclipse.epf.uma.DeliverableDescription) workProduct
								.getPresentation()).getExternalDescription();
						if (((MethodElementEditor) getEditor())
								.mustRestoreValue(control, oldContent)) {
							return;
						}
						String newContent = control.getText();
						if (!newContent.equals(oldContent)) {
							boolean success = actionMgr
									.doAction(
											IActionManager.SET,
											contentElement.getPresentation(),
											UmaPackage.eINSTANCE
													.getDeliverableDescription_ExternalDescription(),
											newContent, -1);
							if (success && isVersionSectionOn()) {
								updateChangeDate();
							}
						}
					}
				});

				ctrl_packaging_guidance.setModalObject(contentElement
						.getPresentation());
				ctrl_packaging_guidance
						.setModalObjectFeature(UmaPackage.eINSTANCE
								.getDeliverableDescription_PackagingGuidance());
				ctrl_packaging_guidance
						.addModifyListener(contentModifyListener);
				ctrl_packaging_guidance.addListener(SWT.Deactivate,
						new Listener() {
							public void handleEvent(Event e) {
								IMethodRichText control = descExpandFlag ? ctrl_expanded
										: ctrl_packaging_guidance;
								if (!control.getModified()) {
									return;
								}
								String oldContent = ((org.eclipse.epf.uma.DeliverableDescription) workProduct
										.getPresentation())
										.getPackagingGuidance();
								if (((MethodElementEditor) getEditor())
										.mustRestoreValue(control, oldContent)) {
									return;
								}
								String newContent = control.getText();
								if (!newContent.equals(oldContent)) {
									boolean success = actionMgr
											.doAction(
													IActionManager.SET,
													contentElement
															.getPresentation(),
													UmaPackage.eINSTANCE
															.getDeliverableDescription_PackagingGuidance(),
													newContent, -1);
									if (success && isVersionSectionOn()) {
										updateChangeDate();
									}
								}
							}
						});
			}
		}
	}
	
	
	/**
	 * Slot Listeners
	 */
	private void addSlotListeners()	{
		// work product slot check button
		ctrl_slot_button.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				Boolean isSlot = new Boolean(ctrl_slot_button.getSelection());
				if (isSlot.booleanValue()) {
					// if this becoming a slot itself
					List<FulfillableElement> fulFills = workProduct
							.getFulfills();
					if (fulFills != null && fulFills.size() != 0) {
						boolean val = AuthoringUIPlugin
								.getDefault()
								.getMsgDialog()
								.displayConfirmation(
										AuthoringUIResources.slotConfirmDialog_title,
										AuthoringUIResources.wpFulFillsConfirmDialog_message);
						if (!val) {
							ctrl_slot_button.setSelection(workProduct
									.getIsAbstract().booleanValue());
							return;
						} else {
							actionMgr.doAction(IActionManager.REMOVE_MANY,
									workProduct, UmaPackage.eINSTANCE
											.getFulfillableElement_Fulfills(),
									fulFills, -1);
						}
					}
				} else {					
					List fulFills = new ArrayList();
					fulFills.addAll(AssociationHelper.getFullFills(workProduct));
					if (fulFills != null && fulFills.size() != 0) {
						boolean val = AuthoringUIPlugin
								.getDefault()
								.getMsgDialog()
								.displayConfirmation(
										AuthoringUIResources.slotConfirmDialog_title,
										AuthoringUIResources.wpSlotFulFillsConfirmDialog_message);
						if (!val) {
							ctrl_slot_button.setSelection(workProduct
									.getIsAbstract().booleanValue());
							return;
						} else {
							for (Iterator itor = fulFills.iterator(); itor
									.hasNext();) {
								WorkProduct wp = (WorkProduct) itor.next();
								actionMgr
										.doAction(
												IActionManager.REMOVE,
												wp,
												UmaPackage.eINSTANCE
														.getFulfillableElement_Fulfills(),
												workProduct, -1);
							}
						}
					}				
				}
				actionMgr.doAction(IActionManager.SET, methodElement,
						UmaPackage.eINSTANCE.getClassifier_IsAbstract(), isSlot,
						-1);
				
				if (isSlot) {		
					addSlotButton.setEnabled(false);
				}
				else {
					addSlotButton.setEnabled(true);
				}
			}
		});

		addSlotButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				IFilter filter = new WorkProductFilter() {
					protected boolean childAccept(Object obj) {
						if (obj instanceof WorkProduct) {
							return ((WorkProduct) obj).getIsAbstract().booleanValue();
						}
						return false;
					}
				};
				List<FulfillableElement> alreadyExisting = new ArrayList<FulfillableElement>();
				alreadyExisting.addAll(workProduct.getFulfills());
				ItemsFilterDialog fd = new ItemsFilterDialog(PlatformUI
						.getWorkbench().getActiveWorkbenchWindow().getShell(),
						filter, methodElement,
						FilterConstants.WORKPRODUCTS, alreadyExisting);
				fd.setViewerSelectionSingle(false);
				fd.setBlockOnOpen(true);
				fd.setTitle(FilterConstants.WORKPRODUCTS);
				fd.open();
				
				if (fd.getSelectedItems().size() > 0) {
					boolean status = actionMgr.doAction(
							IActionManager.ADD_MANY, workProduct,
							UmaPackage.eINSTANCE
									.getFulfillableElement_Fulfills(), fd
									.getSelectedItems(), -1);
					if (!status) {
						return;
					}
					// refresh slot viewer
					slotViewer.refresh();	
				}		
			}
		});
		
		removeSlotButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e){
				IStructuredSelection selection = (IStructuredSelection) slotViewer
						.getSelection();
				if (selection.size() > 0) {
					boolean status = actionMgr.doAction(IActionManager.REMOVE_MANY, workProduct,
							UmaPackage.eINSTANCE
									.getFulfillableElement_Fulfills(),
							selection.toList(), -1);
					
					if (!status) {
						return;
					}
					// refresh slot viewer
					slotViewer.refresh();
					removeSlotButton.setEnabled(false);
				}
			}	
		});
		
		slotViewer.addSelectionChangedListener(new ISelectionChangedListener() {
			public void selectionChanged(SelectionChangedEvent e) {
				IStructuredSelection selection = (IStructuredSelection) slotViewer
						.getSelection();
				if (selection.size() > 0 && !TngUtil.isLocked(workProduct)) {
					removeSlotButton.setEnabled(true);
				}
			}
		});

	}

	/**
	 * @see org.eclipse.epf.authoring.ui.forms.DescriptionFormPage#refresh(boolean)
	 */
	protected void refresh(boolean editable) {
		super.refresh(editable);
		
		if (slotSectionOn)  {
			ctrl_slot_button.setEnabled(editable);
			
			Boolean isAbstract = workProduct.getIsAbstract();
			if (isAbstract != null && editable) {
				if (isAbstract.booleanValue())  {
					addSlotButton.setEnabled(false);
				} else {
					addSlotButton.setEnabled(true);
				}
			}
			else
				addSlotButton.setEnabled(editable);
			
			IStructuredSelection selection = (IStructuredSelection) slotViewer.getSelection();
			if (selection.size() > 0 && editable) {
				removeSlotButton.setEnabled(true);
			} else {
				removeSlotButton.setEnabled(false);
			}
		}
		
		if (tailoringSectionOn) {
			ctrl_impact.setEditable(editable);
			ctrl_reason.setEditable(editable);
			if (workProduct instanceof Artifact)
				ctrl_representation_options.setEditable(editable);
		}
		if (notationSectionOn) {
			if (workProduct instanceof Artifact) {
				ctrl_brief_outline.setEditable(editable);
				ctrl_representation.setEditable(editable);
				ctrl_notation.setEditable(editable);
			}
			if (workProduct instanceof Deliverable) {
				ctrl_external_desc.setEditable(editable);
				ctrl_packaging_guidance.setEditable(editable);
			}
		}
	}

	/**
	 * @see org.eclipse.epf.authoring.ui.forms.DescriptionFormPage#loadData()
	 */
	protected void loadData() {
		super.loadData();

		// IsAbstract attribute
		if (slotSectionOn) {
			Boolean isAbstract = workProduct.getIsAbstract();
			if (isAbstract != null) {
				ctrl_slot_button.setSelection(isAbstract.booleanValue());
			} else
				ctrl_slot_button.setSelection(false);
		}

		
		org.eclipse.epf.uma.WorkProductDescription content = ((org.eclipse.epf.uma.WorkProductDescription) workProduct
				.getPresentation());

		if (purposeOn) {
			String purpose = content.getPurpose();
			ctrl_purpose.setText(purpose == null ? "" : purpose); //$NON-NLS-1$
		}
		if (tailoringSectionOn) {
			String impact = content.getImpactOfNotHaving();
			String reason = content.getReasonsForNotNeeding();
			ctrl_impact.setText(impact == null ? "" : impact); //$NON-NLS-1$	
			ctrl_reason.setText(reason == null ? "" : reason); //$NON-NLS-1$
			if (workProduct instanceof Artifact) {
				ctrl_representation_options
						.setText(((ArtifactDescription) content)
								.getRepresentationOptions() == null ? "" : ((ArtifactDescription) content).getRepresentationOptions()); //$NON-NLS-1$
			}
		}

		
		if (notationSectionOn) {
			if (workProduct instanceof Artifact) {
				ctrl_brief_outline
						.setText(((ArtifactDescription) content)
								.getBriefOutline() == null ? "" : ((ArtifactDescription) content).getBriefOutline()); //$NON-NLS-1$			
				ctrl_representation
						.setText(((ArtifactDescription) content)
								.getRepresentation() == null ? "" : ((ArtifactDescription) content).getRepresentation()); //$NON-NLS-1$
				ctrl_notation
						.setText(((ArtifactDescription) content).getNotation() == null ? "" : ((ArtifactDescription) content).getNotation()); //$NON-NLS-1$
			} else if (workProduct instanceof Deliverable) {
				ctrl_external_desc
						.setText(((DeliverableDescription) content)
								.getExternalDescription() == null ? "" : ((DeliverableDescription) content).getExternalDescription()); //$NON-NLS-1$
				ctrl_packaging_guidance
						.setText(((DeliverableDescription) content)
								.getPackagingGuidance() == null ? "" : ((DeliverableDescription) content).getPackagingGuidance()); //$NON-NLS-1$
			}
		}

	}

	/**
	 * @see org.eclipse.epf.authoring.ui.forms.DescriptionFormPage#getContentElement()
	 */
	protected Object getContentElement() {
		return workProduct;
	}

	/**
	 * @see org.eclipse.epf.authoring.ui.forms.DescriptionFormPage#getTabString()
	 */
	protected String getTabString() {
		return FilterConstants.WORKPRODUCTS;
	}

	/**
	 * @see org.eclipse.epf.authoring.ui.forms.DescriptionFormPage#getFilter()
	 */
	protected IFilter getFilter() {
		filter = new WorkProductFilter() {
			List badlist = new ArrayList();

			protected boolean childAccept(Object obj) {
				if (super.childAccept(obj)) {
					if (obj instanceof ContentElement) {
						if (obj instanceof WorkProduct
								&& ((ContentElement) getHelper()
										.getContentElement()).getType().equals(
										((ContentElement) obj).getType())) {
							// prevent circular dependency from deliverable
							// parts and variability
							if (obj instanceof Deliverable
									&& workProduct instanceof Deliverable) {
								if (!UIHelper.checkCircularDeliverables(
										(Deliverable) obj,
										(Deliverable) workProduct)) {
									badlist.add(obj);
									return false;
								}
								if (((Deliverable) obj)
										.getVariabilityBasedOnElement() != null) {
									if (!UIHelper
											.checkCircularDeliverables(
													(Deliverable) ((Deliverable) obj)
															.getVariabilityBasedOnElement(),
													(Deliverable) workProduct)) {
										badlist.add(obj);
										return false;
									}
								}
								Iterator it1 = TngUtil
										.getGeneralizers((Deliverable) obj);
								while (it1.hasNext()) {
									VariabilityElement ve = (VariabilityElement) it1
											.next();
									if (ve != null) {
										if (ve.equals(obj))
											return false;
										if (!UIHelper
												.checkCircularDeliverables(
														(Deliverable) ve,
														(Deliverable) workProduct)) {
											badlist.add(obj);
											return false;
										}
									}

								}
								// browse through badlist and its deliverable
								// parts.
								List templist = new ArrayList();
								for (Iterator iterator = badlist.iterator(); iterator
										.hasNext();) {
									Object bad = iterator.next();
									UIHelper.deliverablePartsChain(
											(Deliverable) bad, templist);
								}
								if (templist.contains(obj))
									return false;
							}

							return true;
						}
					}
				}
				return false;
			}
		};

		// set additional filter for variability base element checking
		((ContentFilter) filter)
				.setAdditionalFilters(new IFilter[] { new VariabilityBaseElementFilter(
						workProduct) });
		return filter;
	}

	/**
	 * @see org.eclipse.epf.authoring.ui.forms.DescriptionFormPage#loadSectionDescription()
	 */
	public void loadSectionDescription() {
		if (contentElement instanceof Artifact) {
			this.generalSectionDescription = AuthoringUIResources.artifact_generalInfoSection_desc;
			this.detailSectionDescription = AuthoringUIResources.artifact_detailSection_desc;
			this.variabilitySectionDescription = AuthoringUIResources.artifact_variabilitySection_desc;
			this.versionSectionDescription = AuthoringUIResources.artifact_versionInfoSection_desc;
			this.notationSectionDescription = AuthoringUIResources.artifact_notationSection_desc;
			this.tailoringSectionDescription = AuthoringUIResources.artifact_tailoringSection_desc;
			this.iconSectionDescription = AuthoringUIResources.artifact_iconSection_desc;
			this.slotSectionDescription = AuthoringUIResources.artifact_slotSection_desc;
		}
		if (contentElement instanceof Outcome) {
			this.generalSectionDescription = AuthoringUIResources.outcome_generalInfoSection_desc;
			this.detailSectionDescription = AuthoringUIResources.outcome_detailSection_desc;
			this.variabilitySectionDescription = AuthoringUIResources.outcome_variabilitySection_desc;
			this.versionSectionDescription = AuthoringUIResources.outcome_versionInfoSection_desc;
			this.notationSectionDescription = AuthoringUIResources.outcome_notationSection_desc;
			this.tailoringSectionDescription = AuthoringUIResources.outcome_tailoringSection_desc;
			this.iconSectionDescription = AuthoringUIResources.outcome_iconSection_desc;
			this.slotSectionDescription = AuthoringUIResources.outcome_slotSection_desc;
		}
		if (contentElement instanceof Deliverable) {
			this.generalSectionDescription = AuthoringUIResources.deliverable_generalInfoSection_desc;
			this.detailSectionDescription = AuthoringUIResources.deliverable_detailSection_desc;
			this.variabilitySectionDescription = AuthoringUIResources.deliverable_variabilitySection_desc;
			this.versionSectionDescription = AuthoringUIResources.deliverable_versionInfoSection_desc;
			this.notationSectionDescription = AuthoringUIResources.deliverable_notationSection_desc;
			this.tailoringSectionDescription = AuthoringUIResources.deliverable_tailoringSection_desc;
			this.iconSectionDescription = AuthoringUIResources.deliverable_iconSection_desc;
			this.slotSectionDescription = AuthoringUIResources.deliverable_slotSection_desc;
		}
	}

}