import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
+import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import jexer.event.TMouseEvent;
import jexer.event.TResizeEvent;
import jexer.backend.Backend;
+import jexer.backend.AWTBackend;
import jexer.backend.ECMA48Backend;
import jexer.io.Screen;
import jexer.menu.TMenu;
*/
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
+ * secondary that is used for TMessageBox, TInputBox, and similar.
+ */
+ private class WidgetEventHandler implements Runnable {
+ /**
+ * The main application.
+ */
+ private TApplication application;
+
+ /**
+ * Whether or not this WidgetEventHandler is the primary or secondary
+ * thread.
+ */
+ private boolean primary = true;
+
+ /**
+ * Public constructor.
+ *
+ * @param application the main application
+ * @param primary if true, this is the primary event handler thread
+ */
+ public WidgetEventHandler(final TApplication application,
+ final boolean primary) {
+
+ this.application = application;
+ this.primary = primary;
+ }
+
+ /**
+ * The consumer loop.
+ */
+ public void run() {
+
+ // Loop forever
+ while (!application.quit) {
+
+ // Wait until application notifies me
+ while (!application.quit) {
+ try {
+ synchronized (application.drainEventQueue) {
+ if (application.drainEventQueue.size() > 0) {
+ break;
+ }
+ }
+ synchronized (application) {
+ application.wait();
+ if ((!primary)
+ && (application.secondaryEventReceiver == null)
+ ) {
+ // Secondary thread, time to exit
+ return;
+ }
+ break;
+ }
+ } catch (InterruptedException e) {
+ // SQUASH
+ }
+ }
+
+ // Pull all events off the queue
+ for (;;) {
+ TInputEvent event = null;
+ synchronized (application.drainEventQueue) {
+ if (application.drainEventQueue.size() == 0) {
+ 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);
+ }
+ if ((!primary)
+ && (application.secondaryEventReceiver == null)
+ ) {
+ // Secondary thread, time to exit.
+
+ // DO NOT UNLOCK. Primary thread just came back from
+ // primaryHandleEvent() and will unlock in the else
+ // block below.
+ return;
+ } else {
+ // Unlock. Either I am primary thread, or I am
+ // secondary thread and still running.
+ oldLock = unlockHandleEvent();
+ assert (oldLock == true);
+ }
+ }
+ } // while (true) (main runnable loop)
+ }
+ }
+
+ /**
+ * The primary event handler thread.
+ */
+ private WidgetEventHandler primaryEventHandler;
+
+ /**
+ * The secondary event handler thread.
+ */
+ private WidgetEventHandler secondaryEventHandler;
+
+ /**
+ * The widget receiving events from the secondary event handler thread.
+ */
+ private TWidget secondaryEventReceiver;
+
+ /**
+ * Spinlock for the primary and secondary event handlers.
+ * WidgetEventHandler.run() is responsible for setting this value.
+ */
+ private volatile boolean insideHandleEvent = false;
+
+ /**
+ * 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.
*/
public TApplication(final InputStream input,
final OutputStream output) throws UnsupportedEncodingException {
- backend = new ECMA48Backend(input, output);
+ // AWT is the default backend on Windows unless explicitly overridden
+ // by jexer.AWT.
+ boolean useAWT = false;
+ if (System.getProperty("os.name").startsWith("Windows")) {
+ useAWT = true;
+ }
+ if (System.getProperty("jexer.AWT") != null) {
+ if (System.getProperty("jexer.AWT", "false").equals("true")) {
+ useAWT = true;
+ } else {
+ useAWT = false;
+ }
+ }
+
+
+ if (useAWT) {
+ backend = new AWTBackend();
+ } else {
+ backend = new ECMA48Backend(input, output);
+ }
theme = new ColorTheme();
desktopBottom = getScreen().getHeight() - 1;
- fillEventQueue = new LinkedList<TInputEvent>();
- drainEventQueue = new LinkedList<TInputEvent>();
+ fillEventQueue = new ArrayList<TInputEvent>();
+ drainEventQueue = new ArrayList<TInputEvent>();
windows = new LinkedList<TWindow>();
menus = new LinkedList<TMenu>();
subMenus = new LinkedList<TMenu>();
timers = new LinkedList<TTimer>();
accelerators = new HashMap<TKeypress, TMenuItem>();
+
+ // Setup the main consumer thread
+ primaryEventHandler = new WidgetEventHandler(this, true);
+ (new Thread(primaryEventHandler)).start();
}
/**
* Draw everything.
*/
public final void drawAll() {
+ if (debugThreads) {
+ System.err.printf("drawAll() enter\n");
+ }
+
if ((flush) && (!repaint)) {
backend.flushScreen();
flush = false;
return;
}
+ if (debugThreads) {
+ System.err.printf("drawAll() REDRAW\n");
+ }
+
// If true, the cursor is not visible
boolean cursor = false;
metaHandleEvent(event);
}
+ // Prevent stepping on the primary or secondary event handler.
+ stopEventHandlers();
+
// Process timers and call doIdle()'s
doIdle();
// Update the screen
- drawAll();
- }
-
- /*
-
- // Shutdown the fibers
- eventQueue.length = 0;
- if (secondaryEventFiber !is null) {
- assert(secondaryEventReceiver !is null);
- secondaryEventReceiver = null;
- if (secondaryEventFiber.state == Fiber.State.HOLD) {
- // Wake up the secondary handler so that it can exit.
- secondaryEventFiber.call();
+ synchronized (getScreen()) {
+ drawAll();
}
+
+ // Let the event handlers run again.
+ startEventHandlers();
}
- if (primaryEventFiber.state == Fiber.State.HOLD) {
- // Wake up the primary handler so that it can exit.
- primaryEventFiber.call();
+ // Shutdown the consumer threads
+ synchronized (this) {
+ this.notifyAll();
}
- */
backend.shutdown();
}
*/
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
}
}
- // TODO: change to two separate threads
- primaryHandleEvent(event);
-
- /*
-
// Put into the main queue
- addEvent(event);
-
- // Have one of the two consumer Fibers peel the events off
- // the queue.
- if (secondaryEventFiber !is null) {
- assert(secondaryEventFiber.state == Fiber.State.HOLD);
-
- // Wake up the secondary handler for these events
- secondaryEventFiber.call();
- } else {
- assert(primaryEventFiber.state == Fiber.State.HOLD);
-
- // Wake up the primary handler for these events
- primaryEventFiber.call();
- }
- */
+ 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;
}
* @see #primaryHandleEvent(TInputEvent event)
*/
private void secondaryHandleEvent(final TInputEvent event) {
- // TODO
+ secondaryEventReceiver.handleEvent(event);
+ }
+
+ /**
+ * Enable a widget to override the primary event thread.
+ *
+ * @param widget widget that will receive events
+ */
+ public final void enableSecondaryEventReceiver(final TWidget widget) {
+ assert (secondaryEventReceiver == null);
+ assert (secondaryEventHandler == null);
+ assert (widget instanceof TMessageBox);
+ secondaryEventReceiver = widget;
+ secondaryEventHandler = new WidgetEventHandler(this, false);
+ (new Thread(secondaryEventHandler)).start();
+
+ // Refresh
+ repaint = true;
+ }
+
+ /**
+ * Yield to the secondary thread.
+ */
+ 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);
+
+ while (secondaryEventReceiver != null) {
+ synchronized (this) {
+ try {
+ this.wait();
+ } catch (InterruptedException e) {
+ // SQUASH
+ }
+ }
+ }
}
/**
* 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()) {
timer.tick();
- if (timer.recurring == true) {
+ if (timer.recurring) {
keepTimers.add(timer);
}
} else {
// Refresh screen
repaint = true;
- /*
- TODO
-
-
// Check if we are closing a TMessageBox or similar
- if (secondaryEventReceiver !is null) {
- assert(secondaryEventFiber !is null);
+ if (secondaryEventReceiver != null) {
+ assert (secondaryEventHandler != null);
// Do not send events to the secondaryEventReceiver anymore, the
// window is closed.
secondaryEventReceiver = null;
- // Special case: if this is called while executing on a
- // secondaryEventFiber, call it so that widgetEventHandler() can
- // terminate.
- if (secondaryEventFiber.state == Fiber.State.HOLD) {
- secondaryEventFiber.call();
- }
- secondaryEventFiber = null;
-
- // Unfreeze the logic in handleEvent()
- if (primaryEventFiber.state == Fiber.State.HOLD) {
- primaryEventFiber.call();
+ // Wake all threads: primary thread will be consuming events
+ // again, and secondary thread will exit.
+ synchronized (this) {
+ this.notifyAll();
}
}
- */
}
/**
* @return if true, this event was consumed
*/
protected boolean onCommand(final TCommandEvent command) {
- /*
- TODO
// Default: handle cmExit
if (command.equals(cmExit)) {
if (messageBox("Confirmation", "Exit application?",
- TMessageBox.Type.YESNO).result == TMessageBox.Result.YES) {
+ TMessageBox.Type.YESNO).getResult() == TMessageBox.Result.YES) {
quit = true;
}
repaint = true;
}
if (command.equals(cmShell)) {
- openTerminal(0, 0, TWindow.Flag.RESIZABLE);
+ openTerminal(0, 0, TWindow.RESIZABLE);
repaint = true;
return true;
}
repaint = true;
return true;
}
- */
+
return false;
}
// Default: handle MID_EXIT
if (menu.getId() == TMenu.MID_EXIT) {
- /*
- TODO
if (messageBox("Confirmation", "Exit application?",
- TMessageBox.Type.YESNO).result == TMessageBox.Result.YES) {
+ TMessageBox.Type.YESNO).getResult() == TMessageBox.Result.YES) {
quit = true;
}
// System.err.printf("onMenu MID_EXIT result: quit = %s\n", quit);
repaint = true;
return true;
- */
- quit = true;
- repaint = true;
- 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);
*
* @return the new menu
*/
- final public TMenu addWindowMenu() {
+ public final TMenu addWindowMenu() {
TMenu windowMenu = addMenu("&Window");
windowMenu.addDefaultItem(TMenu.MID_TILE);
windowMenu.addDefaultItem(TMenu.MID_CASCADE);
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);
* @param duration number of milliseconds to wait between ticks
* @param recurring if true, re-schedule this timer after every tick
* @param action function to call when button is pressed
+ * @return the timer
*/
public final TTimer addTimer(final long duration, final boolean recurring,
final TAction action) {
}
}
+ /**
+ * Convenience function to spawn a message box.
+ *
+ * @param title window title, will be centered along the top border
+ * @param caption message to display. Use embedded newlines to get a
+ * multi-line box.
+ * @return the new message box
+ */
+ public final TMessageBox messageBox(final String title,
+ final String caption) {
+
+ return new TMessageBox(this, title, caption, TMessageBox.Type.OK);
+ }
+
+ /**
+ * Convenience function to spawn a message box.
+ *
+ * @param title window title, will be centered along the top border
+ * @param caption message to display. Use embedded newlines to get a
+ * multi-line box.
+ * @param type one of the TMessageBox.Type constants. Default is
+ * Type.OK.
+ * @return the new message box
+ */
+ public final TMessageBox messageBox(final String title,
+ final String caption, final TMessageBox.Type type) {
+
+ return new TMessageBox(this, title, caption, type);
+ }
+
+ /**
+ * Convenience function to spawn an input box.
+ *
+ * @param title window title, will be centered along the top border
+ * @param caption message to display. Use embedded newlines to get a
+ * multi-line box.
+ * @return the new input box
+ */
+ public final TInputBox inputBox(final String title, final String caption) {
+
+ return new TInputBox(this, title, caption);
+ }
+
+ /**
+ * Convenience function to spawn an input box.
+ *
+ * @param title window title, will be centered along the top border
+ * @param caption message to display. Use embedded newlines to get a
+ * multi-line box.
+ * @param text initial text to seed the field with
+ * @return the new input box
+ */
+ public final TInputBox inputBox(final String title, final String caption,
+ final String text) {
+
+ 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);
+ }
+
}
git://git.nikiroo.be / nikiroo-utils.git / blobdiff