examples/org.eclipse.gmf.examples.mindmap.lite.rcp/src/org/eclipse/gmf/examples/mindmap/rcp/part/MindmapDiagramEditor.java

/*
 * Copyright (c) 2006, 2007 Borland Software Corporation.
 *  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:
 *      Richard Gronback (Borland) - initial API and implementation
 */

package org.eclipse.gmf.examples.mindmap.rcp.part;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Status;
import org.eclipse.draw2d.DelegatingLayout;
import org.eclipse.draw2d.FreeformLayer;
import org.eclipse.draw2d.LayeredPane;
import org.eclipse.draw2d.PositionConstants;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.common.ui.URIEditorInput;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
import org.eclipse.emf.edit.provider.ReflectiveItemProviderAdapterFactory;
import org.eclipse.emf.edit.provider.resource.ResourceItemProviderAdapterFactory;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.emf.workspace.AbstractEMFOperation;
import org.eclipse.gef.ContextMenuProvider;
import org.eclipse.gef.EditPartViewer;
import org.eclipse.gef.GraphicalViewer;
import org.eclipse.gef.KeyHandler;
import org.eclipse.gef.KeyStroke;
import org.eclipse.gef.LayerConstants;
import org.eclipse.gef.MouseWheelHandler;
import org.eclipse.gef.MouseWheelZoomHandler;
import org.eclipse.gef.editparts.ScalableFreeformRootEditPart;
import org.eclipse.gef.editparts.ZoomManager;
import org.eclipse.gef.palette.PaletteRoot;
import org.eclipse.gef.ui.actions.AlignmentAction;
import org.eclipse.gef.ui.actions.DeleteAction;
import org.eclipse.gef.ui.actions.DirectEditAction;
import org.eclipse.gef.ui.actions.GEFActionConstants;
import org.eclipse.gef.ui.actions.PrintAction;
import org.eclipse.gef.ui.actions.RedoAction;
import org.eclipse.gef.ui.actions.SaveAction;
import org.eclipse.gef.ui.actions.UndoAction;
import org.eclipse.gef.ui.actions.ZoomInAction;
import org.eclipse.gef.ui.actions.ZoomOutAction;
import org.eclipse.gef.ui.parts.GraphicalViewerKeyHandler;
import org.eclipse.gmf.examples.mindmap.Map;
import org.eclipse.gmf.examples.mindmap.MindmapFactory;
import org.eclipse.gmf.examples.mindmap.provider.MindmapItemProviderAdapterFactory;
import org.eclipse.gmf.examples.mindmap.rcp.edit.parts.MindmapEditPartFactory;
import org.eclipse.gmf.examples.mindmap.rcp.providers.ValidateAction;
import org.eclipse.gmf.examples.mindmap.rcp.view.factories.MapViewFactory;
import org.eclipse.gmf.runtime.lite.commands.WrappingCommand;
import org.eclipse.gmf.runtime.lite.edit.parts.update.TransactionalUpdateManager;
import org.eclipse.gmf.runtime.lite.parts.DiagramEditor;
import org.eclipse.gmf.runtime.lite.ui.actions.ActionIds;
import org.eclipse.gmf.runtime.lite.ui.actions.LayoutDiagramAction;
import org.eclipse.gmf.runtime.notation.Diagram;
import org.eclipse.gmf.runtime.notation.NotationFactory;
import org.eclipse.gmf.runtime.notation.NotationPackage;
import org.eclipse.gmf.runtime.notation.provider.NotationItemProviderAdapterFactory;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.swt.SWT;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorSite;
import org.eclipse.ui.IPathEditorInput;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.views.properties.IPropertySheetPage;
import org.eclipse.ui.views.properties.tabbed.ITabbedPropertySheetPageContributor;
import org.eclipse.ui.views.properties.tabbed.TabbedPropertySheetPage;

/**
 * @generated
 */
public class MindmapDiagramEditor extends DiagramEditor {
	/**
	 * @generated
	 */
	public static final String ID = "org.eclipse.gmf.examples.mindmap.rcp.part.MindmapDiagramEditorID"; //$NON-NLS-1$

	/**
	 * @generated
	 */
	private Map diagramRoot;

	/**
	 * @generated
	 */
	private Diagram diagram;

	/**
	 * @generated
	 */
	public Map getDiagramRoot() {
		return diagramRoot;
	}

	/**
	 * @generated
	 */
	public Diagram getDiagram() {
		return diagram;
	}

	/**
	 * @generated
	 */
	private ComposedAdapterFactory domainAdapterFactory;

