*
* The MIT License (MIT)
*
- * Copyright (C) 2017 Kevin Lamonte
+ * Copyright (C) 2019 Kevin Lamonte
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
*/
package jexer;
+import java.io.File;
+import java.io.FileInputStream;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
+import java.text.MessageFormat;
+import java.util.ArrayList;
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 java.util.ResourceBundle;
+import jexer.bits.Cell;
import jexer.bits.CellAttributes;
+import jexer.bits.Clipboard;
import jexer.bits.ColorTheme;
+import jexer.bits.StringUtils;
import jexer.event.TCommandEvent;
import jexer.event.TInputEvent;
import jexer.event.TKeypressEvent;
import jexer.event.TMouseEvent;
import jexer.event.TResizeEvent;
import jexer.backend.Backend;
+import jexer.backend.MultiBackend;
+import jexer.backend.Screen;
import jexer.backend.SwingBackend;
import jexer.backend.ECMA48Backend;
-import jexer.io.Screen;
+import jexer.backend.TWindowBackend;
+import jexer.help.HelpFile;
+import jexer.help.Topic;
import jexer.menu.TMenu;
import jexer.menu.TMenuItem;
+import jexer.menu.TSubMenu;
import static jexer.TCommand.*;
import static jexer.TKeypress.*;
/**
- * TApplication sets up a full Text User Interface application.
+ * TApplication is the main driver class for a full Text User Interface
+ * application. It manages windows, provides a menu bar and status bar, and
+ * processes events received from the user.
*/
public class TApplication implements Runnable {
+ /**
+ * Translated strings.
+ */
+ private static final ResourceBundle i18n = ResourceBundle.getBundle(TApplication.class.getName());
+
// ------------------------------------------------------------------------
- // Public constants -------------------------------------------------------
+ // Constants --------------------------------------------------------------
// ------------------------------------------------------------------------
/**
}
// ------------------------------------------------------------------------
- // Primary/secondary event handlers ---------------------------------------
+ // Variables --------------------------------------------------------------
// ------------------------------------------------------------------------
- /**
- * 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 (this) {
- if (debugThreads) {
- System.err.printf("%s %s sleep\n", this,
- primary ? "primary" : "secondary");
- }
-
- this.wait();
-
- if (debugThreads) {
- System.err.printf("%s %s AWAKE\n", this,
- primary ? "primary" : "secondary");
- }
-
- if ((!primary)
- && (application.secondaryEventReceiver == null)
- ) {
- // Secondary thread, emergency exit. If we
- // got here then something went wrong with
- // the handoff between yield() and
- // closeWindow().
- synchronized (application.primaryEventHandler) {
- application.primaryEventHandler.notify();
- }
- application.secondaryEventHandler = null;
- throw new RuntimeException(
- "secondary exited at wrong time");
- }
- break;
- }
- } catch (InterruptedException e) {
- // SQUASH
- }
- }
-
- // Wait for drawAll() or doIdle() to be done, then handle the
- // events.
- boolean oldLock = lockHandleEvent();
- assert (oldLock == false);
-
- // Pull all events off the queue
- for (;;) {
- TInputEvent event = null;
- synchronized (application.drainEventQueue) {
- if (application.drainEventQueue.size() == 0) {
- break;
- }
- event = application.drainEventQueue.remove(0);
- }
- application.repaint = true;
- 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. 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;
- }
- } // for (;;)
-
- // Unlock. Either I am primary thread, or I am secondary
- // thread and still running.
- oldLock = unlockHandleEvent();
- assert (oldLock == true);
-
- // 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 volatile WidgetEventHandler secondaryEventHandler;
/**
- * The widget receiving events from the secondary event handler thread.
- */
- 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) {
- try {
- // Backoff so that the backend can finish its work.
- Thread.sleep(5);
- } catch (InterruptedException e) {
- // SQUASH
- }
- }
-
- 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
+ * The screen handler thread.
*/
- private boolean unlockHandleEvent() {
- if (debugThreads) {
- System.err.printf(" << unlockHandleEvent(): oldValue %s\n",
- insideHandleEvent);
- }
- synchronized (this) {
- boolean oldValue = insideHandleEvent;
- insideHandleEvent = false;
- return oldValue;
- }
- }
+ private volatile ScreenHandler screenHandler;
/**
- * Spinlock for the primary and secondary event handlers. When true, the
- * event handlers will spinlock wait before calling handleEvent().
+ * The widget receiving events from the secondary event handler thread.
*/
- private volatile boolean lockoutHandleEvent = false;
+ private volatile TWidget secondaryEventReceiver;
/**
- * 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.
+ * Access to the physical screen, keyboard, and mouse.
*/
- 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) {
- try {
- // Backoff so that the event handler can finish its work.
- Thread.sleep(1);
- } catch (InterruptedException e) {
- // SQUASH
- }
- }
-
- if (debugThreads) {
- System.err.printf(" XXX\n");
- }
- }
+ private Backend backend;
/**
- * 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.
+ * The clipboard for copy and paste.
*/
- private void startEventHandlers() {
- if (debugThreads) {
- System.err.printf("<< startEventHandlers()\n");
- }
- lockoutHandleEvent = false;
- }
-
- // ------------------------------------------------------------------------
- // TApplication attributes ------------------------------------------------
- // ------------------------------------------------------------------------
+ private Clipboard clipboard = new Clipboard();
/**
- * Access to the physical screen, keyboard, and mouse.
+ * Actual mouse coordinate X.
*/
- private Backend backend;
+ private int mouseX;
/**
- * Get the Backend.
- *
- * @return the Backend
+ * Actual mouse coordinate Y.
*/
- public final Backend getBackend() {
- return backend;
- }
+ private int mouseY;
/**
- * Get the Screen.
- *
- * @return the Screen
+ * Old drawn version of mouse coordinate X.
*/
- public final Screen getScreen() {
- return backend.getScreen();
- }
+ private int oldDrawnMouseX;
/**
- * Actual mouse coordinate X.
+ * Old drawn version mouse coordinate Y.
*/
- private int mouseX;
+ private int oldDrawnMouseY;
/**
- * Actual mouse coordinate Y.
+ * Old drawn version mouse cell.
*/
- private int mouseY;
+ private Cell oldDrawnMouseCell = new Cell();
/**
- * Old version of mouse coordinate X.
+ * The last mouse up click time, used to determine if this is a mouse
+ * double-click.
*/
- private int oldMouseX;
+ private long lastMouseUpTime;
/**
- * Old version mouse coordinate Y.
+ * The amount of millis between mouse up events to assume a double-click.
*/
- private int oldMouseY;
+ private long doubleClickTime = 250;
/**
* Event queue that is filled by run().
*/
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;
/**
- * The currently acive window.
+ * Timers that are being ticked.
*/
- private TWindow activeWindow = null;
+ private List<TTimer> timers;
/**
- * Timers that are being ticked.
+ * When true, the application has been started.
*/
- private List<TTimer> timers;
+ private volatile boolean started = false;
/**
* When true, exit the application.
* 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;
- }
+ private int desktopTop = 1;
/**
* 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;
- }
-
/**
* An optional TDesktop background window that is drawn underneath
* everything else.
private TDesktop desktop;
/**
- * Set the TDesktop instance.
- *
- * @param desktop a TDesktop instance, or null to remove the one that is
- * set
+ * If true, focus follows mouse: windows automatically raised if the
+ * mouse passes over them.
*/
- public final void setDesktop(final TDesktop desktop) {
- if (this.desktop != null) {
- this.desktop.onClose();
- }
- this.desktop = desktop;
- }
+ private boolean focusFollowsMouse = false;
/**
- * Get the TDesktop instance.
- *
- * @return the desktop, or null if it is not set
+ * If true, display a text-based mouse cursor.
*/
- public final TDesktop getDesktop() {
- return desktop;
- }
+ private boolean textMouse = true;
/**
- * Get the current active window.
- *
- * @return the active window, or null if it is not set
+ * If true, hide the mouse after typing a keystroke.
*/
- public final TWindow getActiveWindow() {
- return activeWindow;
- }
+ private boolean hideMouseWhenTyping = false;
/**
- * Get the list of windows.
- *
- * @return a copy of the list of windows for this application
+ * If true, the mouse should not be displayed because a keystroke was
+ * typed.
*/
- public final List<TWindow> getAllWindows() {
- List<TWindow> result = new LinkedList<TWindow>();
- result.addAll(windows);
- return result;
- }
+ private boolean typingHidMouse = false;
/**
- * If true, focus follows mouse: windows automatically raised if the
- * mouse passes over them.
+ * If true, hide the status bar.
*/
- private boolean focusFollowsMouse = false;
+ private boolean hideStatusBar = false;
/**
- * Get focusFollowsMouse flag.
- *
- * @return true if focus follows mouse: windows automatically raised if
- * the mouse passes over them
+ * If true, hide the menu bar.
*/
- public boolean getFocusFollowsMouse() {
- return focusFollowsMouse;
- }
+ private boolean hideMenuBar = false;
/**
- * Set focusFollowsMouse flag.
- *
- * @param focusFollowsMouse if true, focus follows mouse: windows
- * automatically raised if the mouse passes over them
+ * The list of commands to run before the next I/O check.
*/
- public void setFocusFollowsMouse(final boolean focusFollowsMouse) {
- this.focusFollowsMouse = focusFollowsMouse;
- }
+ private List<Runnable> invokeLaters = new LinkedList<Runnable>();
- // ------------------------------------------------------------------------
- // General behavior -------------------------------------------------------
- // ------------------------------------------------------------------------
+ /**
+ * The last time the screen was resized.
+ */
+ private long screenResizeTime = 0;
/**
- * Display the about dialog.
+ * If true, screen selection is a rectangle.
*/
- protected void showAboutDialog() {
- messageBox("About", "Jexer Version " +
- this.getClass().getPackage().getImplementationVersion(),
- TMessageBox.Type.OK);
+ private boolean screenSelectionRectangle = false;
+
+ /**
+ * If true, the mouse is dragging a screen selection.
+ */
+ private boolean inScreenSelection = false;
+
+ /**
+ * Screen selection starting X.
+ */
+ private int screenSelectionX0;
+
+ /**
+ * Screen selection starting Y.
+ */
+ private int screenSelectionY0;
+
+ /**
+ * Screen selection ending X.
+ */
+ private int screenSelectionX1;
+
+ /**
+ * Screen selection ending Y.
+ */
+ private int screenSelectionY1;
+
+ /**
+ * The help file data. Note package private access.
+ */
+ HelpFile helpFile;
+
+ /**
+ * The stack of help topics. Note package private access.
+ */
+ ArrayList<Topic> helpTopics = new ArrayList<Topic>();
+
+ /**
+ * 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() {
+ // Wrap everything in a try, so that if we go belly up we can let
+ // the user have their terminal back.
+ try {
+ runImpl();
+ } catch (Throwable t) {
+ this.application.restoreConsole();
+ t.printStackTrace();
+ this.application.exit();
+ }
+ }
+
+ /**
+ * The consumer loop.
+ */
+ private void runImpl() {
+ boolean first = true;
+
+ // Loop forever
+ while (!application.quit) {
+
+ // Wait until application notifies me
+ while (!application.quit) {
+ try {
+ synchronized (application.drainEventQueue) {
+ if (application.drainEventQueue.size() > 0) {
+ break;
+ }
+ }
+
+ long timeout = 0;
+ if (first) {
+ first = false;
+ } else {
+ timeout = application.getSleepTime(1000);
+ }
+
+ if (timeout == 0) {
+ // A timer needs to fire, break out.
+ break;
+ }
+
+ if (debugThreads) {
+ System.err.printf("%d %s %s %s sleep %d millis\n",
+ System.currentTimeMillis(), this,
+ primary ? "primary" : "secondary",
+ Thread.currentThread(), timeout);
+ }
+
+ synchronized (this) {
+ this.wait(timeout);
+ }
+
+ if (debugThreads) {
+ System.err.printf("%d %s %s %s AWAKE\n",
+ System.currentTimeMillis(), this,
+ primary ? "primary" : "secondary",
+ Thread.currentThread());
+ }
+
+ if ((!primary)
+ && (application.secondaryEventReceiver == null)
+ ) {
+ // Secondary thread, emergency exit. If we got
+ // here then something went wrong with the
+ // handoff between yield() and closeWindow().
+ synchronized (application.primaryEventHandler) {
+ application.primaryEventHandler.notify();
+ }
+ application.secondaryEventHandler = null;
+ throw new RuntimeException("secondary exited " +
+ "at wrong time");
+ }
+ break;
+ } catch (InterruptedException e) {
+ // SQUASH
+ }
+ } // while (!application.quit)
+
+ // Pull all events off the queue
+ for (;;) {
+ TInputEvent event = null;
+ synchronized (application.drainEventQueue) {
+ if (application.drainEventQueue.size() == 0) {
+ break;
+ }
+ event = application.drainEventQueue.remove(0);
+ }
+
+ // We will have an event to process, so repaint the
+ // screen at the end.
+ application.repaint = true;
+
+ if (primary) {
+ primaryHandleEvent(event);
+ } else {
+ secondaryHandleEvent(event);
+ }
+ if ((!primary)
+ && (application.secondaryEventReceiver == null)
+ ) {
+ // Secondary thread, time to exit.
+
+ // Eliminate my reference so that wakeEventHandler()
+ // resumes working on the primary.
+ application.secondaryEventHandler = null;
+
+ // We are ready to exit, wake up the primary thread.
+ // Remember that it is currently sleeping inside its
+ // primaryHandleEvent().
+ synchronized (application.primaryEventHandler) {
+ application.primaryEventHandler.notify();
+ }
+
+ // All done!
+ return;
+ }
+
+ } // for (;;)
+
+ // Fire timers, update screen.
+ if (!quit) {
+ application.finishEventProcessing();
+ }
+
+ } // while (true) (main runnable loop)
+ }
+ }
+
+ /**
+ * ScreenHandler pushes screen updates to the physical device.
+ */
+ private class ScreenHandler implements Runnable {
+ /**
+ * The main application.
+ */
+ private TApplication application;
+
+ /**
+ * The dirty flag.
+ */
+ private boolean dirty = false;
+
+ /**
+ * Public constructor.
+ *
+ * @param application the main application
+ */
+ public ScreenHandler(final TApplication application) {
+ this.application = application;
+ }
+
+ /**
+ * The screen update loop.
+ */
+ public void run() {
+ // Wrap everything in a try, so that if we go belly up we can let
+ // the user have their terminal back.
+ try {
+ runImpl();
+ } catch (Throwable t) {
+ this.application.restoreConsole();
+ t.printStackTrace();
+ this.application.exit();
+ }
+ }
+
+ /**
+ * The update loop.
+ */
+ private void runImpl() {
+
+ // Loop forever
+ while (!application.quit) {
+
+ // Wait until application notifies me
+ while (!application.quit) {
+ try {
+ synchronized (this) {
+ if (dirty) {
+ dirty = false;
+ break;
+ }
+
+ // Always check within 50 milliseconds.
+ this.wait(50);
+ }
+ } catch (InterruptedException e) {
+ // SQUASH
+ }
+ } // while (!application.quit)
+
+ // Flush the screen contents
+ if (debugThreads) {
+ System.err.printf("%d %s backend.flushScreen()\n",
+ System.currentTimeMillis(), Thread.currentThread());
+ }
+ synchronized (getScreen()) {
+ backend.flushScreen();
+ }
+ } // while (true) (main runnable loop)
+
+ // Shutdown the user I/O thread(s)
+ backend.shutdown();
+ }
+
+ /**
+ * Set the dirty flag.
+ */
+ public void setDirty() {
+ synchronized (this) {
+ dirty = true;
+ }
+ }
+
}
// ------------------------------------------------------------------------
// Constructors -----------------------------------------------------------
// ------------------------------------------------------------------------
+ /**
+ * Public constructor.
+ *
+ * @param backendType BackendType.XTERM, BackendType.ECMA48 or
+ * BackendType.SWING
+ * @param windowWidth the number of text columns to start with
+ * @param windowHeight the number of text rows to start with
+ * @param fontSize the size in points
+ * @throws UnsupportedEncodingException if an exception is thrown when
+ * creating the InputStreamReader
+ */
+ public TApplication(final BackendType backendType, final int windowWidth,
+ final int windowHeight, final int fontSize)
+ throws UnsupportedEncodingException {
+
+ switch (backendType) {
+ case SWING:
+ backend = new SwingBackend(this, windowWidth, windowHeight,
+ fontSize);
+ break;
+ case XTERM:
+ // Fall through...
+ case ECMA48:
+ backend = new ECMA48Backend(this, null, null, windowWidth,
+ windowHeight, fontSize);
+ break;
+ default:
+ throw new IllegalArgumentException("Invalid backend type: "
+ + backendType);
+ }
+ TApplicationImpl();
+ }
+
/**
* Public constructor.
*
*/
public TApplication(final Backend backend) {
this.backend = backend;
+ backend.setListener(this);
TApplicationImpl();
}
* Finish construction once the backend is set.
*/
private void TApplicationImpl() {
+ // Text block mouse option
+ if (System.getProperty("jexer.textMouse", "true").equals("false")) {
+ textMouse = false;
+ }
+
+ // Hide mouse when typing option
+ if (System.getProperty("jexer.hideMouseWhenTyping",
+ "false").equals("true")) {
+
+ hideMouseWhenTyping = true;
+ }
+
+ // Hide status bar option
+ if (System.getProperty("jexer.hideStatusBar",
+ "false").equals("true")) {
+ hideStatusBar = true;
+ }
+
+ // Hide menu bar option
+ if (System.getProperty("jexer.hideMenuBar", "false").equals("true")) {
+ hideMenuBar = true;
+ }
+
theme = new ColorTheme();
- desktopBottom = getScreen().getHeight() - 1;
- fillEventQueue = new ArrayList<TInputEvent>();
- drainEventQueue = new ArrayList<TInputEvent>();
+ desktopTop = (hideMenuBar ? 0 : 1);
+ desktopBottom = getScreen().getHeight() - 1 + (hideStatusBar ? 1 : 0);
+ fillEventQueue = new LinkedList<TInputEvent>();
+ drainEventQueue = new LinkedList<TInputEvent>();
windows = new LinkedList<TWindow>();
- menus = new LinkedList<TMenu>();
- subMenus = new LinkedList<TMenu>();
+ menus = new ArrayList<TMenu>();
+ subMenus = new ArrayList<TMenu>();
timers = new LinkedList<TTimer>();
accelerators = new HashMap<TKeypress, TMenuItem>();
- menuItems = new ArrayList<TMenuItem>();
+ menuItems = new LinkedList<TMenuItem>();
desktop = new TDesktop(this);
- // Setup the main consumer thread
- primaryEventHandler = new WidgetEventHandler(this, true);
- (new Thread(primaryEventHandler)).start();
- }
+ // Special case: the Swing backend needs to have a timer to drive its
+ // blink state.
+ if ((backend instanceof SwingBackend)
+ || (backend instanceof MultiBackend)
+ ) {
+ // Default to 500 millis, unless a SwingBackend has its own
+ // value.
+ long millis = 500;
+ if (backend instanceof SwingBackend) {
+ millis = ((SwingBackend) backend).getBlinkMillis();
+ }
+ if (millis > 0) {
+ addTimer(millis, true,
+ new TAction() {
+ public void DO() {
+ TApplication.this.doRepaint();
+ }
+ }
+ );
+ }
+ }
- // ------------------------------------------------------------------------
- // Screen refresh loop ----------------------------------------------------
- // ------------------------------------------------------------------------
-
- /**
- * Invert the cell color at a position. This is used to track the mouse.
- *
- * @param x column position
- * @param y row position
- */
- private void invertCell(final int x, final int y) {
- if (debugThreads) {
- System.err.printf("invertCell() %d %d\n", x, y);
- }
- CellAttributes attr = getScreen().getAttrXY(x, y);
- attr.setForeColor(attr.getForeColor().invert());
- attr.setBackColor(attr.getBackColor().invert());
- getScreen().putAttrXY(x, y, attr, false);
- }
-
- /**
- * Draw everything.
- */
- private void drawAll() {
- if (debugThreads) {
- System.err.printf("drawAll() enter\n");
- }
-
- if (!repaint) {
- if (debugThreads) {
- System.err.printf("drawAll() !repaint\n");
- }
- synchronized (getScreen()) {
- if ((oldMouseX != mouseX) || (oldMouseY != mouseY)) {
- // The only thing that has happened is the mouse moved.
- // Clear the old position and draw the new position.
- invertCell(oldMouseX, oldMouseY);
- invertCell(mouseX, mouseY);
- oldMouseX = mouseX;
- oldMouseY = mouseY;
- }
- if (getScreen().isDirty()) {
- backend.flushScreen();
+ // Load the help system
+ invokeLater(new Runnable() {
+ /*
+ * This isn't the best solution. But basically if a TApplication
+ * subclass constructor throws and needs to use TExceptionDialog,
+ * it may end up at the bottom of the window stack with a bunch
+ * of modal windows on top of it if said constructors spawn their
+ * windows also via invokeLater(). But if they don't do that,
+ * and instead just conventionally construct their windows, then
+ * this exception dialog will end up on top where it should be.
+ */
+ public void run() {
+ try {
+ ClassLoader loader = Thread.currentThread().getContextClassLoader();
+ helpFile = new HelpFile();
+ helpFile.load(loader.getResourceAsStream("help.xml"));
+ } catch (Exception e) {
+ new TExceptionDialog(TApplication.this, e);
}
- return;
- }
- }
-
- if (debugThreads) {
- System.err.printf("drawAll() REDRAW\n");
- }
-
- // If true, the cursor is not visible
- boolean cursor = false;
-
- // Start with a clean screen
- getScreen().clear();
-
- // Draw the desktop
- if (desktop != null) {
- desktop.drawChildren();
- }
-
- // Draw each window in reverse Z order
- List<TWindow> sorted = new LinkedList<TWindow>(windows);
- Collections.sort(sorted);
- TWindow topLevel = null;
- if (sorted.size() > 0) {
- topLevel = sorted.get(0);
- }
- Collections.reverse(sorted);
- for (TWindow window: sorted) {
- if (window.isShown()) {
- 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.isActive()) {
- menuColor = theme.getColor("tmenu.highlighted");
- menuMnemonicColor = theme.getColor("tmenu.mnemonic.highlighted");
- topLevel = menu;
- } else {
- menuColor = theme.getColor("tmenu");
- menuMnemonicColor = theme.getColor("tmenu.mnemonic");
- }
- // Draw the menu title
- getScreen().hLineXY(x, 0, menu.getTitle().length() + 2, ' ',
- menuColor);
- getScreen().putStringXY(x + 1, 0, menu.getTitle(), menuColor);
- // Draw the highlight character
- getScreen().putCharXY(x + 1 + menu.getMnemonic().getShortcutIdx(),
- 0, menu.getMnemonic().getShortcut(), menuMnemonicColor);
-
- if (menu.isActive()) {
- 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 status bar of the top-level window
- TStatusBar statusBar = null;
- if (topLevel != null) {
- statusBar = topLevel.getStatusBar();
- }
- if (statusBar != null) {
- getScreen().resetClipping();
- statusBar.setWidth(getScreen().getWidth());
- statusBar.setY(getScreen().getHeight() - topLevel.getY());
- statusBar.draw();
- } else {
- CellAttributes barColor = new CellAttributes();
- barColor.setTo(getTheme().getColor("tstatusbar.text"));
- getScreen().hLineXY(0, desktopBottom, getScreen().getWidth(), ' ',
- barColor);
- }
-
- // Draw the mouse pointer
- invertCell(mouseX, mouseY);
- oldMouseX = mouseX;
- oldMouseY = mouseY;
-
- // Place the cursor if it is visible
- TWidget activeWidget = null;
- if (sorted.size() > 0) {
- activeWidget = sorted.get(sorted.size() - 1).getActiveChild();
- if (activeWidget.isCursorVisible()) {
- getScreen().putCursor(true, activeWidget.getCursorAbsoluteX(),
- activeWidget.getCursorAbsoluteY());
- cursor = true;
}
- }
-
- // Kill the cursor
- if (!cursor) {
- getScreen().hideCursor();
- }
-
- // Flush the screen contents
- if (getScreen().isDirty()) {
- backend.flushScreen();
- }
-
- repaint = false;
+ });
}
// ------------------------------------------------------------------------
- // Main loop --------------------------------------------------------------
+ // Runnable ---------------------------------------------------------------
// ------------------------------------------------------------------------
/**
* Run this application until it exits.
*/
public void run() {
+ // System.err.println("*** TApplication.run() begins ***");
+
+ // Start the screen updater thread
+ screenHandler = new ScreenHandler(this);
+ (new Thread(screenHandler)).start();
+
+ // Start the main consumer thread
+ primaryEventHandler = new WidgetEventHandler(this, true);
+ (new Thread(primaryEventHandler)).start();
+
+ started = true;
+
while (!quit) {
- // Timeout is in milliseconds, so default timeout after 1 second
- // of inactivity.
- long timeout = 1000;
-
- // If I've got no updates to render, wait for something from the
- // backend or a timer.
- if (!repaint
- && ((mouseX == oldMouseX) && (mouseY == oldMouseY))
- ) {
- // Never sleep longer than 50 millis. We need time for
- // windows with background tasks to update the display, and
- // still flip buffers reasonably quickly in
- // backend.flushPhysical().
- timeout = getSleepTime(50);
- }
-
- 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 {
- if (debugThreads) {
- System.err.println("sleep " + timeout + " millis");
+ synchronized (this) {
+ boolean doWait = false;
+
+ if (!backend.hasEvents()) {
+ synchronized (fillEventQueue) {
+ if (fillEventQueue.size() == 0) {
+ doWait = true;
+ }
}
- synchronized (this) {
- this.wait(timeout);
+ }
+
+ if (doWait) {
+ // No I/O to dispatch, so wait until the backend
+ // provides new I/O.
+ try {
+ if (debugThreads) {
+ System.err.println(System.currentTimeMillis() +
+ " " + Thread.currentThread() + " MAIN sleep");
+ }
+
+ this.wait();
+
+ if (debugThreads) {
+ System.err.println(System.currentTimeMillis() +
+ " " + Thread.currentThread() + " MAIN AWAKE");
+ }
+ } catch (InterruptedException e) {
+ // I'm awake and don't care why, let's see what's
+ // going on out there.
}
- } catch (InterruptedException e) {
- // I'm awake and don't care why, let's see what's going
- // on out there.
}
- repaint = true;
- }
- // Prevent stepping on the primary or secondary event handler.
- stopEventHandlers();
+ } // synchronized (this)
- // Pull any pending I/O events
- backend.getEvents(fillEventQueue);
+ synchronized (fillEventQueue) {
+ // Pull any pending I/O events
+ backend.getEvents(fillEventQueue);
- // Dispatch each event to the appropriate handler, one at a time.
- for (;;) {
- TInputEvent event = null;
- if (fillEventQueue.size() == 0) {
- break;
+ // Dispatch each event to the appropriate handler, one at a
+ // time.
+ for (;;) {
+ TInputEvent event = null;
+ if (fillEventQueue.size() == 0) {
+ break;
+ }
+ event = fillEventQueue.remove(0);
+ metaHandleEvent(event);
}
- event = fillEventQueue.remove(0);
- metaHandleEvent(event);
}
// Wake a consumer thread if we have any pending events.
wakeEventHandler();
}
- // Process timers and call doIdle()'s
- doIdle();
-
- // Update the screen
- synchronized (getScreen()) {
- drawAll();
- }
-
- // Let the event handlers run again.
- startEventHandlers();
-
} // while (!quit)
// Shutdown the event consumer threads
}
}
- // Shutdown the user I/O thread(s)
- backend.shutdown();
-
// Close all the windows. This gives them an opportunity to release
// resources.
closeAllWindows();
+ // Close the desktop.
+ if (desktop != null) {
+ setDesktop(null);
+ }
+
+ // Give the overarching application an opportunity to release
+ // resources.
+ onExit();
+
+ // System.err.println("*** TApplication.run() exits ***");
}
+ // ------------------------------------------------------------------------
+ // Event handlers ---------------------------------------------------------
+ // ------------------------------------------------------------------------
+
/**
- * Peek at certain application-level events, add to eventQueue, and wake
- * up the consuming Thread.
+ * Method that TApplication subclasses can override to handle menu or
+ * posted command events.
*
- * @param event the input event to consume
+ * @param command command event
+ * @return if true, this event was consumed
*/
- private void metaHandleEvent(final TInputEvent event) {
+ protected boolean onCommand(final TCommandEvent command) {
+ // Default: handle cmExit
+ if (command.equals(cmExit)) {
+ if (messageBox(i18n.getString("exitDialogTitle"),
+ i18n.getString("exitDialogText"),
+ TMessageBox.Type.YESNO).isYes()) {
- if (debugEvents) {
- System.err.printf(String.format("metaHandleEvents event: %s\n",
- event)); System.err.flush();
+ exit();
+ }
+ return true;
}
- if (quit) {
- // Do no more processing if the application is already trying
- // to exit.
- return;
+ if (command.equals(cmHelp)) {
+ if (getActiveWindow() != null) {
+ new THelpWindow(this, getActiveWindow().getHelpTopic());
+ } else {
+ new THelpWindow(this);
+ }
+ return true;
}
- // Special application-wide events -------------------------------
-
- // Abort everything
- if (event instanceof TCommandEvent) {
- TCommandEvent command = (TCommandEvent) event;
- if (command.getCmd().equals(cmAbort)) {
- quit = true;
- return;
- }
+ if (command.equals(cmShell)) {
+ openTerminal(0, 0, TWindow.RESIZABLE);
+ return true;
}
- // Screen resize
- if (event instanceof TResizeEvent) {
- TResizeEvent resize = (TResizeEvent) event;
- synchronized (getScreen()) {
- getScreen().setDimensions(resize.getWidth(),
- resize.getHeight());
- desktopBottom = getScreen().getHeight() - 1;
- mouseX = 0;
- mouseY = 0;
- oldMouseX = 0;
- oldMouseY = 0;
- }
- if (desktop != null) {
- desktop.setDimensions(0, 0, resize.getWidth(),
- resize.getHeight() - 1);
- }
- return;
+ if (command.equals(cmTile)) {
+ tileWindows();
+ return true;
+ }
+ if (command.equals(cmCascade)) {
+ cascadeWindows();
+ return true;
+ }
+ if (command.equals(cmCloseAll)) {
+ closeAllWindows();
+ return true;
}
- // Peek at the mouse position
- if (event instanceof TMouseEvent) {
- TMouseEvent mouse = (TMouseEvent) event;
- synchronized (getScreen()) {
- if ((mouseX != mouse.getX()) || (mouseY != mouse.getY())) {
- oldMouseX = mouseX;
- oldMouseY = mouseY;
- mouseX = mouse.getX();
- mouseY = mouse.getY();
+ if (command.equals(cmMenu) && (hideMenuBar == false)) {
+ if (!modalWindowActive() && (activeMenu == null)) {
+ if (menus.size() > 0) {
+ menus.get(0).setActive(true);
+ activeMenu = menus.get(0);
+ return true;
}
}
}
- // Put into the main queue
- drainEventQueue.add(event);
+ return false;
}
/**
- * 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.
+ * Method that TApplication subclasses can override to handle menu
+ * events.
*
- * @param event the input event to consume
- * @see #secondaryHandleEvent(TInputEvent event)
+ * @param menu menu event
+ * @return if true, this event was consumed
*/
- private void primaryHandleEvent(final TInputEvent event) {
+ protected boolean onMenu(final TMenuEvent menu) {
- if (debugEvents) {
- System.err.printf("Handle event: %s\n", event);
+ // Default: handle MID_EXIT
+ if (menu.getId() == TMenu.MID_EXIT) {
+ if (messageBox(i18n.getString("exitDialogTitle"),
+ i18n.getString("exitDialogText"),
+ TMessageBox.Type.YESNO).isYes()) {
+
+ exit();
+ }
+ return true;
}
- // Special application-wide events -----------------------------------
+ if (menu.getId() == TMenu.MID_HELP_HELP) {
+ new THelpWindow(this, THelpWindow.HELP_HELP);
+ return true;
+ }
- // 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);
+ if (menu.getId() == TMenu.MID_HELP_CONTENTS) {
+ new THelpWindow(this, helpFile.getTableOfContents());
+ return true;
}
- // Handle menu events
- if ((activeMenu != null) && !(event instanceof TCommandEvent)) {
- TMenu menu = activeMenu;
+ if (menu.getId() == TMenu.MID_HELP_INDEX) {
+ new THelpWindow(this, helpFile.getIndex());
+ return true;
+ }
- if (event instanceof TMouseEvent) {
- TMouseEvent mouse = (TMouseEvent) event;
+ if (menu.getId() == TMenu.MID_HELP_SEARCH) {
+ TInputBox inputBox = inputBox(i18n.
+ getString("searchHelpInputBoxTitle"),
+ i18n.getString("searchHelpInputBoxCaption"), "",
+ TInputBox.Type.OKCANCEL);
+ if (inputBox.isOk()) {
+ new THelpWindow(this,
+ helpFile.getSearchResults(inputBox.getText()));
+ }
+ return true;
+ }
- while (subMenus.size() > 0) {
- TMenu subMenu = subMenus.get(subMenus.size() - 1);
- if (subMenu.mouseWouldHit(mouse)) {
- break;
- }
- if ((mouse.getType() == TMouseEvent.Type.MOUSE_MOTION)
- && (!mouse.isMouse1())
- && (!mouse.isMouse2())
- && (!mouse.isMouse3())
- && (!mouse.isMouseWheelUp())
- && (!mouse.isMouseWheelDown())
- ) {
- break;
- }
- // We navigated away from a sub-menu, so close it
- closeSubMenu();
- }
+ if (menu.getId() == TMenu.MID_HELP_PREVIOUS) {
+ if (helpTopics.size() > 1) {
+ Topic previous = helpTopics.remove(helpTopics.size() - 2);
+ helpTopics.remove(helpTopics.size() - 1);
+ new THelpWindow(this, previous);
+ } else {
+ new THelpWindow(this, helpFile.getTableOfContents());
+ }
+ return true;
+ }
- // 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);
+ if (menu.getId() == TMenu.MID_HELP_ACTIVE_FILE) {
+ try {
+ List<String> filters = new ArrayList<String>();
+ filters.add("^.*\\.[Xx][Mm][Ll]$");
+ String filename = fileOpenBox(".", TFileOpenBox.Type.OPEN,
+ filters);
+ if (filename != null) {
+ helpTopics = new ArrayList<Topic>();
+ helpFile = new HelpFile();
+ helpFile.load(new FileInputStream(filename));
}
- mouse.setX(mouse.getX() - menu.getX());
- mouse.setY(mouse.getY() - menu.getY());
+ } catch (Exception e) {
+ // Show this exception to the user.
+ new TExceptionDialog(this, e);
}
- menu.handleEvent(event);
- return;
+ return true;
}
- if (event instanceof TKeypressEvent) {
- TKeypressEvent keypress = (TKeypressEvent) event;
+ if (menu.getId() == TMenu.MID_SHELL) {
+ openTerminal(0, 0, TWindow.RESIZABLE);
+ return true;
+ }
- // See if this key matches an accelerator, and is not being
- // shortcutted by the active window, and if so dispatch the menu
- // event.
- boolean windowWillShortcut = false;
- if (activeWindow != null) {
+ if (menu.getId() == TMenu.MID_TILE) {
+ tileWindows();
+ return true;
+ }
+ if (menu.getId() == TMenu.MID_CASCADE) {
+ cascadeWindows();
+ return true;
+ }
+ if (menu.getId() == TMenu.MID_CLOSE_ALL) {
+ closeAllWindows();
+ return true;
+ }
+ if (menu.getId() == TMenu.MID_ABOUT) {
+ showAboutDialog();
+ return true;
+ }
+ if (menu.getId() == TMenu.MID_REPAINT) {
+ getScreen().clearPhysical();
+ doRepaint();
+ return true;
+ }
+ if (menu.getId() == TMenu.MID_VIEW_IMAGE) {
+ openImage();
+ return true;
+ }
+ if (menu.getId() == TMenu.MID_SCREEN_OPTIONS) {
+ new TFontChooserWindow(this);
+ return true;
+ }
+
+ if (menu.getId() == TMenu.MID_CUT) {
+ postMenuEvent(new TCommandEvent(cmCut));
+ return true;
+ }
+ if (menu.getId() == TMenu.MID_COPY) {
+ postMenuEvent(new TCommandEvent(cmCopy));
+ return true;
+ }
+ if (menu.getId() == TMenu.MID_PASTE) {
+ postMenuEvent(new TCommandEvent(cmPaste));
+ return true;
+ }
+ if (menu.getId() == TMenu.MID_CLEAR) {
+ postMenuEvent(new TCommandEvent(cmClear));
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Method that TApplication subclasses can override to handle keystrokes.
+ *
+ * @param keypress keystroke event
+ * @return if true, this event was consumed
+ */
+ protected boolean onKeypress(final TKeypressEvent keypress) {
+ // Default: only menu shortcuts
+
+ // Process Alt-F, Alt-E, etc. menu shortcut keys
+ if (!keypress.getKey().isFnKey()
+ && keypress.getKey().isAlt()
+ && !keypress.getKey().isCtrl()
+ && (activeMenu == null)
+ && !modalWindowActive()
+ && (hideMenuBar == false)
+ ) {
+
+ assert (subMenus.size() == 0);
+
+ for (TMenu menu: menus) {
+ if (Character.toLowerCase(menu.getMnemonic().getShortcut())
+ == Character.toLowerCase(keypress.getKey().getChar())
+ ) {
+ activeMenu = menu;
+ menu.setActive(true);
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Process background events, and update the screen.
+ */
+ private void finishEventProcessing() {
+ if (debugThreads) {
+ System.err.printf(System.currentTimeMillis() + " " +
+ Thread.currentThread() + " finishEventProcessing()\n");
+ }
+
+ // See if we need to enable/disable the edit menu.
+ EditMenuUser widget = null;
+ if (activeMenu == null) {
+ TWindow activeWindow = getActiveWindow();
+ if (activeWindow != null) {
+ if (activeWindow.getActiveChild() instanceof EditMenuUser) {
+ widget = (EditMenuUser) activeWindow.getActiveChild();
+ }
+ } else if (desktop != null) {
+ if (desktop.getActiveChild() instanceof EditMenuUser) {
+ widget = (EditMenuUser) desktop.getActiveChild();
+ }
+ }
+ if (widget == null) {
+ disableMenuItem(TMenu.MID_CUT);
+ disableMenuItem(TMenu.MID_COPY);
+ disableMenuItem(TMenu.MID_PASTE);
+ disableMenuItem(TMenu.MID_CLEAR);
+ } else {
+ if (widget.isEditMenuCut()) {
+ enableMenuItem(TMenu.MID_CUT);
+ } else {
+ disableMenuItem(TMenu.MID_CUT);
+ }
+ if (widget.isEditMenuCopy()) {
+ enableMenuItem(TMenu.MID_COPY);
+ } else {
+ disableMenuItem(TMenu.MID_COPY);
+ }
+ if (widget.isEditMenuPaste()) {
+ enableMenuItem(TMenu.MID_PASTE);
+ } else {
+ disableMenuItem(TMenu.MID_PASTE);
+ }
+ if (widget.isEditMenuClear()) {
+ enableMenuItem(TMenu.MID_CLEAR);
+ } else {
+ disableMenuItem(TMenu.MID_CLEAR);
+ }
+ }
+ }
+
+ // Process timers and call doIdle()'s
+ doIdle();
+
+ // Update the screen
+ synchronized (getScreen()) {
+ drawAll();
+ }
+
+ // Wake up the screen repainter
+ wakeScreenHandler();
+
+ if (debugThreads) {
+ System.err.printf(System.currentTimeMillis() + " " +
+ Thread.currentThread() + " finishEventProcessing() END\n");
+ }
+ }
+
+ /**
+ * 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) {
+
+ 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
+ // to exit.
+ return;
+ }
+
+ // Special application-wide events -------------------------------
+
+ // Abort everything
+ if (event instanceof TCommandEvent) {
+ TCommandEvent command = (TCommandEvent) event;
+ if (command.equals(cmAbort)) {
+ exit();
+ return;
+ }
+ }
+
+ synchronized (drainEventQueue) {
+ // Screen resize
+ if (event instanceof TResizeEvent) {
+ TResizeEvent resize = (TResizeEvent) event;
+ synchronized (getScreen()) {
+ if ((System.currentTimeMillis() - screenResizeTime >= 15)
+ || (resize.getWidth() < getScreen().getWidth())
+ || (resize.getHeight() < getScreen().getHeight())
+ ) {
+ getScreen().setDimensions(resize.getWidth(),
+ resize.getHeight());
+ screenResizeTime = System.currentTimeMillis();
+ }
+ desktopBottom = getScreen().getHeight() - 1;
+ if (hideStatusBar) {
+ desktopBottom++;
+ }
+ mouseX = 0;
+ mouseY = 0;
+ }
+ if (desktop != null) {
+ desktop.setDimensions(0, desktopTop, resize.getWidth(),
+ (desktopBottom - desktopTop));
+ desktop.onResize(resize);
+ }
+
+ // Change menu edges if needed.
+ recomputeMenuX();
+
+ // We are dirty, redraw the screen.
+ doRepaint();
+
+ /*
+ System.err.println("New screen: " + resize.getWidth() +
+ " x " + resize.getHeight());
+ */
+ return;
+ }
+
+ // Put into the main queue
+ drainEventQueue.add(event);
+ }
+ }
+
+ /**
+ * 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) {
+
+ if (debugEvents) {
+ System.err.printf("%s primaryHandleEvent: %s\n",
+ Thread.currentThread(), event);
+ }
+ TMouseEvent doubleClick = null;
+
+ // Special application-wide events -----------------------------------
+
+ if (event instanceof TKeypressEvent) {
+ if (hideMouseWhenTyping) {
+ typingHidMouse = true;
+ }
+ }
+
+ // Peek at the mouse position
+ if (event instanceof TMouseEvent) {
+ typingHidMouse = false;
+
+ TMouseEvent mouse = (TMouseEvent) event;
+ if (mouse.isMouse1() && (mouse.isShift() || mouse.isCtrl())) {
+ // Screen selection.
+ if (inScreenSelection) {
+ screenSelectionX1 = mouse.getX();
+ screenSelectionY1 = mouse.getY();
+ } else {
+ inScreenSelection = true;
+ screenSelectionX0 = mouse.getX();
+ screenSelectionY0 = mouse.getY();
+ screenSelectionX1 = mouse.getX();
+ screenSelectionY1 = mouse.getY();
+ screenSelectionRectangle = mouse.isCtrl();
+ }
+ } else {
+ if (inScreenSelection) {
+ getScreen().copySelection(clipboard, screenSelectionX0,
+ screenSelectionY0, screenSelectionX1, screenSelectionY1,
+ screenSelectionRectangle);
+ }
+ inScreenSelection = false;
+ }
+
+ if ((mouseX != mouse.getX()) || (mouseY != mouse.getY())) {
+ mouseX = mouse.getX();
+ mouseY = mouse.getY();
+ } else {
+ if ((mouse.getType() == TMouseEvent.Type.MOUSE_DOWN)
+ && (!mouse.isMouseWheelUp())
+ && (!mouse.isMouseWheelDown())
+ ) {
+ if ((mouse.getTime().getTime() - lastMouseUpTime) <
+ doubleClickTime) {
+
+ // This is a double-click.
+ doubleClick = new TMouseEvent(TMouseEvent.Type.
+ MOUSE_DOUBLE_CLICK,
+ mouse.getX(), mouse.getY(),
+ mouse.getAbsoluteX(), mouse.getAbsoluteY(),
+ mouse.isMouse1(), mouse.isMouse2(),
+ mouse.isMouse3(),
+ mouse.isMouseWheelUp(), mouse.isMouseWheelDown(),
+ mouse.isAlt(), mouse.isCtrl(), mouse.isShift());
+
+ } else {
+ // The first click of a potential double-click.
+ lastMouseUpTime = mouse.getTime().getTime();
+ }
+ }
+ }
+
+ // 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.isMouse1())
+ && (!mouse.isMouse2())
+ && (!mouse.isMouse3())
+ && (!mouse.isMouseWheelUp())
+ && (!mouse.isMouseWheelDown())
+ ) {
+ 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 is not being
+ // shortcutted by the active window, and if so dispatch the menu
+ // event.
+ boolean windowWillShortcut = false;
+ TWindow activeWindow = getActiveWindow();
+ if (activeWindow != null) {
assert (activeWindow.isShown());
if (activeWindow.isShortcutKeypress(keypress.getKey())) {
// We do not process this key, it will be passed to the
// Dispatch events to the active window -------------------------------
boolean dispatchToDesktop = true;
- TWindow window = activeWindow;
+ TWindow window = getActiveWindow();
if (window != null) {
assert (window.isActive());
assert (window.isShown());
mouse.setX(mouse.getX() - window.getX());
mouse.setY(mouse.getY() - window.getY());
- if (window.mouseWouldHit(mouse)) {
- dispatchToDesktop = false;
+ if (doubleClick != null) {
+ doubleClick.setX(doubleClick.getX() - window.getX());
+ doubleClick.setY(doubleClick.getY() - window.getY());
+ }
+
+ if (window.mouseWouldHit(mouse)) {
+ dispatchToDesktop = false;
+ }
+ } else if (event instanceof TKeypressEvent) {
+ dispatchToDesktop = false;
+ } else if (event instanceof TMenuEvent) {
+ dispatchToDesktop = false;
+ }
+
+ if (debugEvents) {
+ System.err.printf("TApplication dispatch event: %s\n",
+ event);
+ }
+ window.handleEvent(event);
+ if (doubleClick != null) {
+ window.handleEvent(doubleClick);
+ }
+ }
+ if (dispatchToDesktop) {
+ // This event is fair game for the desktop to process.
+ if (desktop != null) {
+ desktop.handleEvent(event);
+ if (doubleClick != null) {
+ desktop.handleEvent(doubleClick);
+ }
+ }
+ }
+ }
+
+ /**
+ * 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) {
+ TMouseEvent doubleClick = null;
+
+ if (debugEvents) {
+ System.err.printf("%s secondaryHandleEvent: %s\n",
+ Thread.currentThread(), event);
+ }
+
+ // Peek at the mouse position
+ if (event instanceof TMouseEvent) {
+ typingHidMouse = false;
+
+ TMouseEvent mouse = (TMouseEvent) event;
+ if ((mouseX != mouse.getX()) || (mouseY != mouse.getY())) {
+ mouseX = mouse.getX();
+ mouseY = mouse.getY();
+ } else {
+ if ((mouse.getType() == TMouseEvent.Type.MOUSE_DOWN)
+ && (!mouse.isMouseWheelUp())
+ && (!mouse.isMouseWheelDown())
+ ) {
+ if ((mouse.getTime().getTime() - lastMouseUpTime) <
+ doubleClickTime) {
+
+ // This is a double-click.
+ doubleClick = new TMouseEvent(TMouseEvent.Type.
+ MOUSE_DOUBLE_CLICK,
+ mouse.getX(), mouse.getY(),
+ mouse.getAbsoluteX(), mouse.getAbsoluteY(),
+ mouse.isMouse1(), mouse.isMouse2(),
+ mouse.isMouse3(),
+ mouse.isMouseWheelUp(), mouse.isMouseWheelDown(),
+ mouse.isAlt(), mouse.isCtrl(), mouse.isShift());
+
+ } else {
+ // The first click of a potential double-click.
+ lastMouseUpTime = mouse.getTime().getTime();
+ }
+ }
+ }
+ }
+
+ secondaryEventReceiver.handleEvent(event);
+ // Note that it is possible for secondaryEventReceiver to be null
+ // now, because its handleEvent() might have finished out on the
+ // secondary thread. So put any extra processing inside a null
+ // check.
+ if (secondaryEventReceiver != null) {
+ if (doubleClick != null) {
+ secondaryEventReceiver.handleEvent(doubleClick);
+ }
+ }
+ }
+
+ /**
+ * Enable a widget to override the primary event thread.
+ *
+ * @param widget widget that will receive events
+ */
+ public final void enableSecondaryEventReceiver(final TWidget widget) {
+ if (debugThreads) {
+ System.err.println(System.currentTimeMillis() +
+ " enableSecondaryEventReceiver()");
+ }
+
+ assert (secondaryEventReceiver == null);
+ assert (secondaryEventHandler == null);
+ assert ((widget instanceof TMessageBox)
+ || (widget instanceof TFileOpenBox));
+ secondaryEventReceiver = widget;
+ secondaryEventHandler = new WidgetEventHandler(this, false);
+
+ (new Thread(secondaryEventHandler)).start();
+ }
+
+ /**
+ * Yield to the secondary thread.
+ */
+ public final void yield() {
+ if (debugThreads) {
+ System.err.printf(System.currentTimeMillis() + " " +
+ Thread.currentThread() + " yield()\n");
+ }
+
+ assert (secondaryEventReceiver != null);
+
+ while (secondaryEventReceiver != null) {
+ synchronized (primaryEventHandler) {
+ try {
+ primaryEventHandler.wait();
+ } catch (InterruptedException e) {
+ // SQUASH
+ }
+ }
+ }
+ }
+
+ /**
+ * Do stuff when there is no user input.
+ */
+ private void doIdle() {
+ if (debugThreads) {
+ System.err.printf(System.currentTimeMillis() + " " +
+ Thread.currentThread() + " doIdle()\n");
+ }
+
+ synchronized (timers) {
+
+ if (debugThreads) {
+ System.err.printf(System.currentTimeMillis() + " " +
+ Thread.currentThread() + " doIdle() 2\n");
+ }
+
+ // 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()) {
+ // Something might change, so repaint the screen.
+ repaint = true;
+ timer.tick();
+ if (timer.recurring) {
+ keepTimers.add(timer);
+ }
+ } else {
+ keepTimers.add(timer);
+ }
+ }
+ timers.clear();
+ timers.addAll(keepTimers);
+ }
+
+ // Call onIdle's
+ for (TWindow window: windows) {
+ window.onIdle();
+ }
+ if (desktop != null) {
+ desktop.onIdle();
+ }
+
+ // Run any invokeLaters. We make a copy, and run that, because one
+ // of these Runnables might add call TApplication.invokeLater().
+ List<Runnable> invokes = new ArrayList<Runnable>();
+ synchronized (invokeLaters) {
+ invokes.addAll(invokeLaters);
+ invokeLaters.clear();
+ }
+ for (Runnable invoke: invokes) {
+ invoke.run();
+ }
+ doRepaint();
+
+ }
+
+ /**
+ * Wake the sleeping active event handler.
+ */
+ private void wakeEventHandler() {
+ if (!started) {
+ return;
+ }
+
+ if (secondaryEventHandler != null) {
+ synchronized (secondaryEventHandler) {
+ secondaryEventHandler.notify();
+ }
+ } else {
+ assert (primaryEventHandler != null);
+ synchronized (primaryEventHandler) {
+ primaryEventHandler.notify();
+ }
+ }
+ }
+
+ /**
+ * Wake the sleeping screen handler.
+ */
+ private void wakeScreenHandler() {
+ if (!started) {
+ return;
+ }
+
+ synchronized (screenHandler) {
+ screenHandler.notify();
+ }
+ }
+
+ // ------------------------------------------------------------------------
+ // TApplication -----------------------------------------------------------
+ // ------------------------------------------------------------------------
+
+ /**
+ * Place a command on the run queue, and run it before the next round of
+ * checking I/O.
+ *
+ * @param command the command to run later
+ */
+ public void invokeLater(final Runnable command) {
+ synchronized (invokeLaters) {
+ invokeLaters.add(command);
+ }
+ doRepaint();
+ }
+
+ /**
+ * Restore the console to sane defaults. This is meant to be used for
+ * improper exits (e.g. a caught exception in main()), and should not be
+ * necessary for normal program termination.
+ */
+ public void restoreConsole() {
+ if (backend != null) {
+ if (backend instanceof ECMA48Backend) {
+ backend.shutdown();
+ }
+ }
+ }
+
+ /**
+ * Get the Backend.
+ *
+ * @return the Backend
+ */
+ public final Backend getBackend() {
+ return backend;
+ }
+
+ /**
+ * Get the Screen.
+ *
+ * @return the Screen
+ */
+ public final Screen getScreen() {
+ if (backend instanceof TWindowBackend) {
+ // We are being rendered to a TWindow. We can't use its
+ // getScreen() method because that is how it is rendering to a
+ // hardware backend somewhere. Instead use its getOtherScreen()
+ // method.
+ return ((TWindowBackend) backend).getOtherScreen();
+ } else {
+ return backend.getScreen();
+ }
+ }
+
+ /**
+ * Get the color theme.
+ *
+ * @return the theme
+ */
+ public final ColorTheme getTheme() {
+ return theme;
+ }
+
+ /**
+ * Get the clipboard.
+ *
+ * @return the clipboard
+ */
+ public final Clipboard getClipboard() {
+ return clipboard;
+ }
+
+ /**
+ * Repaint the screen on the next update.
+ */
+ public void doRepaint() {
+ repaint = true;
+ wakeEventHandler();
+ }
+
+ /**
+ * 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;
+ }
+
+ /**
+ * 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;
+ }
+
+ /**
+ * Set the TDesktop instance.
+ *
+ * @param desktop a TDesktop instance, or null to remove the one that is
+ * set
+ */
+ public final void setDesktop(final TDesktop desktop) {
+ if (this.desktop != null) {
+ this.desktop.onPreClose();
+ this.desktop.onUnfocus();
+ this.desktop.onClose();
+ }
+ this.desktop = desktop;
+ }
+
+ /**
+ * Get the TDesktop instance.
+ *
+ * @return the desktop, or null if it is not set
+ */
+ public final TDesktop getDesktop() {
+ return desktop;
+ }
+
+ /**
+ * Get the current active window.
+ *
+ * @return the active window, or null if it is not set
+ */
+ public final TWindow getActiveWindow() {
+ for (TWindow window: windows) {
+ if (window.isShown() && window.isActive()) {
+ return window;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Get a (shallow) copy of the window list.
+ *
+ * @return a copy of the list of windows for this application
+ */
+ public final List<TWindow> getAllWindows() {
+ List<TWindow> result = new ArrayList<TWindow>();
+ result.addAll(windows);
+ return result;
+ }
+
+ /**
+ * Get focusFollowsMouse flag.
+ *
+ * @return true if focus follows mouse: windows automatically raised if
+ * the mouse passes over them
+ */
+ public boolean getFocusFollowsMouse() {
+ return focusFollowsMouse;
+ }
+
+ /**
+ * Set focusFollowsMouse flag.
+ *
+ * @param focusFollowsMouse if true, focus follows mouse: windows
+ * automatically raised if the mouse passes over them
+ */
+ public void setFocusFollowsMouse(final boolean focusFollowsMouse) {
+ this.focusFollowsMouse = focusFollowsMouse;
+ }
+
+ /**
+ * Display the about dialog.
+ */
+ protected void showAboutDialog() {
+ String version = getClass().getPackage().getImplementationVersion();
+ if (version == null) {
+ // This is Java 9+, use a hardcoded string here.
+ version = "1.0.0";
+ }
+ messageBox(i18n.getString("aboutDialogTitle"),
+ MessageFormat.format(i18n.getString("aboutDialogText"), version),
+ TMessageBox.Type.OK);
+ }
+
+ /**
+ * Handle the Tool | Open image menu item.
+ */
+ private void openImage() {
+ try {
+ List<String> filters = new ArrayList<String>();
+ filters.add("^.*\\.[Jj][Pp][Gg]$");
+ filters.add("^.*\\.[Jj][Pp][Ee][Gg]$");
+ filters.add("^.*\\.[Pp][Nn][Gg]$");
+ filters.add("^.*\\.[Gg][Ii][Ff]$");
+ filters.add("^.*\\.[Bb][Mm][Pp]$");
+ String filename = fileOpenBox(".", TFileOpenBox.Type.OPEN, filters);
+ if (filename != null) {
+ new TImageWindow(this, new File(filename));
+ }
+ } catch (IOException e) {
+ // Show this exception to the user.
+ new TExceptionDialog(this, e);
+ }
+ }
+
+ /**
+ * Check if application is still running.
+ *
+ * @return true if the application is running
+ */
+ public final boolean isRunning() {
+ if (quit == true) {
+ return false;
+ }
+ return true;
+ }
+
+ // ------------------------------------------------------------------------
+ // Screen refresh loop ----------------------------------------------------
+ // ------------------------------------------------------------------------
+
+ /**
+ * Draw the text mouse at position.
+ *
+ * @param x column position
+ * @param y row position
+ */
+ private void drawTextMouse(final int x, final int y) {
+ TWindow activeWindow = getActiveWindow();
+
+ if (debugThreads) {
+ System.err.printf("%d %s drawTextMouse() %d %d\n",
+ System.currentTimeMillis(), Thread.currentThread(), x, y);
+
+ if (activeWindow != null) {
+ System.err.println("activeWindow.hasHiddenMouse() " +
+ activeWindow.hasHiddenMouse());
+ }
+ }
+
+ // If this cell is on top of a visible window that has requested a
+ // hidden mouse, bail out.
+ if ((activeWindow != null) && (activeMenu == null)) {
+ if ((activeWindow.hasHiddenMouse() == true)
+ && (x > activeWindow.getX())
+ && (x < activeWindow.getX() + activeWindow.getWidth() - 1)
+ && (y > activeWindow.getY())
+ && (y < activeWindow.getY() + activeWindow.getHeight() - 1)
+ ) {
+ return;
+ }
+ }
+
+ // If this cell is on top of the desktop, and the desktop has
+ // requested a hidden mouse, bail out.
+ if ((desktop != null) && (activeWindow == null) && (activeMenu == null)) {
+ if ((desktop.hasHiddenMouse() == true)
+ && (x > desktop.getX())
+ && (x < desktop.getX() + desktop.getWidth() - 1)
+ && (y > desktop.getY())
+ && (y < desktop.getY() + desktop.getHeight() - 1)
+ ) {
+ return;
+ }
+ }
+
+ getScreen().invertCell(x, y);
+ }
+
+ /**
+ * Draw everything.
+ */
+ private void drawAll() {
+ boolean menuIsActive = false;
+
+ if (debugThreads) {
+ System.err.printf("%d %s drawAll() enter\n",
+ System.currentTimeMillis(), Thread.currentThread());
+ }
+
+ // I don't think this does anything useful anymore...
+ if (!repaint) {
+ if (debugThreads) {
+ System.err.printf("%d %s drawAll() !repaint\n",
+ System.currentTimeMillis(), Thread.currentThread());
+ }
+ if ((oldDrawnMouseX != mouseX) || (oldDrawnMouseY != mouseY)) {
+ if (debugThreads) {
+ System.err.printf("%d %s drawAll() !repaint MOUSE\n",
+ System.currentTimeMillis(), Thread.currentThread());
+ }
+
+ // The only thing that has happened is the mouse moved.
+
+ // Redraw the old cell at that position, and save the cell at
+ // the new mouse position.
+ if (debugThreads) {
+ System.err.printf("%d %s restoreImage() %d %d\n",
+ System.currentTimeMillis(), Thread.currentThread(),
+ oldDrawnMouseX, oldDrawnMouseY);
+ }
+ oldDrawnMouseCell.restoreImage();
+ getScreen().putCharXY(oldDrawnMouseX, oldDrawnMouseY,
+ oldDrawnMouseCell);
+ oldDrawnMouseCell = getScreen().getCharXY(mouseX, mouseY);
+ if (backend instanceof ECMA48Backend) {
+ // Special case: the entire row containing the mouse has
+ // to be re-drawn if it has any image data, AND any rows
+ // in between.
+ if (oldDrawnMouseY != mouseY) {
+ for (int i = oldDrawnMouseY; ;) {
+ getScreen().unsetImageRow(i);
+ if (i == mouseY) {
+ break;
+ }
+ if (oldDrawnMouseY < mouseY) {
+ i++;
+ } else {
+ i--;
+ }
+ }
+ } else {
+ getScreen().unsetImageRow(mouseY);
+ }
+ }
+
+ if (inScreenSelection) {
+ getScreen().setSelection(screenSelectionX0,
+ screenSelectionY0, screenSelectionX1, screenSelectionY1,
+ screenSelectionRectangle);
+ }
+
+ if ((textMouse == true) && (typingHidMouse == false)) {
+ // Draw mouse at the new position.
+ drawTextMouse(mouseX, mouseY);
+ }
+
+ oldDrawnMouseX = mouseX;
+ oldDrawnMouseY = mouseY;
+ }
+ if (getScreen().isDirty()) {
+ screenHandler.setDirty();
+ }
+ return;
+ }
+
+ if (debugThreads) {
+ System.err.printf("%d %s drawAll() REDRAW\n",
+ System.currentTimeMillis(), Thread.currentThread());
+ }
+
+ // If true, the cursor is not visible
+ boolean cursor = false;
+
+ // Start with a clean screen
+ getScreen().clear();
+
+ // Draw the desktop
+ if (desktop != null) {
+ desktop.drawChildren();
+ }
+
+ // Draw each window in reverse Z order
+ List<TWindow> sorted = new ArrayList<TWindow>(windows);
+ Collections.sort(sorted);
+ TWindow topLevel = null;
+ if (sorted.size() > 0) {
+ topLevel = sorted.get(0);
+ }
+ Collections.reverse(sorted);
+ for (TWindow window: sorted) {
+ if (window.isShown()) {
+ window.drawChildren();
+ }
+ }
+
+ if (hideMenuBar == false) {
+
+ // 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.isActive()) {
+ menuIsActive = true;
+ menuColor = theme.getColor("tmenu.highlighted");
+ menuMnemonicColor = theme.getColor("tmenu.mnemonic.highlighted");
+ topLevel = menu;
+ } else {
+ menuColor = theme.getColor("tmenu");
+ menuMnemonicColor = theme.getColor("tmenu.mnemonic");
+ }
+ // Draw the menu title
+ getScreen().hLineXY(x, 0,
+ StringUtils.width(menu.getTitle()) + 2, ' ', menuColor);
+ getScreen().putStringXY(x + 1, 0, menu.getTitle(), menuColor);
+ // Draw the highlight character
+ getScreen().putCharXY(x + 1 +
+ menu.getMnemonic().getScreenShortcutIdx(),
+ 0, menu.getMnemonic().getShortcut(), menuMnemonicColor);
+
+ if (menu.isActive()) {
+ ((TWindow) menu).drawChildren();
+ // Reset the screen clipping so we can draw the next
+ // title.
+ getScreen().resetClipping();
+ }
+ x += StringUtils.width(menu.getTitle()) + 2;
+ }
+
+ for (TMenu menu: subMenus) {
+ // Reset the screen clipping so we can draw the next
+ // sub-menu.
+ getScreen().resetClipping();
+ ((TWindow) menu).drawChildren();
+ }
+ }
+ getScreen().resetClipping();
+
+ if (hideStatusBar == false) {
+ // Draw the status bar of the top-level window
+ TStatusBar statusBar = null;
+ if (topLevel != null) {
+ if (topLevel.isShown()) {
+ statusBar = topLevel.getStatusBar();
+ }
+ }
+ if (statusBar != null) {
+ getScreen().resetClipping();
+ statusBar.setWidth(getScreen().getWidth());
+ statusBar.setY(getScreen().getHeight() - topLevel.getY());
+ statusBar.draw();
+ } else {
+ CellAttributes barColor = new CellAttributes();
+ barColor.setTo(getTheme().getColor("tstatusbar.text"));
+ getScreen().hLineXY(0, desktopBottom, getScreen().getWidth(),
+ ' ', barColor);
+ }
+ }
+
+ // Draw the mouse pointer
+ if (debugThreads) {
+ System.err.printf("%d %s restoreImage() %d %d\n",
+ System.currentTimeMillis(), Thread.currentThread(),
+ oldDrawnMouseX, oldDrawnMouseY);
+ }
+ oldDrawnMouseCell = getScreen().getCharXY(mouseX, mouseY);
+ if (backend instanceof ECMA48Backend) {
+ // Special case: the entire row containing the mouse has to be
+ // re-drawn if it has any image data, AND any rows in between.
+ if (oldDrawnMouseY != mouseY) {
+ for (int i = oldDrawnMouseY; ;) {
+ getScreen().unsetImageRow(i);
+ if (i == mouseY) {
+ break;
+ }
+ if (oldDrawnMouseY < mouseY) {
+ i++;
+ } else {
+ i--;
+ }
+ }
+ } else {
+ getScreen().unsetImageRow(mouseY);
+ }
+ }
+
+ if (inScreenSelection) {
+ getScreen().setSelection(screenSelectionX0, screenSelectionY0,
+ screenSelectionX1, screenSelectionY1, screenSelectionRectangle);
+ }
+
+ if ((textMouse == true) && (typingHidMouse == false)) {
+ drawTextMouse(mouseX, mouseY);
+ }
+ oldDrawnMouseX = mouseX;
+ oldDrawnMouseY = mouseY;
+
+ // Place the cursor if it is visible
+ if (!menuIsActive) {
+
+ int visibleWindowCount = 0;
+ for (TWindow window: sorted) {
+ if (window.isShown()) {
+ visibleWindowCount++;
}
- } else if (event instanceof TKeypressEvent) {
- dispatchToDesktop = false;
}
-
- if (debugEvents) {
- System.err.printf("TApplication dispatch event: %s\n",
- event);
+ if (visibleWindowCount == 0) {
+ // No windows are visible, only the desktop. Allow it to
+ // have the cursor.
+ if (desktop != null) {
+ sorted.add(desktop);
+ }
}
- window.handleEvent(event);
- }
- if (dispatchToDesktop) {
- // This event is fair game for the desktop to process.
- if (desktop != null) {
- desktop.handleEvent(event);
+
+ TWidget activeWidget = null;
+ if (sorted.size() > 0) {
+ activeWidget = sorted.get(sorted.size() - 1).getActiveChild();
+ int cursorClipTop = desktopTop;
+ int cursorClipBottom = desktopBottom;
+ if (activeWidget.isCursorVisible()) {
+ if ((activeWidget.getCursorAbsoluteY() <= cursorClipBottom)
+ && (activeWidget.getCursorAbsoluteY() >= cursorClipTop)
+ ) {
+ getScreen().putCursor(true,
+ activeWidget.getCursorAbsoluteX(),
+ activeWidget.getCursorAbsoluteY());
+ cursor = true;
+ } else {
+ // Turn off the cursor. Also place it at 0,0.
+ getScreen().putCursor(false, 0, 0);
+ cursor = false;
+ }
+ }
}
}
- }
- /**
- * 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);
- }
+ // Kill the cursor
+ if (!cursor) {
+ getScreen().hideCursor();
+ }
- /**
- * 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)
- || (widget instanceof TFileOpenBox));
- secondaryEventReceiver = widget;
- secondaryEventHandler = new WidgetEventHandler(this, false);
- (new Thread(secondaryEventHandler)).start();
+ if (getScreen().isDirty()) {
+ screenHandler.setDirty();
+ }
+ repaint = false;
}
/**
- * Yield to the secondary thread.
+ * Force this application to exit.
*/
- 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);
-
- while (secondaryEventReceiver != null) {
- synchronized (primaryEventHandler) {
- try {
- primaryEventHandler.wait();
- } catch (InterruptedException e) {
- // SQUASH
- }
- }
+ public void exit() {
+ quit = true;
+ synchronized (this) {
+ this.notify();
}
}
/**
- * Do stuff when there is no user input.
+ * Subclasses can use this hook to cleanup resources. Called as the last
+ * step of TApplication.run().
*/
- 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) {
- keepTimers.add(timer);
- }
- } else {
- keepTimers.add(timer);
- }
- }
- timers = keepTimers;
-
- // Call onIdle's
- for (TWindow window: windows) {
- window.onIdle();
- }
- if (desktop != null) {
- desktop.onIdle();
- }
+ public void onExit() {
+ // Default does nothing.
}
// ------------------------------------------------------------------------
*
* @param window the window to become the new active window
*/
- public void activateWindow(final TWindow window) {
+ public final void activateWindow(final TWindow window) {
if (hasWindow(window) == false) {
/*
* Someone has a handle to a window I don't have. Ignore this
return;
}
- assert (windows.size() > 0);
-
- if (window.isHidden()) {
- // Unhiding will also activate.
- showWindow(window);
+ if (modalWindowActive() && !window.isModal()) {
+ // Do not activate a non-modal on top of a modal.
return;
}
- assert (window.isShown());
- if (windows.size() == 1) {
- assert (window == windows.get(0));
- if (activeWindow == null) {
- activeWindow = window;
+ synchronized (windows) {
+ // Whatever window might be moving/dragging, stop it now.
+ for (TWindow w: windows) {
+ if (w.inMovements()) {
+ w.stopMovements();
+ }
+ }
+
+ assert (windows.size() > 0);
+
+ if (window.isHidden()) {
+ // Unhiding will also activate.
+ showWindow(window);
+ return;
+ }
+ assert (window.isShown());
+
+ if (windows.size() == 1) {
+ assert (window == windows.get(0));
window.setZ(0);
- activeWindow.setActive(true);
- activeWindow.onFocus();
+ window.setActive(true);
+ window.onFocus();
+ return;
}
- assert (window.isActive());
- assert (activeWindow == window);
- return;
- }
+ if (getActiveWindow() == window) {
+ assert (window.isActive());
- if (activeWindow == window) {
- assert (window.isActive());
+ // Window is already active, do nothing.
+ return;
+ }
- // Window is already active, do nothing.
- return;
- }
+ assert (!window.isActive());
- assert (!window.isActive());
- if (activeWindow != null) {
- assert (activeWindow.getZ() == 0);
+ window.setZ(-1);
+ Collections.sort(windows);
+ int newZ = 0;
+ for (TWindow w: windows) {
+ w.setZ(newZ);
+ newZ++;
+ if ((w != window) && w.isActive()) {
+ w.onUnfocus();
+ }
+ w.setActive(false);
+ }
+ window.setActive(true);
+ window.onFocus();
+
+ } // synchronized (windows)
- activeWindow.onUnfocus();
- activeWindow.setActive(false);
- activeWindow.setZ(window.getZ());
- }
- activeWindow = window;
- activeWindow.setZ(0);
- activeWindow.setActive(true);
- activeWindow.onFocus();
return;
}
return;
}
- assert (windows.size() > 0);
+ synchronized (windows) {
- if (!window.hidden) {
- if (window == activeWindow) {
- if (shownWindowCount() > 1) {
- switchWindow(true);
- } else {
- activeWindow = null;
- window.setActive(false);
- window.onUnfocus();
+ // Whatever window might be moving/dragging, stop it now.
+ for (TWindow w: windows) {
+ if (w.inMovements()) {
+ w.stopMovements();
}
}
+
+ assert (windows.size() > 0);
+
+ if (window.hidden) {
+ return;
+ }
+
+ window.setActive(false);
window.hidden = true;
window.onHide();
- }
+
+ TWindow activeWindow = null;
+ for (TWindow w: windows) {
+ if (w.isShown()) {
+ activeWindow = w;
+ break;
+ }
+ }
+ assert (activeWindow != window);
+ if (activeWindow != null) {
+ activateWindow(activeWindow);
+ }
+
+ } // synchronized (windows)
+
}
/**
return;
}
- assert (windows.size() > 0);
-
if (window.hidden) {
window.hidden = false;
window.onShow();
activateWindow(window);
}
+
}
/**
- * Close window. Note that the window's destructor is NOT called by this
- * method, instead the GC is assumed to do the cleanup.
+ * Close window.
*
* @param window the window to remove
*/
return;
}
+ // Let window know that it is about to be closed, while it is still
+ // visible on screen.
+ window.onPreClose();
+
synchronized (windows) {
- int z = window.getZ();
- window.setZ(-1);
+
+ window.stopMovements();
window.onUnfocus();
+ windows.remove(window);
Collections.sort(windows);
- windows.remove(0);
- activeWindow = null;
+
+ TWindow nextWindow = null;
+ int newZ = 0;
for (TWindow w: windows) {
- if (w.getZ() > z) {
- w.setZ(w.getZ() - 1);
- if (w.getZ() == 0) {
- w.setActive(true);
- w.onFocus();
- assert (activeWindow == null);
- activeWindow = w;
- } else {
- if (w.isActive()) {
- w.setActive(false);
- w.onUnfocus();
- }
+ w.stopMovements();
+ w.setZ(newZ);
+ newZ++;
+
+ // Do not activate a hidden window.
+ if (w.isHidden()) {
+ continue;
+ }
+ if (nextWindow == null) {
+ nextWindow = w;
+ } else {
+ if (w.isActive()) {
+ w.setActive(false);
+ w.onUnfocus();
}
}
}
- }
+
+ if (nextWindow != null) {
+ nextWindow.setActive(true);
+ nextWindow.onFocus();
+ }
+
+ } // synchronized (windows)
// Perform window cleanup
window.onClose();
synchronized (secondaryEventHandler) {
secondaryEventHandler.notify();
}
- }
+
+ } // synchronized (windows)
// Permit desktop to be active if it is the only thing left.
if (desktop != null) {
if (shownWindowCount() < 2) {
return;
}
- assert (activeWindow != null);
+
+ if (modalWindowActive()) {
+ // Do not switch if a window is modal
+ return;
+ }
synchronized (windows) {
- // 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) == activeWindow) {
- assert (activeWindow.isActive());
- activeWindowI = i;
- break;
+ TWindow window = windows.get(0);
+ do {
+ assert (window != null);
+ if (forward) {
+ window.setZ(windows.size());
} else {
- assert (!windows.get(0).isActive());
+ TWindow lastWindow = windows.get(windows.size() - 1);
+ lastWindow.setZ(-1);
}
- }
- assert (activeWindowI >= 0);
-
- // Do not switch if a window is modal
- if (activeWindow.isModal()) {
- return;
- }
- int nextWindowI = activeWindowI;
- for (;;) {
- if (forward) {
- nextWindowI++;
- nextWindowI %= windows.size();
- } else {
- nextWindowI--;
- if (nextWindowI < 0) {
- nextWindowI = windows.size() - 1;
- }
+ Collections.sort(windows);
+ int newZ = 0;
+ for (TWindow w: windows) {
+ w.setZ(newZ);
+ newZ++;
}
- if (windows.get(nextWindowI).isShown()) {
- activateWindow(windows.get(nextWindowI));
- break;
+ window = windows.get(0);
+ } while (!window.isShown());
+
+ // The next visible window is now on top. Renumber the list.
+ for (TWindow w: windows) {
+ w.stopMovements();
+ if ((w != window) && w.isActive()) {
+ assert (w.isShown());
+ w.setActive(false);
+ w.onUnfocus();
}
}
- } // synchronized (windows)
+ // Next visible window is on top.
+ assert (window.isShown());
+ window.setActive(true);
+ window.onFocus();
+
+ } // synchronized (windows)
}
/**
- * Add a window to my window list and make it active.
+ * Add a window to my window list and make it active. Note package
+ * private access.
*
* @param window new window to add
*/
- public final void addWindow(final TWindow window) {
+ final void addWindowToApplication(final TWindow window) {
// Do not add menu windows to the window list.
if (window instanceof TMenu) {
}
synchronized (windows) {
+ if (windows.contains(window)) {
+ throw new IllegalArgumentException("Window " + window +
+ " is already in window list");
+ }
+
+ // Whatever window might be moving/dragging, stop it now.
+ for (TWindow w: windows) {
+ if (w.inMovements()) {
+ w.stopMovements();
+ }
+ }
+
// Do not allow a modal window to spawn a non-modal window. If a
// modal window is active, then this window will become modal
// too.
}
w.setZ(w.getZ() + 1);
}
- }
- windows.add(window);
- if (window.isShown()) {
- activeWindow = window;
- activeWindow.setZ(0);
- activeWindow.setActive(true);
- activeWindow.onFocus();
+ window.setZ(0);
+ window.setActive(true);
+ window.onFocus();
+ windows.add(0, window);
+ } else {
+ window.setZ(windows.size());
+ windows.add(window);
}
if (((window.flags & TWindow.CENTERED) == 0)
- && smartWindowPlacement) {
+ && ((window.flags & TWindow.ABSOLUTEXY) == 0)
+ && (smartWindowPlacement == true)
+ && (!(window instanceof TDesktop))
+ ) {
doSmartPlacement(window);
}
if (desktop != null) {
desktop.setActive(false);
}
+
}
/**
return false;
}
+ /**
+ * Check if there is a window with overridden menu flag on top.
+ *
+ * @return true if the active window is overriding the menu
+ */
+ private boolean overrideMenuWindowActive() {
+ TWindow activeWindow = getActiveWindow();
+ if (activeWindow != null) {
+ if (activeWindow.hasOverriddenMenu()) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
/**
* Close all open windows.
*/
int newHeight1 = ((getScreen().getHeight() - 1) / b);
int newHeight2 = ((getScreen().getHeight() - 1) / (b + c));
- List<TWindow> sorted = new LinkedList<TWindow>(windows);
+ List<TWindow> sorted = new ArrayList<TWindow>(windows);
Collections.sort(sorted);
Collections.reverse(sorted);
for (int i = 0; i < sorted.size(); i++) {
}
TWindow w = sorted.get(i);
+ int oldWidth = w.getWidth();
+ int oldHeight = w.getHeight();
+
w.setX(logicalX * newWidth);
w.setWidth(newWidth);
if (i >= ((a - 1) * b)) {
w.setY((logicalY * newHeight1) + 1);
w.setHeight(newHeight1);
}
+ if ((w.getWidth() != oldWidth)
+ || (w.getHeight() != oldHeight)
+ ) {
+ w.onResize(new TResizeEvent(TResizeEvent.Type.WIDGET,
+ w.getWidth(), w.getHeight()));
+ }
}
}
}
}
int x = 0;
int y = 1;
- List<TWindow> sorted = new LinkedList<TWindow>(windows);
+ List<TWindow> sorted = new ArrayList<TWindow>(windows);
Collections.sort(sorted);
Collections.reverse(sorted);
for (TWindow window: sorted) {
continue;
}
for (int x = w.getX(); x < w.getX() + w.getWidth(); x++) {
+ if (x < 0) {
+ continue;
+ }
if (x >= width) {
continue;
}
for (int y = w.getY(); y < w.getY() + w.getHeight(); y++) {
+ if (y < 0) {
+ continue;
+ }
if (y >= height) {
continue;
}
*/
private boolean mouseOnMenu(final TMouseEvent mouse) {
assert (activeMenu != null);
- List<TMenu> menus = new LinkedList<TMenu>(subMenus);
+ List<TMenu> menus = new ArrayList<TMenu>(subMenus);
Collections.reverse(menus);
for (TMenu menu: menus) {
if (menu.mouseWouldHit(mouse)) {
if ((mouse.getType() == TMouseEvent.Type.MOUSE_DOWN)
&& (mouse.isMouse1())
&& (!modalWindowActive())
+ && (!overrideMenuWindowActive())
&& (mouse.getAbsoluteY() == 0)
+ && (hideMenuBar == false)
) {
for (TMenu menu: subMenus) {
// They selected the menu, go activate it
for (TMenu menu: menus) {
- if ((mouse.getAbsoluteX() >= menu.getX())
- && (mouse.getAbsoluteX() < menu.getX()
- + menu.getTitle().length() + 2)
+ if ((mouse.getAbsoluteX() >= menu.getTitleX())
+ && (mouse.getAbsoluteX() < menu.getTitleX()
+ + StringUtils.width(menu.getTitle()) + 2)
) {
menu.setActive(true);
activeMenu = menu;
&& (mouse.isMouse1())
&& (activeMenu != null)
&& (mouse.getAbsoluteY() == 0)
+ && (hideMenuBar == false)
) {
TMenu oldMenu = activeMenu;
// See if we should switch menus
for (TMenu menu: menus) {
- if ((mouse.getAbsoluteX() >= menu.getX())
- && (mouse.getAbsoluteX() < menu.getX()
- + menu.getTitle().length() + 2)
+ if ((mouse.getAbsoluteX() >= menu.getTitleX())
+ && (mouse.getAbsoluteX() < menu.getTitleX()
+ + StringUtils.width(menu.getTitle()) + 2)
) {
menu.setActive(true);
activeMenu = menu;
if (((focusFollowsMouse == true)
&& (mouse.getType() == TMouseEvent.Type.MOUSE_MOTION))
- || (mouse.getType() == TMouseEvent.Type.MOUSE_UP)
+ || (mouse.getType() == TMouseEvent.Type.MOUSE_DOWN)
) {
synchronized (windows) {
- Collections.sort(windows);
if (windows.get(0).isModal()) {
// Modal windows don't switch
return;
}
if (window.mouseWouldHit(mouse)) {
- if (window == windows.get(0)) {
- // Clicked on the same window, nothing to do
- assert (window.isActive());
- return;
- }
-
- // We will be switching to another window
- assert (windows.get(0).isActive());
- assert (windows.get(0) == activeWindow);
- assert (!window.isActive());
- activeWindow.onUnfocus();
- activeWindow.setActive(false);
- activeWindow.setZ(window.getZ());
- activeWindow = window;
- window.setZ(0);
- window.setActive(true);
- window.onFocus();
+ activateWindow(window);
return;
}
}
}
}
+ /**
+ * Get a (shallow) copy of the menu list.
+ *
+ * @return a copy of the menu list
+ */
+ public final List<TMenu> getAllMenus() {
+ return new ArrayList<TMenu>(menus);
+ }
+
+ /**
+ * Add a top-level menu to the list.
+ *
+ * @param menu the menu to add
+ * @throws IllegalArgumentException if the menu is already used in
+ * another TApplication
+ */
+ public final void addMenu(final TMenu menu) {
+ if ((menu.getApplication() != null)
+ && (menu.getApplication() != this)
+ ) {
+ throw new IllegalArgumentException("Menu " + menu + " is already " +
+ "part of application " + menu.getApplication());
+ }
+ closeMenu();
+ menus.add(menu);
+ recomputeMenuX();
+ }
+
+ /**
+ * Remove a top-level menu from the list.
+ *
+ * @param menu the menu to remove
+ * @throws IllegalArgumentException if the menu is already used in
+ * another TApplication
+ */
+ public final void removeMenu(final TMenu menu) {
+ if ((menu.getApplication() != null)
+ && (menu.getApplication() != this)
+ ) {
+ throw new IllegalArgumentException("Menu " + menu + " is already " +
+ "part of application " + menu.getApplication());
+ }
+ closeMenu();
+ menus.remove(menu);
+ recomputeMenuX();
+ }
+
/**
* Turn off a sub-menu.
*/
*/
public final void switchMenu(final boolean forward) {
assert (activeMenu != null);
+ assert (hideMenuBar == false);
for (TMenu menu: subMenus) {
menu.setActive(false);
if (forward) {
if (i < menus.size() - 1) {
i++;
+ } else {
+ i = 0;
}
} else {
if (i > 0) {
i--;
+ } else {
+ i = menus.size() - 1;
}
}
activeMenu.setActive(false);
for (TMenuItem item: menuItems) {
if ((item.getId() >= lower) && (item.getId() <= upper)) {
item.setEnabled(false);
+ item.getParent().activate(0);
}
}
}
for (TMenuItem item: menuItems) {
if (item.getId() == id) {
item.setEnabled(true);
+ item.getParent().activate(0);
}
}
}
for (TMenuItem item: menuItems) {
if ((item.getId() >= lower) && (item.getId() <= upper)) {
item.setEnabled(true);
+ item.getParent().activate(0);
+ }
+ }
+ }
+
+ /**
+ * Get the menu item associated with this ID.
+ *
+ * @param id the menu item ID
+ * @return the menu item, or null if not found
+ */
+ public final TMenuItem getMenuItem(final int id) {
+ for (TMenuItem item: menuItems) {
+ if (item.getId() == id) {
+ return item;
}
}
+ return null;
}
/**
int x = 0;
for (TMenu menu: menus) {
menu.setX(x);
- x += menu.getTitle().length() + 2;
+ menu.setTitleX(x);
+ x += StringUtils.width(menu.getTitle()) + 2;
+
+ // Don't let the menu window exceed the screen width
+ int rightEdge = menu.getX() + menu.getWidth();
+ if (rightEdge > getScreen().getWidth()) {
+ menu.setX(getScreen().getWidth() - menu.getWidth());
+ }
+ }
+ }
+
+ /**
+ * Post an event to process.
+ *
+ * @param event new event to add to the queue
+ */
+ public final void postEvent(final TInputEvent event) {
+ synchronized (this) {
+ synchronized (fillEventQueue) {
+ fillEventQueue.add(event);
+ }
+ if (debugThreads) {
+ System.err.println(System.currentTimeMillis() + " " +
+ Thread.currentThread() + " postEvent() wake up main");
+ }
+ this.notify();
}
}
* @param event new event to add to the queue
*/
public final void postMenuEvent(final TInputEvent event) {
- synchronized (fillEventQueue) {
- fillEventQueue.add(event);
+ synchronized (this) {
+ synchronized (fillEventQueue) {
+ fillEventQueue.add(event);
+ }
+ if (debugThreads) {
+ System.err.println(System.currentTimeMillis() + " " +
+ Thread.currentThread() + " postMenuEvent() wake up main");
+ }
+ closeMenu();
+ this.notify();
}
- closeMenu();
}
/**
return menu;
}
+ /**
+ * Convenience function to add a default tools (hamburger) menu.
+ *
+ * @return the new menu
+ */
+ public final TMenu addToolMenu() {
+ TMenu toolMenu = addMenu(i18n.getString("toolMenuTitle"));
+ toolMenu.addDefaultItem(TMenu.MID_REPAINT);
+ toolMenu.addDefaultItem(TMenu.MID_VIEW_IMAGE);
+ toolMenu.addDefaultItem(TMenu.MID_SCREEN_OPTIONS);
+ TStatusBar toolStatusBar = toolMenu.newStatusBar(i18n.
+ getString("toolMenuStatus"));
+ toolStatusBar.addShortcutKeypress(kbF1, cmHelp, i18n.getString("Help"));
+ return toolMenu;
+ }
+
/**
* Convenience function to add a default "File" menu.
*
* @return the new menu
*/
public final TMenu addFileMenu() {
- TMenu fileMenu = addMenu("&File");
- fileMenu.addDefaultItem(TMenu.MID_OPEN_FILE);
- fileMenu.addSeparator();
+ TMenu fileMenu = addMenu(i18n.getString("fileMenuTitle"));
fileMenu.addDefaultItem(TMenu.MID_SHELL);
+ fileMenu.addSeparator();
fileMenu.addDefaultItem(TMenu.MID_EXIT);
- TStatusBar statusBar = fileMenu.newStatusBar("File-management " +
- "commands (Open, Save, Print, etc.)");
- statusBar.addShortcutKeypress(kbF1, cmHelp, "Help");
+ TStatusBar statusBar = fileMenu.newStatusBar(i18n.
+ getString("fileMenuStatus"));
+ statusBar.addShortcutKeypress(kbF1, cmHelp, i18n.getString("Help"));
return fileMenu;
}
* @return the new menu
*/
public final TMenu addEditMenu() {
- TMenu editMenu = addMenu("&Edit");
- editMenu.addDefaultItem(TMenu.MID_CUT);
- editMenu.addDefaultItem(TMenu.MID_COPY);
- editMenu.addDefaultItem(TMenu.MID_PASTE);
- editMenu.addDefaultItem(TMenu.MID_CLEAR);
- TStatusBar statusBar = editMenu.newStatusBar("Editor operations, " +
- "undo, and Clipboard access");
- statusBar.addShortcutKeypress(kbF1, cmHelp, "Help");
+ TMenu editMenu = addMenu(i18n.getString("editMenuTitle"));
+ editMenu.addDefaultItem(TMenu.MID_UNDO, false);
+ editMenu.addDefaultItem(TMenu.MID_REDO, false);
+ editMenu.addSeparator();
+ editMenu.addDefaultItem(TMenu.MID_CUT, false);
+ editMenu.addDefaultItem(TMenu.MID_COPY, false);
+ editMenu.addDefaultItem(TMenu.MID_PASTE, false);
+ editMenu.addDefaultItem(TMenu.MID_CLEAR, false);
+ TStatusBar statusBar = editMenu.newStatusBar(i18n.
+ getString("editMenuStatus"));
+ statusBar.addShortcutKeypress(kbF1, cmHelp, i18n.getString("Help"));
return editMenu;
}
* @return the new menu
*/
public final TMenu addWindowMenu() {
- TMenu windowMenu = addMenu("&Window");
+ TMenu windowMenu = addMenu(i18n.getString("windowMenuTitle"));
windowMenu.addDefaultItem(TMenu.MID_TILE);
windowMenu.addDefaultItem(TMenu.MID_CASCADE);
windowMenu.addDefaultItem(TMenu.MID_CLOSE_ALL);
windowMenu.addDefaultItem(TMenu.MID_WINDOW_NEXT);
windowMenu.addDefaultItem(TMenu.MID_WINDOW_PREVIOUS);
windowMenu.addDefaultItem(TMenu.MID_WINDOW_CLOSE);
- TStatusBar statusBar = windowMenu.newStatusBar("Open, arrange, and " +
- "list windows");
- statusBar.addShortcutKeypress(kbF1, cmHelp, "Help");
+ TStatusBar statusBar = windowMenu.newStatusBar(i18n.
+ getString("windowMenuStatus"));
+ statusBar.addShortcutKeypress(kbF1, cmHelp, i18n.getString("Help"));
return windowMenu;
}
* @return the new menu
*/
public final TMenu addHelpMenu() {
- TMenu helpMenu = addMenu("&Help");
+ TMenu helpMenu = addMenu(i18n.getString("helpMenuTitle"));
helpMenu.addDefaultItem(TMenu.MID_HELP_CONTENTS);
helpMenu.addDefaultItem(TMenu.MID_HELP_INDEX);
helpMenu.addDefaultItem(TMenu.MID_HELP_SEARCH);
helpMenu.addDefaultItem(TMenu.MID_HELP_ACTIVE_FILE);
helpMenu.addSeparator();
helpMenu.addDefaultItem(TMenu.MID_ABOUT);
- TStatusBar statusBar = helpMenu.newStatusBar("Access online help");
- statusBar.addShortcutKeypress(kbF1, cmHelp, "Help");
+ TStatusBar statusBar = helpMenu.newStatusBar(i18n.
+ getString("helpMenuStatus"));
+ statusBar.addShortcutKeypress(kbF1, cmHelp, i18n.getString("Help"));
return helpMenu;
}
- // ------------------------------------------------------------------------
- // Event handlers ---------------------------------------------------------
- // ------------------------------------------------------------------------
-
- /**
- * 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;
- }
- return true;
- }
-
- if (command.equals(cmShell)) {
- openTerminal(0, 0, TWindow.RESIZABLE);
- return true;
- }
-
- if (command.equals(cmTile)) {
- tileWindows();
- return true;
- }
- if (command.equals(cmCascade)) {
- cascadeWindows();
- return true;
- }
- if (command.equals(cmCloseAll)) {
- closeAllWindows();
- 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;
- }
- return true;
- }
-
- if (menu.getId() == TMenu.MID_SHELL) {
- openTerminal(0, 0, TWindow.RESIZABLE);
- return true;
- }
-
- if (menu.getId() == TMenu.MID_TILE) {
- tileWindows();
- return true;
- }
- if (menu.getId() == TMenu.MID_CASCADE) {
- cascadeWindows();
- return true;
- }
- if (menu.getId() == TMenu.MID_CLOSE_ALL) {
- closeAllWindows();
- return true;
- }
- if (menu.getId() == TMenu.MID_ABOUT) {
- showAboutDialog();
- return true;
- }
- return false;
- }
-
/**
- * Method that TApplication subclasses can override to handle keystrokes.
+ * Convenience function to add a default "Table" menu.
*
- * @param keypress keystroke event
- * @return if true, this event was consumed
+ * @return the new menu
*/
- protected boolean onKeypress(final TKeypressEvent keypress) {
- // Default: only menu shortcuts
-
- // Process Alt-F, Alt-E, etc. menu shortcut keys
- if (!keypress.getKey().isFnKey()
- && keypress.getKey().isAlt()
- && !keypress.getKey().isCtrl()
- && (activeMenu == null)
- && !modalWindowActive()
- ) {
-
- assert (subMenus.size() == 0);
-
- for (TMenu menu: menus) {
- if (Character.toLowerCase(menu.getMnemonic().getShortcut())
- == Character.toLowerCase(keypress.getKey().getChar())
- ) {
- activeMenu = menu;
- menu.setActive(true);
- return true;
- }
- }
- }
-
- return false;
+ public final TMenu addTableMenu() {
+ TMenu tableMenu = addMenu(i18n.getString("tableMenuTitle"));
+ tableMenu.addDefaultItem(TMenu.MID_TABLE_RENAME_COLUMN, false);
+ tableMenu.addDefaultItem(TMenu.MID_TABLE_RENAME_ROW, false);
+ tableMenu.addSeparator();
+
+ TSubMenu viewMenu = tableMenu.addSubMenu(i18n.
+ getString("tableSubMenuView"));
+ viewMenu.addDefaultItem(TMenu.MID_TABLE_VIEW_ROW_LABELS, false);
+ viewMenu.addDefaultItem(TMenu.MID_TABLE_VIEW_COLUMN_LABELS, false);
+ viewMenu.addDefaultItem(TMenu.MID_TABLE_VIEW_HIGHLIGHT_ROW, false);
+ viewMenu.addDefaultItem(TMenu.MID_TABLE_VIEW_HIGHLIGHT_COLUMN, false);
+
+ TSubMenu borderMenu = tableMenu.addSubMenu(i18n.
+ getString("tableSubMenuBorders"));
+ borderMenu.addDefaultItem(TMenu.MID_TABLE_BORDER_NONE, false);
+ borderMenu.addDefaultItem(TMenu.MID_TABLE_BORDER_ALL, false);
+ borderMenu.addDefaultItem(TMenu.MID_TABLE_BORDER_CELL_NONE, false);
+ borderMenu.addDefaultItem(TMenu.MID_TABLE_BORDER_CELL_ALL, false);
+ borderMenu.addDefaultItem(TMenu.MID_TABLE_BORDER_RIGHT, false);
+ borderMenu.addDefaultItem(TMenu.MID_TABLE_BORDER_LEFT, false);
+ borderMenu.addDefaultItem(TMenu.MID_TABLE_BORDER_TOP, false);
+ borderMenu.addDefaultItem(TMenu.MID_TABLE_BORDER_BOTTOM, false);
+ borderMenu.addDefaultItem(TMenu.MID_TABLE_BORDER_DOUBLE_BOTTOM, false);
+ borderMenu.addDefaultItem(TMenu.MID_TABLE_BORDER_THICK_BOTTOM, false);
+ TSubMenu deleteMenu = tableMenu.addSubMenu(i18n.
+ getString("tableSubMenuDelete"));
+ deleteMenu.addDefaultItem(TMenu.MID_TABLE_DELETE_LEFT, false);
+ deleteMenu.addDefaultItem(TMenu.MID_TABLE_DELETE_UP, false);
+ deleteMenu.addDefaultItem(TMenu.MID_TABLE_DELETE_ROW, false);
+ deleteMenu.addDefaultItem(TMenu.MID_TABLE_DELETE_COLUMN, false);
+ TSubMenu insertMenu = tableMenu.addSubMenu(i18n.
+ getString("tableSubMenuInsert"));
+ insertMenu.addDefaultItem(TMenu.MID_TABLE_INSERT_LEFT, false);
+ insertMenu.addDefaultItem(TMenu.MID_TABLE_INSERT_RIGHT, false);
+ insertMenu.addDefaultItem(TMenu.MID_TABLE_INSERT_ABOVE, false);
+ insertMenu.addDefaultItem(TMenu.MID_TABLE_INSERT_BELOW, false);
+ TSubMenu columnMenu = tableMenu.addSubMenu(i18n.
+ getString("tableSubMenuColumn"));
+ columnMenu.addDefaultItem(TMenu.MID_TABLE_COLUMN_NARROW, false);
+ columnMenu.addDefaultItem(TMenu.MID_TABLE_COLUMN_WIDEN, false);
+ TSubMenu fileMenu = tableMenu.addSubMenu(i18n.
+ getString("tableSubMenuFile"));
+ fileMenu.addDefaultItem(TMenu.MID_TABLE_FILE_OPEN_CSV, false);
+ fileMenu.addDefaultItem(TMenu.MID_TABLE_FILE_SAVE_CSV, false);
+ fileMenu.addDefaultItem(TMenu.MID_TABLE_FILE_SAVE_TEXT, false);
+
+ TStatusBar statusBar = tableMenu.newStatusBar(i18n.
+ getString("tableMenuStatus"));
+ statusBar.addShortcutKeypress(kbF1, cmHelp, i18n.getString("Help"));
+ return tableMenu;
}
// ------------------------------------------------------------------------
Date now = new Date();
long nowTime = now.getTime();
long sleepTime = timeout;
- for (TTimer timer: timers) {
- long nextTickTime = timer.getNextTick().getTime();
- if (nextTickTime < nowTime) {
- return 0;
- }
- long timeDifference = nextTickTime - nowTime;
- if (timeDifference < sleepTime) {
- sleepTime = timeDifference;
+ synchronized (timers) {
+ for (TTimer timer: timers) {
+ long nextTickTime = timer.getNextTick().getTime();
+ if (nextTickTime < nowTime) {
+ return 0;
+ }
+
+ long timeDifference = nextTickTime - nowTime;
+ if (timeDifference < sleepTime) {
+ sleepTime = timeDifference;
+ }
}
}
+
assert (sleepTime >= 0);
assert (sleepTime <= timeout);
return sleepTime;
return new TInputBox(this, title, caption, text);
}
+ /**
+ * 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
+ * @param type one of the Type constants. Default is Type.OK.
+ * @return the new input box
+ */
+ public final TInputBox inputBox(final String title, final String caption,
+ final String text, final TInputBox.Type type) {
+
+ return new TInputBox(this, title, caption, text, type);
+ }
+
/**
* Convenience function to open a terminal window.
*
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 closeOnExit if true, close the window when the command exits
+ * @return the terminal new window
+ */
+ public final TTerminalWindow openTerminal(final int x, final int y,
+ final boolean closeOnExit) {
+
+ return openTerminal(x, y, TWindow.RESIZABLE, closeOnExit);
+ }
+
/**
* Convenience function to open a terminal window.
*
return new TTerminalWindow(this, x, y, flags);
}
+ /**
+ * 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
+ * @param closeOnExit if true, close the window when the command exits
+ * @return the terminal new window
+ */
+ public final TTerminalWindow openTerminal(final int x, final int y,
+ final int flags, final boolean closeOnExit) {
+
+ return new TTerminalWindow(this, x, y, flags, closeOnExit);
+ }
+
+ /**
+ * Convenience function to open a terminal window and execute a custom
+ * command line inside it.
+ *
+ * @param x column relative to parent
+ * @param y row relative to parent
+ * @param commandLine the command line to execute
+ * @return the terminal new window
+ */
+ public final TTerminalWindow openTerminal(final int x, final int y,
+ final String commandLine) {
+
+ return openTerminal(x, y, TWindow.RESIZABLE, commandLine);
+ }
+
+ /**
+ * Convenience function to open a terminal window and execute a custom
+ * command line inside it.
+ *
+ * @param x column relative to parent
+ * @param y row relative to parent
+ * @param commandLine the command line to execute
+ * @param closeOnExit if true, close the window when the command exits
+ * @return the terminal new window
+ */
+ public final TTerminalWindow openTerminal(final int x, final int y,
+ final String commandLine, final boolean closeOnExit) {
+
+ return openTerminal(x, y, TWindow.RESIZABLE, commandLine, closeOnExit);
+ }
+
+ /**
+ * Convenience function to open a terminal window and execute a custom
+ * command line inside it.
+ *
+ * @param x column relative to parent
+ * @param y row relative to parent
+ * @param flags mask of CENTERED, MODAL, or RESIZABLE
+ * @param command the command line to execute
+ * @return the terminal new window
+ */
+ public final TTerminalWindow openTerminal(final int x, final int y,
+ final int flags, final String [] command) {
+
+ return new TTerminalWindow(this, x, y, flags, command);
+ }
+
+ /**
+ * Convenience function to open a terminal window and execute a custom
+ * command line inside it.
+ *
+ * @param x column relative to parent
+ * @param y row relative to parent
+ * @param flags mask of CENTERED, MODAL, or RESIZABLE
+ * @param command the command line to execute
+ * @param closeOnExit if true, close the window when the command exits
+ * @return the terminal new window
+ */
+ public final TTerminalWindow openTerminal(final int x, final int y,
+ final int flags, final String [] command, final boolean closeOnExit) {
+
+ return new TTerminalWindow(this, x, y, flags, command, closeOnExit);
+ }
+
+ /**
+ * Convenience function to open a terminal window and execute a custom
+ * command line inside it.
+ *
+ * @param x column relative to parent
+ * @param y row relative to parent
+ * @param flags mask of CENTERED, MODAL, or RESIZABLE
+ * @param commandLine the command line to execute
+ * @return the terminal new window
+ */
+ public final TTerminalWindow openTerminal(final int x, final int y,
+ final int flags, final String commandLine) {
+
+ return new TTerminalWindow(this, x, y, flags, commandLine.split("\\s+"));
+ }
+
+ /**
+ * Convenience function to open a terminal window and execute a custom
+ * command line inside it.
+ *
+ * @param x column relative to parent
+ * @param y row relative to parent
+ * @param flags mask of CENTERED, MODAL, or RESIZABLE
+ * @param commandLine the command line to execute
+ * @param closeOnExit if true, close the window when the command exits
+ * @return the terminal new window
+ */
+ public final TTerminalWindow openTerminal(final int x, final int y,
+ final int flags, final String commandLine, final boolean closeOnExit) {
+
+ return new TTerminalWindow(this, x, y, flags, commandLine.split("\\s+"),
+ closeOnExit);
+ }
+
/**
* Convenience function to spawn an file open box.
*
return box.getFilename();
}
+ /**
+ * Convenience function to spawn a file open box.
+ *
+ * @param path path of selected file
+ * @param type one of the Type constants
+ * @param filter a string that files must match to be displayed
+ * @return the result of the new file open box
+ * @throws IOException of a java.io operation throws
+ */
+ public final String fileOpenBox(final String path,
+ final TFileOpenBox.Type type, final String filter) throws IOException {
+
+ ArrayList<String> filters = new ArrayList<String>();
+ filters.add(filter);
+
+ TFileOpenBox box = new TFileOpenBox(this, path, type, filters);
+ return box.getFilename();
+ }
+
+ /**
+ * Convenience function to spawn a file open box.
+ *
+ * @param path path of selected file
+ * @param type one of the Type constants
+ * @param filters a list of strings that files must match to be displayed
+ * @return the result of the new file open box
+ * @throws IOException of a java.io operation throws
+ */
+ public final String fileOpenBox(final String path,
+ final TFileOpenBox.Type type,
+ final List<String> filters) throws IOException {
+
+ TFileOpenBox box = new TFileOpenBox(this, path, type, filters);
+ return box.getFilename();
+ }
+
/**
* Convenience function to create a new window and make it active.
* Window will be located at (0, 0).
* @param title window title, will be centered along the top border
* @param width width of window
* @param height height of window
+ * @return the new window
*/
public final TWindow addWindow(final String title, final int width,
final int height) {
TWindow window = new TWindow(this, title, 0, 0, width, height);
return window;
}
+
/**
* Convenience function to create a new window and make it active.
* Window will be located at (0, 0).
* @param width width of window
* @param height height of window
* @param flags bitmask of RESIZABLE, CENTERED, or MODAL
+ * @return the new window
*/
public final TWindow addWindow(final String title,
final int width, final int height, final int flags) {
* @param y row relative to parent
* @param width width of window
* @param height height of window
+ * @return the new window
*/
public final TWindow addWindow(final String title,
final int x, final int y, final int width, final int height) {
* @param width width of window
* @param height height of window
* @param flags mask of RESIZABLE, CENTERED, or MODAL
+ * @return the new window
*/
public final TWindow addWindow(final String title,
final int x, final int y, final int width, final int height,