/*******************************************************************************

 * Copyright (c) 2004 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials 

 * are made available under the terms of the Common Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/cpl-v10.html

 * 

 * Contributors:

 *     IBM Corporation - initial API and implementation

 ******************************************************************************/

package org.eclipse.jface.dialogs;

import org.eclipse.jface.action.Action;

import org.eclipse.jface.action.GroupMarker;

import org.eclipse.jface.action.IAction;

import org.eclipse.jface.action.IMenuManager;

import org.eclipse.jface.action.MenuManager;

import org.eclipse.jface.resource.ImageDescriptor;

import org.eclipse.jface.util.Geometry;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.ShellAdapter;

import org.eclipse.swt.events.ShellEvent;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Event;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Listener;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.swt.widgets.Monitor;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.swt.widgets.ToolBar;

import org.eclipse.swt.widgets.ToolItem;

import org.eclipse.swt.widgets.Tracker;

/**

 * The <code>PopupDialog</code> is a generic and customizable dialog comprised

 * of three components: a header, the dialog's content and a footer. The

 * following properties can be set for this dialog:

 * 

 * <ul>

 * 

 * <li>Background and Border color: default color is the widget color.</li>

 * <li>Shell style: default style for the shell is SWT.NO_TRIM.</li>

 * <li>Footer component: If the <code>hasFooter</code> flag is set, the pop

 * up dialog will contain a footer component. To fill the footer's content,

 * override <code>createFooterContent(Composite)</code>.</li>

 * <li>Header component: If the <code>hasHeader</code> flag is set, the pop

 * up dialog will contain a header component. To fill the header's content,

 * override <code>createHeaderContent(Composite)</code>.</li>

 * <li>Move property: Specify if the pop up dialog should be moveable. If the

 * <code>isMoveable</code> property is set, a pull down menu with a move

 * action will be added to the dialog. You can also set the standard move

 * capability by setting the appropriate shell style.</li>

 * <li>Resize property: Specify if the pop up dialog should be resizable. If

 * the <code>isResizable</code> property is set, a pull down menu with a

 * resize action will be added to the dialog. You can also set the standard

 * resize capability by setting the appropriate shell style (i.e: SWT.RESIZE).

 * </li>

 * <li>Allow the user to remember the bounds: Setting this property will add an

 * action item to the pull down menu that will allow the user to select whether

 * he/she wants to remember the dialog's bounds if they have changed.</li>

 * <li>Remember the bounds of the dialog: Set whether the dialog should

 * remember its bounds after it is closed. The location of the dialog is

 * remembered relative to its parent, or relative to the display if no parent is

 * set.</li>

 * <li>Remember the properties of the dialog: Set whether the dialog should

 * remember its properties (color, style, parent) on close.</li>

 * <li>Dialog location: If the pop up dialog's parent component is set,

 * pre-defined locations (relative to the parent) can be set: TOP, BOTTOM,

 * RIGHT, LEFT, TOP_LEFT, TOP_RIGHT, BOTTOM_LEFT, BOTTOM_RIGHT. If no location

 * is set, the dialog will be positioned at the center of its parent, or at the

 * center of the display if no parent is set.</li>

 * <li>Dialog size: If the pop up dialog's size is not set, the default size

 * will be computed using <code>SWT.DEFAULT</code>.</li>

 * <li>Dialog content: To specify the dialog's content, override

 * <code>createDialogContent(Composite)</code>.</li>

 * <li>closeCondition: The dialog's close condition can be set to

 * <code>closeDialogOnDeactivation</code>. If no close condition set, the

 * default is for the pop up dialog to close when its <code>close()</code>

 * method is called.</li>

 * </ul>

 * 

 * The default behavior for the pop up dialog is to contain no header and no

 * footer, with widget colors for border and background, SWT.NO_TRIM as the

 * shell style and no resize or moving capabilities.

 * 

 */

public class PopupDialog {

	/**

	 * Move action for the dialog.

	 */

	private class MoveAction extends Action {

