source: josm/trunk/src/org/openstreetmap/josm/gui/PleaseWaitRunnable.java@ 1023

// License: GPL. Copyright 2007 by Immanuel Scholz and others
package org.openstreetmap.josm.gui;

import static org.openstreetmap.josm.tools.I18n.tr;

import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;

import javax.swing.JOptionPane;

import org.openstreetmap.josm.Main;
import org.xml.sax.SAXException;

/**
 * Instanced of this thread will display a "Please Wait" message in middle of JOSM
 * to indicate a progress beeing executed.
 *
 * @author Imi
 */
public abstract class PleaseWaitRunnable implements Runnable {

        public String errorMessage;

        private boolean closeDialogCalled = false;
        private boolean cancelled = false;

        private final String title;

        /**
         * Create the runnable object with a given message for the user.
         */
        public PleaseWaitRunnable(String title) {
                this.title = title;
                Main.pleaseWaitDlg.cancel.addActionListener(new ActionListener(){
                        public void actionPerformed(ActionEvent e) {
                                if (!cancelled) {
                                        cancelled = true;
                                        cancel();
                                }
                        }
                });
                Main.pleaseWaitDlg.addWindowListener(new WindowAdapter(){
                        @Override public void windowClosing(WindowEvent e) {
                                if (!closeDialogCalled) {
                                        if (!cancelled) {
                                                cancelled = true;
                                                cancel();
                                        }
                                        closeDialog();
                                }
                        }
                });
        }

        public final void run() {
                try {
                        if (cancelled)
                                return; // since realRun isn't executed, do not call to finish

                        // reset dialog state
                        Main.pleaseWaitDlg.setTitle(title);
                        errorMessage = null;
                        closeDialogCalled = false;

                        // show the dialog
                        synchronized (this) {
                    EventQueue.invokeLater(new Runnable() {
                        public void run() {
                                synchronized (PleaseWaitRunnable.this) {
                                        PleaseWaitRunnable.this.notifyAll();
                                }
                                Main.pleaseWaitDlg.setVisible(true);
                        }
                    });
                    try {wait();} catch (InterruptedException e) {}
                        }

                        realRun();
                } catch (SAXException x) {
                        x.printStackTrace();
                        errorMessage = tr("Error while parsing")+": "+x.getMessage();
                } catch (FileNotFoundException x) {
                        x.printStackTrace();
                        errorMessage = tr("File not found")+": "+x.getMessage();
                } catch (IOException x) {
                        x.printStackTrace();
                        errorMessage = x.getMessage();
                } finally {
                        closeDialog();
                }
        }

        /**
         * User pressed cancel button.
         */
        protected abstract void cancel();

        /**
         * Called in the worker thread to do the actual work. When any of the
         * exception is thrown, a message box will be displayed and closeDialog
         * is called. finish() is called in any case.
         */
        protected abstract void realRun() throws SAXException, IOException;

        /**
         * Finish up the data work. Is guaranteed to be called if realRun is called.
         * Finish is called in the gui thread just after the dialog disappeared.
         */
        protected abstract void finish();

        /**
         * Close the dialog. Usually called from worker thread.
         */
        public void closeDialog() {
                if (closeDialogCalled)
                        return;
                closeDialogCalled  = true;
                try {
                        Runnable runnable = new Runnable(){
                                public void run() {
                                        try {
                                                finish();
                                        } finally {
                                                Main.pleaseWaitDlg.setVisible(false);
                                                Main.pleaseWaitDlg.dispose();
                                        }
                                        if (errorMessage != null)
                                                JOptionPane.showMessageDialog(Main.parent, errorMessage);
                                }
                        };

                        // make sure, this is called in the dispatcher thread ASAP
                        if (EventQueue.isDispatchThread())
                                runnable.run();
                        else
                                EventQueue.invokeAndWait(runnable);

                } catch (InterruptedException e) {
                } catch (InvocationTargetException e) {
                        throw new RuntimeException(e);
                }
        }
}