//------------------------------------------------------------------------------
// 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
//------------------------------------------------------------------------------
/*
 * 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.diagram.core.part;

import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.draw2d.PositionConstants;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.impl.AdapterImpl;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.epf.common.CommonPlugin;
import org.eclipse.epf.diagram.core.DiagramCorePlugin;
import org.eclipse.epf.diagram.core.DiagramCoreResources;
import org.eclipse.epf.diagram.core.actions.AccessibilityMoveAction;
import org.eclipse.epf.diagram.core.actions.CreateElementAction;
import org.eclipse.epf.diagram.core.actions.DelegateAction;
import org.eclipse.epf.diagram.core.actions.DiagramActionsService;
import org.eclipse.epf.diagram.core.bridge.BridgeHelper;
import org.eclipse.epf.diagram.core.bridge.DiagramAdapter;
import org.eclipse.epf.diagram.core.part.util.DiagramEditorUtil;
import org.eclipse.epf.diagram.core.providers.DiagramContextMenuProvider;
import org.eclipse.epf.diagram.core.providers.SharedResourceDiagramDocumentProvider;
import org.eclipse.epf.diagram.core.services.DiagramManager;
import org.eclipse.epf.diagram.core.services.DiagramService;
import org.eclipse.epf.diagram.core.util.DiagramConstants;
import org.eclipse.epf.diagram.model.NamedNode;
import org.eclipse.epf.library.ILibraryManager;
import org.eclipse.epf.library.ILibraryServiceListener;
import org.eclipse.epf.library.LibraryService;
import org.eclipse.epf.library.LibraryServiceListener;
import org.eclipse.epf.library.LibraryServiceUtil;
import org.eclipse.epf.library.configuration.ProcessAuthoringConfigurator;
import org.eclipse.epf.library.edit.command.IActionManager;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.library.events.ILibraryChangeListener;
import org.eclipse.epf.library.ui.IMethodElementProvider;
import org.eclipse.epf.services.ILibraryPersister;
import org.eclipse.epf.ui.editors.IMethodEditor;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.MethodConfiguration;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.Process;
import org.eclipse.epf.uma.ProcessComponent;
import org.eclipse.epf.uma.UmaPackage;
import org.eclipse.gef.ContextMenuProvider;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.KeyHandler;
import org.eclipse.gef.KeyStroke;
import org.eclipse.gef.commands.Command;
import org.eclipse.gef.ui.actions.ActionRegistry;
import org.eclipse.gef.ui.actions.GEFActionConstants;
import org.eclipse.gef.ui.parts.ScrollingGraphicalViewer;
import org.eclipse.gmf.runtime.common.core.util.StringStatics;
import org.eclipse.gmf.runtime.diagram.ui.actions.ActionIds;
import org.eclipse.gmf.runtime.diagram.ui.actions.internal.SelectAllAction;
import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart;
import org.eclipse.gmf.runtime.diagram.ui.parts.DiagramGraphicalViewer;
import org.eclipse.gmf.runtime.diagram.ui.parts.IDiagramGraphicalViewer;
import org.eclipse.gmf.runtime.diagram.ui.requests.CreateUnspecifiedTypeConnectionRequest;
import org.eclipse.gmf.runtime.diagram.ui.requests.RequestConstants;
import org.eclipse.gmf.runtime.diagram.ui.resources.editor.document.IDocumentProvider;
import org.eclipse.gmf.runtime.diagram.ui.resources.editor.ide.editor.FileDiagramEditor;
import org.eclipse.gmf.runtime.diagram.ui.resources.editor.parts.DiagramDocumentEditor;
import org.eclipse.gmf.runtime.emf.type.core.IElementType;
import org.eclipse.gmf.runtime.notation.Diagram;
import org.eclipse.gmf.runtime.notation.Edge;
import org.eclipse.gmf.runtime.notation.View;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.ide.IGotoMarker;
import org.eclipse.ui.services.IDisposable;
import org.eclipse.uml2.uml.ActivityNode;

/**
 * @author Phong Nguyen Le
 * @author skannoor
 * @since 1.2
 */
public abstract class AbstractDiagramEditor extends FileDiagramEditor implements IGotoMarker, IMethodEditor {