		MoveAction() {

			super("Move", IAction.AS_PUSH_BUTTON); //$NON-NLS-1$

		}

		/*

		 * (non-Javadoc)

		 * 

		 * @see org.eclipse.jface.action.IAction#run()

		 */

		public void run() {

			performTrackerAction(SWT.NONE);

		}

	}

	/**

	 * 

	 * Remember bounds action for the dialog.

	 */

	private class RememberBoundsAction extends Action {

		RememberBoundsAction() {

			super("Remember bounds", IAction.AS_CHECK_BOX); //$NON-NLS-1$

			setChecked(rememberDialogBounds);

		}

		/*

		 * (non-Javadoc)

		 * 

		 * @see org.eclipse.jface.action.IAction#run()

		 */

		public void run() {

			rememberDialogBounds = isChecked();

		}

	}

	/**

	 * 

	 * Resize action for the dialog.

	 */

	private class ResizeAction extends Action {

		ResizeAction() {

			super("Resize", IAction.AS_PUSH_BUTTON); //$NON-NLS-1$

		}

		/*

		 * @see org.eclipse.jface.action.Action#run()

		 */

		public void run() {

			performTrackerAction(SWT.RESIZE);

		}

	}

	/**

	 * At the top (middle) of the parent shell.

	 */

	final public static int TOP = 0;

	/**

	 * At the bottom (middle) of the parent shell.

	 */

	final public static int BOTTOM = 1;

	/**

	 * At the right (middle) of the parent shell.

	 */

	final public static int RIGHT = 2;

	/**

	 * At the left (middle) of the parent shell.

	 */

	final public static int LEFT = 3;

	/**

	 * At the top left of the parent shell.

	 */

	final public static int TOP_LEFT = 4;

	/**

	 * At the top right of the parent shell.

	 */

	final public static int TOP_RIGHT = 5;

	/**

	 * At the bottom left of the parent shell.

	 */

	final public static int BOTTOM_LEFT = 6;

	/**

	 * At the bottom right of the parent shell.

	 */

	final public static int BOTTOM_RIGHT = 7;

	// Margin height and width for locations

	private final int marginWidth = 5;

	private final int marginHeight = 5;

	/**

	 * Close the dialong when it is de-activated.

	 */

	public final static int closeDialogOnDeactivate = 0;

	/**

	 * By default, the dialog has no closing condition.

	 */

	private int closeCondition = -1;

	// Flag to remember the dialog properties (color, size, shell style)

	private boolean rememberDialogProperties = false;

	// Flag to remember the bounds of the dialog (size and location)

	private boolean rememberDialogBounds = false;

	// Background and border colors

	private Color backGroundColor = null;

	private Color borderColor = null;

	// Bounds of the dialog (location relative to the parent, or display if

	// parent is null)

	protected Point deltaLocation = null;

	// Current size for the dialog.

	protected Point currentSize = null;

	// The dialog's toolbar for the move and resize capabilities

	private ToolBar fToolBar = null;

	// The dialog's menu manager

	private MenuManager fViewMenuManager = null;

	// The menu's image

	private Image menuImage = null;

	// The dialog's shell

	private Shell dialogShell = null;

	// The dialog's parent shell

	private Shell parentShell = null;

	// The shell's style

	private int shellStyle = SWT.NO_TRIM;

	// Specify whether the dialog should be moveable

	private boolean isMoveable = false;

	// Specify whether the dialog should be resizable

	private boolean isResizable = false;

	// Specify whether the dialog should have a footer component

	private boolean hasFooter = false;

	// Specify whether the dialog should have a header component

	private boolean hasHeader = false;

	// Specify whether the dialog should allow the user to opt

	// to remember the dialog's bounds

	private boolean showRememberBounds = false;

	/**

	 * Constructs a new instance of <code>PopupInformationDialog</code>. When

	 * the dialog is first constructed, it contains no widgets.

	 * 

	 * @param parent

	 *            The parent shell (could be null).

	 */

	public PopupDialog(Shell parent) {

		parentShell = parent;

	}