	/**
	 * @generated
	 */
	public AdapterFactory getDomainAdapterFactory() {
		if (domainAdapterFactory == null) {
			List factories = new ArrayList();
			factories.add(new ResourceItemProviderAdapterFactory());
			factories.add(new MindmapItemProviderAdapterFactory());
			factories.add(new ReflectiveItemProviderAdapterFactory());
			factories.add(new NotationItemProviderAdapterFactory());
			domainAdapterFactory = new ComposedAdapterFactory(factories);
		}
		return domainAdapterFactory;
	}

	/**
	 * @generated
	 */
	protected void createActions() {
		addStackAction(new UndoAction(this));
		addStackAction(new RedoAction(this));
		addEditPartAction(new DeleteAction((IWorkbenchPart) this));
		addEditPartAction(new DirectEditAction((IWorkbenchPart) this));
		addEditPartAction(new AlignmentAction((IWorkbenchPart) this,
				PositionConstants.LEFT));
		addEditPartAction(new AlignmentAction((IWorkbenchPart) this,
				PositionConstants.RIGHT));
		addEditPartAction(new AlignmentAction((IWorkbenchPart) this,
				PositionConstants.TOP));
		addEditPartAction(new AlignmentAction((IWorkbenchPart) this,
				PositionConstants.BOTTOM));
		addEditPartAction(new AlignmentAction((IWorkbenchPart) this,
				PositionConstants.CENTER));
		addEditPartAction(new AlignmentAction((IWorkbenchPart) this,
				PositionConstants.MIDDLE));
		addEditorAction(new SaveAction(this));
		addEditorAction(new PrintAction(this));
		addEditorAction(new LayoutDiagramAction(this));
		IAction zoomIn = new ZoomInAction(getZoomManager());
		IAction zoomOut = new ZoomOutAction(getZoomManager());
		addAction(zoomIn);
		addAction(zoomOut);
		getSite().getKeyBindingService().registerAction(zoomIn);
		getSite().getKeyBindingService().registerAction(zoomOut);
		KeyHandler keyHandler = getGraphicalViewer().getKeyHandler();
		keyHandler.put(KeyStroke.getPressed(SWT.DEL, 127, 0),
				getActionRegistry().getAction(ActionFactory.DELETE.getId()));
		keyHandler.put(KeyStroke.getPressed(SWT.F2, 0), getActionRegistry()
				.getAction(GEFActionConstants.DIRECT_EDIT));

		addAction(new ValidateAction(this));

	}

	/**
	 * @generated
	 */
	public void dispose() {
		TransactionalUpdateManager updateManager = (TransactionalUpdateManager) getGraphicalViewer()
				.getProperty(TransactionalUpdateManager.class.getName());
		if (updateManager != null) {
			updateManager.dispose();
		}
		// important: always call super implementation of dispose
		super.dispose();
	}

	/**
	 * @generated
	 */
	public void doSave(IProgressMonitor monitor) {
		try {
			save(monitor);
			getCommandStack().markSaveLocation();
		} catch (CoreException e) {
			ErrorDialog.openError(getSite().getShell(),
					Messages.MindmapDiagramEditor_errorSavingTitle,
					Messages.MindmapDiagramEditor_errorSavingMessage, e
							.getStatus());
		}
	}

	/**
	 * @generated
	 */
	public void configurePalette(PaletteRoot paletteRoot) {
		new MindmapPaletteFactory().contributeToPalette(paletteRoot);
	}

	/**
	 * @generated
	 */
	protected IPropertySheetPage getPropertySheetPage() {
		if (myPropertySheetPage == null) {
			myPropertySheetPage = new TabbedPropertySheetPage(
					new ITabbedPropertySheetPageContributor() {
						public String getContributorId() {
							return MindmapDiagramEditorPlugin.ID;
						}
					});
		}
		return myPropertySheetPage;
	}

	/**
	 * @generated
	 */
	private IPropertySheetPage myPropertySheetPage;

	/**
	 * @generated
	 */
	public void init(IEditorSite site, IEditorInput input)
			throws PartInitException {
		URI file = getURIFromInput(input);
		if (file == null) {
			throw new PartInitException(
					Messages.MindmapDiagramEditor_InvalidInputMsg);
		}
		super.init(site, input);
		// validate
		if (getDiagramRoot() == null) {
			throw new PartInitException(
					Messages.MindmapDiagramEditor_InvalidInputMsg);
		}
	}

	/**
	 * @generated
	 */
	protected void setInput(IEditorInput input) {
		URI file = getURIFromInput(input);
		load(file);
		setPartName(input.getName());
		super.setInput(input);
	}

