//------------------------------------------------------------------------------
// 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.text.MessageFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.impl.AdapterImpl;
import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider;
import org.eclipse.epf.authoring.ui.AuthoringUIHelpContexts;
import org.eclipse.epf.authoring.ui.AuthoringUIImages;
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.ChangeHistoryDialog;
import org.eclipse.epf.authoring.ui.dialogs.ItemsFilterDialog;
import org.eclipse.epf.authoring.ui.editors.ConfigurationEditorInput;
import org.eclipse.epf.authoring.ui.editors.MethodElementEditor;
import org.eclipse.epf.authoring.ui.editors.MethodElementEditorInput;
import org.eclipse.epf.authoring.ui.filters.ContentFilter;
import org.eclipse.epf.authoring.ui.richtext.IMethodRichText;
import org.eclipse.epf.authoring.ui.richtext.IMethodRichTextEditor;
import org.eclipse.epf.authoring.ui.views.ViewHelper;
import org.eclipse.epf.common.utils.StrUtil;
import org.eclipse.epf.library.LibraryService;
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.RemoveReferencesCommand;
import org.eclipse.epf.library.edit.itemsfilter.FilterConstants;
import org.eclipse.epf.library.edit.util.Misc;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.library.ui.LibraryUIText;
import org.eclipse.epf.library.util.LibraryUtil;
import org.eclipse.epf.library.util.PluginReferenceChecker;
import org.eclipse.epf.richtext.RichTextListener;
import org.eclipse.epf.services.ILibraryPersister;
import org.eclipse.epf.uma.ContentDescription;
import org.eclipse.epf.uma.Guidance;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodPlugin;
import org.eclipse.epf.uma.SupportingMaterial;
import org.eclipse.epf.uma.UmaPackage;
import org.eclipse.epf.uma.util.UmaUtil;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.fieldassist.DecoratedField;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.ModifyListener;
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.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IEditorSite;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.forms.IManagedForm;
import org.eclipse.ui.forms.editor.FormEditor;
import org.eclipse.ui.forms.events.HyperlinkAdapter;
import org.eclipse.ui.forms.events.HyperlinkEvent;
import org.eclipse.ui.forms.widgets.FormToolkit;
import org.eclipse.ui.forms.widgets.ImageHyperlink;
import org.eclipse.ui.forms.widgets.Section;
import org.eclipse.ui.forms.widgets.TableWrapData;

import com.ibm.icu.text.DateFormat;

/**
 * Description page for method plugin
 * 
 * @author Shilpa Toraskar
 * @author Kelvin Low
 * @author Phong Nguyen Le
 * @since 1.0
 * fix for https://bugs.eclipse.org/bugs/show_bug.cgi?id=176382
 */
public class MethodPluginDescriptionPage extends BaseFormPage implements IRefreshable {

	private static final String FORM_PREFIX = LibraryUIText.TEXT_METHOD_PLUGIN
			+ ": "; //$NON-NLS-1$

	private Text ctrl_name;

	private Text ctrl_brief_desc, ctrl_r_brief_desc;

	private CheckboxTableViewer ctrl_refModel;

	private Section generalSection, refModelSection;

	private Composite generalComposite, refModelComposite;

	private boolean descExpandFlag = false;

	private MethodPlugin plugin;

	private IActionManager actionMgr;

	protected Section versionSection;

	protected Composite versionComposite;

	private Text ctrl_authors;

	private Text ctrl_change_date;

	private Text ctrl_change_desc;

	private Text ctrl_version;

	protected boolean versionSectionOn = true;

	protected boolean anyAttributeModified = false;

	protected static final int VERSION_SECTION_ID = 3;

	protected IMethodRichTextEditor ctrl_version_expanded;

	protected ImageHyperlink expandVersionLink;

	protected DecoratedField expandVersionLabel;

	protected Composite expandedVersionComposite;

	protected ModifyListener modelModifyListener;

	protected ModifyListener contentModifyListener;

	protected static final int GENERAL_SECTION_ID = 1;

	private IMethodRichText activeControl;

	protected Label label_copyright;

	protected TableViewer copyright_viewer;

	protected Table ctrl_copyright;

	protected IStructuredContentProvider copyrightContentProvider;

	private ILabelProvider labelProviderBase = new AdapterFactoryLabelProvider(
			TngAdapterFactory.INSTANCE
					.getNavigatorView_ComposedAdapterFactory());;

	private Button copyright_button;

	private Button copyright_button_deselect;

	private Button ctrl_changeable;

	private Button view_history_button;

	public boolean notificationEnabled = true;

	protected Adapter userChangeableAdapter;

	private ModifyListener nameModifyListener;

	private String lastChangeHistory = ""; //$NON-NLS-1$

	/**
	 * Creates a new instance.
	 */
	public MethodPluginDescriptionPage(FormEditor editor) {
		super(editor, AuthoringUIText.DESCRIPTION_PAGE_TITLE,
				AuthoringUIText.DESCRIPTION_PAGE_TITLE);

		actionMgr = ((MethodElementEditor) editor).getActionManager();
		userChangeableAdapter = new UserChangeableAdapter();
	}