	/**

	 * Constructs a new instance of <code>PopupInformationDialog</code>. When

	 * the dialog is first constructed, it contains no widgets.

	 * 

	 * @param parent

	 *            The parent shell. Or null to create a top level shell.

	 * @param shellStyle

	 *            The shell style.

	 */

	public PopupDialog(Shell parent, int shellStyle) {

		this.shellStyle = shellStyle;

		parentShell = parent;

	}

	/**

	 * Constructs a new instance of <code>PopupInformationDialog</code>. When

	 * the dialog is first constructed, it contains no widgets.

	 * 

	 * @param parent

	 *            The parent shell.

	 * @param shellStyle

	 *            The shell style.

	 * @param backGroundColor

	 *            The background color.

	 * @param borderColor

	 *            The border color.

	 */

	public PopupDialog(Shell parent, int shellStyle, Color backGroundColor,

			Color borderColor) {

		this.shellStyle = shellStyle;

		parentShell = parent;

		this.backGroundColor = backGroundColor;

		this.borderColor = borderColor;

	}

	/**

	 * Constructs a new instance of <code>PopupInformationDialog</code>. When

	 * the dialog is first constructed, it contains no widgets.

	 * 

	 * @param parent

	 *            The parent shell.

	 * @param shellStyle

	 *            The shell style.

	 * @param isMoveable

	 *            The move property of the dialog.

	 * @param isResizable

	 *            The resizable property of the dialog.

	 * @param hasFooter

	 *            Specify footer component for the dialog.

	 * @param hasHeader

	 *            Specify header component for the dialog.

	 * @param showRememberBounds

	 *            Show the remember bounds menu item.

	 * @param backGroundColor

	 *            Specify the background color for the dialog.

	 * @param borderColor

	 *            Specify the border color for the dialog.

	 */

	public PopupDialog(Shell parent, int shellStyle, boolean isMoveable,

			boolean isResizable, boolean hasFooter, boolean hasHeader,

			boolean showRememberBounds, Color backGroundColor, Color borderColor) {

		this.shellStyle = shellStyle;

		this.parentShell = parent;

		this.isMoveable = isMoveable;

		this.isResizable = isResizable;

		this.hasFooter = hasFooter;

		this.hasHeader = hasHeader;

		this.backGroundColor = backGroundColor;

		this.borderColor = borderColor;

		this.showRememberBounds = showRememberBounds;

	}

	/**

	 * Close the dialog.

	 * 

	 */

	public void close() {

		close(rememberDialogProperties);

	}

	/**

	 * Close the dialog and specify if the current dialog properties should be

	 * remembered.

	 * 

	 * @param rememberDialogProperties

	 *            Remember the dialog properties (colors, move/resize

	 *            properties, shell style).

	 */

	public void close(final boolean rememberDialogProperties) {

		this.rememberDialogProperties = rememberDialogProperties;

		// Persist the bounds

		if (rememberDialogBounds) {

			currentSize = dialogShell.getSize();

			deltaLocation = getDeltaLocation(dialogShell.getLocation());

		} else {

			deltaLocation = null;

			currentSize = null;

		}

		// Reset style, colors...

		if (!rememberDialogProperties) {

			resetDialogSettings();

		}

		// Clean up variables

		menuImage.dispose();

		menuImage = null;

		fToolBar = null;

		fViewMenuManager = null;

		// dispose

		dialogShell.dispose();

		dialogShell = null;

	}

	/**

	 * Uses the Window's default location computation. Overrite to perform

	 * specific location calculations.

	 */

	protected Point computeLocation(Point size) {

		// If the location has not been set, compute default

		if (deltaLocation == null) {

			return getDefaultLocation(size);

		}

		Display display = dialogShell.getDisplay();

		// getParentShell() could be null

		return display.map(parentShell, null, deltaLocation);

	}

	/**

	 * Compute the size of the dialog.

	 * 

	 * @return the size of the dialog.

	 */

	protected Point computeSize() {

		if (currentSize == null) {

			return dialogShell.computeSize(SWT.DEFAULT, SWT.DEFAULT, true);

		}

		return currentSize;

	}

