~berthold-daum/zora/trunk

/*
 * This file is part of the ZoRa project: http://www.photozora.org.
 *
 * ZoRa is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * ZoRa is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with ZoRa; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * (c) 2009 Berthold Daum  (berthold.daum@bdaum.de)
 */

package com.bdaum.zoom.ui.internal.hover;

import java.util.Arrays;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.ControlListener;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.events.MouseTrackAdapter;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.ToolTip;

import com.bdaum.zoom.batch.internal.Daemon;
import com.bdaum.zoom.cat.model.asset.Region;
import com.bdaum.zoom.ui.internal.UiActivator;
import com.bdaum.zoom.ui.internal.views.IHoverSubject;

/**
 * A text hovering controller. The controller registers with the text widget's
 * control as a <code>MouseTrackListener<code>. When
 * receiving a mouse hover event, it opens a popup window using the
 * appropriate <code>IGalleryHover</code> to initialize the window's display
 * information. The controller closes the window if the mouse pointer leaves the
 * area for which the display information has been computed.
 * <p>
 */
@SuppressWarnings("restriction")
public class HoveringController extends MouseTrackAdapter {

	private static final int MINDURATION = 1000;
	private static final int ADDITIONALHOVERTIMEPERCHARACTER = 25;

	/**
	 * The window closer.
	 */
	class WindowCloser extends MouseTrackAdapter implements MouseListener,
			MouseMoveListener, ControlListener, KeyListener, FocusListener {

		Object fCoveredObject;
		String[] fCoveredRegions;

		/**
		 * Creates a new window closer for the given area.
		 */
		public WindowCloser(Object coveredObject, Region[] coveredRegions) {
			fCoveredObject = coveredObject;
			if (coveredRegions != null) {
				fCoveredRegions = new String[coveredRegions.length];
				for (int i = 0; i < coveredRegions.length; i++)
					fCoveredRegions[i] = coveredRegions[i].getStringId();
			} else
				fCoveredRegions = null;
		}

		/**
		 * Starts watching whether the popup window must be closed.
		 */
		public void start() {
			final Control control = viewer.getControl();
			control.addMouseListener(this);
			control.addMouseMoveListener(this);
			control.addMouseTrackListener(this);
			control.addControlListener(this);
			control.addKeyListener(this);
			control.addFocusListener(this);
			toolTip.setVisible(true);
			if (MINDURATION > 0) {
				final int msecs = MINDURATION
						+ (toolTip.getMessage().length() + toolTip.getText()
								.length()) * ADDITIONALHOVERTIMEPERCHARACTER;
				new Daemon(Messages.HoveringController_hover_control, -1L) {
					@Override
					protected void doRun(IProgressMonitor monitor) {
						if (!control.isDisposed())
							control.getDisplay().asyncExec(new Runnable() {
								public void run() {
									if (!control.isDisposed())
										stop();
								}
							});

					}
				}.schedule(msecs);
			}
		}

		/**
		 * Closes the popup window and stops watching.
		 */
		void stop() {
			Control control = viewer.getControl();
			control.removeMouseListener(this);
			control.removeMouseMoveListener(this);
			control.removeMouseTrackListener(this);
			control.removeControlListener(this);
			control.removeKeyListener(this);
			control.removeFocusListener(this);
			install();
			toolTip.setVisible(false);
		}

		/*
		 * @see MouseMoveListener#mouseMove
		 */

		public void mouseMove(MouseEvent event) {
			Object foundItem = viewer.findObject(event.x, event.y);
			String[] foundRegions = viewer.findRegions(event.x, event.y);
			if (foundItem != fCoveredObject
					|| !Arrays.equals(foundRegions, fCoveredRegions)) {
				stop();
			}
		}

		/*
		 * @see MouseListener#mouseUp(MouseEvent)
		 */

		public void mouseUp(MouseEvent event) {
			// do nothing
		}

		/*
		 * @see MouseListener#mouseDown(MouseEvent)
		 */

		public void mouseDown(MouseEvent event) {
			stop();
		}

		/*
		 * @see MouseListener#mouseDoubleClick(MouseEvent)
		 */

		public void mouseDoubleClick(MouseEvent event) {
			stop();
		}

		/*
		 * @see MouseTrackAdapter#mouseExit(MouseEvent)
		 */

		@Override
		public void mouseExit(MouseEvent event) {
			stop();
		}

		/*
		 * @see ControlListener#controlResized(ControlEvent)
		 */

		public void controlResized(ControlEvent event) {
			stop();
		}

		/*
		 * @see ControlListener#controlMoved(ControlEvent)
		 */

		public void controlMoved(ControlEvent event) {
			stop();
		}

		/*
		 * @see KeyListener#keyReleased(KeyEvent)
		 */

		public void keyReleased(KeyEvent event) {
			// do nothing
		}

		/*
		 * @see KeyListener#keyPressed(KeyEvent)
		 */

		public void keyPressed(KeyEvent event) {
			stop();
		}

		/*
		 * @see FocusListener#focusLost(FocusEvent)
		 */

		public void focusLost(FocusEvent event) {
			if (viewer.getControl() == event.widget) {
				event.display.asyncExec(new Runnable() {

					public void run() {
						stop();
					}
				});
			}
		}

		/*
		 * @see FocusListener#focusGained(FocusEvent)
		 */

		public void focusGained(FocusEvent event) {
			// do nothing
		}
	}

