/*******************************************************************************
 * Copyright (c) 2004, 2005 Sybase, Inc. 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:
 *     Sybase, Inc. - initial API and implementation
 *******************************************************************************/

package org.eclipse.jst.jsf.facesconfig.ui.pageflow;

import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.LightweightSystem;
import org.eclipse.draw2d.MarginBorder;
import org.eclipse.draw2d.Viewport;
import org.eclipse.draw2d.parts.ScrollableThumbnail;
import org.eclipse.gef.ContextMenuProvider;
import org.eclipse.gef.EditDomain;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.EditPartListener;
import org.eclipse.gef.EditPartViewer;
import org.eclipse.gef.LayerConstants;
import org.eclipse.gef.RootEditPart;
import org.eclipse.gef.editparts.ScalableFreeformRootEditPart;
import org.eclipse.gef.editparts.ScalableRootEditPart;
import org.eclipse.gef.ui.parts.TreeViewer;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jst.jsf.facesconfig.ui.EditorPlugin;
import org.eclipse.jst.jsf.facesconfig.ui.pageflow.editpart.PageflowTreePartFactory;
import org.eclipse.jst.jsf.facesconfig.ui.pageflow.model.PageflowElement;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.ui.part.EditorPart;
import org.eclipse.ui.part.Page;
import org.eclipse.ui.part.PageBook;
import org.eclipse.ui.views.contentoutline.IContentOutlinePage;

/**
 * This is an implementation of an outline page showing an overview figure and
 * an tree outline of the main graphical viewer provided by the current active
 * page of an multi page editor.
 * 
 */