	/**

	 * Create the dialog's content.

	 * 

	 */

	protected void createContents() {

		menuImage = ImageDescriptor.createFromFile(PopupDialog.class,

				"images/view_menu.gif").createImage();//$NON-NLS-1$

		// Create a border around the outside of the shell.

		dialogShell.setBackground(borderColor);

		final GridLayout shellLayout = new GridLayout(1, false);

		shellLayout.marginHeight = 1;

		shellLayout.marginWidth = 1;

		dialogShell.setLayout(shellLayout);

		// To handle closing of shell for example

		setCloseCondition();

		// Create the top-level composite for the dialog

		final Composite contents = new Composite(dialogShell, SWT.NONE);

		contents.setBackground(backGroundColor);

		GridLayout layout = new GridLayout();

		layout.marginHeight = 1;

		layout.marginWidth = 1;

		contents.setLayout(layout);

		contents.setLayoutData(new GridData(GridData.FILL_BOTH));

		// Create the header area

		createHeaderArea(contents);

		// Create the dialog content of the pop up

		createDialogArea(contents);

		if (hasFooter) {

			// Create the footer content of the pop up

			createFooterArea(contents);

		}

	}

	/**

	 * Create the dialog area.

	 * 

	 * @param parent

	 *            The parent composite.

	 */

	protected void createDialogArea(Composite parent) {

		// Create a composite for the dialog area.

		final Composite composite = new Composite(parent, SWT.NONE);

		final GridLayout compositeLayout = new GridLayout();

		compositeLayout.marginHeight = 0;

		compositeLayout.marginWidth = 0;

		composite.setLayout(compositeLayout);

		composite.setLayoutData(new GridData(GridData.FILL_BOTH));

		composite.setBackground(parent.getBackground());

		// Fill in top part

		createDialogContent(parent);

	}

	/**

	 * Create the dialog's content. This method should be overriden to fill the

	 * dialog's content. The default implementation does not create anything.

	 * 

	 * @param parent

	 *            The parent composite.

	 * 

	 */

	protected void createDialogContent(Composite parent) {

		// default implementation does nothing

	}

	/**

	 * Create the dialog's menu for the resize, move and remember bounds

	 * actions.

	 * 

	 * @param parent

	 *            The parent composite.

	 */