	private DiagramManager diagramMgr;
	private DiagramActionsService actionService = null;
	
	private long fModificationStamp;
	private Activity activity;
	private AdapterImpl titleAdapter;

	private IResourceChangeListener resourceChangeListener = new IResourceChangeListener() {

		public void resourceChanged(IResourceChangeEvent event) {
			if(event.getSource() == diagramMgr) {
				IDocumentProvider docProvider = getDocumentProvider();
				if(docProvider instanceof SharedResourceDiagramDocumentProvider) {
					if(!isDirty()) {
						((SharedResourceDiagramDocumentProvider)docProvider).handleElementContentChanged(getEditorInput());
					}
				}				
			}
		}
		
	};
	
	// Listeners to refresh diagram if configuration got changed
	//
	private ILibraryChangeListener libraryListener = new ILibraryChangeListener() {
		public void libraryChanged(int option, Collection collection) {
			switch (option) {
			case ILibraryChangeListener.OPTION_CHANGED: {
				if (collection != null && collection.contains(currentConfig)) {
					MethodConfiguration config = ProcessAuthoringConfigurator.INSTANCE.getMethodConfiguration();
					try {
						ProcessAuthoringConfigurator.INSTANCE.setMethodConfiguration(currentConfig);					
						refresh();
					}
					finally {
						ProcessAuthoringConfigurator.INSTANCE.setMethodConfiguration(config);
					}
				}		
				break;
			}
			// handled by libSvcListener
			//
//			case ILibraryChangeListener.OPTION_CONFIGURATION_SELECTED: {
//				configChanged();
//				break;
//			}
			}
		}
	};
	
	private ILibraryServiceListener libSvcListener = new LibraryServiceListener() {

		public void configurationSet(MethodConfiguration config) {
			configChanged();
		}

	};

	private MethodConfiguration currentConfig;

	//TODO: if this flag is set, refresh diagram if needed when the editor is activated 
	private boolean needRefresh;
	private DiagramService diagramSvc;

	public AbstractDiagramEditor() {
		super(true);
	}
	
	public AbstractDiagramEditor(boolean hasFlyoutPalette) {
		super(hasFlyoutPalette);
	}

	protected String getEditingDomainID() {
		return "org.eclipse.epf.diagram.EditingDomain"; //$NON-NLS-1$
	}

	protected DiagramManager getDiagramManager() {
		if (diagramMgr == null) {
			org.eclipse.epf.uma.Process proc = TngUtil.getOwningProcess(activity);
			diagramMgr = DiagramManager.getInstance(proc, this);
			diagramMgr.addResourceChangeListener(resourceChangeListener);
		}
		return diagramMgr;
	}
	
	protected DiagramService getDiagramService() {
		if(diagramSvc == null) {
			diagramSvc = new DiagramService();
		}
		return diagramSvc;
	}

