/* (non-Javadoc)

		 * @see org.eclipse.jface.dialogs.TrayDialog#close()

		 */

		public boolean close() {

			boolean result = super.close();

			if (listener != null && !modalitySwitch) {

				listener.statusDialogClosed();

			}

			return result;

		}

	private IStatusDialogListener listener;

	/**

	 * This method adds a listener to the dialog. Listener will be notified

	 * about dialog state changes. There can be only one listener set.

	 * <p>

	 * <strong>EXPERIMENTAL</strong>. This class or interface has been added as

	 * part of a work in progress. There is a guarantee neither that this API

	 * will work nor that it will remain the same. Please do not use this API

	 * without consulting with the Platform/UI team.

	 * </p>

	 * 

	 * @see IStatusDialogListener

	 * @param listener

	 *            A listener to be set. <code>null</code> can be used to clear

	 *            the listener.

	 * @since 3.5

	 */

	public void setStatusDialogListener(IStatusDialogListener listener) {

		this.listener = listener;

	}

	private boolean dialogClosed = false;

	private IStatusDialogListener listener = new IStatusDialogListener(){

		public void statusDialogClosed() {

			dialogClosed = true;

		}

	};

		statusDialog.setStatusDialogListener(listener);

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

 * Copyright (c) 2008 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 org.eclipse.ui.statushandlers;

/**

 * This interface allows for listening to dialog state changes. The dialog is

 * managed by {@link WorkbenchStatusDialogManager}.

 * 

 * <p>

 * <strong>EXPERIMENTAL</strong>. This class or interface has been added as part

 * of a work in progress. There is a guarantee neither that this API will work

 * nor that it will remain the same. Please do not use this API without

 * consulting with the Platform/UI team.

 * </p>

 * 

 * @since 3.5

 */

public interface IStatusDialogListener {

	/**

	 * This method is called when the status dialog is closed by user.

	 */

	public void statusDialogClosed();

}

import org.eclipse.swt.widgets.Display;

import org.eclipse.ui.statushandlers.IStatusDialogListener;

import org.eclipse.ui.statushandlers.StatusManager;

import org.eclipse.ui.statushandlers.WorkbenchErrorHandler;

	private final static String MESSAGE_3 = "TEST_MESSAGE_2";

	/**

	 * This test checks if the calling thread is really blocked. It opens a

	 * dialog with the BLOCK flag in UI thread, and then monitors in the

	 * background thread that the dialog really appears (in 50 tries, 50

	 * milliseconds each). After the dialog appears, "OK" selection is emulated,

	 * the dialog is closed and the handle method returns. At this point there

	 * can be no shell.

	 */

	public void testBlockingBehavior1() {

		WorkbenchErrorHandler weh = new WorkbenchErrorHandler();

		Thread thread = new Thread(new Runnable(){

			public void run() {

				int count = 50;

				final boolean opened[] = new boolean[]{false};

				while (!opened[0] && count-- != 0) {

					try {

						Thread.sleep(50);

					} catch (InterruptedException e) {

						e.printStackTrace();

					}

					Display.getDefault().syncExec(new Runnable() {

						public void run() {

							opened[0] = StatusDialogUtil.getStatusShell() != null;

							if(opened[0]){

								selectWidget(StatusDialogUtil.getOkButton());

							}

						}

					});

				}

				assertTrue("Dialog should appear!", count > 0);

			}

		});

		thread.start();

		weh.handle(createStatusAdapter(MESSAGE_1), StatusManager.BLOCK);

		assertNull("Dialog should block the calling thread!", StatusDialogUtil

				.getStatusShell());

	}

	/**

	 * This is more advanced version of testBlockingBehavior1. We have 2

	 * background threads that raise statuses. UI thread also raises one. No

	 * thread can proceed until "OK" is emulated (and this will happen if the

	 * dialog is opened and three statuses were reported).

	 */

	public void testBlockingBehavior2() {

		final WorkbenchErrorHandler weh = new WorkbenchErrorHandler();

		Thread thread1 = new Thread(new Runnable() {

			public void run() {

				weh.handle(createStatusAdapter(MESSAGE_1), StatusManager.BLOCK);

				Display.getDefault().syncExec(new Runnable() {

					public void run() {

						assertNull("Dialog should block the calling thread!",

								StatusDialogUtil.getStatusShell());

					}

				});

			}

		});

		thread1.start();

		Thread thread2 = new Thread(new Runnable() {

			public void run() {

				weh.handle(createStatusAdapter(MESSAGE_2), StatusManager.BLOCK);

				Display.getDefault().syncExec(new Runnable() {

					public void run() {

						assertNull("Dialog should block the calling thread!",

								StatusDialogUtil.getStatusShell());

					}

				});

			}

		});

		thread2.start();

		Thread checker = new Thread(new Runnable() {

			public void run() {

				int count = 50;

				final boolean statusesShown[] = new boolean[] { false };

				while (!statusesShown[0] && count-- != 0) {

					try {

						Thread.sleep(50);

					} catch (InterruptedException e) {

						e.printStackTrace();

					}

					Display.getDefault().syncExec(new Runnable() {

						public void run() {

							boolean dialogVisible = StatusDialogUtil

									.getStatusShell() != null;

							statusesShown[0] = dialogVisible

									&& StatusDialogUtil.getTable()

											.getItemCount() == 3;

							if (statusesShown[0]) {

								selectWidget(StatusDialogUtil.getOkButton());

							}

						}

					});

				}

				assertTrue(

						"Dialog should appear and all statuses should be shown",

						count > 0);

			}

		});

		checker.start();

		weh.handle(createStatusAdapter(MESSAGE_3), StatusManager.BLOCK);

		assertNull("Dialog should block the calling thread!", StatusDialogUtil

				.getStatusShell());

	}

	/**

	 * Check that listener is notified about dialog closure when the dialog is

	 * closed by the user.

	 */

	public void testListener1(){

		final boolean[] dialogClosedInvoked = new boolean[]{false};

		wsdm.setStatusDialogListener(new IStatusDialogListener(){

			public void statusDialogClosed() {

				dialogClosedInvoked[0] = true;

			}

		});

		wsdm.addStatusAdapter(createStatusAdapter(MESSAGE_1), false);

		selectWidget(StatusDialogUtil.getOkButton());

		assertTrue(dialogClosedInvoked[0]);

	}

	/**

	 * Check that listener is not notified about dialog closure when the

	 * modality is switched.

	 */

	public void testListener2(){

		final boolean[] dialogClosedInvoked = new boolean[]{false};

		wsdm.setStatusDialogListener(new IStatusDialogListener(){

			public void statusDialogClosed() {

				dialogClosedInvoked[0] = true;

			}

		});

		wsdm.addStatusAdapter(createStatusAdapter(MESSAGE_1), false);

		wsdm.addStatusAdapter(createStatusAdapter(MESSAGE_1), true);

		assertFalse(dialogClosedInvoked[0]);

		selectWidget(StatusDialogUtil.getOkButton());

		// now should be notified

		assertTrue(dialogClosedInvoked[0]);

	}