/*******************************************************************************
 * <copyright>
 *
 * Copyright (c) 2011, 2011 SAP AG.
 * 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:
 *    Bug 336488 - DiagramEditor API
 *    pjpaulin - Bug 352120 - Now uses IDiagramContainerUI interface
 *
 * </copyright>
 *
 *******************************************************************************/
package org.eclipse.graphiti.ui.editor;

import org.eclipse.gef.KeyHandler;
import org.eclipse.gef.Tool;
import org.eclipse.gef.dnd.TemplateTransferDragSourceListener;
import org.eclipse.gef.palette.PaletteRoot;
import org.eclipse.gef.tools.ConnectionCreationTool;
import org.eclipse.gef.tools.CreationTool;
import org.eclipse.gef.ui.palette.DefaultPaletteViewerPreferences;
import org.eclipse.gef.ui.palette.FlyoutPaletteComposite;
import org.eclipse.gef.ui.palette.FlyoutPaletteComposite.FlyoutPreferences;
import org.eclipse.gef.ui.palette.PaletteViewer;
import org.eclipse.gef.ui.palette.PaletteViewerPreferences;
import org.eclipse.gef.ui.palette.PaletteViewerProvider;
import org.eclipse.gef.ui.parts.GraphicalEditorWithFlyoutPalette;
import org.eclipse.graphiti.ui.internal.GraphitiUIPlugin;
import org.eclipse.graphiti.ui.internal.editor.GFPaletteRoot;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.KeyEvent;

/**
 * This class can be subclassed by clients to adapt the palette appearance and
 * behavior of the Graphiti diagram Editor. The API is very much aligned with
 * the way GEF handles the palette within its editors, see
 * {@link GraphicalEditorWithFlyoutPalette} for more information on that. To
 * exchange the default implementation you have to return an instance of your
 * subclass in the method {@link DiagramBehavior#createPaletteBehaviour()}.<br>
 * Note that there is always a 1:1 relation with a {@link DiagramBehavior}.
 * 
 * @since 0.9
 */
public class DefaultPaletteBehavior {

	/**
	 * Property name for storing the location (east, west) of the palette within
	 * the editor in an Eclipse preference store.
	 */
	protected static final String PROPERTY_PALETTE_DOCK_LOCATION = "Dock location"; //$NON-NLS-1$

	/**
	 * Property name for storing the size of the palette within the editor in an
	 * Eclipse preference store.
	 */
	protected static final String PROPERTY_PALETTE_SIZE = "Palette Size"; //$NON-NLS-1$

	/**
	 * Property name for storing the state (collapsed, expanded, hidden) of the
	 * palette within the editor in an Eclipse preference store.
	 */
	protected static final String PROPERTY_PALETTE_STATE = "Palette state"; //$NON-NLS-1$

	/**
	 * The initial size of the palette.
	 */
	protected static final int DEFAULT_PALETTE_SIZE = 130;

	/**
	 * The associated {@link DiagramBehavior}
	 * 
	 * @since 0.10
	 */
	protected final DiagramBehavior diagramBehavior;

	private PaletteRoot paletteRoot;

	/**
	 * Creates a new standard palette behaviour for a Graphiti diagram editor.
	 * The passed {@link DiagramBehavior} is closely linked to this instance (1:1
	 * relation) and both instances will have a common lifecycle.
	 * 
	 * @param diagramEditor
	 *            The associated {@link DiagramBehavior}.
	 * @since 0.10
	 */
	public DefaultPaletteBehavior(DiagramBehavior diagramBehavior) {
		super();
		this.diagramBehavior = diagramBehavior;
	}

	/**
	 * Creates the {@link PaletteRoot} of this editor. To retrieve the
	 * {@link PaletteRoot} object use {@link #getPaletteRoot()} instead which
	 * will return an already existing instance or create a new one by
	 * delegating to this method.
	 * 
	 * @return a new Graphiti specific {@link PaletteRoot} instance
	 * @see org.eclipse.graphiti.ui.editor.GraphicalEditorIncludingPalette#getPaletteRoot()
	 */
	protected PaletteRoot createPaletteRoot() {
		return new GFPaletteRoot(diagramBehavior.getDiagramTypeProvider());
	}

	/**
	 * Returns the already existing {@link PaletteRoot} instance for the
	 * {@link DiagramBehavior} associated the this palette behavior or creates a
	 * new {@link PaletteRoot} instance in case none exists.
	 * 
	 * @return a new Graphiti specific {@link PaletteRoot} instance
	 */
	public PaletteRoot getPaletteRoot() {
		if (paletteRoot == null) {
			paletteRoot = createPaletteRoot();
		}
		return paletteRoot;
	}

	/**
	 * Initializes the used GEF palette viewer to display the palette as
	 * defined. The default implementation initializes the preference store with
	 * the GEF {@link DefaultPaletteViewerPreferences} and triggers a refresh of
	 * the palette.
	 */
	public void initializeViewer() {
		// Set preference-store for palette
		PaletteViewer paletteViewer = diagramBehavior.getEditDomain().getPaletteViewer();
		if (paletteViewer != null) {
			IPreferenceStore store = GraphitiUIPlugin.getDefault().getPreferenceStore();
			paletteViewer.setPaletteViewerPreferences(new DefaultPaletteViewerPreferences(store));

			// Refresh the PaletteViewer
			// This can be achieved by firing a font-change-event from the
			// IPreferenceStore. It would be nicer, if the PaletteViewer would
			// have some kind of refresh()-method directly.
			store.firePropertyChangeEvent(PaletteViewerPreferences.PREFERENCE_FONT, null, null);
		}
	}

