X-Git-Url: http://git.nikiroo.be/?a=blobdiff_plain;f=src%2Fjexer%2FTApplication.java;h=e710895b555c6d645f21cc06870a4e25afff0a7a;hb=92554d64c21c6a477fd23a06ca3a64a542b622a3;hp=e887b5d8d7c93bcf79c7ff81802d1555030bc9f3;hpb=99144c716d7a37efd12cedef46e3e0c406ef1349;p=fanfix.git diff --git a/src/jexer/TApplication.java b/src/jexer/TApplication.java index e887b5d..e710895 100644 --- a/src/jexer/TApplication.java +++ b/src/jexer/TApplication.java @@ -69,6 +69,11 @@ public class TApplication { */ 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 @@ -115,12 +120,33 @@ public class TApplication { 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; @@ -148,6 +174,7 @@ public class TApplication { } else { secondaryHandleEvent(event); } + application.repaint = true; if ((!primary) && (application.secondaryEventReceiver == null) ) { @@ -155,7 +182,15 @@ public class TApplication { // DO NOT UNLOCK. Primary thread just came back from // primaryHandleEvent() and will unlock in the else - // block below. + // 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 @@ -163,7 +198,14 @@ public class TApplication { 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) } } @@ -171,17 +213,17 @@ public class TApplication { /** * 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. @@ -189,6 +231,22 @@ public class TApplication { */ 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. @@ -355,22 +413,16 @@ public class TApplication { /** * When true, exit the application. */ - private boolean quit = false; + private volatile boolean quit = false; /** * When true, repaint the entire screen. */ - private boolean repaint = true; + private volatile boolean repaint = true; /** - * Request full repaint on next screen refresh. - */ - public final void setRepaint() { - 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; @@ -436,9 +488,9 @@ public class TApplication { 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; @@ -484,10 +536,6 @@ public class TApplication { return; } - if (!repaint) { - return; - } - if (debugThreads) { System.err.printf("drawAll() REDRAW\n"); } @@ -582,24 +630,48 @@ public class TApplication { 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 (;;) { @@ -613,6 +685,13 @@ public class TApplication { 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(); @@ -626,14 +705,28 @@ public class TApplication { // Let the event handlers run again. startEventHandlers(); - } - // Shutdown the consumer threads - synchronized (this) { - this.notifyAll(); + } // 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(); + } /** @@ -644,10 +737,10 @@ public class TApplication { */ 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 @@ -692,13 +785,6 @@ public class TApplication { 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(); - } } /** @@ -711,7 +797,9 @@ public class TApplication { */ 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 ----------------------------------- @@ -804,7 +892,10 @@ public class TApplication { 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; } @@ -851,15 +942,19 @@ public class TApplication { 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"); } /** @@ -874,7 +969,7 @@ public class TApplication { Date now = new Date(); List keepTimers = new LinkedList(); for (TTimer timer: timers) { - if (timer.getNextTick().getTime() < now.getTime()) { + if (timer.getNextTick().getTime() <= now.getTime()) { timer.tick(); if (timer.recurring) { keepTimers.add(timer); @@ -894,24 +989,27 @@ public class TApplication { /** * 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; } /** @@ -953,10 +1051,10 @@ public class TApplication { // 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(); } } } @@ -1259,14 +1357,11 @@ public class TApplication { 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(); @@ -1307,14 +1402,11 @@ public class TApplication { 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(); @@ -1521,8 +1613,6 @@ public class TApplication { 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 sorted = new LinkedList(windows); Collections.sort(sorted); @@ -1662,4 +1752,29 @@ public class TApplication { 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); + } + }