	/**
	 * @generated
	 */
	private URI getURIFromInput(IEditorInput input) {
		if (input == null) {
			return null;
		}
		if (input instanceof URIEditorInput) {
			return ((URIEditorInput) input).getURI();
		}
		if (input instanceof IPathEditorInput) {
			return URI.createFileURI(((IPathEditorInput) input).getPath()
					.toOSString());
		}
		URI uri = (URI) input.getAdapter(URI.class);
		if (uri != null) {
			return uri;
		}
		return null;
	}

	/**
	 * @generated
	 */
	private void load(URI diagramFile) {
		diagramRoot = null;
		diagram = null;
		if (diagramFile == null) {
			return;
		}
		final URI diagramFileURI = diagramFile;
		TransactionalEditingDomain editingDomain = getEditingDomain();
		final ResourceSet resourceSet = editingDomain.getResourceSet();
		final Resource diagramResource = resourceSet.getResource(diagramFile
				.trimFragment(), true);
		if (diagramResource == null) {
			return;
		}
		AbstractEMFOperation operation = new AbstractEMFOperation(
				editingDomain, Messages.MindmapDiagramEditor_LoadDiagram, null) {
			protected IStatus doExecute(IProgressMonitor monitor,
					IAdaptable info) throws ExecutionException {
				if (diagramFileURI.fragment() != null) {
					EObject possibleDiagram = diagramResource
							.getEObject(diagramFileURI.fragment());
					if (possibleDiagram instanceof Diagram) {
						diagram = (Diagram) possibleDiagram;
					} else {
						return Status.CANCEL_STATUS;
					}
				} else {
					diagram = (Diagram) findInResource(diagramResource,
							Diagram.class);
					if (diagram == null) {
						diagram = NotationFactory.eINSTANCE.createDiagram();
						diagramResource.getContents().add(0, diagram);
						//Auxiliary creation should not be undoable.
						try {
							diagramResource.save(getSaveOptions());
						} catch (IOException e) {
							diagram = null;
							diagramRoot = null;
							return Status.CANCEL_STATUS;
						}
					}
				}
				diagramRoot = (Map) diagram.getElement();
				if (diagramRoot == null) {
					diagramRoot = (Map) findInResource(diagramResource,
							Map.class);
					if (diagramRoot == null) {
						diagramRoot = MindmapFactory.eINSTANCE.createMap();
						diagramResource.getContents().add(0, diagramRoot);
						//We don't want this auxiliary creation to be undoable.
						try {
							diagramResource.save(getSaveOptions());
						} catch (IOException e) {
							diagram = null;
							diagramRoot = null;
							return Status.CANCEL_STATUS;
						}
					}
					if (!diagramRoot.equals(diagram.getElement())) {
						diagram.setElement(diagramRoot);
					}
				}
				if (!diagram.eIsSet(NotationPackage.eINSTANCE.getView_Type())) {
					MapViewFactory.INSTANCE.decorateView(diagram);
					doSave(new NullProgressMonitor());
				}
				return Status.OK_STATUS;
			}
		};
		try {
			operation.execute(new NullProgressMonitor(), null);
		} catch (ExecutionException e) {
			diagram = null;
			diagramRoot = null;
		}
	}

	/**
	 * @generated
	 */
	private Object findInResource(Resource resource, Class expectedClass) {
		for (Iterator it = resource.getContents().iterator(); it.hasNext();) {
			Object next = it.next();
			if (expectedClass.isInstance(next)) {
				return next;
			}
		}
		return null;
	}

	/**
	 * @generated
	 */
	public void initializeGraphicalViewer() {
		// initialize the viewer with input
		ScalableFreeformRootEditPart root = new ScalableFreeformRootEditPart();
		root.getZoomManager().setZoomLevels(getZoomLevels());
		root.getZoomManager().setZoomLevelContributions(
				Arrays.asList(new String[] { ZoomManager.FIT_WIDTH,
						ZoomManager.FIT_HEIGHT }));
		getGraphicalViewer().setRootEditPart(root);
		getGraphicalViewer().setEditPartFactory(new MindmapEditPartFactory());
		TransactionalUpdateManager updateManager = new TransactionalUpdateManager(
				getGraphicalViewer());
		getGraphicalViewer().setProperty(
				TransactionalUpdateManager.class.getName(), updateManager);

		LayeredPane printableLayers = (LayeredPane) root
				.getLayer(LayerConstants.PRINTABLE_LAYERS);
		FreeformLayer extLabelsLayer = new FreeformLayer();
		extLabelsLayer.setLayoutManager(new DelegatingLayout());
		printableLayers.addLayerAfter(extLabelsLayer,
				MindmapEditPartFactory.EXTERNAL_NODE_LABELS_LAYER,
				LayerConstants.PRIMARY_LAYER);
		getGraphicalViewer().setContents(getDiagram());
		Command updateCommand = updateManager
				.buildRefreshNotationModelCommand();
		if (updateCommand != null && updateCommand.canExecute()) {
			getCommandStack().execute(
					new WrappingCommand(getEditingDomain(), updateCommand));
		}
	}

