* Application provides a handful of methods that are invoked as part of * starting the application. Subclasses need only override those they are * interested in. The following outlines the order the methods are invoked in * as well as what they are intended for. All methods are invoked on the * event dispatching thread. *
*
* Application also provides a sequence of methods for exiting the
* application. When exit is invoked the following methods are invoked:
*
* Concrete implementations need only override getName, but will undoubtedly
* override one of the various init methods as well.
*/
public abstract class Application implements Thread.UncaughtExceptionHandler {
private static Application APPLICATION;
private static final int RUN_POST_INIT_EVENT_QUEUE_EMPTY = 0;
private static final int RUN_START_ON_EDT = 1;
private static final int RUN_WAIT_EVENTS = 2;
private static final int UNCAUGHT_EXCEPTION = 3;
private static final int RUN_WAIT_FOR_BACKGROUND_THREADS = 4;
// Exception that has been thrown. This is used to track if an exception
// is thrown while alerting the user to the current exception.
private Throwable throwable = null;
// ThreadFactory for vending threads that are automatically registered.
private ThreadFactory threadFactory;
// Threads we'll block on when exiting.
private List
* When exit is invoked the Application will block until all background
* threads have exited.
*
* @return a ThreadFactory suitable for background threads
* @see #registerThread
* @see #waitForBackgroundThreadsToExit
*/
public ThreadFactory getBackgroundThreadFactory() {
if (threadFactory == null) {
threadFactory = new SwingThreadFactory();
}
return threadFactory;
}
/**
* Registers a background thread with the Application. When the application
* exits it will block until all background threads have completed.
*
* This method is thread safe.
*
* @param thread the Thread to wait for completion on
* @throws IllegalArgumentException if thread is null
*/
public final void registerThread(Thread thread) {
if (thread == null) {
throw new IllegalArgumentException("Thread must be non-null");
}
synchronized(threads) {
// Prune any bogus references
Iterator
*
* getClass().getName().resources.Resources.
*
* @return the name used to locate the Applications ResourceBundle
*/
protected String getResourceBundleName() {
return getClass().getPackage().getName() + ".resources.Resources";
}
/**
* Returns a ThreadFactory suitable for threads used within Swing
* applications. Threads created by the returned ThreadFactory are
* automatically registered with the Application, are not daemon, and
* have a priority of Thread.MIN_PRIORITY.
* main. Refer to
* init sequence for details on which methods
* this invokes.
*
* @throws IllegalStateException if start has already been invoked
* @see init sequence
*/
public final void start() {
if (started) {
throw new IllegalStateException("Application is already running");
}
started = true;
if (!EventQueue.isDispatchThread()) {
SwingUtilities.invokeLater(new Handler(RUN_START_ON_EDT));
} else {
startOnEDT();
}
}
private void startOnEDT() {
preInit();
init();
fireApplicationDidInit();
postInit();
new Thread(new Handler(RUN_WAIT_EVENTS)).start();
}
/**
* Returns whether the application should be allowed to exit. This
* is invoked from exit. A return value of false will stop the application
* from exiting.
*
* @return whether or not the application should be allowed to exit; this
* implementation unconditionally returns true
* @see #exit
*/
protected boolean canExit() {
return true;
}
/**
* Invoked as part of exiting the application. Refer to
* exit sequence for details on when this
* method is invoked.
*/
protected void exiting() {
}
private boolean listenersCanExit() {
if (appListeners != null) {
for (ApplicationListener listener : appListeners) {
if (!listener.canApplicationExit()) {
return false;
}
}
}
return true;
}
/**
* Blocks until all registered threads have completed. This is invoked
* from exit. If necessary this method will invoke
* createBackgroundThreadDialog to create a modal dialog that is shown
* while waiting for background threads to exit.
*
* @see #exit
* @see #createBackgroundThreadDialog
*/
protected void waitForBackgroundThreadsToExit() {
// Do a quick check to see if we'll need to show a modal dialog. If
// after 100 ms threads are still running, then show a modal dialog.
if (!waitForBackgroundThreadsToExit(100)) {
// spawn background thread
JDialog threadDialog = createBackgroundThreadDialog();
new Thread(new Handler(RUN_WAIT_FOR_BACKGROUND_THREADS, threadDialog)).
start();
threadDialog.setVisible(true);
}
}
// Invoked on a background thread
private void waitForBackgroundThreadsToExitInBackground(JDialog dialog) {
waitForBackgroundThreadsToExit(Long.MAX_VALUE);
// The background thread is spawned prior to making the dialog visible.
// As such, we need to block until the dialog is visible.
while (!dialog.isVisible()) {
try {
Thread.sleep(10);
} catch (InterruptedException ex) {
}
}
dialog.setVisible(false);
}
// Blocks until the background threads exit, or maxWaitTime milliseconds has
// expired.
private boolean waitForBackgroundThreadsToExit(long maxWaitTime) {
boolean done = false;
long start = System.currentTimeMillis();
while (!done) {
Thread thread = null;
synchronized (threads) {
Iteratorexit.
*
* @param thread the thread the exception was thrown on
* @param throwable the thrown exception
* @see #getUncaughtExceptionDialog
*/
public void uncaughtException(Thread thread, final Throwable throwable) {
synchronized(this) {
if (this.throwable != null) {
// An exception has occured while we're trying to display
// the current exception, bale.
System.err.println("exception thrown while altering user");
throwable.printStackTrace();
System.exit(1);
} else {
this.throwable = throwable;
}
}
throwable.printStackTrace();
if (!SwingUtilities.isEventDispatchThread()) {
SwingUtilities.invokeLater(new Handler(UNCAUGHT_EXCEPTION));
} else {
uncaughtException0();
}
}
/**
* Returns the dialog that is shown when an uncaught exception is
* encountered.
*
* @see #uncaughtException
* @return dialog to show when an uncaught exception is encountered
*/
protected JDialog getUncaughtExceptionDialog() {
// PENDING: this needs to be localized.
JOptionPane optionPane = new JOptionPane(
"An unrecoverable error has occured. " + getName() +
" will now exit", JOptionPane.ERROR_MESSAGE);
return optionPane.createDialog(null, "Error");
}
private void uncaughtException0() {
Throwable throwable;
synchronized(this) {
throwable = this.throwable;
}
JDialog dialog = getUncaughtExceptionDialog();
dialog.setVisible(true);
System.exit(1);
}
/**
* Returns the dialog to show when waiting for any background threads
* to exit. The returned dialog must be modal.
*
* @return dialog to shown when waiting for background threads to exit
*/
protected JDialog createBackgroundThreadDialog() {
JDialog dialog = new JDialog((Frame)null, getName(), true);
dialog.setLayout(new GridBagLayout());
// PENDING: localize this
dialog.add(new JLabel("Waiting for processing to complete..."),
new GridBagConstraints(0, 0, 1, 1, 0, 0,
GridBagConstraints.LINE_START, GridBagConstraints.NONE,
new Insets(5, 5, 0, 50), 0, 0));
JProgressBar pb = new JProgressBar();
pb.setIndeterminate(true);
dialog.add(pb,
new GridBagConstraints(0, 1, 1, 1, 1, 0,
GridBagConstraints.LINE_START, GridBagConstraints.HORIZONTAL,
new Insets(5, 5, 5, 5), 0, 0));
dialog.setResizable(false);
dialog.pack();
dialog.setLocationRelativeTo(null);
dialog.setDefaultCloseOperation(JDialog.DO_NOTHING_ON_CLOSE);
return dialog;
}
private void waitForEmptyEventQ() {
boolean qEmpty = false;
JPanel bogusComponent = new JPanel();
EventQueue q = Toolkit.getDefaultToolkit().getSystemEventQueue();
while (!qEmpty) {
NotifyingPaintEvent e = new NotifyingPaintEvent(bogusComponent);
q.postEvent(e);
synchronized(e) {
// Wait until the event has been dispatched
while (!e.isDispatched()) {
try {
e.wait();
} catch (InterruptedException ie) {
}
}
// Check if the q is empty
qEmpty = e.qEmpty();
}
}
SwingUtilities.invokeLater(new Handler(RUN_POST_INIT_EVENT_QUEUE_EMPTY));
}
// Coalesced Runnable implementation to avoid numerous inner classes.
private class Handler implements Runnable {
private final int type;
private final Object[] args;
Handler(int type, Object...args) {
this.type = type;
this.args = args;
}
public void run() {
switch (this.type) {
case RUN_POST_INIT_EVENT_QUEUE_EMPTY:
postInitEventQueueEmpty();
break;
case RUN_START_ON_EDT:
startOnEDT();
break;
case RUN_WAIT_EVENTS:
waitForEmptyEventQ();
break;
case UNCAUGHT_EXCEPTION:
uncaughtException0();
break;
case RUN_WAIT_FOR_BACKGROUND_THREADS:
waitForBackgroundThreadsToExitInBackground((JDialog)this.args[0]);
break;
}
}
}
// Used in determining when the event Q is empty
private class NotifyingPaintEvent extends PaintEvent
implements ActiveEvent {
private boolean _dispatched = false;
private boolean _qEmpty;
NotifyingPaintEvent(Component x) {
super(x, PaintEvent.UPDATE, null);
}
public synchronized boolean isDispatched() {
return _dispatched;
}
public synchronized boolean qEmpty() {
return _qEmpty;
}
public void dispatch() {
EventQueue q = Toolkit.getDefaultToolkit().getSystemEventQueue();
_qEmpty = (q.peekEvent() == null);
synchronized(this) {
_dispatched = true;
notifyAll();
}
}
}
private static class SwingThreadFactory implements ThreadFactory {
public Thread newThread(Runnable r) {
Thread thread = new Thread(r, "swing-thread");
thread.setDaemon(false);
thread.setPriority(Thread.MIN_PRIORITY);
Application.getInstance().registerThread(thread);
return thread;
}
}
}