*/
public class TApplication {
+ /**
+ * If true, emit thread stuff to System.err.
+ */
+ private static final boolean debugThreads = false;
+
+ /**
+ * If true, emit events being processed to System.err.
+ */
+ private static final boolean debugEvents = false;
+
/**
* WidgetEventHandler is the main event consumer loop. There are at most
* two such threads in existence: the primary for normal case and a
break;
}
}
- synchronized (application) {
- application.wait();
+
+ synchronized (this) {
+ /*
+ System.err.printf("%s %s sleep\n", this, primary ?
+ "primary" : "secondary");
+ */
+
+ this.wait();
+
+ /*
+ System.err.printf("%s %s AWAKE\n", this, primary ?
+ "primary" : "secondary");
+ */
+
if ((!primary)
&& (application.secondaryEventReceiver == null)
) {
- // Secondary thread, time to exit
+ // Secondary thread, emergency exit. If we
+ // got here then something went wrong with
+ // the handoff between yield() and
+ // closeWindow().
+
+ System.err.printf("secondary exiting at wrong time, why?\n");
+ synchronized (application.primaryEventHandler) {
+ application.primaryEventHandler.notify();
+ }
+ application.secondaryEventHandler = null;
return;
}
break;
}
event = application.drainEventQueue.remove(0);
}
+ // Wait for drawAll() or doIdle() to be done, then handle
+ // the event.
+ boolean oldLock = lockHandleEvent();
+ assert (oldLock == false);
if (primary) {
primaryHandleEvent(event);
} else {
secondaryHandleEvent(event);
}
+ application.repaint = true;
if ((!primary)
&& (application.secondaryEventReceiver == null)
) {
- // Secondary thread, time to exit
+ // Secondary thread, time to exit.
+
+ // DO NOT UNLOCK. Primary thread just came back from
+ // primaryHandleEvent() and will unlock in the else
+ // block below. Just wake it up.
+ synchronized (application.primaryEventHandler) {
+ application.primaryEventHandler.notify();
+ }
+ // Now eliminate my reference so that
+ // wakeEventHandler() resumes working on the primary.
+ application.secondaryEventHandler = null;
+
+ // All done!
return;
+ } else {
+ // Unlock. Either I am primary thread, or I am
+ // secondary thread and still running.
+ oldLock = unlockHandleEvent();
+ assert (oldLock == true);
}
+ } // for (;;)
+
+ // I have done some work of some kind. Tell the main run()
+ // loop to wake up now.
+ synchronized (application) {
+ application.notify();
}
+
} // while (true) (main runnable loop)
}
}
/**
* The primary event handler thread.
*/
- private WidgetEventHandler primaryEventHandler;
+ private volatile WidgetEventHandler primaryEventHandler;
/**
* The secondary event handler thread.
*/
- private WidgetEventHandler secondaryEventHandler;
+ private volatile WidgetEventHandler secondaryEventHandler;
/**
* The widget receiving events from the secondary event handler thread.
*/
- private TWidget secondaryEventReceiver;
+ private volatile TWidget secondaryEventReceiver;
+
+ /**
+ * Spinlock for the primary and secondary event handlers.
+ * WidgetEventHandler.run() is responsible for setting this value.
+ */
+ private volatile boolean insideHandleEvent = false;
+
+ /**
+ * Wake the sleeping active event handler.
+ */
+ private void wakeEventHandler() {
+ if (secondaryEventHandler != null) {
+ synchronized (secondaryEventHandler) {
+ secondaryEventHandler.notify();
+ }
+ } else {
+ assert (primaryEventHandler != null);
+ synchronized (primaryEventHandler) {
+ primaryEventHandler.notify();
+ }
+ }
+ }
+
+ /**
+ * Set the insideHandleEvent flag to true. lockoutEventHandlers() will
+ * spin indefinitely until unlockHandleEvent() is called.
+ *
+ * @return the old value of insideHandleEvent
+ */
+ private boolean lockHandleEvent() {
+ if (debugThreads) {
+ System.err.printf(" >> lockHandleEvent(): oldValue %s",
+ insideHandleEvent);
+ }
+ boolean oldValue = true;
+
+ synchronized (this) {
+ // Wait for TApplication.run() to finish using the global state
+ // before allowing further event processing.
+ while (lockoutHandleEvent == true);
+
+ oldValue = insideHandleEvent;
+ insideHandleEvent = true;
+ }
+
+ if (debugThreads) {
+ System.err.printf(" ***\n");
+ }
+ return oldValue;
+ }
+
+ /**
+ * Set the insideHandleEvent flag to false. lockoutEventHandlers() will
+ * spin indefinitely until unlockHandleEvent() is called.
+ *
+ * @return the old value of insideHandleEvent
+ */
+ private boolean unlockHandleEvent() {
+ if (debugThreads) {
+ System.err.printf(" << unlockHandleEvent(): oldValue %s\n",
+ insideHandleEvent);
+ }
+ synchronized (this) {
+ boolean oldValue = insideHandleEvent;
+ insideHandleEvent = false;
+ return oldValue;
+ }
+ }
+
+ /**
+ * Spinlock for the primary and secondary event handlers. When true, the
+ * event handlers will spinlock wait before calling handleEvent().
+ */
+ private volatile boolean lockoutHandleEvent = false;
+
+ /**
+ * TApplication.run() needs to be able rely on the global data structures
+ * being intact when calling doIdle() and drawAll(). Tell the event
+ * handlers to wait for an unlock before handling their events.
+ */
+ private void stopEventHandlers() {
+ if (debugThreads) {
+ System.err.printf(">> stopEventHandlers()");
+ }
+
+ lockoutHandleEvent = true;
+ // Wait for the last event to finish processing before returning
+ // control to TApplication.run().
+ while (insideHandleEvent == true);
+
+ if (debugThreads) {
+ System.err.printf(" XXX\n");
+ }
+ }
+
+ /**
+ * TApplication.run() needs to be able rely on the global data structures
+ * being intact when calling doIdle() and drawAll(). Tell the event
+ * handlers that it is now OK to handle their events.
+ */
+ private void startEventHandlers() {
+ if (debugThreads) {
+ System.err.printf("<< startEventHandlers()\n");
+ }
+ lockoutHandleEvent = false;
+ }
/**
* Access to the physical screen, keyboard, and mouse.
/**
* When true, exit the application.
*/
- private boolean quit = false;
+ private volatile boolean quit = false;
/**
* When true, repaint the entire screen.
*/
- private boolean repaint = true;
-
- /**
- * Request full repaint on next screen refresh.
- */
- public final void setRepaint() {
- repaint = true;
- }
+ private volatile boolean repaint = true;
/**
- * When true, just flush updates from the screen.
+ * When true, just flush updates from the screen. This is only used to
+ * minimize physical writes for the mouse cursor.
*/
private boolean flush = false;
if (useAWT) {
- backend = new AWTBackend();
+ backend = new AWTBackend(this);
} else {
- backend = new ECMA48Backend(input, output);
+ backend = new ECMA48Backend(this, input, output);
}
theme = new ColorTheme();
desktopBottom = getScreen().getHeight() - 1;
* Draw everything.
*/
public final void drawAll() {
+ if (debugThreads) {
+ System.err.printf("drawAll() enter\n");
+ }
+
if ((flush) && (!repaint)) {
backend.flushScreen();
flush = false;
return;
}
- if (!repaint) {
- return;
+ if (debugThreads) {
+ System.err.printf("drawAll() REDRAW\n");
}
// If true, the cursor is not visible
while (!quit) {
// Timeout is in milliseconds, so default timeout after 1 second
// of inactivity.
- int timeout = getSleepTime(1000);
-
- // See if there are any definitely events waiting to be processed
- // or a screen redraw to do. If so, do not wait if there is no
- // I/O coming in.
- synchronized (drainEventQueue) {
- if (drainEventQueue.size() > 0) {
- timeout = 0;
+ long timeout = 0;
+
+ // If I've got no updates to render, wait for something from the
+ // backend or a timer.
+ if (!repaint && !flush) {
+ // Never sleep longer than 100 millis, to get windows with
+ // background tasks an opportunity to update the display.
+ timeout = getSleepTime(100);
+
+ // See if there are any definitely events waiting to be
+ // processed. If so, do not wait -- either there is I/O
+ // coming in or the primary/secondary threads are still
+ // working.
+ synchronized (drainEventQueue) {
+ if (drainEventQueue.size() > 0) {
+ timeout = 0;
+ }
+ }
+ synchronized (fillEventQueue) {
+ if (fillEventQueue.size() > 0) {
+ timeout = 0;
+ }
}
}
- synchronized (fillEventQueue) {
- if (fillEventQueue.size() > 0) {
- timeout = 0;
+
+ if (timeout > 0) {
+ // As of now, I've got nothing to do: no I/O, nothing from
+ // the consumer threads, no timers that need to run ASAP. So
+ // wait until either the backend or the consumer threads have
+ // something to do.
+ try {
+ synchronized (this) {
+ this.wait(timeout);
+ }
+ } catch (InterruptedException e) {
+ // I'm awake and don't care why, let's see what's going
+ // on out there.
}
}
// Pull any pending I/O events
- backend.getEvents(fillEventQueue, timeout);
+ backend.getEvents(fillEventQueue);
// Dispatch each event to the appropriate handler, one at a time.
for (;;) {
metaHandleEvent(event);
}
+ // Wake a consumer thread if we have any pending events.
+ synchronized (drainEventQueue) {
+ if (drainEventQueue.size() > 0) {
+ wakeEventHandler();
+ }
+ }
+
+ // Prevent stepping on the primary or secondary event handler.
+ stopEventHandlers();
+
// Process timers and call doIdle()'s
doIdle();
// Update the screen
- drawAll();
- }
+ synchronized (getScreen()) {
+ drawAll();
+ }
- // Shutdown the consumer threads
- synchronized (this) {
- this.notifyAll();
+ // Let the event handlers run again.
+ startEventHandlers();
+
+ } // while (!quit)
+
+ // Shutdown the event consumer threads
+ if (secondaryEventHandler != null) {
+ synchronized (secondaryEventHandler) {
+ secondaryEventHandler.notify();
+ }
+ }
+ if (primaryEventHandler != null) {
+ synchronized (primaryEventHandler) {
+ primaryEventHandler.notify();
+ }
}
+ // Shutdown the user I/O thread(s)
backend.shutdown();
+
+ // Close all the windows. This gives them an opportunity to release
+ // resources.
+ closeAllWindows();
+
}
/**
*/
private void metaHandleEvent(final TInputEvent event) {
- /*
- System.err.printf(String.format("metaHandleEvents event: %s\n",
- event)); System.err.flush();
- */
+ if (debugEvents) {
+ System.err.printf(String.format("metaHandleEvents event: %s\n",
+ event)); System.err.flush();
+ }
if (quit) {
// Do no more processing if the application is already trying
synchronized (drainEventQueue) {
drainEventQueue.add(event);
}
-
- // Wake all threads: primary thread will either be consuming events
- // again or waiting in yield(), and secondary thread will either not
- // exist or consuming events.
- synchronized (this) {
- this.notifyAll();
- }
}
/**
*/
private void primaryHandleEvent(final TInputEvent event) {
- // System.err.printf("Handle event: %s\n", event);
+ if (debugEvents) {
+ System.err.printf("Handle event: %s\n", event);
+ }
// Special application-wide events -----------------------------------
mouse.setX(mouse.getX() - window.getX());
mouse.setY(mouse.getY() - window.getY());
}
- // System.err("TApplication dispatch event: %s\n", event);
+ if (debugEvents) {
+ System.err.printf("TApplication dispatch event: %s\n",
+ event);
+ }
window.handleEvent(event);
break;
}
*/
public final void yield() {
assert (secondaryEventReceiver != null);
+ // This is where we handoff the event handler lock from the primary
+ // to secondary thread. We unlock here, and in a future loop the
+ // secondary thread locks again. When it gives up, we have the
+ // single lock back.
+ boolean oldLock = unlockHandleEvent();
+ assert (oldLock == true);
+
+ // System.err.printf("YIELD\n");
+
while (secondaryEventReceiver != null) {
- synchronized (this) {
+ synchronized (primaryEventHandler) {
try {
- this.wait();
+ primaryEventHandler.wait();
} catch (InterruptedException e) {
// SQUASH
}
}
}
+
+ // System.err.printf("EXIT YIELD\n");
}
/**
* Do stuff when there is no user input.
*/
private void doIdle() {
+ if (debugThreads) {
+ System.err.printf("doIdle()\n");
+ }
+
// Now run any timers that have timed out
Date now = new Date();
List<TTimer> keepTimers = new LinkedList<TTimer>();
for (TTimer timer: timers) {
- if (timer.getNextTick().getTime() < now.getTime()) {
+ if (timer.getNextTick().getTime() <= now.getTime()) {
timer.tick();
if (timer.recurring) {
keepTimers.add(timer);
/**
* Get the amount of time I can sleep before missing a Timer tick.
*
- * @param timeout = initial (maximum) timeout
+ * @param timeout = initial (maximum) timeout in millis
* @return number of milliseconds between now and the next timer event
*/
- protected int getSleepTime(final int timeout) {
+ protected long getSleepTime(final long timeout) {
Date now = new Date();
+ long nowTime = now.getTime();
long sleepTime = timeout;
for (TTimer timer: timers) {
- if (timer.getNextTick().getTime() < now.getTime()) {
+ long nextTickTime = timer.getNextTick().getTime();
+ if (nextTickTime < nowTime) {
return 0;
}
- if ((timer.getNextTick().getTime() > now.getTime())
- && ((timer.getNextTick().getTime() - now.getTime()) < sleepTime)
- ) {
- sleepTime = timer.getNextTick().getTime() - now.getTime();
+
+ long timeDifference = nextTickTime - nowTime;
+ if (timeDifference < sleepTime) {
+ sleepTime = timeDifference;
}
}
assert (sleepTime >= 0);
- return (int)sleepTime;
+ assert (sleepTime <= timeout);
+ return sleepTime;
}
/**
// window is closed.
secondaryEventReceiver = null;
- // Wake all threads: primary thread will be consuming events
- // again, and secondary thread will exit.
- synchronized (this) {
- this.notifyAll();
+ // Wake the secondary thread, it will wake the primary as it
+ // exits.
+ synchronized (secondaryEventHandler) {
+ secondaryEventHandler.notify();
}
}
}
return true;
}
- /*
- TODO
if (command.equals(cmShell)) {
- openTerminal(0, 0, TWindow.Flag.RESIZABLE);
+ openTerminal(0, 0, TWindow.RESIZABLE);
repaint = true;
return true;
}
- */
if (command.equals(cmTile)) {
tileWindows();
return true;
}
- /*
- TODO
- if (menu.id == TMenu.MID_SHELL) {
- openTerminal(0, 0, TWindow.Flag.RESIZABLE);
+ if (menu.getId() == TMenu.MID_SHELL) {
+ openTerminal(0, 0, TWindow.RESIZABLE);
repaint = true;
return true;
}
- */
if (menu.getId() == TMenu.MID_TILE) {
tileWindows();
* @param title menu title
* @return the new menu
*/
- public final TMenu addMenu(String title) {
+ public final TMenu addMenu(final String title) {
int x = 0;
int y = 0;
TMenu menu = new TMenu(this, x, y, title);
int newWidth = (getScreen().getWidth() / a);
int newHeight1 = ((getScreen().getHeight() - 1) / b);
int newHeight2 = ((getScreen().getHeight() - 1) / (b + c));
- // System.err.printf("Z %s a %s b %s c %s newWidth %s newHeight1 %s newHeight2 %s",
- // z, a, b, c, newWidth, newHeight1, newHeight2);
List<TWindow> sorted = new LinkedList<TWindow>(windows);
Collections.sort(sorted);
return new TInputBox(this, title, caption, text);
}
+ /**
+ * Convenience function to open a terminal window.
+ *
+ * @param x column relative to parent
+ * @param y row relative to parent
+ * @return the terminal new window
+ */
+ public final TTerminalWindow openTerminal(final int x, final int y) {
+ return openTerminal(x, y, TWindow.RESIZABLE);
+ }
+
+ /**
+ * Convenience function to open a terminal window.
+ *
+ * @param x column relative to parent
+ * @param y row relative to parent
+ * @param flags mask of CENTERED, MODAL, or RESIZABLE
+ * @return the terminal new window
+ */
+ public final TTerminalWindow openTerminal(final int x, final int y,
+ final int flags) {
+
+ return new TTerminalWindow(this, x, y, flags);
+ }
+
}