	private void createDialogMenu(Composite parent) {

		fToolBar = new ToolBar(parent, SWT.FLAT);

		ToolItem viewMenuButton = new ToolItem(fToolBar, SWT.PUSH, 0);

		fToolBar.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_END

				| GridData.GRAB_HORIZONTAL | GridData.FILL_HORIZONTAL));

		fToolBar.setBackground(parent.getBackground());

		viewMenuButton.setImage(menuImage);

		viewMenuButton.setToolTipText("Menu"); //$NON-NLS-1$

		viewMenuButton.addSelectionListener(new SelectionAdapter() {

			public void widgetSelected(SelectionEvent e) {

				showDialogMenu();

			}

		});

	}

	/**

	 * Creates the footer area for the dialog.

	 */

	protected void createFooterArea(Composite parent) {

		final Composite composite = new Composite(parent, SWT.NONE);

		composite.setLayout(new GridLayout());

		composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

		composite.setBackground(parent.getBackground());

		createSeparator(parent);

		// Fill in bottom part

		createFooterContent(parent);

	}

	/**

	 * Creates the footer content of the pop up dialog if the

	 * <code>hasFooter</code> flag is set to true. Default implementation does

	 * nothing. Override this method to specify the content of the footer

	 * component.

	 * 

	 * @param parent

	 *            The parent composite.

	 */

	protected void createFooterContent(Composite parent) {

		// default implementation does nothing

	}

	/**

	 * Create the header aread for the dialog.

	 * 

	 * @param parent

	 *            The parent composite.

	 */

	protected void createHeaderArea(final Composite parent) {

		boolean hasMenu = isResizable || isMoveable;

		if (!hasHeader && !(hasMenu)) {

			// If the dialog does not have a header and the menu, don't create

			// anything

			return;

		}

		int numColumns = 1;

		if (hasHeader) {

			numColumns = 2;

		}

		Composite headerComposite = new Composite(parent, SWT.NONE);

		headerComposite.setBackground(parent.getBackground());

		GridLayout layout = new GridLayout(numColumns, false);

		layout.marginHeight = 0;

		layout.marginWidth = 0;

		headerComposite.setLayout(layout);

		headerComposite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

		if (hasHeader) {

			// Should be overwritten - does nothing

			createHeaderContent(headerComposite);

		}

		if (hasMenu) {

			createDialogMenu(headerComposite);

		}

		createSeparator(parent);

	}

	/**

	 * Creates the header content of the pop up dialog if the

	 * <code>hasHeader</code> flag is set to true. Default implementation does

	 * nothing. Override this method to specify the content of the header

	 * component.

	 * 

	 * @param parent

	 *            The parent composite.

	 */

	protected void createHeaderContent(Composite parent) {

		// default implementation does nothing

	}

	/**

	 * Create the separator.

	 * 

	 * @param parent

	 *            The parent composite.

	 */

	private void createSeparator(Composite parent) {

		Label separator = new Label(parent, SWT.SEPARATOR | SWT.HORIZONTAL

				| SWT.LINE_DOT);

		separator.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

	}

	/**

	 * Create the shell for the dialog.

	 * 

	 */

	protected void createShell() {

		// Create the shell

		dialogShell = new Shell(parentShell, shellStyle);

		// To handle "ESC" case

		dialogShell.addShellListener(new ShellAdapter() {

			public void shellClosed(ShellEvent event) {

				event.doit = false; // don't close now

				close();

			}

		});

		GridLayout layout = new GridLayout();

		layout.marginHeight = 0;

		layout.marginWidth = 0;

		dialogShell.setLayout(layout);

	}

	/**

	 * Fill the dialog's menu.

	 * 

	 * @param dialogMenu

	 *            The dialog's menu.

	 */

	protected void fillDialogMenu(IMenuManager dialogMenu) {

		dialogMenu.add(new GroupMarker("SystemMenuStart")); //$NON-NLS-1$

		if (isMoveable) {

			dialogMenu.add(new MoveAction());

		}

		if (isResizable) {

			dialogMenu.add(new ResizeAction());

		}

		if (showRememberBounds) {

			dialogMenu.add(new RememberBoundsAction());

		}

	}

	/**

	 * Get the bottom Y coordinate.

	 * 

	 * @param parentLocation

	 *            The parent location.

	 * @param parentSize

	 *            The parent's size.

	 * @return the bottom Y coordinate.

	 */

	private int getBottomYCoordinate(Point parentLocation, Point parentSize) {

		return parentLocation.y + parentSize.y + marginHeight;

	}

	/**

	 * Return the computed location.

	 * 

	 * @param locationType

	 *            The location type.

	 * @param newSize

	 *            The dialog's size.

	 * @return the new dialog's location.

	 */

	private Point getComputedLocation(int locationType, Point newSize) {

		Point parentLocation = parentShell.getLocation();

		Point parentSize = parentShell.getSize();

		Point newLocation = null;

		switch (locationType) {

		// TOP

		case 0:

			newLocation = new Point(getMiddleXCoordinate(parentLocation,

					parentSize, newSize), getTopYCoordinate(newSize,

					parentLocation));

			break;

		// BOTTOM

		case 1:

			newLocation = new Point(getMiddleXCoordinate(parentLocation,

					parentSize, newSize), getBottomYCoordinate(parentLocation,

					parentSize));

			break;

		// RIGHT

		case 2:

			newLocation = new Point(getRightXCoordinate(parentLocation,

					parentSize), getMiddleYCoordinate(newSize, parentLocation,

					parentSize));

			break;

		// LEFT

		case 3:

			newLocation = new Point(

					getLeftXCoordinate(newSize, parentLocation),

					getMiddleYCoordinate(newSize, parentLocation, parentSize));

			break;

		// TOP_LEFT

		case 4:

			newLocation = new Point(

					getLeftXCoordinate(newSize, parentLocation),

					getTopYCoordinate(newSize, parentLocation));

			break;

		// TOP_RIGHT

		case 5:

			newLocation = new Point(getRightXCoordinate(parentLocation,

					parentSize), getTopYCoordinate(newSize, parentLocation));

			break;

		// BOTTOM_LEFT

		case 6:

			newLocation = new Point(

					getLeftXCoordinate(newSize, parentLocation),

					getBottomYCoordinate(parentLocation, parentSize));

			break;

		// BOTTOM_RIGHT

		case 7:

			newLocation = new Point(getRightXCoordinate(parentLocation,

					parentSize), getBottomYCoordinate(parentLocation,

					parentSize));

			break;

		}

		return newLocation;

	}

	/**

	 * Default location compuation. The default location positions the dialog at

	 * the center of its parent, or at the center of the display if the parent

	 * has not been set.

	 * 

	 * @param initialSize

	 *            The dialog's size.

	 * @return default location.

	 */

	protected Point getDefaultLocation(Point initialSize) {

		Monitor monitor = dialogShell.getDisplay().getPrimaryMonitor();

		if (parentShell != null) {

			monitor = parentShell.getMonitor();

		}

		Rectangle monitorBounds = monitor.getClientArea();

		Point centerPoint;

		if (parentShell != null) {

			centerPoint = Geometry.centerPoint(parentShell.getBounds());

		} else {

			centerPoint = Geometry.centerPoint(monitorBounds);

		}

		return new Point(centerPoint.x - (initialSize.x / 2), Math.max(

				monitorBounds.y, Math.min(centerPoint.y

						- (initialSize.y * 2 / 3), monitorBounds.y

						+ monitorBounds.height - initialSize.y)));

	}

	/**

	 * Return the location relative to the parent (or the display if parent is

	 * null).

	 * 

	 * @param childLocation

	 *            The child's location.

	 * @return the location relative to the parent's location.

	 */

	private Point getDeltaLocation(Point childLocation) {

		Display display = null;

		if (dialogShell != null) {

			display = dialogShell.getDisplay();

		} else {

			display = Display.getDefault();

		}

		// parentShell could be null

		return display.map(null, parentShell, childLocation);

	}

	/**

	 * Get the left X coordinate.

	 * 

	 * @param newSize

	 *            The new size.

	 * @param parentLocation

	 *            The parent location.

	 * @return the left X coordinate.

	 */

	private int getLeftXCoordinate(Point newSize, Point parentLocation) {

		return (parentLocation.x - newSize.x) - marginWidth;

	}

	/**

	 * Get the middle X coordinate.

	 * 

	 * @param parentLocation

	 *            The parent location.

	 * @param parentSize

	 *            The parent size.

	 * @param childSize

	 *            The child size.

	 * @return the middle X coordinate.

	 */

	private int getMiddleXCoordinate(Point parentLocation, Point parentSize,

			Point childSize) {

		return parentLocation.x + parentSize.x / 2 - childSize.x / 2;

	}

	/**

	 * Get the middle Y coordinate.

	 * 

	 * @param newSize

	 *            The new size.

	 * @param parentLocation

	 *            The parent location.

	 * @param parentSize

	 *            The parent's size.

	 * @return the middle Y coordinate.

	 */

	private int getMiddleYCoordinate(Point newSize, Point parentLocation,

			Point parentSize) {

		return parentLocation.y + parentSize.y / 2 - newSize.y / 2;

	}

	/**

	 * Get the right X coordinate.

	 * 

	 * @param parentLocation

	 *            The parent location.

	 * @param parentSize

	 *            The parent's size.

	 * @return the right X coordinate.

	 */

	private int getRightXCoordinate(Point parentLocation, Point parentSize) {

		return parentLocation.x + parentSize.x + marginWidth;

	}

	/**

	 * Get the top Y coordinate.

	 * 

	 * @param size

	 *            The dialog's size.

	 * @param parentLocation

	 *            The parent location.

	 * @return the top Y coordinate.

	 */

	private int getTopYCoordinate(Point size, Point parentLocation) {

		return parentLocation.y - size.y - marginHeight;

	}

	/**

	 * Initialize the shell's bounds.

	 * 

	 */

	protected void initializeBounds() {

		Point size = computeSize();

		Point location = computeLocation(size);

		dialogShell.setBounds(new Rectangle(location.x, location.y, size.x,

				size.y));

	}

	/**

	 * Checks whether the dialog is open.

	 * 

	 * @return returns true if the dialog is open, false otherwise.

	 */

	public boolean isOpen() {

		return dialogShell != null;

	}

	/**

	 * Open the pop up dialog.

	 * 

	 */

	public void open() {

		// If the dialog is already open, dispose the shell and recreate it

		if (dialogShell != null) {

			close();

		}

		// create shell

		createShell();

		createContents();

		initializeBounds();

		// open the window

		dialogShell.open();

	}

	/**

	 * Perform the requested tracker action (resize or move).

	 * 

	 * @param style

	 *            The track style (resize or move).

	 */

	private void performTrackerAction(int style) {

		Tracker tracker = new Tracker(dialogShell.getDisplay(), style);

		tracker.setStippled(true);

		Rectangle[] r = new Rectangle[] { dialogShell.getBounds() };

		tracker.setRectangles(r);

		if (tracker.open()) {

			dialogShell.setBounds(tracker.getRectangles()[0]);

		}

	}

	/**

	 * Clear the shell settings.

	 * 

	 */

	protected void resetDialogSettings() {

		// Reset values

		backGroundColor = null;

		borderColor = null;

		closeCondition = -1;

		rememberDialogProperties = false;

		shellStyle = SWT.NO_TRIM;

		isMoveable = true;

		isResizable = true;

		hasFooter = true;

		hasHeader = true;

		parentShell = null;

		showRememberBounds = false;

	}

	/**

	 * Set the background color of the dialog.

	 * 

	 * @param color

	 *            The color.

	 */

	public void setBackGroundColor(Color color) {

		backGroundColor = color;

	}

	/**

	 * Set the border color of the dialog.

	 * 

	 * @param color

	 *            The color.

	 */

	public void setBorderColor(Color color) {

		borderColor = color;

	}

	/**

	 * Set the closing condition for the dialog.

	 * 

	 */

	protected void setCloseCondition() {

		switch (closeCondition) {

		case closeDialogOnDeactivate:

			dialogShell.addListener(SWT.Deactivate, new Listener() {

				public void handleEvent(Event event) {

					dialogShell.removeListener(SWT.Deactivate, this);

					close();

				}

			});

			break;

		default:

		}

	}

	/**

	 * Set the dialog's closing condition.

	 * 

	 * @param closingStyle

	 *            The closing style.

	 */

	public void setCloseCondition(int closingStyle) {

		this.closeCondition = closingStyle;

	}

	/**

	 * Specify if the pop up dialog has a footer component.

	 * 

	 * @param hasFooter

	 *            Footer component flag.

	 */

	public void setHasFooter(boolean hasFooter) {

		this.hasFooter = hasFooter;

	}

	/**

	 * Specifiy if the pop up dialog has a header component.

	 * 

	 * @param hasHeader

	 *            Header component flag.

	 */

	public void setHasHeader(boolean hasHeader) {

		this.hasHeader = hasHeader;

	}

	/**

	 * Specify if the dialog is moveable. If the flag is set to true, a pull

	 * down menu is added to the top right corner of the dialog to provide that

	 * functionality. To allow the move functionality without having the pull

	 * down menu, just specify the appropriate shell style.

	 * 

	 * @param isMoveable

	 *            Moveable flag.

	 */

	public void setIsMoveable(boolean isMoveable) {

		this.isMoveable = isMoveable;

	}

	/**

	 * Specify if the dialog is resizable. If the flag is set to true, a pull

	 * down menu is added to the top right corner of the dialog to provide that

	 * functionality. To allow the resize functionality without having the pull

	 * down menu, just specify the appropriate shell style (i.e.:

	 * <code>setShellStyle(SWT.RESIZE)</code>).

	 * 

	 * @param isResizable

	 *            Resizable flag.

	 */

	public void setIsResizable(boolean isResizable) {

		this.isResizable = isResizable;

	}

	/**

	 * Set the diaog's location.

	 * 

	 * @param x

	 *            The width.

	 * @param y

	 *            The height.

	 */

	public void setLocation(int x, int y) {

		// Store the location relative to its parent

		deltaLocation = getDeltaLocation(new Point(x, y));

	}

	/**

	 * Set the location of the dialog. The location type is relative to the

	 * parent, hence, the parent shell cannot be null.

	 * 

	 * @param locationType

	 *            The location type.

	 * @param newSize

	 *            The size of the dialog.

	 */

	public void setLocation(int locationType, Point newSize) {

		Point newLocation = getComputedLocation(locationType, newSize);

		if (newLocation != null) {

			deltaLocation = getDeltaLocation(newLocation);

			this.currentSize = newSize;

		}

	}

	/**

	 * Set the location.

	 * 

	 * @param childLocation

	 *            The child location.

	 */

	public void setLocation(Point childLocation) {

		// Store the location relative to its parent

		deltaLocation = getDeltaLocation(childLocation);

	}

	/**

	 * Specify if the pop up dialog should remember its bounds (size and

	 * location) on close.

	 * 

	 * @param rememberBounds

	 *            Remember bounds flag.

	 */

	public void setRememberDialogBounds(boolean rememberBounds) {

		this.rememberDialogBounds = rememberBounds;

	}

	/**

	 * Specify if the pop up diaog should remember its properties (colors, shell

	 * style, closing style...) on close.

	 * 

	 * @param rememberProperties

	 *            Remember properties flag.

	 */

	public void setRememberDialogProperties(boolean rememberProperties) {

		this.rememberDialogProperties = rememberProperties;

	}

	/**

	 * Set the shell's style.

	 * 

	 * @param newShellStyle

	 *            The shell style.

	 */

	public void setShellStyle(int newShellStyle) {

		this.shellStyle = newShellStyle;

	}

	/**

	 * Set whether the dialog should allow the user to chose to save or discard

	 * the pop up's bounds through a menu item.

	 * 

	 * @param showRememberBounds

	 *            Flag to show the remember bounds menu item.

	 */

	public void setShowRememberBounds(boolean showRememberBounds) {

		this.showRememberBounds = showRememberBounds;

	}

	/**

	 * Set the dialog's size.

	 * 

	 * @param x

	 *            The width.

	 * @param y

	 *            The height.

	 */

	public void setSize(int x, int y) {

		if (currentSize == null) {

			currentSize = new Point(x, y);

		} else {

			currentSize.x = x;

			currentSize.y = y;

		}

	}

	/**

	 * Set the size of the dialog.

	 * 

	 * @param point

	 *            The dialog's size.

	 */

	public void setSize(Point point) {

		currentSize = point;

	}

	/**

	 * Show the dialog's menu.

	 * 

	 */

	private void showDialogMenu() {

		fViewMenuManager = new MenuManager();

		fillDialogMenu(fViewMenuManager);

		Menu aMenu = fViewMenuManager.createContextMenu(dialogShell);

		Rectangle bounds = fToolBar.getBounds();

		Point topLeft = new Point(bounds.x, bounds.y + bounds.height);

		topLeft = dialogShell.toDisplay(topLeft);

		aMenu.setLocation(topLeft.x, topLeft.y);

		aMenu.setVisible(true);

	}

}

GIF89a¢o/iŸ=t¤Sˆ^‘°N‘³xµÂÿÿÿ!ù,xºÜþ0ÊIk#ë  FHt—P¤éÔZp,ÏK;