	/**
	 * @see org.eclipse.epf.authoring.ui.forms.BaseFormPage#init(org.eclipse.ui.IEditorSite, org.eclipse.ui.IEditorInput)
	 */
	public void init(IEditorSite site, IEditorInput input) {
		super.init(site, input);
		MethodElementEditorInput methodElementInput = (MethodElementEditorInput) input;
		Object obj = methodElementInput.getMethodElement();
		plugin = (MethodPlugin) obj;
		if (userChangeableAdapter != null) {
			plugin.eAdapters().add(userChangeableAdapter);
		}
	}

	/**
	 * @see org.eclipse.ui.forms.editor.createFormContent(IManagedForm)
	 */
	protected void createFormContent(IManagedForm managedForm) {
		super.createFormContent(managedForm);
		createEditorContent(toolkit);
		createReferenceContent(toolkit);
		setContextHelp();
		loadData();
		addListeners();
	}

	private void setContextHelp() {
		if (generalComposite != null) {
			PlatformUI
					.getWorkbench()
					.getHelpSystem()
					.setHelp(
							generalComposite.getParent().getParent(),
							AuthoringUIHelpContexts.PLUGIN_EDITOR_DESCRIPTION_ALL_CONTEXT);
		}
	}

	/**
	 * Creates the editor page content.
	 * 
	 * @param toolkit
	 *            The form toolkit.
	 */
	protected void createEditorContent(FormToolkit toolkit) {
		form.setText(FORM_PREFIX + plugin.getName());

		// Create the General section.
		generalSection = toolkit.createSection(form.getBody(),
				Section.DESCRIPTION | Section.TWISTIE | Section.EXPANDED
						| Section.TITLE_BAR);

		TableWrapData td = new TableWrapData(TableWrapData.FILL_GRAB);
		generalSection.setLayoutData(td);
		generalSection.setText(AuthoringUIText.GENERAL_INFO_SECTION_NAME);
		generalSection.setDescription(MessageFormat.format(
				AuthoringUIText.GENERAL_INFO_SECTION_DESC,
				new String[] { LibraryUIText.getUITextLower(methodElement) }));
		generalSection.setLayout(new GridLayout());

		generalComposite = toolkit.createComposite(generalSection);
		generalComposite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		generalComposite.setLayout(new GridLayout(3, false));
		generalSection.setClient(generalComposite);

		// name
		ctrl_name = createTextEditWithLabel(toolkit, generalComposite,
				AuthoringUIText.NAME_TEXT);

		// brief desc
		ctrl_brief_desc = createTextEditWithLabel2(toolkit, generalComposite,
				AuthoringUIText.BRIEF_DESCRIPTION_TEXT);

		if (versionSectionOn) {
			createVersionSection(toolkit);
			createVersionSectionContent();
		}

		toolkit.paintBordersFor(generalComposite);

		// set focus on the name attribute
		Display display = form.getBody().getDisplay();
		if (!(display == null || display.isDisposed())) {
			display.asyncExec(new Runnable() {
				public void run() {
					ctrl_name.setFocus();
				}
			});
		}
	}

	private void createReferenceContent(FormToolkit toolkit) {
		// Ref Model Section
		refModelSection = toolkit.createSection(form.getBody(),
				Section.DESCRIPTION | Section.TWISTIE | Section.EXPANDED
						| Section.TITLE_BAR);
		TableWrapData td1 = new TableWrapData(TableWrapData.FILL_GRAB);
		refModelSection.setLayoutData(td1);
		refModelSection
				.setText(AuthoringUIText.REFERENCED_PLUGINS_SECTION_NAME);
		refModelSection
				.setDescription(AuthoringUIText.REFERENCED_PLUGINS_SECTION_DESC);
		refModelSection.setLayout(new GridLayout());

		refModelComposite = toolkit.createComposite(refModelSection);
		refModelComposite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		refModelComposite.setLayout(new GridLayout(2, false));
		refModelSection.setClient(refModelComposite);

		Table ctrl_table = toolkit.createTable(refModelComposite, SWT.CHECK);
		{
			GridData gridData = new GridData(GridData.BEGINNING
					| GridData.FILL_BOTH);
			gridData.heightHint = 100;
			ctrl_table.setLayoutData(gridData);
		}

		ctrl_refModel = new CheckboxTableViewer(ctrl_table);
		ILabelProvider labelProvider = new LabelProvider() {
			public String getText(Object element) {
				MethodPlugin plugin = (MethodPlugin) element;
				return plugin.getName();
			}
		};
		ctrl_refModel.setLabelProvider(labelProvider);

		Label l_r_brief_desc = toolkit.createLabel(refModelComposite,
				AuthoringUIText.BRIEF_DESCRIPTION_TEXT);
		{
			GridData gridData = new GridData(GridData.BEGINNING);
			gridData.horizontalSpan = 3;
			l_r_brief_desc.setLayoutData(gridData);
		}

		ctrl_r_brief_desc = toolkit.createText(refModelComposite,
				"", SWT.MULTI | SWT.WRAP | SWT.V_SCROLL | SWT.READ_ONLY); //$NON-NLS-1$
		{
			GridData gridData = new GridData(GridData.FILL_HORIZONTAL
					| GridData.GRAB_HORIZONTAL);
			gridData.heightHint = 80;
			ctrl_r_brief_desc.setLayoutData(gridData);
		}

		toolkit.paintBordersFor(refModelComposite);
	}