	protected TransactionalEditingDomain createEditingDomain() {
		TransactionalEditingDomain domain = getDiagramManager().getEditingDomain();
		domain.setID(getEditingDomainID());
		return domain;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.gmf.runtime.diagram.ui.resources.editor.parts.DiagramDocumentEditor#setDocumentProvider(org.eclipse.ui.IEditorInput)
	 */
	protected void setDocumentProvider(IEditorInput input) {
		setDocumentProvider(new SharedResourceDiagramDocumentProvider(getDiagramManager()) {
			@Override
			protected void doSynchronize(Object element, IProgressMonitor monitor) throws CoreException {
				// reload diagram's resource
				//
				DiagramManager mgr = getDiagramManager();
				try {
					mgr.removeResourceChangeListener(resourceChangeListener);
					mgr.reload();
				} catch (IOException e) {
					throw new CoreException(new Status(IStatus.ERROR, DiagramCorePlugin.getPluginId(),
							0, "Error reloading diagram", e)); //$NON-NLS-1$
				}
				finally {
					mgr.addResourceChangeListener(resourceChangeListener);
				}
				super.doSynchronize(element, monitor);
			}
		});		
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.gmf.runtime.diagram.ui.resources.editor.parts.DiagramDocumentEditor#doSetInput(org.eclipse.ui.IEditorInput, boolean)
	 * @custom
	 */
	public void doSetInput(IEditorInput input, boolean releaseEditorContents)
			throws CoreException {
		activity = (Activity) getMethodElement(input);
		DiagramEditorInputProxy inputProxy = null;
		if (input instanceof DiagramEditorInputProxy) {
			inputProxy = (DiagramEditorInputProxy) input;
			inputProxy.setTransactionalEditingDomain(createEditingDomain());
		}
		super.doSetInput(input, releaseEditorContents);
		if(isEditable() && inputProxy != null && !inputProxy.isNewDiagram()) {
			getDiagramManager().backupDiagram(activity, getDiagram());
		}
		initializeTitle(input);
	}

	/**
	 * Initializes the editor's title based on the given editor input.
	 *
	 * @param input the editor input to be used
	 * @custom
	 */
	private void initializeTitle(IEditorInput input) {

		String title = ""; //$NON-NLS-1$
		if (input != null) {
			DiagramFileEditorInputProxy fileInput = (DiagramFileEditorInputProxy) input;
			DiagramEditorInput diagramInput = fileInput.getDiagramEditorInput();
			MethodElement inputElement = diagramInput.getMethodElement();
			if (inputElement != null) {
				//title = inputElement.getName();
				title = getPartNamePrefix() + 
							inputElement.getName()+
							StringStatics.COMMA + StringStatics.SPACE + 
							diagramInput.getSuppression().getProcess().getName(); 
//				ILabelProvider labelProvider = new AdapterFactoryLabelProvider(
//						TngAdapterFactory.INSTANCE
//								.getNavigatorView_ComposedAdapterFactory());
				Image titleImage = getPartImage();				
				setTitleImage(titleImage);
			}
		}
		setPartName(title);
		firePropertyChange(PROP_DIRTY);
	}

	/**
	 * (non-Javadoc)
	 * @see org.eclipse.gmf.runtime.diagram.ui.resources.editor.parts.DiagramDocumentEditor#sanityCheckState(org.eclipse.ui.IEditorInput)
	 * @custom
	 */
	protected void sanityCheckState(IEditorInput input) {
		IDocumentProvider p = getDocumentProvider();
		if (p == null)
			return;

		long stamp = p.getModificationStamp(input);
		if (stamp != fModificationStamp) {
			fModificationStamp = stamp;
			if (!p.isSynchronized(input)) {
				handleEditorInputChanged();
				if(!p.isSynchronized(input) && p instanceof SharedResourceDiagramDocumentProvider) {
					((SharedResourceDiagramDocumentProvider)p).allowEditing(input);
				}
			}
		}
		updateState(getEditorInput());
	}
	
	/*
	 * (non-Javadoc)
	 * @see org.eclipse.gmf.runtime.diagram.ui.resources.editor.parts.DiagramDocumentEditor#dispose()
	 */
	public void dispose() {
		Diagram diagram = getDiagram();
		
		// if changes discarded, reverse to saved
		//		
		if(isDirty()) {
			reverseToSaved();
		}		
		
		if(titleAdapter != null){
			MethodElement e = getMethodElement(getEditorInput());
			if(e != null){
				e.eAdapters().remove(titleAdapter);
			}
			titleAdapter = null;
		}
		
		if(diagramMgr != null) {
			if(activity != null && diagram != null) {
				diagramMgr.removeDiagramBackup(activity, diagram.getType());
			}
			diagramMgr.removeResourceChangeListener(resourceChangeListener);
			diagramMgr.removeConsumer(this);
		}		
		
		if(diagramSvc != null) {
			diagramSvc.dispose();
		}
				
		ILibraryManager manager = LibraryService.getInstance().getCurrentLibraryManager();
		if (manager != null) {
			manager.removeListener(libraryListener);
		}
		LibraryService.getInstance().removeListener(libSvcListener);
		
		// Remove the adapter from the uml activity if editor is closed.
		if(getDiagram().getElement() instanceof org.eclipse.uml2.uml.Activity){
			org.eclipse.uml2.uml.Activity act = (org.eclipse.uml2.uml.Activity)getDiagram().getElement();
			if(act != null && getDiagramAdapter() != null){
				act.eAdapters().remove(getDiagramAdapter());
			}
		}
		
		// dispose the input
		//
		IEditorInput input = getEditorInput();
		if(input instanceof IDisposable) {
			((IDisposable)input).dispose();
		}
		
		DiagramEditPart editPart = getDiagramEditPart();
		if(editPart != null) {
			editPart.setModel(null);
		}

		super.dispose();
	
	}

	private DiagramAdapter getDiagramAdapter() {
		View view = ((View) getDiagramEditPart().getModel());
		return view != null ? (DiagramAdapter) BridgeHelper
				.getNodeAdapter(view.getElement()) : null;
	}

	private void reverseToSaved() {
		try {
			IDocumentProvider p = getDocumentProvider();
			if(p instanceof SharedResourceDiagramDocumentProvider) {
				((SharedResourceDiagramDocumentProvider)p).reverseToSaved(getEditorInput());
			}
			
			DiagramAdapter adapter = getDiagramAdapter();
			if(adapter == null) {
				//TODO: reverse to saved for ADD and WPDD
				return;
			}
			IActionManager actionMgr = adapter.getActionManager();
			boolean dirty = actionMgr.isSaveNeeded();
			if (dirty) {
				actionMgr.undoAll();
//				getOperationHistory().undo(getUndoContext(), new NullProgressMonitor(), null);
//				getOperationHistory().dispose(getUndoContext(), true, true, true);
			}
			getActionManager().clear();

			// save the undone changes only if the resource has been changed outside this editor
			//
			boolean saveNeeded = dirty
			&& getLastModified() > adapter.getUmaLastModified();
			MethodElement me;
			if (saveNeeded && (me = getMethodElementFromInput()) != null) {
				ILibraryPersister.FailSafeMethodLibraryPersister persister = LibraryServiceUtil
				.getCurrentPersister().getFailSafePersister();
				try {
					persister.save(me.eResource());
					persister.commit();
				} catch (Exception e) {
					CommonPlugin.getDefault().getLogger().logError(e);
					try {
						persister.rollback();
					} catch (Exception ex) {
						//TODO: reload library needed
						//					ViewHelper.reloadCurrentLibrary(getSite().getShell(), null);
						ex.printStackTrace();
					}
				}
			}
		}
		catch(Exception e) {
			CommonPlugin.getDefault().getLogger().logError(e);
			e.printStackTrace();
		}
	}

	private Process getProcess() {
		Object input = getEditorInput();
		if (input instanceof IDiagramFileEditorInputProxy) {
			return ((IDiagramFileEditorInputProxy) input)
					.getDiagramEditorInput().getSuppression().getProcess();
		}
		return null;
	}
	
	protected MethodElement getMethodElementFromInput() {
		return getMethodElement(getEditorInput());
	}
	
	private static MethodElement getMethodElement(IEditorInput input) {
		if (input instanceof DiagramFileEditorInputProxy) {
			return ((DiagramFileEditorInputProxy) input)
					.getDiagramEditorInput().getMethodElement();
		}
		return null;
	}

	private long getLastModified() {
		Resource resource = getMethodElementFromInput().eResource();
		if (resource != null && resource.getURI().isFile()) {
			File file = new File(resource.getURI().toFileString());
			return file.lastModified();
		}
		return -1;
	}

	public void doSave(IProgressMonitor progressMonitor) {
		DiagramAdapter diagramAdapter = getDiagramAdapter();
		if(diagramAdapter != null) {
			IActionManager actionMgr = getDiagramAdapter().getActionManager();
			if (actionMgr != null && actionMgr.isSaveNeeded()) {
				try {
					progressMonitor.beginTask("Saving", IProgressMonitor.UNKNOWN); //$NON-NLS-1$
					ILibraryPersister.FailSafeMethodLibraryPersister persister = LibraryServiceUtil
					.getCurrentPersister().getFailSafePersister();
					try {
						for (Iterator iter = actionMgr.getModifiedResources()
								.iterator(); iter.hasNext();) {
							Resource resource = (Resource) iter.next();
							progressMonitor.setTaskName(NLS.bind(DiagramCoreResources.Progress_Saving_message,
									resource.getURI().isFile() ? resource.getURI()
											.toFileString() : "")); //$NON-NLS-1$
							persister.save(resource);
						}
						persister.commit();
						actionMgr.saveIsDone();
					} catch (Exception e) {
						CommonPlugin.getDefault().getLogger().logError(e);
						try {
							persister.rollback();
						} catch (Exception ex) {
							CommonPlugin.getDefault().getLogger().logError(ex);
							//						ViewHelper
							//						.reloadCurrentLibaryOnRollbackError(getSite()
							//						.getShell());
							return;
						}
						
						/*
						 * NO UI module should not involve with UI classes
						 * use callback to handle such kind of situation
						 * Jinhua Xi, 01/13/08
						*/
//						CommonPlugin.getDefault().getMsgDialog().displayWarning(
//								getSite().getShell().getText(),
//								DiagramCoreResources.Warning_Saving_Diagram, e.getMessage(),
//								e);
						CommonPlugin.getDefault().getMsgCallback().displayWarning(
								CommonPlugin.getDefault(), 
								DiagramCoreResources.Warning_Saving_Diagram, e.getMessage(),
								e);
					
						return;
					}

				} finally {
					progressMonitor.done();
				}

			}
		}

		super.doSave(progressMonitor);
	}
	
	private class DiagramGraphicalViewerEx extends DiagramGraphicalViewer implements IDiagramEditorInputProvider {

		public DiagramEditorInput getDiagramEditorInput() {
			return ((IDiagramFileEditorInputProxy)getEditorInput()).getDiagramEditorInput();
		}

		public IEditorPart getEditor() {
			return AbstractDiagramEditor.this;
		}				
	}
	
	@Override
	protected ScrollingGraphicalViewer createScrollingGraphicalViewer() {
		return new DiagramGraphicalViewerEx();
	}
	
	@Override
	protected void configureGraphicalViewer() {
		super.configureGraphicalViewer();
		
		currentConfig = LibraryService.getInstance().getCurrentMethodConfiguration();
		
		// listen to change for current selection of MethodConfiguration or changes in 
		// current configuration.
		//
		LibraryService.getInstance().addListener(libSvcListener);
		ILibraryManager manager = LibraryService.getInstance().getCurrentLibraryManager();
		if (manager != null) {
			manager.addListener(libraryListener);
		}
		getGraphicalControl().addListener(SWT.MouseDoubleClick, new Listener() {
			public void handleEvent(Event event) {
				handleDoubleClick(event);
			}
		});
		IDiagramGraphicalViewer viewer =  getDiagramGraphicalViewer();
        ContextMenuProvider provider = new DiagramContextMenuProvider(this,
                getDiagramGraphicalViewer());
            viewer.setContextMenu(provider);
            getSite().registerContextMenu(ActionIds.DIAGRAM_EDITOR_CONTEXT_MENU,
                provider, viewer);
		if(actionService != null){
			actionService.setGraphicalViewer(viewer);
		}
		
		titleAdapter = new AdapterImpl(){
			@Override
			public void notifyChanged(Notification msg) {
				switch (msg.getFeatureID(MethodElement.class)) {
				case UmaPackage.METHOD_ELEMENT__NAME:
//					setName(msg.getNewStringValue());
					initializeTitle(getEditorInput());
					break;
				}
			}
		};
		MethodElement e = getMethodElement(getEditorInput());
		if(e != null && titleAdapter != null){
			e.eAdapters().add(titleAdapter);
		}
	}
		
	private void configChanged() {
		MethodConfiguration config = LibraryService.getInstance().getCurrentMethodConfiguration();
		if(currentConfig != config) {
			// refresh only if the active part is this diagram editor or process editor of the process
			// that owns this diagram
			//
			IWorkbenchPart activePart = getSite().getWorkbenchWindow().getPartService().getActivePart();
			boolean refresh = activePart == this;
			if(!refresh) {
				if(activePart instanceof IEditorPart) {
					IEditorInput input = ((IEditorPart)activePart).getEditorInput();
					if(input instanceof IMethodElementProvider) {
						Object e = ((IMethodElementProvider)input).getMethodElement();
						if(e instanceof ProcessComponent) {
							refresh = e instanceof ProcessComponent && 
							getProcess() == ((ProcessComponent)e).getProcess();
						}
					}
				}
			}
			if(refresh) {
				currentConfig = config;
				refresh();
				needRefresh = false;
			}
			else {
				needRefresh = true;
			}
		}
	}
	
	public void refresh() {
		if(getDocumentProvider() instanceof SharedResourceDiagramDocumentProvider){
			SharedResourceDiagramDocumentProvider docProvider = ((SharedResourceDiagramDocumentProvider)getDocumentProvider());
			DiagramEditPart editPart = getDiagramEditPart();
			boolean wasDirty = isDirty();
			boolean wasBaseDirty = false;
			IEditorPart baseEditor = null;
			final boolean isInherited = DiagramEditorUtil.isInherited(editPart);
			if(isInherited) {
				MethodElement element = BridgeHelper.getMethodElement(editPart.getDiagramView());
				String type = editPart.getDiagramView().getType();
				
				// try to find the dirty flag of base diagram editor
				//
				IEditorReference[] editorRefs = getSite().getPage().getEditorReferences();
				for (int i = 0; i < editorRefs.length; i++) {
					IEditorReference ref = editorRefs[i];
					try {
						if(ref.getEditorInput() instanceof IDiagramFileEditorInputProxy) {
							DiagramEditorInput input = ((IDiagramFileEditorInputProxy)ref.getEditorInput()).getDiagramEditorInput();
							if(input.getWrapper() == null && input.getMethodElement() == element &&
									DiagramManager.getDiagramType(type) == input.getDiagramType()) {
								IEditorPart editor = ref.getEditor(false);
								if(editor != null) {
									wasBaseDirty = editor.isDirty();
									baseEditor = editor;
									break;
								}
							}
						}
					} catch (PartInitException e) {
						DiagramCorePlugin.getDefault().getLogger().logError(e);
					}
				}
			}

			docProvider.setContent(getEditorInput());
			if(wasDirty) {
				docProvider.setCanSaveDocument(getEditorInput());
			}
			// editors can become dirty after refresh
			// clear dirty flag
			//
			else if(isDirty()) {
				((SharedResourceDiagramDocumentProvider) getDocumentProvider())
						.markDocumentAsSaved((IFileEditorInput)getEditorInput());
			}
			if(baseEditor != null && !wasBaseDirty) {
				((SharedResourceDiagramDocumentProvider)((DiagramDocumentEditor)baseEditor).getDocumentProvider())
					.markDocumentAsSaved((IFileEditorInput) baseEditor.getEditorInput());
			}
			updateState(getEditorInput());
		}
	}
	
	// Does nothing but for override. 
	protected void handleDoubleClick(Event event) {
	}
	
	@Override
	public boolean isDirty() {
		if(!DiagramEditorUtil.isModifiable(getEditorInput())){
			return false;
		}
		return super.isDirty();
	}
	
	@Override
	public boolean isEditable() {
		if(getDocumentProvider() instanceof SharedResourceDiagramDocumentProvider){
			return !((SharedResourceDiagramDocumentProvider)getDocumentProvider()).getLockedState();
		}
		return true;
	}
	
	@Override
	protected KeyHandler getKeyHandler() {
		KeyHandler keyHandler =  super.getKeyHandler();
		if(keyHandler != null){
			ActionRegistry registry = getActionRegistry();
			IAction action = registry.getAction(ActionFactory.DELETE.getId());
			
			if(action != null && !(action instanceof DelegateAction)){
				getActionRegistry().removeAction(action);
				getSelectionActions().remove(action);
				action = new DelegateAction((IWorkbenchPart)this,ActionFactory.DELETE.getId());
				action.setId(ActionFactory.DELETE.getId());
				getActionRegistry().registerAction(action);
				getSelectionActions().add(action.getId());
			}
            keyHandler.put(KeyStroke.getPressed(SWT.DEL, 127, 0),
            	getActionRegistry().getAction(ActionFactory.DELETE.getId()));
            keyHandler.put(KeyStroke.getPressed(SWT.BS, 8, 0),
                    getActionRegistry().getAction(ActionFactory.DELETE.getId()));
            keyHandler.put(/* CTRL + D */
                        KeyStroke.getPressed((char) 0x04, 100, SWT.CTRL),
                            getActionRegistry().getAction(
                               ActionFactory.DELETE.getId()));
            getActionRegistry().registerAction(new AccessibilityMoveAction(this,PositionConstants.SOUTH));
            AccessibilityMoveAction moveAction = ((AccessibilityMoveAction)getActionRegistry().getAction(AccessibilityMoveAction.MOVE_DOWN_ACTION));
            keyHandler.put(KeyStroke.getPressed(SWT.ARROW_DOWN, SWT.CTRL),
            		moveAction);
            
            getActionRegistry().registerAction(new AccessibilityMoveAction(this,PositionConstants.NORTH));
            moveAction = ((AccessibilityMoveAction)getActionRegistry().getAction(AccessibilityMoveAction.MOVE_UP_ACTION));
            keyHandler.put(KeyStroke.getPressed(SWT.ARROW_UP, SWT.CTRL),
            		moveAction);
            
            getActionRegistry().registerAction(new AccessibilityMoveAction(this,PositionConstants.WEST));
            moveAction = ((AccessibilityMoveAction)getActionRegistry().getAction(AccessibilityMoveAction.MOVE_LEFT_ACTION));
            keyHandler.put(KeyStroke.getPressed(SWT.ARROW_LEFT, SWT.CTRL),
            		moveAction);
            
            getActionRegistry().registerAction(new AccessibilityMoveAction(this,PositionConstants.EAST));
            moveAction = ((AccessibilityMoveAction)getActionRegistry().getAction(AccessibilityMoveAction.MOVE_RIGHT_ACTION));
            keyHandler.put(KeyStroke.getPressed(SWT.ARROW_RIGHT, SWT.CTRL),
            		moveAction);
            
            /* CTRL + A */
            action = SelectAllAction.createSelectAllAction(getEditorSite()
					.getWorkbenchWindow().getActivePage());
            getActionRegistry().registerAction(action);
            getSelectionActions().add(action.getId());
			keyHandler.put(
            		KeyStroke.getReleased((char) 0x1, 97, SWT.CTRL),
            		action);
			// Key pressed event for CTRL + A is not triggered, use key released event for now
			//
			keyHandler.put(
            		KeyStroke.getReleased((char) 0x1, 97, SWT.CTRL),
            		action);
 		}
		
		return keyHandler;
	}
	
	
	@Override
	protected void createActions() {
		super.createActions();
		createControlFlowAction();
		
		// Register alignment actions:
		actionService = new DiagramActionsService(
				getDiagramManager().getEditingDomain(),
				getGraphicalViewer(),
				getEditDomain(), getActionRegistry());
		actionService.registerHorizontalAlignAverageAction();
		actionService.registerHorizontalAlignFirstSelectedAction();
		actionService.registerVerticalAlignAverageAction();
		actionService.registerVerticalAlignFirstSelectedAction();
		
	}
	
	protected IAction createAnAction(String actionName,
			List<IElementType> elementType, String actionId,
			String tooltipString, ImageDescriptor imagedesc) {
		CreateElementAction action = new CreateElementAction(this, actionName);
		action.setElementTypes(elementType);
		action.setPreferenceHint(getPreferencesHint());
		action.setImageDescriptor(imagedesc);
		action.setToolTipText(tooltipString);
		action.setId(actionId);
		return action;
	}
	
	public void contributeToContextMenu(IMenuManager menu) {
		if(actionService != null){
			actionService.createAlignMenu(menu, isEditable());
		}
		addToMenu(menu, DiagramConstants.CREATE_LINK,
				GEFActionConstants.MB_ADDITIONS, true, true);
	}
	
	protected void addToMenu(IMenuManager menu, String id, String groupName, 
			boolean separator, boolean append) {
		boolean canModify = isEditable();
		if (id != null) {
			IAction action = getActionRegistry().getAction(id);
			if (action != null && action.isEnabled() && canModify) {
				if (append) {
					menu.appendToGroup(groupName, action);
				} else {
					menu.prependToGroup(groupName, action);
				}
				if (separator) {
					menu.insertAfter(id, new Separator());
				}
			}
		}else{
			if(separator && canModify){
				if(append){
					menu.appendToGroup(groupName, new Separator());
				}else{
					menu.prependToGroup(groupName, new Separator());
				}
			}
		}
	}
	
	/**
	 * To reset the layout of the diagram.
	 */
	public void resetLayout(){
		// does nothing. client should implement.
	}
	
	
	/**
	 * Refresh diagram
	 */
	public void refreshDiagram(){
		refresh();
	}
	
	protected abstract String getPartNamePrefix();
	
	protected abstract Image getPartImage();
	
	private void createControlFlowAction(){
		IAction linkAction = new Action(DiagramCoreResources.ActivityDiagram_Palette_control_flow_create_text) { //$NON-NLS-1$
			public void run() {
				List editParts = getGraphicalViewer().getSelectedEditParts();
				if (editParts.size() == 2) {
					EditPart sourceEditPart = (EditPart) editParts.get(0);
					EditPart targetEditPart = (EditPart) editParts.get(1);
					
					View sourceModel = (View)sourceEditPart.getModel();
					View targetModel = (View)targetEditPart.getModel();
					
					if(BridgeHelper.isReadOnly(sourceModel) 
							|| BridgeHelper.isReadOnly(targetModel))
						return;
					
					CreateUnspecifiedTypeConnectionRequest connectionRequest = 
						getCreateControlFlowRequest();
					if (connectionRequest != null) {
						connectionRequest.setSourceEditPart(null);
						connectionRequest.setTargetEditPart(targetEditPart);
						connectionRequest
								.setType(RequestConstants.REQ_CONNECTION_START);
						connectionRequest.setLocation(new Point(0, 0));
						sourceEditPart.getCommand(connectionRequest);

						connectionRequest.setSourceEditPart(sourceEditPart);
						connectionRequest.setTargetEditPart(targetEditPart);
						connectionRequest
								.setType(RequestConstants.REQ_CONNECTION_END);
						connectionRequest.setLocation(new Point(0, 0));

						DiagramEditPart diagramEditPart = getDiagramEditPart();
						if (diagramEditPart.isEditModeEnabled()) {
							Command cmd = targetEditPart
									.getCommand(connectionRequest);
							if (cmd != null && cmd.canExecute()) {
								cmd.execute();
							}
						}
					}
				}
			}

			public boolean isEnabled() {
				if(getCreateControlFlowRequest()== null) return false;
				List editParts = getGraphicalViewer().getSelectedEditParts();
				if (editParts.size() == 2) {
					EditPart sourceEditPart = (EditPart) editParts.get(0);
					EditPart targetEditPart = (EditPart) editParts.get(1);

					View sourceModel = (View) sourceEditPart.getModel();
					View targetModel = (View) targetEditPart.getModel();
					if(BridgeHelper.isReadOnly(sourceModel) 
							|| BridgeHelper.isReadOnly(targetModel))
						return false;
					
					for (Iterator iter = getDiagram().getEdges().iterator(); iter.hasNext();) {
						Edge edge = (Edge) iter.next();
						if(edge.getSource()== sourceModel && edge.getTarget() == targetModel){
							return false;
						}
					}
					
					if (sourceModel.getElement() instanceof ActivityNode
							| sourceModel.getElement() instanceof NamedNode
							|| targetModel.getElement() instanceof ActivityNode
							|| targetModel.getElement() instanceof NamedNode) {
						return true;
					}
					
				}
				return false;
			}

			public String getId() {
				return DiagramConstants.CREATE_LINK;
			}
			@Override
			public ImageDescriptor getImageDescriptor() {
				return DiagramConstants.CONTROL_FLOW_IMAGE_DESCRIPTOR;
			}
		};
		getActionRegistry().registerAction(linkAction);
	}

	/**
	 * Does nothing client should implement.
	 * @return
	 */
	protected CreateUnspecifiedTypeConnectionRequest getCreateControlFlowRequest() {
		return null;
	}
	
	protected Diagram getDiagram(Activity activity, int type) {
		return getDiagramService().getDiagram(activity, type);
	}

}