+ * 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);
+ }
+ if (primary) {
+ primaryHandleEvent(event);
+ } else {
+ secondaryHandleEvent(event);
+ }
+ if ((!primary)
+ && (application.secondaryEventReceiver == null)
+ ) {
+ // Secondary thread, time to exit
+ return;
+ }
+ }
+ } // 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;
+
+ /**
+ * Access to the physical screen, keyboard, and mouse.
+ */
+ private Backend backend;
+
+ /**
+ * Get the Screen.
+ *
+ * @return the Screen
+ */
+ public final Screen getScreen() {
+ return backend.getScreen();
+ }
+
+ /**
+ * Actual mouse coordinate X.
+ */
+ private int mouseX;
+
+ /**
+ * Actual mouse coordinate Y.
+ */
+ private int mouseY;
+
+ /**
+ * Event queue that is filled by run().
+ */
+ private List<TInputEvent> fillEventQueue;
+
+ /**
+ * Event queue that will be drained by either primary or secondary
+ * Thread.
+ */
+ private List<TInputEvent> drainEventQueue;
+
+ /**
+ * Top-level menus in this application.
+ */
+ private List<TMenu> menus;
+
+ /**
+ * Stack of activated sub-menus in this application.
+ */
+ private List<TMenu> subMenus;
+
+ /**
+ * The currently acive menu.
+ */
+ private TMenu activeMenu = null;
+
+ /**
+ * Active keyboard accelerators.
+ */
+ private Map<TKeypress, TMenuItem> accelerators;
+
+ /**
+ * Windows and widgets pull colors from this ColorTheme.
+ */
+ private ColorTheme theme;
+
+ /**
+ * Get the color theme.
+ *
+ * @return the theme
+ */
+ public final ColorTheme getTheme() {
+ return theme;
+ }
+
+ /**
+ * The top-level windows (but not menus).
+ */
+ private List<TWindow> windows;
+
+ /**
+ * Timers that are being ticked.
+ */
+ private List<TTimer> timers;
+
+ /**
+ * When true, exit the application.
+ */
+ private 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;
+ }
+
+ /**
+ * When true, just flush updates from the screen.
+ */
+ private boolean flush = false;
+
+ /**
+ * Y coordinate of the top edge of the desktop. For now this is a
+ * constant. Someday it would be nice to have a multi-line menu or
+ * toolbars.
+ */
+ private static final int desktopTop = 1;
+
+ /**
+ * Get Y coordinate of the top edge of the desktop.
+ *
+ * @return Y coordinate of the top edge of the desktop
+ */
+ public final int getDesktopTop() {
+ return desktopTop;
+ }
+
+ /**
+ * Y coordinate of the bottom edge of the desktop.
+ */
+ private int desktopBottom;
+
+ /**
+ * Get Y coordinate of the bottom edge of the desktop.
+ *
+ * @return Y coordinate of the bottom edge of the desktop
+ */
+ public final int getDesktopBottom() {
+ return desktopBottom;
+ }
+
+ /**
+ * Public constructor.
+ *
+ * @param input an InputStream connected to the remote user, or null for
+ * System.in. If System.in is used, then on non-Windows systems it will
+ * be put in raw mode; shutdown() will (blindly!) put System.in in cooked
+ * mode. input is always converted to a Reader with UTF-8 encoding.
+ * @param output an OutputStream connected to the remote user, or null
+ * for System.out. output is always converted to a Writer with UTF-8
+ * encoding.
+ * @throws UnsupportedEncodingException if an exception is thrown when
+ * creating the InputStreamReader
+ */
+ public TApplication(final InputStream input,
+ final OutputStream output) throws UnsupportedEncodingException {
+
+ // 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 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();
+ }
+
+ /**
+ * Invert the cell at the mouse pointer position.
+ */
+ private void drawMouse() {
+ CellAttributes attr = getScreen().getAttrXY(mouseX, mouseY);
+ attr.setForeColor(attr.getForeColor().invert());
+ attr.setBackColor(attr.getBackColor().invert());
+ getScreen().putAttrXY(mouseX, mouseY, attr, false);
+ flush = true;
+
+ if (windows.size() == 0) {
+ repaint = true;
+ }
+ }
+
+ /**
+ * Draw everything.
+ */
+ public final void drawAll() {
+ if ((flush) && (!repaint)) {
+ backend.flushScreen();
+ flush = false;
+ return;
+ }
+
+ if (!repaint) {
+ return;
+ }
+
+ // If true, the cursor is not visible
+ boolean cursor = false;
+
+ // Start with a clean screen
+ getScreen().clear();
+
+ // Draw the background
+ CellAttributes background = theme.getColor("tapplication.background");
+ getScreen().putAll(GraphicsChars.HATCH, background);
+
+ // Draw each window in reverse Z order
+ List<TWindow> sorted = new LinkedList<TWindow>(windows);
+ Collections.sort(sorted);
+ Collections.reverse(sorted);
+ for (TWindow window: sorted) {
+ window.drawChildren();
+ }
+
+ // Draw the blank menubar line - reset the screen clipping first so
+ // it won't trim it out.
+ getScreen().resetClipping();
+ getScreen().hLineXY(0, 0, getScreen().getWidth(), ' ',
+ theme.getColor("tmenu"));
+ // Now draw the menus.
+ int x = 1;
+ for (TMenu menu: menus) {
+ CellAttributes menuColor;
+ CellAttributes menuMnemonicColor;
+ if (menu.getActive()) {
+ menuColor = theme.getColor("tmenu.highlighted");
+ menuMnemonicColor = theme.getColor("tmenu.mnemonic.highlighted");
+ } else {
+ menuColor = theme.getColor("tmenu");
+ menuMnemonicColor = theme.getColor("tmenu.mnemonic");
+ }
+ // Draw the menu title
+ getScreen().hLineXY(x, 0, menu.getTitle().length() + 2, ' ',
+ menuColor);
+ getScreen().putStrXY(x + 1, 0, menu.getTitle(), menuColor);
+ // Draw the highlight character
+ getScreen().putCharXY(x + 1 + menu.getMnemonic().getShortcutIdx(),
+ 0, menu.getMnemonic().getShortcut(), menuMnemonicColor);
+
+ if (menu.getActive()) {
+ menu.drawChildren();
+ // Reset the screen clipping so we can draw the next title.
+ getScreen().resetClipping();
+ }
+ x += menu.getTitle().length() + 2;
+ }
+
+ for (TMenu menu: subMenus) {
+ // Reset the screen clipping so we can draw the next sub-menu.
+ getScreen().resetClipping();
+ menu.drawChildren();
+ }
+
+ // Draw the mouse pointer
+ drawMouse();
+
+ // Place the cursor if it is visible
+ TWidget activeWidget = null;
+ if (sorted.size() > 0) {
+ activeWidget = sorted.get(sorted.size() - 1).getActiveChild();
+ if (activeWidget.visibleCursor()) {
+ getScreen().putCursor(true, activeWidget.getCursorAbsoluteX(),
+ activeWidget.getCursorAbsoluteY());
+ cursor = true;
+ }
+ }
+
+ // Kill the cursor
+ if (!cursor) {
+ getScreen().hideCursor();
+ }
+
+ // Flush the screen contents
+ backend.flushScreen();
+
+ repaint = false;
+ flush = false;
+ }
+
+ /**
+ * Run this application until it exits.
+ */
+ public final void run() {
+ 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;
+ }
+ }
+ synchronized (fillEventQueue) {
+ if (fillEventQueue.size() > 0) {
+ timeout = 0;
+ }
+ }
+
+ // Pull any pending I/O events
+ backend.getEvents(fillEventQueue, timeout);
+
+ // Dispatch each event to the appropriate handler, one at a time.
+ for (;;) {
+ TInputEvent event = null;
+ synchronized (fillEventQueue) {
+ if (fillEventQueue.size() == 0) {
+ break;
+ }
+ event = fillEventQueue.remove(0);
+ }
+ metaHandleEvent(event);
+ }
+
+ // Process timers and call doIdle()'s
+ doIdle();
+
+ // Update the screen
+ drawAll();
+ }
+
+ // Shutdown the consumer threads
+ synchronized (this) {
+ this.notifyAll();
+ }
+
+ backend.shutdown();
+ }
+
+ /**
+ * Peek at certain application-level events, add to eventQueue, and wake
+ * up the consuming Thread.
+ *
+ * @param event the input event to consume
+ */
+ private void metaHandleEvent(final TInputEvent event) {
+
+ /*
+ 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
+ // to exit.
+ return;
+ }
+
+ // Special application-wide events -------------------------------
+
+ // Abort everything
+ if (event instanceof TCommandEvent) {
+ TCommandEvent command = (TCommandEvent) event;
+ if (command.getCmd().equals(cmAbort)) {
+ quit = true;
+ return;
+ }
+ }
+
+ // Screen resize
+ if (event instanceof TResizeEvent) {
+ TResizeEvent resize = (TResizeEvent) event;
+ getScreen().setDimensions(resize.getWidth(),
+ resize.getHeight());
+ desktopBottom = getScreen().getHeight() - 1;
+ repaint = true;
+ mouseX = 0;
+ mouseY = 0;
+ return;
+ }
+
+ // Peek at the mouse position
+ if (event instanceof TMouseEvent) {
+ TMouseEvent mouse = (TMouseEvent) event;
+ if ((mouseX != mouse.getX()) || (mouseY != mouse.getY())) {
+ mouseX = mouse.getX();
+ mouseY = mouse.getY();
+ drawMouse();
+ }
+ }
+
+ // Put into the main queue
+ 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();
+ }
+ }
+
+ /**
+ * Dispatch one event to the appropriate widget or application-level
+ * event handler. This is the primary event handler, it has the normal
+ * application-wide event handling.
+ *
+ * @param event the input event to consume
+ * @see #secondaryHandleEvent(TInputEvent event)
+ */
+ private void primaryHandleEvent(final TInputEvent event) {
+
+ // System.err.printf("Handle event: %s\n", event);
+
+ // Special application-wide events -----------------------------------
+
+ // Peek at the mouse position
+ if (event instanceof TMouseEvent) {
+ // See if we need to switch focus to another window or the menu
+ checkSwitchFocus((TMouseEvent) event);
+ }
+
+ // Handle menu events
+ if ((activeMenu != null) && !(event instanceof TCommandEvent)) {
+ TMenu menu = activeMenu;
+
+ if (event instanceof TMouseEvent) {
+ TMouseEvent mouse = (TMouseEvent) event;
+
+ while (subMenus.size() > 0) {
+ TMenu subMenu = subMenus.get(subMenus.size() - 1);
+ if (subMenu.mouseWouldHit(mouse)) {
+ break;
+ }
+ if ((mouse.getType() == TMouseEvent.Type.MOUSE_MOTION)
+ && (!mouse.getMouse1())
+ && (!mouse.getMouse2())
+ && (!mouse.getMouse3())
+ && (!mouse.getMouseWheelUp())
+ && (!mouse.getMouseWheelDown())
+ ) {
+ break;
+ }
+ // We navigated away from a sub-menu, so close it
+ closeSubMenu();
+ }
+
+ // Convert the mouse relative x/y to menu coordinates
+ assert (mouse.getX() == mouse.getAbsoluteX());
+ assert (mouse.getY() == mouse.getAbsoluteY());
+ if (subMenus.size() > 0) {
+ menu = subMenus.get(subMenus.size() - 1);
+ }
+ mouse.setX(mouse.getX() - menu.getX());
+ mouse.setY(mouse.getY() - menu.getY());
+ }
+ menu.handleEvent(event);
+ return;
+ }
+
+ if (event instanceof TKeypressEvent) {
+ TKeypressEvent keypress = (TKeypressEvent) event;
+
+ // See if this key matches an accelerator, and if so dispatch the
+ // menu event.
+ TKeypress keypressLowercase = keypress.getKey().toLowerCase();
+ TMenuItem item = null;
+ synchronized (accelerators) {
+ item = accelerators.get(keypressLowercase);
+ }
+ if (item != null) {
+ // Let the menu item dispatch
+ item.dispatch();
+ return;
+ } else {
+ // Handle the keypress
+ if (onKeypress(keypress)) {
+ return;
+ }
+ }
+ }
+
+ if (event instanceof TCommandEvent) {
+ if (onCommand((TCommandEvent) event)) {
+ return;
+ }
+ }
+
+ if (event instanceof TMenuEvent) {
+ if (onMenu((TMenuEvent) event)) {
+ return;
+ }
+ }
+
+ // Dispatch events to the active window -------------------------------
+ for (TWindow window: windows) {
+ if (window.getActive()) {
+ if (event instanceof TMouseEvent) {
+ TMouseEvent mouse = (TMouseEvent) event;
+ // Convert the mouse relative x/y to window coordinates
+ assert (mouse.getX() == mouse.getAbsoluteX());
+ assert (mouse.getY() == mouse.getAbsoluteY());
+ mouse.setX(mouse.getX() - window.getX());
+ mouse.setY(mouse.getY() - window.getY());
+ }
+ // System.err("TApplication dispatch event: %s\n", event);
+ window.handleEvent(event);
+ break;
+ }
+ }
+ }
+ /**
+ * Dispatch one event to the appropriate widget or application-level
+ * event handler. This is the secondary event handler used by certain
+ * special dialogs (currently TMessageBox and TFileOpenBox).
+ *
+ * @param event the input event to consume
+ * @see #primaryHandleEvent(TInputEvent event)
+ */
+ private void secondaryHandleEvent(final TInputEvent event) {
+ 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);
+ while (secondaryEventReceiver != null) {
+ synchronized (this) {
+ try {
+ this.wait();
+ } catch (InterruptedException e) {
+ // SQUASH
+ }
+ }
+ }
+ }
+
+ /**
+ * Do stuff when there is no user input.
+ */
+ private void doIdle() {
+ // 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) {
+ keepTimers.add(timer);
+ }
+ } else {
+ keepTimers.add(timer);
+ }
+ }
+ timers = keepTimers;
+
+ // Call onIdle's
+ for (TWindow window: windows) {
+ window.onIdle();
+ }
+ }
+
+ /**
+ * Get the amount of time I can sleep before missing a Timer tick.
+ *
+ * @param timeout = initial (maximum) timeout
+ * @return number of milliseconds between now and the next timer event
+ */
+ protected int getSleepTime(final int timeout) {
+ Date now = new Date();
+ long sleepTime = timeout;
+ for (TTimer timer: timers) {
+ if (timer.getNextTick().getTime() < now.getTime()) {
+ return 0;
+ }
+ if ((timer.getNextTick().getTime() > now.getTime())
+ && ((timer.getNextTick().getTime() - now.getTime()) < sleepTime)
+ ) {
+ sleepTime = timer.getNextTick().getTime() - now.getTime();
+ }
+ }
+ assert (sleepTime >= 0);
+ return (int)sleepTime;
+ }
+
+ /**
+ * Close window. Note that the window's destructor is NOT called by this
+ * method, instead the GC is assumed to do the cleanup.
+ *
+ * @param window the window to remove
+ */
+ public final void closeWindow(final TWindow window) {
+ int z = window.getZ();
+ window.setZ(-1);
+ Collections.sort(windows);
+ windows.remove(0);
+ TWindow activeWindow = null;
+ for (TWindow w: windows) {
+ if (w.getZ() > z) {
+ w.setZ(w.getZ() - 1);
+ if (w.getZ() == 0) {
+ w.setActive(true);
+ assert (activeWindow == null);
+ activeWindow = w;
+ } else {
+ w.setActive(false);
+ }
+ }
+ }
+
+ // Perform window cleanup
+ window.onClose();
+
+ // Refresh screen
+ repaint = true;
+
+ // Check if we are closing a TMessageBox or similar
+ if (secondaryEventReceiver != null) {
+ assert (secondaryEventHandler != null);
+
+ // Do not send events to the secondaryEventReceiver anymore, the
+ // window is closed.
+ secondaryEventReceiver = null;
+
+ // Wake all threads: primary thread will be consuming events
+ // again, and secondary thread will exit.
+ synchronized (this) {
+ this.notifyAll();
+ }
+ }
+ }
+
+ /**
+ * Switch to the next window.
+ *
+ * @param forward if true, then switch to the next window in the list,
+ * otherwise switch to the previous window in the list
+ */
+ public final void switchWindow(final boolean forward) {
+ // Only switch if there are multiple windows
+ if (windows.size() < 2) {
+ return;
+ }
+
+ // Swap z/active between active window and the next in the list
+ int activeWindowI = -1;
+ for (int i = 0; i < windows.size(); i++) {
+ if (windows.get(i).getActive()) {
+ activeWindowI = i;
+ break;
+ }
+ }
+ assert (activeWindowI >= 0);
+
+ // Do not switch if a window is modal
+ if (windows.get(activeWindowI).isModal()) {
+ return;
+ }
+
+ int nextWindowI;
+ if (forward) {
+ nextWindowI = (activeWindowI + 1) % windows.size();
+ } else {
+ if (activeWindowI == 0) {
+ nextWindowI = windows.size() - 1;
+ } else {
+ nextWindowI = activeWindowI - 1;
+ }
+ }
+ windows.get(activeWindowI).setActive(false);
+ windows.get(activeWindowI).setZ(windows.get(nextWindowI).getZ());
+ windows.get(nextWindowI).setZ(0);
+ windows.get(nextWindowI).setActive(true);
+
+ // Refresh
+ repaint = true;
+ }
+
+ /**
+ * Add a window to my window list and make it active.
+ *
+ * @param window new window to add
+ */
+ public final void addWindow(final TWindow window) {
+ // Do not allow a modal window to spawn a non-modal window
+ if ((windows.size() > 0) && (windows.get(0).isModal())) {
+ assert (window.isModal());
+ }
+ for (TWindow w: windows) {
+ w.setActive(false);
+ w.setZ(w.getZ() + 1);
+ }
+ windows.add(window);
+ window.setActive(true);
+ window.setZ(0);
+ }
+
+ /**
+ * Check if there is a system-modal window on top.
+ *
+ * @return true if the active window is modal
+ */
+ private boolean modalWindowActive() {
+ if (windows.size() == 0) {
+ return false;
+ }
+ return windows.get(windows.size() - 1).isModal();
+ }
+
+ /**
+ * Check if a mouse event would hit either the active menu or any open
+ * sub-menus.
+ *
+ * @param mouse mouse event
+ * @return true if the mouse would hit the active menu or an open
+ * sub-menu
+ */
+ private boolean mouseOnMenu(final TMouseEvent mouse) {
+ assert (activeMenu != null);
+ List<TMenu> menus = new LinkedList<TMenu>(subMenus);
+ Collections.reverse(menus);
+ for (TMenu menu: menus) {
+ if (menu.mouseWouldHit(mouse)) {
+ return true;
+ }
+ }
+ return activeMenu.mouseWouldHit(mouse);
+ }
+
+ /**
+ * See if we need to switch window or activate the menu based on
+ * a mouse click.
+ *
+ * @param mouse mouse event
+ */
+ private void checkSwitchFocus(final TMouseEvent mouse) {
+
+ if ((mouse.getType() == TMouseEvent.Type.MOUSE_DOWN)
+ && (activeMenu != null)
+ && (mouse.getAbsoluteY() != 0)
+ && (!mouseOnMenu(mouse))
+ ) {
+ // They clicked outside the active menu, turn it off
+ activeMenu.setActive(false);
+ activeMenu = null;
+ for (TMenu menu: subMenus) {
+ menu.setActive(false);
+ }
+ subMenus.clear();
+ // Continue checks
+ }
+
+ // See if they hit the menu bar
+ if ((mouse.getType() == TMouseEvent.Type.MOUSE_DOWN)
+ && (mouse.getMouse1())
+ && (!modalWindowActive())
+ && (mouse.getAbsoluteY() == 0)
+ ) {
+
+ for (TMenu menu: subMenus) {
+ menu.setActive(false);
+ }
+ subMenus.clear();
+
+ // They selected the menu, go activate it
+ for (TMenu menu: menus) {
+ if ((mouse.getAbsoluteX() >= menu.getX())
+ && (mouse.getAbsoluteX() < menu.getX()
+ + menu.getTitle().length() + 2)
+ ) {
+ menu.setActive(true);
+ activeMenu = menu;
+ } else {
+ menu.setActive(false);
+ }
+ }
+ repaint = true;
+ return;
+ }
+
+ // See if they hit the menu bar
+ if ((mouse.getType() == TMouseEvent.Type.MOUSE_MOTION)
+ && (mouse.getMouse1())
+ && (activeMenu != null)
+ && (mouse.getAbsoluteY() == 0)
+ ) {
+
+ TMenu oldMenu = activeMenu;
+ for (TMenu menu: subMenus) {
+ menu.setActive(false);
+ }
+ subMenus.clear();
+
+ // See if we should switch menus
+ for (TMenu menu: menus) {
+ if ((mouse.getAbsoluteX() >= menu.getX())
+ && (mouse.getAbsoluteX() < menu.getX()
+ + menu.getTitle().length() + 2)
+ ) {
+ menu.setActive(true);
+ activeMenu = menu;
+ }
+ }
+ if (oldMenu != activeMenu) {
+ // They switched menus
+ oldMenu.setActive(false);
+ }
+ repaint = true;
+ return;
+ }
+
+ // Only switch if there are multiple windows
+ if (windows.size() < 2) {
+ return;
+ }
+
+ // Switch on the upclick
+ if (mouse.getType() != TMouseEvent.Type.MOUSE_UP) {
+ return;
+ }
+
+ Collections.sort(windows);
+ if (windows.get(0).isModal()) {
+ // Modal windows don't switch
+ return;
+ }
+
+ for (TWindow window: windows) {
+ assert (!window.isModal());
+ if (window.mouseWouldHit(mouse)) {
+ if (window == windows.get(0)) {
+ // Clicked on the same window, nothing to do
+ return;
+ }
+
+ // We will be switching to another window
+ assert (windows.get(0).getActive());
+ assert (!window.getActive());
+ windows.get(0).setActive(false);
+ windows.get(0).setZ(window.getZ());
+ window.setZ(0);
+ window.setActive(true);
+ repaint = true;
+ return;
+ }
+ }
+
+ // Clicked on the background, nothing to do
+ return;
+ }
+
+ /**
+ * Turn off the menu.
+ */
+ public final void closeMenu() {
+ if (activeMenu != null) {
+ activeMenu.setActive(false);
+ activeMenu = null;
+ for (TMenu menu: subMenus) {
+ menu.setActive(false);
+ }
+ subMenus.clear();
+ }
+ repaint = true;
+ }
+
+ /**
+ * Turn off a sub-menu.
+ */
+ public final void closeSubMenu() {
+ assert (activeMenu != null);
+ TMenu item = subMenus.get(subMenus.size() - 1);
+ assert (item != null);
+ item.setActive(false);
+ subMenus.remove(subMenus.size() - 1);
+ repaint = true;
+ }
+
+ /**
+ * Switch to the next menu.
+ *
+ * @param forward if true, then switch to the next menu in the list,
+ * otherwise switch to the previous menu in the list
+ */
+ public final void switchMenu(final boolean forward) {
+ assert (activeMenu != null);
+
+ for (TMenu menu: subMenus) {
+ menu.setActive(false);
+ }
+ subMenus.clear();
+
+ for (int i = 0; i < menus.size(); i++) {
+ if (activeMenu == menus.get(i)) {
+ if (forward) {
+ if (i < menus.size() - 1) {
+ i++;
+ }
+ } else {
+ if (i > 0) {
+ i--;
+ }
+ }
+ activeMenu.setActive(false);
+ activeMenu = menus.get(i);
+ activeMenu.setActive(true);
+ repaint = true;
+ return;
+ }
+ }
+ }
+
+ /**
+ * Method that TApplication subclasses can override to handle menu or
+ * posted command events.
+ *
+ * @param command command event
+ * @return if true, this event was consumed
+ */
+ protected boolean onCommand(final TCommandEvent command) {
+ // Default: handle cmExit
+ if (command.equals(cmExit)) {
+ if (messageBox("Confirmation", "Exit application?",
+ TMessageBox.Type.YESNO).getResult() == TMessageBox.Result.YES) {
+ quit = true;
+ }
+ repaint = true;
+ return true;
+ }
+
+ /*
+ TODO
+ if (command.equals(cmShell)) {
+ openTerminal(0, 0, TWindow.Flag.RESIZABLE);
+ repaint = true;
+ return true;
+ }
+ */
+
+ if (command.equals(cmTile)) {
+ tileWindows();
+ repaint = true;
+ return true;
+ }
+ if (command.equals(cmCascade)) {
+ cascadeWindows();
+ repaint = true;
+ return true;
+ }
+ if (command.equals(cmCloseAll)) {
+ closeAllWindows();
+ repaint = true;
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Method that TApplication subclasses can override to handle menu
+ * events.
+ *
+ * @param menu menu event
+ * @return if true, this event was consumed
+ */
+ protected boolean onMenu(final TMenuEvent menu) {
+
+ // Default: handle MID_EXIT
+ if (menu.getId() == TMenu.MID_EXIT) {
+ if (messageBox("Confirmation", "Exit application?",
+ TMessageBox.Type.YESNO).getResult() == TMessageBox.Result.YES) {
+ quit = true;
+ }
+ // System.err.printf("onMenu MID_EXIT result: quit = %s\n", quit);
+ repaint = true;
+ return true;
+ }
+
+ /*
+ TODO
+ if (menu.id == TMenu.MID_SHELL) {
+ openTerminal(0, 0, TWindow.Flag.RESIZABLE);
+ repaint = true;
+ return true;
+ }
+ */
+
+ if (menu.getId() == TMenu.MID_TILE) {
+ tileWindows();
+ repaint = true;
+ return true;
+ }
+ if (menu.getId() == TMenu.MID_CASCADE) {
+ cascadeWindows();
+ repaint = true;
+ return true;
+ }
+ if (menu.getId() == TMenu.MID_CLOSE_ALL) {
+ closeAllWindows();
+ repaint = true;
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Method that TApplication subclasses can override to handle keystrokes.
+ *
+ * @param keypress keystroke event
+ * @return if true, this event was consumed