	private void setCheckboxForCurrentBase(List currentBaseList) {
		ctrl_refModel.setAllChecked(false);
		for (int i = 0; i < currentBaseList.size(); i++) {
			MethodPlugin model = (MethodPlugin) currentBaseList.get(i);
			ctrl_refModel.setChecked(model, true);
		}
	}

	/**
	 * Add listeners
	 * 
	 */
	private void addListeners() {
		MethodElementEditor editor = (MethodElementEditor) getEditor();

		form.addListener(SWT.Activate, new Listener() {
			public void handleEvent(Event e) {
				// Clear the old items and add the newly allowable items.
				ctrl_refModel.getTable().clearAll();
				ctrl_refModel.refresh();

				List allowableList = PluginReferenceChecker
						.getApplicableBasePlugins(plugin);
				ctrl_refModel.add(allowableList.toArray());

				List currentBaseList = plugin.getBases();
				setCheckboxForCurrentBase(currentBaseList);

				if (!plugin.getUserChangeable().booleanValue()) {
					enableControls(false);
				} else {
					enableControls(true);
				}
				copyright_viewer.refresh();
			}
		});

		final ModifyListener modifyListener = editor
				.createModifyListener(plugin);

		nameModifyListener = editor.createModifyListener(plugin, true);
		ctrl_name.addModifyListener(nameModifyListener);
		ctrl_name.addListener(SWT.Deactivate, new Listener() {
			public void handleEvent(Event e) {
				String oldContent = plugin.getName();
				if (((MethodElementEditor) getEditor()).mustRestoreValue(
						e.widget, oldContent)) {
					return;
				}
				if (ctrl_name.getText().equals(plugin.getName())) {
					return;
				}

				// Check invalid characters first.
				
				// 178462
				String msg = null;
				String name = ctrl_name.getText().trim();
				if (name != null) {
					if (name.indexOf("&") > -1) {
						msg = NLS
								.bind(
										LibraryEditResources.invalidElementNameError4_msg,
										name);
					} else {
						msg = LibraryUtil.checkPluginName(null, name);
					}
				}
				
				String validName = StrUtil.makeValidFileName(ctrl_name
						.getText());
				if (msg == null) {
					// Check duplicate plug-in name.
					msg = LibraryUtil.checkPluginName(plugin, validName);
				}
				if (msg == null) {
					if (!validName.equals(plugin.getName())) {
						Shell shell = getSite().getShell();
						msg = AuthoringUIResources.bind(AuthoringUIResources.methodPluginDescriptionPage_confirmRename, (new Object[] { plugin.getName(), ctrl_name.getText() })); //$NON-NLS-1$
						String title = AuthoringUIResources.methodPluginDescriptionPage_confirmRename_title; //$NON-NLS-1$
						if (!MessageDialog.openConfirm(shell, title, msg)) {
							ctrl_name.setText(plugin.getName());
							return;
						}

						e.doit = true;
						ctrl_name.setText(validName);
						boolean status = actionMgr.doAction(IActionManager.SET,
								plugin, UmaPackage.eINSTANCE
										.getNamedElement_Name(), validName, -1);

						if (!status) {
							return;
						}
						form.setText(FORM_PREFIX + plugin.getName());
						updateChangeDate();

						// adjust plugin location and save the editor
						//
						BusyIndicator.showWhile(getSite().getShell()
								.getDisplay(), new Runnable() {
							public void run() {
								MethodElementEditor editor = (MethodElementEditor) getEditor();
								editor.doSave(new NullProgressMonitor());
								ILibraryPersister.FailSafeMethodLibraryPersister persister = editor
										.getPersister();
								try {
									persister
											.adjustLocation(plugin.eResource());
									persister.commit();
								} catch (RuntimeException e) {
									AuthoringUIPlugin.getDefault().getLogger()
											.logError(e);
									try {
										persister.rollback();
									} catch (Exception ex) {
										AuthoringUIPlugin.getDefault()
												.getLogger().logError(ex);
										ViewHelper
												.reloadCurrentLibaryOnRollbackError(getSite()
														.getShell());
										return;
									}
									AuthoringUIPlugin
											.getDefault()
											.getMsgDialog()
											.displayWarning(
													getSite().getShell()
															.getText(),
													AuthoringUIResources.methodPluginDescriptionPage_cannotRenamePluginFolder
													, e.getMessage(), e);
								}
							}
						});
					}
				} else {
					ctrl_name.setText(plugin.getName());
					Shell shell = getSite().getShell();
					AuthoringUIPlugin.getDefault().getMsgDialog().displayError(
							shell.getText(), msg);
					e.doit = false;
					ctrl_name.getDisplay().asyncExec(new Runnable() {
						public void run() {
							ctrl_name.setFocus();
							ctrl_name.selectAll();
						}
					});
				}
			}
		});
		ctrl_name.addFocusListener(new FocusAdapter() {
			public void focusGained(FocusEvent e) {
				((MethodElementEditor) getEditor()).setCurrentFeatureEditor(e.widget,
						UmaPackage.eINSTANCE.getNamedElement_Name());
			}
		});

		ctrl_brief_desc.addModifyListener(modifyListener);
		ctrl_brief_desc.addFocusListener(new FocusAdapter() {
			public void focusGained(FocusEvent e) {
				((MethodElementEditor) getEditor()).setCurrentFeatureEditor(e.widget,
						UmaPackage.eINSTANCE.getMethodElement_BriefDescription());
			}

			public void focusLost(FocusEvent e) {
				String oldContent = plugin.getBriefDescription();
				if (((MethodElementEditor) getEditor()).mustRestoreValue(
						e.widget, oldContent)) {
					return;
				}
				String newContent = ctrl_brief_desc.getText();
				if (!newContent.equals(oldContent)) {
					boolean status = actionMgr.doAction(IActionManager.SET,
							plugin, UmaPackage.eINSTANCE
									.getMethodElement_BriefDescription(),
							newContent, -1);
					if (status) {
						ctrl_brief_desc.setText(newContent);
					}
				}
			}
		});

		ctrl_refModel
				.addSelectionChangedListener(new ISelectionChangedListener() {
					public void selectionChanged(SelectionChangedEvent event) {
						StructuredSelection selectedList = (StructuredSelection) event
								.getSelection();
						MethodPlugin selectedObj = (MethodPlugin) selectedList
								.getFirstElement();
						if (selectedObj == null)
							return;
						ctrl_r_brief_desc.setText(selectedObj
								.getBriefDescription());
					}

				});

		ctrl_refModel.addCheckStateListener(new ICheckStateListener() {
			public void checkStateChanged(CheckStateChangedEvent event) {
				Object obj = event.getElement();

				ctrl_r_brief_desc.setText(((MethodPlugin) obj)
						.getBriefDescription());

				if (TngUtil.isLocked(plugin)) {
					ctrl_refModel.setChecked(obj, !event.getChecked());
					return;
				}

				if (event.getChecked()) {
					// TODO: Change this to be not un-doable due to the circular
					// dependency check.
					actionMgr.doAction(IActionManager.ADD, plugin,
							UmaPackage.eINSTANCE.getMethodPlugin_Bases(),
							(MethodPlugin) obj, -1);
				} else {
					final MethodPlugin base = (MethodPlugin) obj;
					
					// 168389
					boolean hasReference = false;
					List list = LibraryService.getInstance()
							.getCurrentMethodLibrary().getMethodPlugins();
					List<MethodPlugin> ref = new ArrayList<MethodPlugin>();					
					list.addAll(base.getBases());					
					for (Iterator iter = list.iterator(); iter.hasNext();) {
						MethodPlugin element = (MethodPlugin) iter.next();
						if (Misc.isBaseOf(base, element)) {
							if (UmaUtil.hasReference(plugin, element)) {
								hasReference = true;
								ref.add(element); // add all referenced plugins.
							}
						} else {
							if(UmaUtil.hasReference(plugin, element)){
								hasReference = true;
								ref.add(element); // add all referenced plugins.
							}
						}
					}

					// Checks if the plugin has any reference that is a element of the removed base
					if (hasReference) {
						String message = AuthoringUIResources
								.bind(
										AuthoringUIResources.methodPluginDescriptionRemoveRefConfirm_message,
										plugin.getName());
						Shell shell = getSite().getShell();
						if (AuthoringUIPlugin.getDefault().getMsgDialog()
								.displayConfirmation(shell.getText(), message)) {

							// remove all references that are element of the removed base
							// 168389
							for (int i = 0; i < ref.size(); i++) {
								MethodPlugin refPlugin = (MethodPlugin) ref
										.get(i);
								actionMgr.execute(new RemoveReferencesCommand(
										plugin, refPlugin));
							}						
							ctrl_refModel.setChecked(base, false);
						} else {
							// restore the checked state of the
							Display.getCurrent().asyncExec(new Runnable() {

								public void run() {
									ctrl_refModel.setChecked(base, true);
								}
							});
							return;
						}
					}

					// change this to be not un-doable due to the circular
					// dependency check
					// plugin.getBases().remove(obj);
					actionMgr.doAction(IActionManager.REMOVE, plugin,
							UmaPackage.eINSTANCE.getMethodPlugin_Bases(),
							(MethodPlugin) obj, -1);
				}

				// double check circular dependency, not necessary here
				PluginReferenceChecker.hasCircularConflictWithPlugin(plugin);

				updateChangeDate();
			}

		});

		if (versionSectionOn) {
			addVersionSectionListeners();
		}
	}