	/**
	 * @generated
	 */
	public void configureGraphicalViewer() {
		super.configureGraphicalViewer();
		GraphicalViewer viewer = getGraphicalViewer();
		// configure the context menu
		ContextMenuProvider provider = new MindmapDiagramEditorContextMenuProvider(
				viewer);
		viewer.setContextMenu(provider);
		getSite()
				.registerContextMenu(
						MindmapDiagramEditorPlugin.ID + ".editor.contextmenu", provider, getSite().getSelectionProvider()); //$NON-NLS-1$

		KeyHandler keyHandler = new GraphicalViewerKeyHandler(viewer);
		viewer.setKeyHandler(keyHandler);

		viewer.setProperty(MouseWheelHandler.KeyGenerator.getKey(SWT.CTRL),
				MouseWheelZoomHandler.SINGLETON);
	}

	/**
	 * @generated
	 */
	public boolean isFlyoutPalette() {
		return true;
	}

	/**
	 * @generated
	 */
	protected java.util.Map getSaveOptions() {
		return MindmapDiagramEditorUtil.getSaveOptions();
	}

	/**
	 * @generated
	 */
	private class MindmapDiagramEditorContextMenuProvider extends
			ContextMenuProvider {
		/**
		 * @generated
		 */
		public MindmapDiagramEditorContextMenuProvider(EditPartViewer viewer) {
			super(viewer);
		}

		/**
		 * @generated
		 */
		public void buildContextMenu(IMenuManager menuManager) {
			GEFActionConstants.addStandardActionGroups(menuManager);
			appendActionToMenu(menuManager, ActionFactory.UNDO.getId(),
					GEFActionConstants.GROUP_UNDO);
			appendActionToMenu(menuManager, ActionFactory.REDO.getId(),
					GEFActionConstants.GROUP_UNDO);
			appendActionToMenu(menuManager, ActionFactory.COPY.getId(),
					GEFActionConstants.GROUP_EDIT);
			appendActionToMenu(menuManager, ActionFactory.PASTE.getId(),
					GEFActionConstants.GROUP_EDIT);
			appendActionToMenu(menuManager, ActionFactory.DELETE.getId(),
					GEFActionConstants.GROUP_EDIT);
			appendActionToMenu(menuManager, GEFActionConstants.DIRECT_EDIT,
					GEFActionConstants.GROUP_EDIT);
			appendAlignmentSubmenu(menuManager);
			appendActionToMenu(menuManager, ActionFactory.SAVE.getId(),
					GEFActionConstants.GROUP_SAVE);
			appendActionToMenu(menuManager, ActionIds.LAYOUT_ALL_ACTION,
					GEFActionConstants.GROUP_REST);
			appendActionToMenu(menuManager, ValidateAction.VALIDATE_ACTION_KEY,
					GEFActionConstants.GROUP_REST);

		}

		/**
		 * @generated
		 */
		private void appendAlignmentSubmenu(IMenuManager menuManager) {
			// Alignment Actions
			MenuManager submenu = new MenuManager(
					Messages.MindmapDiagramEditor_Align);
			submenu.add(new Separator(GEFActionConstants.MB_ADDITIONS));

			appendActionToMenu(submenu, GEFActionConstants.ALIGN_LEFT,
					GEFActionConstants.MB_ADDITIONS);
			appendActionToMenu(submenu, GEFActionConstants.ALIGN_CENTER,
					GEFActionConstants.MB_ADDITIONS);
			appendActionToMenu(submenu, GEFActionConstants.ALIGN_RIGHT,
					GEFActionConstants.MB_ADDITIONS);
			appendActionToMenu(submenu, GEFActionConstants.ALIGN_TOP,
					GEFActionConstants.MB_ADDITIONS);
			appendActionToMenu(submenu, GEFActionConstants.ALIGN_MIDDLE,
					GEFActionConstants.MB_ADDITIONS);
			appendActionToMenu(submenu, GEFActionConstants.ALIGN_BOTTOM,
					GEFActionConstants.MB_ADDITIONS);

			if (!submenu.isEmpty()) {
				menuManager.appendToGroup(GEFActionConstants.GROUP_REST,
						submenu);
			}
		}

		/**
		 * @generated
		 */
		private void appendActionToMenu(IMenuManager menu, String actionId,
				String menuGroup) {
			IAction action = getActionRegistry().getAction(actionId);
			if (action != null && action.isEnabled()) {
				menu.appendToGroup(menuGroup, action);
			}
		}
	}
}