	/** The popup window shell */
	// Shell fWindowShell;
	/** The label shown in the popup window shell */
	// private Canvas fWindowLabel;
	/** Remembers the previous mouse hover location */
	private Object fHoverObject = null;

	/** The hover information * */
	private HoverInfo info;

	private IHoverSubject viewer;

	private ToolTip toolTip;

	/**
	 * Creates a new text hovering controller for the given text viewer. The
	 * controller registers as mouse track listener on the text viewer's text
	 * widget. Initially, the popup window is invisible.
	 *
	 * @param viewer
	 *            the viewer for which the controller is created
	 */
	public HoveringController(IHoverSubject viewer) {
		this.viewer = viewer;
		toolTip = new ToolTip(viewer.getControl().getShell(), SWT.BALLOON);
		toolTip.setAutoHide(false);
	}

	/**
	 * Determines the location of the popup window depending on the size of the
	 * covered area and the coordinates at which the window has been requested.
	 *
	 * @param x
	 *            the x coordinate at which the window has been requested
	 * @param y
	 *            the y coordinate at which the window has been requested
	 * @param coveredArea
	 *            graphical area of the hover region
	 * @return the location of the hover popup window
	 */
	private Point computeWindowLocation(int x, int y) {
		return viewer.getControl().toDisplay(new Point(x + 20, y + 10));
	}

	/**
	 * Disposes this hovering controller
	 */
	public void dispose() {
		if (toolTip != null)
			toolTip.dispose();
	}

	/**
	 * Installs this hovering controller on its viewer.
	 */
	public void install() {
		fHoverObject = null;
		viewer.getControl().addMouseTrackListener(this);
	}

	/*
	 * @see MouseTrackAdapter#mouseHover
	 */

	@Override
	public void mouseHover(MouseEvent event) {
		if (UiActivator.getDefault().getShowHover()) {
			IGalleryHover hover = viewer.getGalleryHover(event);
			if (hover != null) {
				info = hover.getHoverInfo(viewer, event.x, event.y,
						event.stateMask);
				if (info != null && !info.object.equals(fHoverObject)) {
					fHoverObject = info.object;
					if (toolTip != null && !toolTip.isDisposed())
						showWindow(info.object, info.regions,
								computeWindowLocation(event.x, event.y));
				}
			}
		}
	}

	/**
	 * Opens the hover popup window at the specified location. The window closes
	 * if the mouse pointer leaves the specified area.
	 *
	 * @param coveredArea
	 *            the area about which the hover popup window presents
	 *            information
	 * @param coveredArea
	 *            a list of annotated subregions
	 * @param location
	 *            the location of the hover popup window will pop up
	 */
	private void showWindow(Object coveredObject, Region[] coveredRegions,
			Point location) {

		toolTip.setText(info.getTitle());
		toolTip.setMessage(info.getText());
		toolTip.setLocation(location);
		new WindowCloser(coveredObject, coveredRegions).start();
		uninstall();
	}

	/**
	 * Uninstalls this hovering controller from its text viewer.
	 */
	public void uninstall() {
		Control canvas = viewer.getControl();
		if (canvas != null && !canvas.isDisposed())
			canvas.removeMouseTrackListener(this);
	}

}