	protected void enableControls(boolean editable) {
		ctrl_name.setEditable(editable);
		ctrl_authors.setEditable(editable);
		ctrl_brief_desc.setEditable(editable);
		ctrl_version.setEditable(editable);
		ctrl_change_desc.setEditable(editable);
		copyright_button.setEnabled(editable);
		copyright_button_deselect.setEnabled(editable);
		ctrl_r_brief_desc.setEditable(false);
	}

	/**
	 * Loads initial data from model
	 */
	private void loadData() {
		String name = plugin.getName();
		String desc = plugin.getBriefDescription();
		ctrl_name.setText(name == null ? "" : name); //$NON-NLS-1$
		ctrl_brief_desc.setText(desc == null ? "" : desc); //$NON-NLS-1$

		if (versionSectionOn) {
			loadVersionSectionData();
		}
	}

	/**
	 * Check to see whether version section is visible or not
	 * @return Returns the versionSectionOn.
	 */
	public boolean isVersionSectionOn() {
		return versionSectionOn;
	}

	/**
	 * Set version section to be visible or not
	 * @param versionSectionOn
	 *            The versionSectionOn to set.
	 */
	public void setVersionSectionOn(boolean versionSectionOn) {
		this.versionSectionOn = versionSectionOn;
	}

	private void createVersionSection(FormToolkit toolkit) {
		versionSection = toolkit.createSection(form.getBody(),
				Section.DESCRIPTION | Section.TWISTIE | Section.EXPANDED
						| Section.TITLE_BAR);
		TableWrapData td = new TableWrapData(TableWrapData.FILL_GRAB);
		versionSection.setLayoutData(td);
		versionSection.setText(AuthoringUIText.VERSION_INFO_SECTION_NAME);
		versionSection.setDescription(MessageFormat.format(
				AuthoringUIText.VERSION_INFO_SECTION_DESC,
				new String[] { LibraryUIText.getUITextLower(methodElement) }));
		versionSection.setLayout(new GridLayout());

		versionComposite = toolkit.createComposite(versionSection);
		versionComposite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		versionComposite.setLayout(new GridLayout(5, false));
		versionSection.setClient(versionComposite);
	}