	/**
	 * Returns the Graphiti specific preferences for the palette. This method
	 * will be called by the GEF {@link GraphicalEditorWithFlyoutPalette} during
	 * initialization.
	 * 
	 * @return a Graphiti specific instanceof {@link FlyoutPreferences}.
	 */
	public FlyoutPreferences getPalettePreferences() {
		return new FlyoutPreferences() {
			public int getDockLocation() {
				return getPreferenceStore().getInt(PROPERTY_PALETTE_DOCK_LOCATION);
			}

			public int getPaletteState() {
				// TODO ? Move isShowFlyoutPalette from TBP to
				// DefaultPaletteBehaviour?
				if (!diagramBehavior.getDiagramTypeProvider().getCurrentToolBehaviorProvider().isShowFlyoutPalette()) {
					return 8; // FlyoutPaletteComposite.STATE_HIDDEN is private
				}
				return getPreferenceStore().getInt(PROPERTY_PALETTE_STATE);
			}

			public int getPaletteWidth() {
				return getPreferenceStore().getInt(PROPERTY_PALETTE_SIZE);
			}

			public void setDockLocation(int location) {
				getPreferenceStore().setValue(PROPERTY_PALETTE_DOCK_LOCATION, location);
			}

			public void setPaletteState(int state) {
				getPreferenceStore().setValue(PROPERTY_PALETTE_STATE, state);
			}

			public void setPaletteWidth(int width) {
				getPreferenceStore().setValue(PROPERTY_PALETTE_SIZE, width);
			}
		};
	}

	/**
	 * Returns the PaletteViewerProvider, which can be used to create a new
	 * PaletteViewer. This method can be overwritten to return a subclass of the
	 * PaletteViewerProvider, which configures the PaletteViewer with a
	 * different ContextMenu, with a PaletteCustomizer or with a different
	 * IPreferencesStore. Do not call this method directly, instead call
	 * getPaletteViewerProvider(), which buffers the created object.
	 * <p>
	 * By default this method returns a new PaletteViewerProvider.
	 * 
	 * @return The PaletteViewerProvider, which can be used to create a new
	 *         PaletteViewer.
	 */
	protected PaletteViewerProvider createPaletteViewerProvider() {
		return new PaletteViewerProvider(diagramBehavior.getEditDomain()) {
			private KeyHandler paletteKeyHandler = null;

			protected void configurePaletteViewer(PaletteViewer viewer) {
				super.configurePaletteViewer(viewer);
				viewer.getKeyHandler().setParent(getPaletteKeyHandler());
				viewer.addDragSourceListener(new TemplateTransferDragSourceListener(viewer));
			}

			/**
			 * @return Palette Key Handler for the palette
			 */
			private KeyHandler getPaletteKeyHandler() {
				if (paletteKeyHandler == null) {
					paletteKeyHandler = new KeyHandler() {
						/**
						 * Processes a <i>key released </i> event. This method
						 * is called by the Tool whenever a key is released, and
						 * the Tool is in the proper state. Overridden to
						 * support pressing the enter key to create a shape or
						 * connection (between two selected shapes)
						 * 
						 * @param event
						 *            the KeyEvent
						 * @return <code>true</code> if KeyEvent was handled in
						 *         some way
						 */
						public boolean keyReleased(KeyEvent event) {
							if (event.keyCode == SWT.Selection) {
								Tool tool = getEditDomain().getPaletteViewer().getActiveTool().createTool();
								if (tool instanceof CreationTool || tool instanceof ConnectionCreationTool) {
									tool.keyUp(event, diagramBehavior.getDiagramContainer().getGraphicalViewer());
									// Deactivate current selection
									getEditDomain().getPaletteViewer().setActiveTool(null);
									return true;
								}
							}
							return super.keyReleased(event);
						}
					};
				}
				return paletteKeyHandler;
			}
		};
	}

	/**
	 * Refreshes the palette.
	 */
	public void refreshPalette() {
		PaletteRoot pr = getPaletteRoot();
		if (pr instanceof GFPaletteRoot) {
			GFPaletteRoot gpr = (GFPaletteRoot) pr;
			gpr.updatePaletteEntries();
		}
	}

	/**
	 * Disposes this instance. Must be called before closing the associated
	 * Graphiti diagram editor. The default implementation clears the
	 * {@link #paletteRoot} reference.
	 */
	public void dispose() {
		paletteRoot = null;
	}

	private IPreferenceStore getPreferenceStore() {
		IPreferenceStore ps = GraphitiUIPlugin.getDefault().getPreferenceStore();
		ps.setDefault(DefaultPaletteBehavior.PROPERTY_PALETTE_STATE, FlyoutPaletteComposite.STATE_PINNED_OPEN);
		ps.setDefault(DefaultPaletteBehavior.PROPERTY_PALETTE_SIZE, DEFAULT_PALETTE_SIZE);
		return ps;
	}
}