/********************************************************************************
    * Copyright (c) 2000, 2004 IBM Corporation 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:
    * IBM Corporation - initial API and implementation
    ******************************************************************************/
   package sk.uniba.euromath.editor.wizards;
   import java.util.ArrayList;
  import java.util.List;
  import org.eclipse.core.runtime.IStatus;
  import org.eclipse.jface.dialogs.IDialogConstants;
  import org.eclipse.jface.dialogs.IMessageProvider;
  import org.eclipse.jface.dialogs.IPageChangeProvider;
  import org.eclipse.jface.dialogs.IPageChangedListener;
  import org.eclipse.jface.dialogs.MessageDialog;
  import org.eclipse.jface.dialogs.PageChangedEvent;
  import org.eclipse.jface.dialogs.TitleAreaDialog;
  import org.eclipse.jface.util.Assert;
  import org.eclipse.core.runtime.ListenerList;
  import org.eclipse.jface.util.SafeRunnable;
  import org.eclipse.swt.SWT;
  import org.eclipse.swt.events.SelectionAdapter;
  import org.eclipse.swt.events.SelectionEvent;
  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.Button;
  import org.eclipse.swt.widgets.Composite;
  import org.eclipse.swt.widgets.Control;
  import org.eclipse.swt.widgets.Label;
  import org.eclipse.swt.widgets.Layout;
  import org.eclipse.swt.widgets.Shell;
  import sk.uniba.euromath.EuroMath;
  import sk.uniba.euromath.editor.lang.Messages;
  import sk.uniba.euromath.editor.widgets.ValidityMessages;
  import sk.uniba.euromath.tools.JavaTools;
  import sk.uniba.euromath.tools.StringTools;
  /***
   * A dialog to show a wizard to the end user.
   * <p>
   * In typical usage, the client instantiates this class with a particular
   * wizard. The dialog serves as the wizard container and orchestrates the
   * presentation of its pages.
   * <p>
   * The standard layout is roughly as follows: it has an area at the top
   * containing both the wizard's title, description, and image; the actual wizard
   * page appears in the middle; below that is a progress indicator (which is made
   * visible if needed); and at the bottom of the page is message line and a
   * button bar containing Help, Next, Back, Finish, and Cancel buttons (or some
   * subset).
   * </p>
   * <p>
   * Wizard is not disposed when the dialog exits.
   * </p>
   */
  public final class WizardDialog extends TitleAreaDialog implements
  		IPageChangeProvider {
  	/***
  	 * Image registry key for error message image (value
  	 * <code>"dialog_title_error_image"</code>).
  	 */
  	public static final String WIZ_IMG_ERROR = "dialog_title_error_image"; //$NON-NLS-1$
  	/***
  	 * The wizard the dialog is currently showing.
  	 */
  	private final IWizard wizard;
  	// Navigation buttons
  	private Button backButton;
  	private Button nextButton;
  	private Button finishButton;
  	private Button cancelButton;
  	private SelectionAdapter cancelListener;
  	private Composite pageContainer;
  	private final PageContainerFillLayout pageContainerLayout = new PageContainerFillLayout(
  			5, 5, 300, 225);
  	private int pageWidth = SWT.DEFAULT;
  	private int pageHeight = SWT.DEFAULT;
  	private ListenerList pageChangedListeners = new ListenerList(ListenerList.IDENTITY);
  	/***
  	 * A layout for a container which includes several pages, like a notebook,
  	 * wizard, or preference dialog. The size computed by this layout is the
  	 * maximum width and height of all pages currently inserted into the
  	 * container.
  	 */
  	protected class PageContainerFillLayout extends Layout {
  		/***
  		 * The margin width; <code>5</code> pixels by default.
  		 */
  		public int marginWidth = 5;
  		/***
  		 * The margin height; <code>5</code> pixels by default.
  		 */
  		public int marginHeight = 5;
  		/***
  		 * The minimum width; <code>0</code> pixels by default.
  		 */
  		public int minimumWidth = 0;
 		/***
 		 * The minimum height; <code>0</code> pixels by default.
 		 */
 		public int minimumHeight = 0;
 		/***
 		 * Creates new layout object.
 		 * @param mw the margin width
 		 * @param mh the margin height
 		 * @param minW the minimum width
 		 * @param minH the minimum height
 		 */
 		public PageContainerFillLayout(int mw, int mh, int minW, int minH) {
 			marginWidth = mw;
 			marginHeight = mh;
 			minimumWidth = minW;
 			minimumHeight = minH;
 		}
 		/*
 		 * (non-Javadoc) Method declared on Layout.
 		 */
 		@Override
 		public Point computeSize(Composite composite, int wHint, int hHint,
 				boolean force) {
 			if (wHint != SWT.DEFAULT && hHint != SWT.DEFAULT)
 				return new Point(wHint, hHint);
 			Point result = null;
 			Control[] children = composite.getChildren();
 			if (children.length > 0) {
 				result = new Point(0, 0);
 				for (int i = 0; i < children.length; i++) {
 					Point cp = children[i].computeSize(wHint, hHint, force);
 					result.x = Math.max(result.x, cp.x);
 					result.y = Math.max(result.y, cp.y);
 				}
 				result.x = result.x + 2 * marginWidth;
 				result.y = result.y + 2 * marginHeight;
 			} else {
 				Rectangle rect = composite.getClientArea();
 				result = new Point(rect.width, rect.height);
 			}
 			result.x = Math.max(result.x, minimumWidth);
 			result.y = Math.max(result.y, minimumHeight);
 			if (wHint != SWT.DEFAULT)
 				result.x = wHint;
 			if (hHint != SWT.DEFAULT)
 				result.y = hHint;
 			return result;
 		}
 		/***
 		 * Returns the client area for the given composite according to this
 		 * layout.
 		 * @param c the composite
 		 * @return the client area rectangle
 		 */
 		public Rectangle getClientArea(Composite c) {
 			Rectangle rect = c.getClientArea();
 			rect.x = rect.x + marginWidth;
 			rect.y = rect.y + marginHeight;
 			rect.width = rect.width - 2 * marginWidth;
 			rect.height = rect.height - 2 * marginHeight;
 			return rect;
 		}
 		/*
 		 * (non-Javadoc) Method declared on Layout.
 		 */
 		@Override
 		public void layout(Composite composite, boolean force) {
 			Rectangle rect = getClientArea(composite);
 			Control[] children = composite.getChildren();
 			for (int i = 0; i < children.length; i++) {
 				children[i].setBounds(rect);
 			}
 		}
 		/***
 		 * Lays outs the page according to this layout.
 		 * @param w the control
 		 */
 		public void layoutPage(Control w) {
 			w.setBounds(getClientArea(w.getParent()));
 		}
 		/***
 		 * Sets the location of the page so that its origin is in the upper left
 		 * corner.
 		 * @param w the control
 		 */
 		public void setPageLocation(Control w) {
 			w.setLocation(marginWidth, marginHeight);
 		}
 	}
 	/***
 	 * The name of the functionality that the wizard provides. Shown in the
 	 * window caption.
 	 */
 	private final String processName;
 	/***
 	 * Creates a new wizard dialog for the given wizard.
 	 * @param parentShell the parent shell
 	 * @param newWizard the wizard this dialog is working on
 	 * @param processName the name of the functionality that the wizard
 	 * provides. Shown in the window caption.
 	 */
 	public WizardDialog(Shell parentShell, IWizard newWizard, String processName) {
 		super(parentShell);
 		if (newWizard == null)
 			throw new IllegalArgumentException("wizard must not be null"); //$NON-NLS-1$
 		setShellStyle(SWT.CLOSE | SWT.TITLE | SWT.BORDER
 				| SWT.APPLICATION_MODAL | SWT.RESIZE | getDefaultOrientation());
 		wizard = newWizard;
 		this.processName = processName;
 		// since VAJava can't initialize an instance var with an anonymous
 		// class outside a constructor we do it here:
 		cancelListener = new SelectionAdapter() {
 			/*
 			 * (non-Javadoc)
 			 * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent)
 			 */
 			@Override
 			public void widgetSelected(SelectionEvent e) {
 				cancelPressed();
 			}
 		};
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see org.eclipse.jface.window.Window#configureShell(org.eclipse.swt.widgets.Shell)
 	 */
 	@Override
 	protected void configureShell(Shell newShell) {
 		super.configureShell(newShell);
 		newShell.setText(processName);
 	}
 	/***
 	 * On these composites the page controls are placed. Last composite shows
 	 * the current page.
 	 */
 	private final List<Composite> pageTiles = new ArrayList<Composite>();
 	/***
 	 * List of wizard pages. Last page is the page currently being shown.
 	 */
 	private final List<BaseWizardPage> wizardPages = new ArrayList<BaseWizardPage>();
 	/***
 	 * The Back button has been pressed.
 	 */
 	protected void backPressed() {
 		if (!wizard.hasPrevious())
 			throw new IllegalStateException("The button must be grayed out"); //$NON-NLS-1$
 		BaseWizardPage current = wizard.current();
 		// dispose the page and show previous
 		current.dispose();
 		final Composite lastTile = pageTiles.get(pageTiles.size() - 1);
 		BaseWizardPage lastPage = wizardPages.get(wizardPages.size() - 1);
 		if (lastPage != current)
 			throw new IllegalStateException("The wizard offers illegal pages."); //$NON-NLS-1$
 		lastTile.dispose();
 		pageTiles.remove(pageTiles.size() - 1);
 		wizardPages.remove(wizardPages.size() - 1);
 		current = wizard.previous();
 		lastPage = wizardPages.get(wizardPages.size() - 1);
 		if (lastPage != current)
 			throw new IllegalStateException("The wizard offers illegal pages."); //$NON-NLS-1$
 		showLastPage();
 		firePageChanged();
 	}
 	/*
 	 * (non-Javadoc) Method declared on Dialog.
 	 */
 	@Override
 	protected void buttonPressed(int buttonId) {
 		switch (buttonId) {
 			case IDialogConstants.BACK_ID: {
 				backPressed();
 				break;
 			}
 			case IDialogConstants.NEXT_ID: {
 				nextPressed();
 				break;
 			}
 			case IDialogConstants.FINISH_ID: {
 				finishPressed();
 				break;
 			}
 		// The Cancel button has a listener which calls cancelPressed directly
 		}
 	}
 	/***
 	 * Calculates the difference in size between the given page and the page
 	 * container. A larger page results in a positive delta.
 	 * @param tile composite where the page is placed.
 	 * @return the size difference encoded as a
 	 * <code>new Point(deltaWidth,deltaHeight)</code>
 	 */
 	private Point calculatePageSizeDelta(Composite tile) {
 		Point contentSize = tile.computeSize(SWT.DEFAULT, SWT.DEFAULT, true);
 		Rectangle rect = pageContainerLayout.getClientArea(pageContainer);
 		Point containerSize = new Point(rect.width, rect.height);
 		return new Point(Math.max(0, contentSize.x - containerSize.x), Math
 				.max(0, contentSize.y - containerSize.y));
 	}
 	/*
 	 * (non-Javadoc) Method declared on Dialog.
 	 */
 	@Override
 	protected void cancelPressed() {
 		// Close the dialog. The check whether the dialog can be
 		// closed or not is done in <code>okToClose</code>.
 		// This ensures that the check is also evaluated when the user
 		// presses the window's close button.
 		setReturnCode(CANCEL);
 		close();
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see org.eclipse.jface.window.Window#close()
 	 */
 	@Override
 	public boolean close() {
 		if (okToClose())
 			return hardClose();
 		return false;
 	}
 	/***
 	 * Creates and returns the contents of this dialog's button bar.
 	 * <p>
 	 * The <code>WizardDialog</code> implementation of this framework method
 	 * prevents the composite's columns from being made equal width in order to
 	 * remove the margin between the Back and Next buttons.
 	 * </p>
 	 * @param parent the parent composite to contain the button bar
 	 * @return the button bar control
 	 */
 	@Override
 	protected Control createButtonBar(Composite parent) {
 		Composite composite = (Composite) super.createButtonBar(parent);
 		((GridLayout) composite.getLayout()).makeColumnsEqualWidth = false;
 		return composite;
 	}
 	/*
 	 * (non-Javadoc) Method declared on Dialog.
 	 */
 	@Override
 	protected void createButtonsForButtonBar(Composite parent) {
 		createPreviousAndNextButtons(parent);
 		finishButton = createButton(parent, IDialogConstants.FINISH_ID,
 				IDialogConstants.FINISH_LABEL, true);
 		cancelButton = createCancelButton(parent);
 	}
 	/***
 	 * Creates the Cancel button for this wizard dialog. Creates a standard (<code>SWT.PUSH</code>)
 	 * button and registers for its selection events. Note that the number of
 	 * columns in the button bar composite is incremented. The Cancel button is
 	 * created specially to give it a removeable listener.
 	 * @param parent the parent button bar
 	 * @return the new Cancel button
 	 */
 	private Button createCancelButton(Composite parent) {
 		// increment the number of columns in the button bar
 		((GridLayout) parent.getLayout()).numColumns++;
 		Button button = new Button(parent, SWT.PUSH);
 		button.setText(IDialogConstants.CANCEL_LABEL);
 		setButtonLayoutData(button);
 		button.setFont(parent.getFont());
 		button.setData(new Integer(IDialogConstants.CANCEL_ID));
 		button.addSelectionListener(cancelListener);
 		return button;
 	}
 	/***
 	 * Return the cancel button if the id is a the cancel id.
 	 * @param id the button id
 	 * @return the button corresponding to the button id
 	 */
 	@Override
 	protected Button getButton(int id) {
 		if (id == IDialogConstants.CANCEL_ID)
 			return cancelButton;
 		return super.getButton(id);
 	}
 	/***
 	 * The <code>WizardDialog</code> implementation of this
 	 * <code>Window</code> method calls <code>super.createContents</code> to
 	 * create the controls. Then it shows the first page.
 	 */
 	@Override
 	protected Control createContents(Composite parent) {
 		Control contents = super.createContents(parent);
 		// Create and show the first page
 		final BaseWizardPage first = wizard.current();
 		if (first == null)
 			return contents;
 		// initialize the page
 		final Composite tile = new Composite(pageContainer, SWT.NONE);
 		tile.setLayout(new GridLayout(1, false));
 		tile.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
 		first.createControl(tile);
 		first.setContext(pageContext);
 		pageTiles.add(tile);
 		wizardPages.add(first);
 		// show the next page
 		showLastPage();
 		return contents;
 	}
 	/*
 	 * (non-Javadoc) Method declared on Dialog.
 	 */
 	@Override
 	protected Control createDialogArea(Composite parent) {
 		Composite composite = (Composite) super.createDialogArea(parent);
 		// Build the Page container
 		pageContainer = createPageContainer(composite);
 		GridData gd = new GridData(GridData.FILL_BOTH);
 		gd.widthHint = pageWidth;
 		gd.heightHint = pageHeight;
 		pageContainer.setLayoutData(gd);
 		pageContainer.setFont(parent.getFont());
 		// Insert a progress monitor
 		GridLayout pmlayout = new GridLayout();
 		pmlayout.numColumns = 1;
 		// Build the separator line
 		Label separator = new Label(composite, SWT.HORIZONTAL | SWT.SEPARATOR);
 		separator.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
 		return composite;
 	}
 	/***
 	 * Creates the container that holds all pages.
 	 * @param parent
 	 * @return Composite
 	 */
 	private Composite createPageContainer(Composite parent) {
 		Composite result = new Composite(parent, SWT.NULL);
 		result.setLayout(pageContainerLayout);
 		return result;
 	}
 	/***
 	 * Creates the Previous and Next buttons for this wizard dialog. Creates
 	 * standard (<code>SWT.PUSH</code>) buttons and registers for their
 	 * selection events. Note that the number of columns in the button bar
 	 * composite is incremented. These buttons are created specially to prevent
 	 * any space between them.
 	 * @param parent the parent button bar
 	 * @return a composite containing the new buttons
 	 */
 	private Composite createPreviousAndNextButtons(Composite parent) {
 		// increment the number of columns in the button bar
 		((GridLayout) parent.getLayout()).numColumns++;
 		Composite composite = new Composite(parent, SWT.NONE);
 		// create a layout with spacing and margins appropriate for the font
 		// size.
 		GridLayout layout = new GridLayout();
 		layout.numColumns = 0; // will be incremented by createButton
 		layout.marginWidth = 0;
 		layout.marginHeight = 0;
 		layout.horizontalSpacing = 0;
 		layout.verticalSpacing = 0;
 		composite.setLayout(layout);
 		GridData data = new GridData(GridData.HORIZONTAL_ALIGN_CENTER
 				| GridData.VERTICAL_ALIGN_CENTER);
 		composite.setLayoutData(data);
 		composite.setFont(parent.getFont());
 		backButton = createButton(composite, IDialogConstants.BACK_ID,
 				IDialogConstants.BACK_LABEL, false);
 		nextButton = createButton(composite, IDialogConstants.NEXT_ID,
 				IDialogConstants.NEXT_LABEL, false);
 		return composite;
 	}
 	/***
 	 * The Finish button has been pressed.
 	 */
 	protected void finishPressed() {
 		if (!wizard.canFinish())
 			throw new IllegalStateException("Finish button should be disabled"); //$NON-NLS-1$
 		// Wizards are added to the nested wizards list in setWizard.
 		// This means that the current wizard is always the last wizard in the
 		// list.
 		// Note that we first call the current wizard directly (to give it a
 		// chance to
 		// abort, do work, and save state) then call the remaining n-1 wizards
 		// in the
 		// list (to save state).
 		if (wizard.performFinish()) {
 			// Hard close the dialog.
 			setReturnCode(OK);
 			hardClose();
 		}
 	}
 	/***
 	 * Returns page, currently shown on screen.
 	 * @return currently shown page.
 	 */
 	public BaseWizardPage getCurrentPage() {
 		return wizard.current();
 	}
 	/***
 	 * Returns the wizard this dialog is currently displaying.
 	 * @return the current wizard
 	 */
 	protected IWizard getWizard() {
 		return wizard;
 	}
 	/***
 	 * Closes this window.
 	 * @return <code>true</code> if the window is (or was already) closed, and
 	 * <code>false</code> if it is still open
 	 */
 	private boolean hardClose() {
 		// dispose all pages.
 		for (BaseWizardPage page : wizardPages) {
 			page.dispose();
 		}
 		// dispose the wizard itself
 		wizard.dispose();
 		// close the form
 		return super.close();
 	}
 	/***
 	 * The Next button has been pressed.
 	 */
 	protected void nextPressed() {
 		if (!wizard.hasNext())
 			throw new IllegalStateException("Next button must not be enabled"); //$NON-NLS-1$
 		final BaseWizardPage next;
 		try {
 			next = wizard.next();
 		} catch (ProviderException ex) {
 			// error happened during creating next wizard. show error msg
 			// and stay at current page.
 			EuroMath.log(IStatus.ERROR, 0,
 					"Provider has thrown error while creating next wizard", ex); //$NON-NLS-1$
 			MessageDialog.openError(getShell(), Messages.getString("ERROR"), ex //$NON-NLS-1$
 					.getLocalizedMessage());
 			return;
 		}
 		// initialize the page
 		final Composite tile = new Composite(pageContainer, SWT.NONE);
 		tile.setLayout(new GridLayout(1, false));
 		tile.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
 		next.createControl(tile);
 		next.setContext(pageContext);
 		pageTiles.add(tile);
 		wizardPages.add(next);
 		// show the next page
 		showLastPage();
 		firePageChanged();
 	}
 	/***
 	 * Checks whether it is alright to close this wizard dialog and performed
 	 * standard cancel processing. If there is a long running operation in
 	 * progress, this method posts an alert message saying that the wizard
 	 * cannot be closed.
 	 * @return <code>true</code> if it is alright to close this dialog, and
 	 * <code>false</code> if it is not
 	 */
 	private boolean okToClose() {
 		return wizard.performCancel();
 	}
 	/***
 	 * Sets the minimum page size used for the pages.
 	 * @param minWidth the minimum page width
 	 * @param minHeight the minimum page height
 	 * @see #setMinimumPageSize(Point)
 	 */
 	public void setMinimumPageSize(int minWidth, int minHeight) {
 		Assert.isTrue(minWidth >= 0 && minHeight >= 0);
 		pageContainerLayout.minimumWidth = minWidth;
 		pageContainerLayout.minimumHeight = minHeight;
 	}
 	/***
 	 * Sets the minimum page size used for the pages.
 	 * @param size the page size encoded as <code>new Point(width,height)</code>
 	 * @see #setMinimumPageSize(int,int)
 	 */
 	public void setMinimumPageSize(Point size) {
 		setMinimumPageSize(size.x, size.y);
 	}
 	/***
 	 * Sets the size of all pages. The given size takes precedence over computed
 	 * sizes.
 	 * @param width the page width
 	 * @param height the page height
 	 * @see #setPageSize(Point)
 	 */
 	public void setPageSize(int width, int height) {
 		pageWidth = width;
 		pageHeight = height;
 	}
 	/***
 	 * Sets the size of all pages. The given size takes precedence over computed
 	 * sizes.
 	 * @param size the page size encoded as <code>new Point(width,height)</code>
 	 * @see #setPageSize(int,int)
 	 */
 	public void setPageSize(Point size) {
 		setPageSize(size.x, size.y);
 	}
 	/***
 	 * Ensures that the last page is the visible one.
 	 */
 	private void showLastPage() {
 		final Composite currentTile = pageTiles.get(pageTiles.size() - 1);
 		currentTile.setVisible(true);
 		if (pageTiles.size() > 1) {
 			final Composite prevTile = pageTiles.get(pageTiles.size() - 2);
 			prevTile.setVisible(false);
 		}
 		// ensure the dialog is large enough for this page
 		updateSize(currentTile);
 		// update the dialog controls
 		update();
 	}
 	/***
 	 * Updates this dialog's controls to reflect the current page.
 	 */
 	protected void update() {
 		// Update the title bar
 		updateTitleBar();
 		// Update the buttons
 		updateButtons();
 	}
 	/***
 	 * Updates buttons state.
 	 */
 	private void updateButtons() {
 		final boolean canFinish = wizard.canFinish();
 		final boolean canFlipToNextPage = wizard.hasNext();
 		backButton.setEnabled(wizard.hasPrevious());
 		nextButton.setEnabled(canFlipToNextPage);
 		finishButton.setEnabled(canFinish);
 		// finish is default unless it is diabled and next is enabled
 		if (canFlipToNextPage && !canFinish)
 			getShell().setDefaultButton(nextButton);
 		else
 			getShell().setDefaultButton(finishButton);
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see org.eclipse.jface.dialogs.TitleAreaDialog#setMessage(java.lang.String,
 	 * int)
 	 */
 	@Override
 	public void setMessage(String newMessage, int newType) {
 		super.setMessage(newMessage, newType);
 		currentMessage = newMessage;
 		currentMessageLevel = newType;
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see org.eclipse.jface.dialogs.TitleAreaDialog#setErrorMessage(java.lang.String)
 	 */
 	@Override
 	public void setErrorMessage(String newErrorMessage) {
 		super.setErrorMessage(newErrorMessage);
 		currentErrorMessage = newErrorMessage;
 	}
 	/***
 	 * Returns current error message.
 	 * @return current error message.
 	 */
 	public String getErrorMessage() {
 		return currentErrorMessage;
 	}
 	/***
 	 * Returns current message.
 	 * @return current message.
 	 */
 	public String getMessage() {
 		return currentMessage;
 	}
 	/***
 	 * Returns current message's level.
 	 * @return current message's level.
 	 */
 	public int getMessageType() {
 		return currentMessageLevel;
 	}
 	/***
 	 * Updates currently shown messages from current page.
 	 */
 	private void updateMessage() {
 		if (wizard.current() == null)
 			setMessages(null);
 		else
 			setMessages(wizard.current().getMessages());
 	}
 	/***
 	 * Currently shown error message.
 	 */
 	private String currentErrorMessage = null;
 	/***
 	 * Currently shown message.
 	 */
 	private String currentMessage = null;
 	/***
 	 * Level of currently shown message.
 	 */
 	private int currentMessageLevel = IMessageProvider.NONE;
 	/***
 	 * Updates messages.
 	 * @param messages validity messages. If <code>null</code> then all
 	 * messages are cleared.
 	 */
 	private void setMessages(ValidityMessages messages) {
 		if (messages == null) {
 			if (getErrorMessage() != null)
 				setErrorMessage(null);
 			if (getMessage() != null) {
 				setMessage(null, IMessageProvider.NONE);
 			}
 			return;
 		}
 		// check if we have new error message.
 		if (!JavaTools.equals(getErrorMessage(), messages.error))
 			setErrorMessage(messages.error);
 		if (messages.error != null) {
 			// cannot show both error and warning, bail out.
 			return;
 		}
 		// check if we have new warning message.
 		if ((getMessageType() != IMessageProvider.WARNING)
 				|| (!JavaTools.equals(getMessage(), messages.warning))) {
 			// warning message has been changed. Update, but only if needed. We
 			// don't have to null warning message if there is non-null info
 			// message.
 			if ((messages.warning != null) || (messages.info == null))
 				setMessage(messages.warning, IMessageProvider.WARNING);
 		}
 		if (messages.warning != null) {
 			// cannot show both warning and information, bail out.
 			return;
 		}
 		// check if we have new information message.
 		if ((getMessageType() != IMessageProvider.INFORMATION)
 				|| (!JavaTools.equals(getMessage(), messages.info))) {
 			setMessage(messages.info, IMessageProvider.INFORMATION);
 		}
 	}
 	/***
 	 * Changes the shell size to the given size, ensuring that it is no larger
 	 * than the display bounds.
 	 * @param width the shell width
 	 * @param height the shell height
 	 */
 	private void setShellSize(int width, int height) {
 		Rectangle size = getShell().getBounds();
 		size.height = height;
 		size.width = width;
 		getShell().setBounds(getConstrainedShellBounds(size));
 	}
 	/***
 	 * Computes the correct dialog size for the current page and resizes its
 	 * shell if nessessary. Also causes the container to refresh its layout.
 	 * @param tile the composite where the wizard page is placed, to use to
 	 * resize the dialog
 	 * @since 2.0
 	 */
 	protected void updateSize(Composite tile) {
 		updateSizeForPage(tile);
 		pageContainerLayout.layoutPage(tile);
 	}
 	/***
 	 * Updates size of the window.
 	 */
 	public void updateSize() {
 		updateSize(pageTiles.get(pageTiles.size() - 1));
 	}
 	/***
 	 * Computes the correct dialog size for the given page and resizes its shell
 	 * if nessessary.
 	 * @param tile the composite where the wizard page is placed
 	 */
 	private void updateSizeForPage(Composite tile) {
 		// ensure the page container is large enough
 		Point delta = calculatePageSizeDelta(tile);
 		if (delta.x > 0 || delta.y > 0) {
 			// increase the size of the shell
 			Shell shell = getShell();
 			Point shellSize = shell.getSize();
 			setShellSize(shellSize.x + delta.x, shellSize.y + delta.y);
 			constrainShellSize();
 		}
 	}
 	/***
 	 * Updates the titlebar.
 	 */
 	private void updateTitleBar() {
 		final String s = StringTools.nonNullStr(wizard.getName());
 		setTitle(s);
 		final BaseWizardPage currentPage = wizard.current();
 		if (currentPage != null)
 			setTitleImage(currentPage.titleImage);
 		updateMessage();
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see org.eclipse.jface.dialogs.IPageChangeProvider#getSelectedPage()
 	 */
 	public Object getSelectedPage() {
 		return getCurrentPage();
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see org.eclipse.jface.dialog.IPageChangeProvider#addPageChangedListener()
 	 */
 	public void addPageChangedListener(IPageChangedListener listener) {
 		pageChangedListeners.add(listener);
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see org.eclipse.jface.dialog.IPageChangeProvider#removePageChangedListener()
 	 */
 	public void removePageChangedListener(IPageChangedListener listener) {
 		pageChangedListeners.remove(listener);
 	}
 	/***
 	 * Notifies any selection changed listeners that the selected page has
 	 * changed. Only listeners registered at the time this method is called are
 	 * notified.
 	 * @see IPageChangedListener#pageChanged
 	 */
 	protected void firePageChanged() {
 		final PageChangedEvent event = new PageChangedEvent(this, wizard
 				.current());
 		Object[] listeners = pageChangedListeners.getListeners();
 		for (int i = 0; i < listeners.length; ++i) {
 			final IPageChangedListener l = (IPageChangedListener) listeners[i];
 			SafeRunnable.run(new SafeRunnable() {
 				public void run() {
 					l.pageChanged(event);
 				}
 			});
 		}
 	}
 	/***
 	 * The context given to each page.
 	 * @author Martin Vysny
 	 */
 	private final class PageContext implements IWizardPageContext {
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.editor.wizards.IWizardPageContext#getShell()
 		 */
 		public Shell getShell() {
 			return WizardDialog.this.getShell();
 		}
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.editor.wizards.IWizardPageContext#updateMessages()
 		 */
 		public void updateMessages() {
 			update();
 		}
 	}
 	/***
 	 * Context given to each page.
 	 */
 	private final IWizardPageContext pageContext = new PageContext();
 }