	/**
	 * Create the Version section content.
	 */
	private void createVersionSectionContent() {
		String fillText = (plugin.getVersion() == null ? "" : plugin.getVersion());
		ctrl_version = createTextEditWithLabel4(toolkit, versionComposite,
				AuthoringUIText.VERSION_TEXT, SWT.DEFAULT, SWT.SINGLE, fillText);
		
		fillText = plugin.getChangeDate() == null ? "" : //$NON-NLS-1$
			DateFormat.getDateInstance(DateFormat.FULL).format(
					plugin.getChangeDate());

		ctrl_change_date = createTextEditWithLabel4(toolkit, versionComposite,
				AuthoringUIText.CHANGE_DATE_TEXT, SWT.DEFAULT, SWT.SINGLE, fillText);
		ctrl_change_date.setEditable(false);
		
		ctrl_change_desc = createTextEditWithLabel5(toolkit, versionComposite,
				AuthoringUIText.CHANGE_DESCRIPTION_TEXT);

		Composite viewHistoryButtonPane = createComposite(toolkit,
				versionComposite,  GridData.HORIZONTAL_ALIGN_END, 1, 1, 1);
		{
			GridData gridData = new GridData( GridData.HORIZONTAL_ALIGN_END);
			gridData.heightHint = 40;
			viewHistoryButtonPane.setLayoutData(gridData);
		}
		view_history_button = toolkit.createButton(viewHistoryButtonPane,
				AuthoringUIText.VIEW_HISTORY_BUTTON_TEXT, SWT.PUSH);
		{
			GridData gridData = new GridData(GridData.HORIZONTAL_ALIGN_END);
			gridData.widthHint = DescriptionFormPage.BUTTON_WIDTH;
			view_history_button.setLayoutData(gridData);
		}
		
		ctrl_authors = createTextEditWithLabel5(toolkit, versionComposite,
				AuthoringUIText.AUTHORS_TEXT, 40, SWT.MULTI);
		
		label_copyright = createLabel(toolkit, versionComposite,
				AuthoringUIText.COPYRIGHT_TEXT, 2);
		ctrl_copyright = createTable(toolkit, versionComposite, SWT.SINGLE
				| SWT.READ_ONLY, GridData.FILL_HORIZONTAL | GridData.BEGINNING | GridData.FILL_VERTICAL,
				5, 400, 1, 2);
		copyright_viewer = new TableViewer(ctrl_copyright);
		initContentProviderCopyright();
		copyright_viewer.setLabelProvider(labelProviderBase);
		copyright_viewer.setInput(plugin);
		
		
		Composite buttonpane = createComposite(toolkit, versionComposite,
				GridData.HORIZONTAL_ALIGN_END, 1, 1, 1);
		{
			GridData gridData = new GridData(GridData.HORIZONTAL_ALIGN_END);
			buttonpane.setLayoutData(gridData);
		}
		copyright_button = toolkit.createButton(buttonpane,
				AuthoringUIText.SELECT_BUTTON_TEXT, SWT.SIMPLE);
		{
			GridData gridData = new GridData(GridData.HORIZONTAL_ALIGN_END);
			gridData.widthHint = DescriptionFormPage.BUTTON_WIDTH;
			copyright_button.setLayoutData(gridData);
		}
		copyright_button_deselect = toolkit.createButton(buttonpane,
				AuthoringUIText.DESELECT_BUTTON_TEXT, SWT.SIMPLE);
		{
			GridData gridData = new GridData(GridData.HORIZONTAL_ALIGN_END);
			gridData.widthHint = DescriptionFormPage.BUTTON_WIDTH;
			copyright_button_deselect.setLayoutData(gridData);
		}		

		ctrl_changeable = toolkit
				.createButton(
						versionComposite,
						AuthoringUIResources.methodPluginDescriptionPage_lockPluginLabel, SWT.CHECK); //$NON-NLS-1$

		// Create the expanded composite.
		expandedVersionComposite = toolkit.createComposite(versionSection,
				SWT.NONE);
		expandedVersionComposite.setLayoutData(new GridData(
				GridData.FILL_HORIZONTAL));
		expandedVersionComposite.setLayout(new GridLayout(2, false));
		expandedVersionComposite.setVisible(false);

		// Add the expand/collapse hyperlink image.
		expandVersionLink = toolkit.createImageHyperlink(
				expandedVersionComposite, SWT.NONE);
		expandVersionLink.setImage(AuthoringUIImages.IMG_EXPANDED);
		expandVersionLink.setUnderlined(false);
		expandVersionLink.setToolTipText(AuthoringUIResources.closeRTE); //$NON-NLS-1$
		expandVersionLink.addHyperlinkListener(new HyperlinkAdapter() {
			public void linkActivated(HyperlinkEvent e) {
				toggle(e, VERSION_SECTION_ID);
			}
		});

		// Add the expand/collapse hyperlink text.
		expandVersionLabel = createDecoratedLabel(toolkit, expandedVersionComposite, ""); //$NON-NLS-1$
		toolkit.paintBordersFor(expandedVersionComposite);
		toolkit.paintBordersFor(versionComposite);
	}