public class PageflowEditorOutlinePage extends Page implements
		IContentOutlinePage {
	/** the pageflow editor */
	private final PageflowEditor editor;

	/** the outlineContent for the tree viewer */
	private PageflowElement outlineContent = null;

	/** the control of the overview */
	private Canvas overview = null;

	/** the root edit part (outlineContent for the thumbnail) */
	private RootEditPart overviewContent = null;

	/** the thumbnail */
	private ScrollableThumbnail thumbnail = null;

	/** the tree viewer */
	private TreeViewer treeViewer = null;

	/** the control of the tree view */
	private Control outline = null;

	/** the pagebook */
	private PageBook pageBook = null;

	/** action for showing the tree page */
	private IAction showOutlineAction = null;

	/** action for showing the overview page */
	private IAction showOverviewAction = null;

	/** the LightweightSystem */
	private LightweightSystem lws = null;

	/** the edit domain */
	private EditDomain editDomain = null;

	/**
	 * Creates a new PageflowEditorOutlinePage instance.
	 * 
	 * @param editor -
	 *            Pageflow Editor
	 */
	public PageflowEditorOutlinePage(EditorPart editor) {
		super();
		this.editor = (PageflowEditor) editor;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see ISelectionProvider#addSelectionChangedListener(ISelectionChangedListener)
	 */
	public void addSelectionChangedListener(ISelectionChangedListener listener) {
		getTreeViewer().addSelectionChangedListener(listener);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see IPage#createControl(Composite)
	 */
	public void createControl(Composite parent) {
		// pagebook
		pageBook = new PageBook(parent, SWT.NONE);

		// tree viewer control
		outline = getTreeViewer().createControl(pageBook);
		configureEditPartViewer(getTreeViewer());

		// overview canvas
		overview = new Canvas(pageBook, SWT.NONE);
		lws = new LightweightSystem(overview);

		// create actions
		IToolBarManager tbm = getSite().getActionBars().getToolBarManager();
		showOutlineAction = new Action() {
			public void run() {
				showPage(outline);
			}
		};
		showOutlineAction.setImageDescriptor(EditorPlugin.getDefault()
				.getImageDescriptor("facesconfig/Pageflow_Outline.gif")); //$NON-NLS-1$
		tbm.add(showOutlineAction);
		showOverviewAction = new Action() {
			public void run() {
				showPage(overview);
			}
		};
		showOverviewAction.setImageDescriptor(EditorPlugin.getDefault()
				.getImageDescriptor("facesconfig/Pageflow_Outline_Overview.gif")); //$NON-NLS-1$
		tbm.add(showOverviewAction);

		// initialize outline page
		initializeOutlineViewer();

		// initialize overview
		initializeOverview();

		// initialize pagebook
		showPage(outline);
	}

	/**
	 * Configures the outline viewer
	 */
	private void initializeOutlineViewer() {
		if (null != getEditDomain()) {
			getEditDomain().addViewer(getTreeViewer());
		}
		// getTreeViewer().setEditPartFactory(new PageflowTreePartFactory());

		// synchronize selections
		editor.getSelectionSynchronizer().addViewer(getTreeViewer());

		// add content
		getTreeViewer().setContents(getOutlineContent());
	}

	/**
	 * Shows the spcified page.
	 * 
	 * @param id -
	 *            control id of pagebook in outline page. it is can be _outline
	 *            or _overview
	 */
	protected void showPage(Control id) {
		if (id == outline) {
			showOutlineAction.setChecked(true);
			showOverviewAction.setChecked(false);
			pageBook.showPage(outline);
			if (thumbnail != null) {
				thumbnail.setVisible(false);
			}
		} else if (id == overview) {
			showOutlineAction.setChecked(false);
			showOverviewAction.setChecked(true);
			pageBook.showPage(overview);
			if (thumbnail != null) {
				thumbnail.setVisible(true);
			}
		}
	}

	/**
	 * Returns the current edit domain.
	 * 
	 * @return - the edit domain
	 */
	public EditDomain getEditDomain() {
		return editDomain;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see IPage#dispose()
	 */
	public void dispose() {
		editor.getSelectionSynchronizer().removeViewer(getTreeViewer());

		if (null != thumbnail) {
			thumbnail.deactivate();
		}

		super.dispose();
	}

	/**
	 * initialize Overview.
	 * 
	 */
	private void initializeOverview() {
		// check if control was created
		if (null == lws) {
			return;
		}

		// deactivate old thumbnail
		if (null != thumbnail) {
			thumbnail.deactivate();
		}

		// create empty thumbnail
		thumbnail = new ScrollableThumbnail();
		thumbnail.setBorder(new MarginBorder(3));
		lws.setContents(thumbnail);

		// initialize thumbnail
		if (null != getOverviewContent()) {
			Viewport viewport = null;
			IFigure source = null;
			if (getOverviewContent() instanceof ScalableFreeformRootEditPart) {
				viewport = (Viewport) ((ScalableFreeformRootEditPart) getOverviewContent())
						.getFigure();
				source = ((ScalableFreeformRootEditPart) getOverviewContent())
						.getLayer(LayerConstants.PRINTABLE_LAYERS);
			}
			if (getOverviewContent() instanceof ScalableRootEditPart) {
				viewport = (Viewport) ((ScalableRootEditPart) getOverviewContent())
						.getFigure();
				source = ((ScalableRootEditPart) getOverviewContent())
						.getLayer(LayerConstants.PRINTABLE_LAYERS);
			}

			if (null != viewport && null != source) {
				thumbnail.setViewport(viewport);
				thumbnail.setSource(source);
			}
		}
	}

	/**
	 * Returns the outlineContent.
	 * 
	 * @return - the outlineContent
	 */
	public PageflowElement getOutlineContent() {
		return outlineContent;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see IPage#getControl()
	 */
	public Control getControl() {
		return pageBook;
	}

	/**
	 * Returns the root edit part
	 * 
	 * @return - the root edit part
	 */
	public RootEditPart getOverviewContent() {
		return overviewContent;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see ISelectionProvider#getSelection()
	 */
	public ISelection getSelection() {
		return getTreeViewer().getSelection();
	}

	/**
	 * Returns the tree viewer.
	 * 
	 * @return - the tree viewer
	 */
	public TreeViewer getTreeViewer() {
		if (null == treeViewer) {
			treeViewer = new TreeViewer();
			treeViewer.setEditPartFactory(new PageflowTreePartFactory());
		}

		return treeViewer;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see ISelectionProvider#removeSelectionChangedListener(ISelectionChangedListener)
	 */
	public void removeSelectionChangedListener(
			ISelectionChangedListener listener) {
		getTreeViewer().removeSelectionChangedListener(listener);
	}

	/**
	 * Sets the outlineContent.
	 * 
	 * @param element -
	 *            Pageflow Element
	 */
	public void setOutlineContent(PageflowElement element) {
		if (outlineContent != element) {
			outlineContent = element;

			// refresh viewer
			if (null != getTreeViewer().getControl()) {
				getTreeViewer().setContents(element);

				// bugfix: something is overwriting visibility
				if (null != pageBook) {
					if (showOverviewAction.isChecked()) {
						showPage(outline);
						showPage(overview);
					} else {
						showPage(outline);
					}
				}
			}
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see IPage#setFocus()
	 */
	public void setFocus() {
		if (getControl() != null) {
			getControl().setFocus();
		}
	}

	/**
	 * Sets the root edit part.
	 * 
	 * @param part -
	 *            root edit part for pageflow model
	 */
	public void setOverviewContent(RootEditPart part) {
		if (overviewContent != part) {
			overviewContent = part;
			// reinitialize thumbnail
			// if (null != thumbnail && thumbnail.isVisible())
			initializeOverview();
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see ISelectionProvider#setSelection(ISelection)
	 */
	public void setSelection(ISelection selection) {
		getTreeViewer().setSelection(selection);
	}

	/**
	 * Initializes this outline page from a given editor page.
	 * 
	 * @param newPage -
	 *            Pageflow EditorPage
	 */
	public void initialize(PageflowEditor newPage) {
		if (null != newPage.getGraphicalViewer()) {
			setOverviewContent(newPage.getGraphicalViewer().getRootEditPart());
			EditPart currentContent = newPage.getGraphicalViewer()
					.getContents();
			setOutlineContent(null != currentContent ? (PageflowElement) currentContent
					.getModel()
					: null);
			setEditDomain(newPage.getEditDomain());
			getViewerContentListener().setViewer(newPage.getGraphicalViewer());
		} else {
			setOverviewContent(null);
			setOutlineContent(null);
			setEditDomain(null);
		}
	}

	/**
	 * Sets the edit domain.
	 * 
	 * @param domain -
	 *            editor's edit domain
	 */
	public void setEditDomain(EditDomain domain) {
		if (editDomain != domain) {
			// refresh viewer
			if (null != getTreeViewer()) {
				if (null != editDomain) {
					editDomain.removeViewer(getTreeViewer());
				}
				if (null != domain) {
					domain.addViewer(getTreeViewer());
				}
			}
			editDomain = domain;
		}
	}

	/**
	 * the current viewer content listener
	 */
	private final ViewerContentListener viewerContentListener = new ViewerContentListener();

	/**
	 * This class listens for changes of the content of an EditPartViewer. If
	 * the content changed, it will update the outline viewer.
	 * <p>
	 * Important: this class has to be disposed with
	 * <code>setViewer(null)</code>.
	 * 
	 * @author Gunnar Wagenknecht
	 */
	private class ViewerContentListener implements EditPartListener {
		/* the viewer */
		private EditPartViewer _viewer;

		/**
		 * Sets a new viewer. <code>null</code> is allowed to dispose.
		 * 
		 * @param viewer
		 */
		public void setViewer(EditPartViewer viewer) {
			if (null != this._viewer)
				this._viewer.getRootEditPart().removeEditPartListener(this);

			this._viewer = viewer;

			if (null != this._viewer)
				this._viewer.getRootEditPart().addEditPartListener(this);
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.gef.EditPartListener#childAdded(org.eclipse.gef.EditPart,
		 *      int)
		 */
		public void childAdded(EditPart child, int index) {
			// this is out event, update the viewers
			if (child.getModel() instanceof PageflowElement)
				setOutlineContent((PageflowElement) child.getModel());
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.gef.EditPartListener#partActivated(org.eclipse.gef.EditPart)
		 */
		public void partActivated(EditPart editpart) {
            // do nothing
		}

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.gef.EditPartListener#partDeactivated(org.eclipse.gef.EditPart)
		 */
		public void partDeactivated(EditPart editpart) {
            // do nothing
        }

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.gef.EditPartListener#removingChild(org.eclipse.gef.EditPart,
		 *      int)
		 */
		public void removingChild(EditPart child, int index) {
            // do nothing
        }

		/*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.gef.EditPartListener#selectedStateChanged(org.eclipse.gef.EditPart)
		 */
		public void selectedStateChanged(EditPart editpart) {
            // do nothing
		}
	}

	/**
	 * Returns the viewer content listener.
	 * 
	 * @return the viewer content listener
	 */
	private ViewerContentListener getViewerContentListener() {
		return viewerContentListener;
	}

	/**
	 * Configures the specified <code>EditPartViewer</code>.
	 * 
	 * @param viewer
	 */
	protected void configureEditPartViewer(EditPartViewer viewer) {
		// configure the shared key handler
		if (viewer.getKeyHandler() != null) {
			viewer.getKeyHandler().setParent(editor.getSharedKeyHandler());
		}

		// configure the context menu
		ContextMenuProvider provider = new PageflowEditorContextMenuProvider(
				viewer, editor.getActionRegistry());
		viewer.setContextMenu(provider);
		getSite().registerContextMenu(
				EditorPlugin.getPluginId()
						+ ".pageflow.editor.outlineview.contextmenu", provider, //$NON-NLS-1$
				getSite().getSelectionProvider());
	}

}