	private void initContentProviderCopyright() {
		copyrightContentProvider = new AdapterFactoryContentProvider(
				TngAdapterFactory.INSTANCE
						.getNavigatorView_ComposedAdapterFactory()) {
			public Object[] getElements(Object object) {
				List list = new ArrayList();
				if (plugin.getCopyrightStatement() != null) {
					list.add(plugin.getCopyrightStatement());
				}
				return list.toArray();
			}
		};
		copyright_viewer.setContentProvider(copyrightContentProvider);
	}

	protected void addVersionSectionListeners() {

		final MethodElementEditor editor = (MethodElementEditor) getEditor();

		modelModifyListener = editor.createModifyListener(plugin);
		contentModifyListener = editor.createModifyListener(plugin);

		ctrl_version.addModifyListener(contentModifyListener);
		ctrl_version.addFocusListener(new FocusAdapter() {
			public void focusGained(FocusEvent e) {
				((MethodElementEditor) getEditor()).setCurrentFeatureEditor(e.widget,
						UmaPackage.eINSTANCE.getMethodUnit_Version());
			}

			public void focusLost(FocusEvent e) {
				String oldContent = plugin.getVersion();
				if (((MethodElementEditor) getEditor()).mustRestoreValue(
						e.widget, oldContent)) {
					return;
				}
				String newContent = StrUtil
						.getPlainText(ctrl_version.getText());
				if (!newContent.equals(oldContent)) {
					actionMgr.doAction(IActionManager.SET, plugin,
							UmaPackage.eINSTANCE.getMethodUnit_Version(),
							newContent, -1);
					updateChangeDate();
				}
			}
		});

		ctrl_authors.addModifyListener(contentModifyListener);
		ctrl_authors.addFocusListener(new FocusAdapter() {
			public void focusGained(FocusEvent e) {
				((MethodElementEditor) getEditor()).setCurrentFeatureEditor(e.widget,
						UmaPackage.eINSTANCE.getMethodUnit_Authors());
			}

			public void focusLost(FocusEvent e) {
				String oldContent = plugin.getAuthors();
				if (((MethodElementEditor) getEditor()).mustRestoreValue(
						e.widget, oldContent)) {
					return;
				}
				String newContent = StrUtil
						.getPlainText(ctrl_authors.getText());
				if (!newContent.equals(oldContent)) {
					actionMgr.doAction(IActionManager.SET, plugin,
							UmaPackage.eINSTANCE.getMethodUnit_Authors(),
							newContent, -1);
					updateChangeDate();
				}
			}
		});

		copyright_button.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				IFilter filter = new ContentFilter() {
					protected boolean childAccept(Object obj) {
						if (obj instanceof Guidance) {
							return (obj instanceof SupportingMaterial);
						}
						return false;
					}
				};
				List alreadyExsting = new ArrayList();
				if (ctrl_copyright.getItemCount() > 0) {
					TableItem item = ctrl_copyright.getItems()[0];
					if (item.getData() != null)
						alreadyExsting.add(item.getData());
				}
				ItemsFilterDialog fd = new ItemsFilterDialog(PlatformUI
						.getWorkbench().getActiveWorkbenchWindow().getShell(),
						filter, plugin, FilterConstants.SUPPORTING_MATERIALS,
						alreadyExsting);
				fd.setViewerSelectionSingle(true);
				fd.setBlockOnOpen(true);
				fd.setTitle(FilterConstants.SUPPORTING_MATERIALS);
				fd.open();
				fd.getSelectedItems();
				if (fd.getSelectedItems().size() > 0) {
					editor.getActionManager().doAction(
							IActionManager.SET,
							plugin,
							UmaPackage.eINSTANCE
									.getMethodUnit_CopyrightStatement(),
							(SupportingMaterial) fd.getSelectedItems().get(0),
							-1);
				}
				copyright_viewer.refresh();

			}
		});

		ctrl_change_desc.addModifyListener(contentModifyListener);
		ctrl_change_desc.addFocusListener(new FocusAdapter() {
			public void focusGained(FocusEvent e) {
				((MethodElementEditor) getEditor()).setCurrentFeatureEditor(e.widget,
						UmaPackage.eINSTANCE.getMethodUnit_ChangeDescription());
			}

			public void focusLost(FocusEvent e) {
				String oldContent = plugin.getChangeDescription();
				char delimiter = AuthoringUIResources.ChangeHistoryDialog_delimiter.charAt(0); //$NON-NLS-1$

				if (((MethodElementEditor) getEditor()).mustRestoreValue(
						e.widget, oldContent)) {
					return;
				}
				String newContent = ctrl_change_desc.getText();

				newContent = newContent.replace(delimiter, ' '); //$NON-NLS-1$ //$NON-NLS-2$

				if (!newContent.equals(lastChangeHistory)) {
					lastChangeHistory = newContent;
					if ((oldContent != null)
							&& (!(StrUtil.isBlank(oldContent)))) {
						newContent = oldContent + delimiter + newContent; //$NON-NLS-1$
					}

					actionMgr.doAction(IActionManager.SET, plugin,
							UmaPackage.eINSTANCE
									.getMethodUnit_ChangeDescription(),
							newContent, -1);

					updateChangeDate();
				}

			}

		});

		view_history_button.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {

				ChangeHistoryDialog dlg = new ChangeHistoryDialog(PlatformUI
						.getWorkbench().getActiveWorkbenchWindow().getShell(),
						plugin);
				dlg.open();
			}
		});

		copyright_button_deselect.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				actionMgr
						.doAction(IActionManager.SET, plugin,
								UmaPackage.eINSTANCE
										.getMethodUnit_CopyrightStatement(),
								null, -1);
				copyright_viewer.refresh();
			}
		});

		ctrl_changeable.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				notificationEnabled = true;

				
				IStatus status = TngUtil.checkEdit(plugin, getSite().getShell());
				if (status.isOK()) {
					
					String message = AuthoringUIResources
							.bind(
									AuthoringUIResources.methodPluginDescriptionPage_lockPlugin_message,
									plugin.getName());
					Shell shell = getSite().getShell();
					if (AuthoringUIPlugin.getDefault().getMsgDialog()
							.displayConfirmation(shell.getText(), message)) {
						// close editors on any change in ctrl_changeable
						// if (ctrl_changeable.getSelection()) {
						getDirtyEditors(null);
						boolean ret = actionMgr.doAction(IActionManager.SET,
								plugin, UmaPackage.eINSTANCE
										.getMethodPlugin_UserChangeable(),
								new Boolean(!ctrl_changeable.getSelection()),
								-1);
						// in case of readonly file, roll back changes.
						if (!ret) {
							ctrl_changeable.setSelection(!ctrl_changeable
									.getSelection());
							return;
						}

						// }
						enableControls(!ctrl_changeable.getSelection());
					} else {
						// actionMgr.undo();
						ctrl_changeable.setSelection(!ctrl_changeable
								.getSelection());
						enableControls(!ctrl_changeable.getSelection());
						// return;
					}
				} else {
					AuthoringUIPlugin.getDefault().getMsgDialog().displayError(
							AuthoringUIResources.editDialog_title,
							AuthoringUIResources.editDialog_msgCannotEdit,
							status);
					return;
				}
				copyright_viewer.refresh();
				
				// refresh editor title image. 
				((MethodElementEditor)getEditor()).refreshTitleImage();
			}

			/**
			 * Return a list of dirty editors associated with the given Plugin.
			 * editors from MethodElementEditor.
			 * 
			 * @return List the dirty editors
			 */
			List getDirtyEditors(MethodPlugin methodplugin) {
				IWorkbenchPage workbenchPage = AuthoringUIPlugin.getDefault()
						.getWorkbench().getActiveWorkbenchWindow()
						.getActivePage();
				IEditorReference[] editorReferences = workbenchPage
						.getEditorReferences();
				ArrayList closeEditorRefs = new ArrayList();
				for (int i = 0; i < editorReferences.length; i++) {
					IEditorReference reference = editorReferences[i];
					IEditorPart editor = reference.getEditor(true);
					if (editor != null) {
						IEditorInput input = editor.getEditorInput();
						MethodElement element = null;
						if (input instanceof MethodElementEditorInput) {
							element = ((MethodElementEditorInput) input)
									.getMethodElement();
						} else if (input instanceof ConfigurationEditorInput) {
							element = ((ConfigurationEditorInput) input)
									.getConfiguration();
						}
						if (element != null
								&& (element.eContainer() == null || UmaUtil
										.isContainedBy(element, plugin))) {
							if (!element.equals(plugin))
								closeEditorRefs.add(reference);
						}
					}
				}
				int size = closeEditorRefs.size();
				IEditorReference[] references = new IEditorReference[size];
				for (int i = 0; i < size; i++) {
					references[i] = (IEditorReference) closeEditorRefs.get(i);
				}
				workbenchPage.closeEditors(references, true);
				return null;
			}
		});
	}

	/*
	 * update the change date if any attribute is modified.
	 */
	protected void updateChangeDate() {

		Date changeDate = plugin.getChangeDate();
		DateFormat df = DateFormat.getDateInstance(DateFormat.FULL);

		String oldContent = ""; //$NON-NLS-1$
		if (changeDate != null) {
			oldContent = df.format(changeDate);
		}

		Date currentDate = new Date();
		String newContent = df.format(currentDate);
		if (!newContent.equals(oldContent)) {
			actionMgr.doAction(IActionManager.SET, plugin, UmaPackage.eINSTANCE
					.getMethodUnit_ChangeDate(), currentDate, -1);
			ctrl_change_date.setText(newContent);
		}
	}

	protected void loadVersionSectionData() {
		ctrl_version
				.setText(plugin.getVersion() == null ? "" : plugin.getVersion()); //$NON-NLS-1$
		ctrl_authors
				.setText(plugin.getAuthors() == null ? "" : plugin.getAuthors()); //$NON-NLS-1$
		ctrl_change_desc.setText(""); //$NON-NLS-1$
		ctrl_change_date.setText(plugin.getChangeDate() == null ? "" : //$NON-NLS-1$
				DateFormat.getDateInstance(DateFormat.FULL).format(
						plugin.getChangeDate())); //$NON-NLS-1$
		ctrl_changeable
				.setSelection(!plugin.getUserChangeable().booleanValue());
	}

	/**
	 * Toggle Description control to expand and control state
	 * 
	 */
	protected void toggle(HyperlinkEvent e, int id) {
		// TODO: We should combine these methods into one. One way to do it,
		// dispoing
		// ctrl_expanded every time it collapses and creating it when we expand.
		// At present, there is no method to dispose
		if (id == GENERAL_SECTION_ID) {
			toggle(e);
		}
		if (id == VERSION_SECTION_ID) {
			toggleVersionSection(e);
		}
	}

	private void toggleVersionSection(HyperlinkEvent e) {
		if (ctrl_version_expanded == null) {
			ctrl_version_expanded = createRichTextEditor(toolkit,
					expandedVersionComposite, SWT.MULTI | SWT.WRAP
							| SWT.V_SCROLL, GridData.FILL_BOTH, getRichTextEditorHeight(), getRichTextEditorWidth(), 2,
							expandVersionLabel); //$NON-NLS-1$
			ctrl_version_expanded.addModifyListener(contentModifyListener);
		}

		if (descExpandFlag) {
			versionComposite.setVisible(true);
			expandedVersionComposite.setVisible(false);
			versionSection.setClient(versionComposite);
			refModelSection.setExpanded(true);
			generalSection.setExpanded(true);
			IMethodRichText richText = getActiveRichTextControl();
			richText.setText(ctrl_version_expanded.getText());
			for (Iterator i = richText.getListeners(); i.hasNext();) {
				RichTextListener listener = (RichTextListener) i.next();
				ctrl_version_expanded.removeListener(listener.getEventType(),
						listener.getListener());
			}
			if (ctrl_version_expanded.getModified()) {
				((MethodElementEditor) getEditor())
						.saveModifiedRichText(ctrl_version_expanded);
			}
			richText.setFocus();
		} else {
			versionComposite.setVisible(false);
			expandedVersionComposite.setVisible(true);
			versionSection.setClient(expandedVersionComposite);
			refModelSection.setExpanded(false);
			generalSection.setExpanded(false);
			((Label)expandVersionLabel.getControl())
					.setText((String) ((ImageHyperlink) e.getSource())
							.getData("Title")); //$NON-NLS-1$    		
			IMethodRichText richText = (IMethodRichText) e.getHref();
			ctrl_version_expanded.setText(richText.getText());
			ctrl_version_expanded.setModalObject(richText.getModalObject());
			ctrl_version_expanded.setModalObjectFeature(richText
					.getModalObjectFeature());
			for (Iterator i = richText.getListeners(); i.hasNext();) {
				RichTextListener listener = (RichTextListener) i.next();
				ctrl_version_expanded.addListener(listener.getEventType(),
						listener.getListener());
			}
			ctrl_version_expanded.setFocus();
			setActiveRichTextControl(richText);
		}

		versionSection.layout(true);
		descExpandFlag = !descExpandFlag;
	}

	/**
	 * Set active rich text control
	 */
	private void setActiveRichTextControl(IMethodRichText ctrl) {
		activeControl = ctrl;
	}

	/**
	 * Get Active Rich text control.
	 */
	private IMethodRichText getActiveRichTextControl() {
		return activeControl;
	}

	protected class UserChangeableAdapter extends AdapterImpl {
		public void notifyChanged(Notification msg) {
			switch (msg.getFeatureID(MethodPlugin.class)) {
			case UmaPackage.METHOD_PLUGIN__USER_CHANGEABLE:
				Boolean b = (Boolean) msg.getNewValue();
				setUserChangeable(b.booleanValue());
				return;
			}
		}
	}

	public void setUserChangeable(boolean userChangeable) {
		if (!notificationEnabled)
			return;
		notificationEnabled = false;
		plugin.setUserChangeable(Boolean.valueOf(userChangeable));
	}

	/**
	 * @see org.eclipse.ui.forms.editor.FormPage#dispose()
	 */
	public void dispose() {
		plugin.eAdapters().remove(userChangeableAdapter);
		super.dispose();
	}

	/**
	 * @see org.eclipse.epf.authoring.ui.forms.IRefreshable#refreshName(java.lang.String)
	 */
	public void refreshName(String newName) {
		if (newName != null) {
			if ((ctrl_name != null) && !(ctrl_name.isDisposed())) {
				ctrl_name.removeModifyListener(nameModifyListener);
				ctrl_name.setText(newName);
				ctrl_name.addModifyListener(nameModifyListener);
				form.setText(FORM_PREFIX + plugin.getName());
			}
		}
	}

}