-/**
+/*
* Jexer - Java Text User Interface
*
* License: LGPLv3 or later
package jexer;
import java.io.InputStream;
+import java.io.IOException;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.util.Collections;
import jexer.event.TMouseEvent;
import jexer.event.TResizeEvent;
import jexer.backend.Backend;
-import jexer.backend.AWTBackend;
+import jexer.backend.SwingBackend;
import jexer.backend.ECMA48Backend;
import jexer.io.Screen;
import jexer.menu.TMenu;
/**
* TApplication sets up a full Text User Interface application.
*/
-public class TApplication {
+public class TApplication implements Runnable {
/**
* If true, emit thread stuff to System.err.
*/
private static final boolean debugEvents = false;
+ /**
+ * Two backend types are available.
+ */
+ public static enum BackendType {
+ /**
+ * A Swing JFrame.
+ */
+ SWING,
+
+ /**
+ * An ECMA48 / ANSI X3.64 / XTERM style terminal.
+ */
+ ECMA48,
+
+ /**
+ * Synonym for ECMA48.
+ */
+ XTERM
+ }
+
/**
* WidgetEventHandler is the main event consumer loop. There are at most
* two such threads in existence: the primary for normal case and a
}
}
+ // 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;
}
event = application.drainEventQueue.remove(0);
}
- // Wait for drawAll() or doIdle() to be done, then handle
- // the event.
- boolean oldLock = lockHandleEvent();
- assert (oldLock == false);
application.repaint = true;
if (primary) {
primaryHandleEvent(event);
// All done!
return;
- } else {
- // Unlock. Either I am primary thread, or I am
- // secondary thread and still running.
- oldLock = unlockHandleEvent();
- assert (oldLock == true);
}
} // 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) {
synchronized (this) {
// Wait for TApplication.run() to finish using the global state
// before allowing further event processing.
- while (lockoutHandleEvent == true) {}
+ while (lockoutHandleEvent == true) {
+ try {
+ // Backoff so that the backend can finish its work.
+ Thread.sleep(5);
+ } catch (InterruptedException e) {
+ // SQUASH
+ }
+ }
oldValue = insideHandleEvent;
insideHandleEvent = true;
lockoutHandleEvent = true;
// Wait for the last event to finish processing before returning
// control to TApplication.run().
- while (insideHandleEvent == true) {}
+ 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 Map<TKeypress, TMenuItem> accelerators;
+ /**
+ * All menu items.
+ */
+ private List<TMenuItem> menuItems;
+
/**
* Windows and widgets pull colors from this ColorTheme.
*/
/**
* Public constructor.
*
+ * @param backendType BackendType.XTERM, BackendType.ECMA48 or
+ * BackendType.SWING
+ * @throws UnsupportedEncodingException if an exception is thrown when
+ * creating the InputStreamReader
+ */
+ public TApplication(final BackendType backendType)
+ throws UnsupportedEncodingException {
+
+ switch (backendType) {
+ case SWING:
+ backend = new SwingBackend(this);
+ break;
+ case XTERM:
+ // Fall through...
+ case ECMA48:
+ backend = new ECMA48Backend(this, null, null);
+ break;
+ default:
+ throw new IllegalArgumentException("Invalid backend type: "
+ + backendType);
+ }
+ TApplicationImpl();
+ }
+
+ /**
+ * Public constructor. The backend type will be BackendType.ECMA48.
+ *
* @param input an InputStream connected to the remote user, or null for
* System.in. If System.in is used, then on non-Windows systems it will
* be put in raw mode; shutdown() will (blindly!) put System.in in cooked
public TApplication(final InputStream input,
final OutputStream output) throws UnsupportedEncodingException {
- // AWT is the default backend on Windows unless explicitly overridden
- // by jexer.AWT.
- boolean useAWT = false;
- if (System.getProperty("os.name").startsWith("Windows")) {
- useAWT = true;
- }
- if (System.getProperty("jexer.AWT") != null) {
- if (System.getProperty("jexer.AWT", "false").equals("true")) {
- useAWT = true;
- } else {
- useAWT = false;
- }
- }
+ backend = new ECMA48Backend(this, input, output);
+ TApplicationImpl();
+ }
+ /**
+ * Public constructor. This hook enables use with new non-Jexer
+ * backends.
+ *
+ * @param backend a Backend that is already ready to go.
+ */
+ public TApplication(final Backend backend) {
+ this.backend = backend;
+ TApplicationImpl();
+ }
- if (useAWT) {
- backend = new AWTBackend(this);
- } else {
- backend = new ECMA48Backend(this, input, output);
- }
+ /**
+ * Finish construction once the backend is set.
+ */
+ private void TApplicationImpl() {
theme = new ColorTheme();
desktopBottom = getScreen().getHeight() - 1;
fillEventQueue = new ArrayList<TInputEvent>();
subMenus = new LinkedList<TMenu>();
timers = new LinkedList<TTimer>();
accelerators = new HashMap<TKeypress, TMenuItem>();
+ menuItems = new ArrayList<TMenuItem>();
// Setup the main consumer thread
primaryEventHandler = new WidgetEventHandler(this, true);
/**
* Draw everything.
*/
- public final void drawAll() {
+ private void drawAll() {
if (debugThreads) {
System.err.printf("drawAll() enter\n");
}
if (!repaint) {
- 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 ((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();
for (TMenu menu: menus) {
CellAttributes menuColor;
CellAttributes menuMnemonicColor;
- if (menu.getActive()) {
+ if (menu.isActive()) {
menuColor = theme.getColor("tmenu.highlighted");
menuMnemonicColor = theme.getColor("tmenu.mnemonic.highlighted");
} else {
// Draw the menu title
getScreen().hLineXY(x, 0, menu.getTitle().length() + 2, ' ',
menuColor);
- getScreen().putStrXY(x + 1, 0, menu.getTitle(), 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.getActive()) {
+ if (menu.isActive()) {
menu.drawChildren();
// Reset the screen clipping so we can draw the next title.
getScreen().resetClipping();
TWidget activeWidget = null;
if (sorted.size() > 0) {
activeWidget = sorted.get(sorted.size() - 1).getActiveChild();
- if (activeWidget.visibleCursor()) {
+ if (activeWidget.isCursorVisible()) {
getScreen().putCursor(true, activeWidget.getCursorAbsoluteX(),
activeWidget.getCursorAbsoluteY());
cursor = true;
/**
* Run this application until it exits.
*/
- public final void run() {
+ public void run() {
while (!quit) {
// Timeout is in milliseconds, so default timeout after 1 second
// of inactivity.
if (!repaint
&& ((mouseX == oldMouseX) && (mouseY == oldMouseY))
) {
- // Never sleep longer than 100 millis, to get windows with
- // background tasks an opportunity to update the display.
- timeout = getSleepTime(100);
-
- // See if there are any definitely events waiting to be
- // processed. If so, do not wait -- either there is I/O
- // coming in or the primary/secondary threads are still
- // working.
- synchronized (drainEventQueue) {
- if (drainEventQueue.size() > 0) {
- timeout = 0;
- }
- }
- synchronized (fillEventQueue) {
- if (fillEventQueue.size() > 0) {
- timeout = 0;
- }
- }
+ // 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) {
repaint = true;
}
+ // Prevent stepping on the primary or secondary event handler.
+ stopEventHandlers();
+
// Pull any pending I/O events
backend.getEvents(fillEventQueue);
// Dispatch each event to the appropriate handler, one at a time.
for (;;) {
TInputEvent event = null;
- synchronized (fillEventQueue) {
- if (fillEventQueue.size() == 0) {
- break;
- }
- event = fillEventQueue.remove(0);
+ if (fillEventQueue.size() == 0) {
+ break;
}
+ event = fillEventQueue.remove(0);
metaHandleEvent(event);
}
// Wake a consumer thread if we have any pending events.
- synchronized (drainEventQueue) {
- if (drainEventQueue.size() > 0) {
- wakeEventHandler();
- }
+ if (drainEventQueue.size() > 0) {
+ wakeEventHandler();
}
- // Prevent stepping on the primary or secondary event handler.
- stopEventHandlers();
-
// Process timers and call doIdle()'s
doIdle();
}
// Put into the main queue
- synchronized (drainEventQueue) {
- drainEventQueue.add(event);
- }
+ drainEventQueue.add(event);
}
/**
break;
}
if ((mouse.getType() == TMouseEvent.Type.MOUSE_MOTION)
- && (!mouse.getMouse1())
- && (!mouse.getMouse2())
- && (!mouse.getMouse3())
- && (!mouse.getMouseWheelUp())
- && (!mouse.getMouseWheelDown())
+ && (!mouse.isMouse1())
+ && (!mouse.isMouse2())
+ && (!mouse.isMouse3())
+ && (!mouse.isMouseWheelUp())
+ && (!mouse.isMouseWheelDown())
) {
break;
}
item = accelerators.get(keypressLowercase);
}
if (item != null) {
- if (item.getEnabled()) {
+ if (item.isEnabled()) {
// Let the menu item dispatch
item.dispatch();
return;
// Dispatch events to the active window -------------------------------
for (TWindow window: windows) {
- if (window.getActive()) {
+ if (window.isActive()) {
if (event instanceof TMouseEvent) {
TMouseEvent mouse = (TMouseEvent) event;
// Convert the mouse relative x/y to window coordinates
public final void enableSecondaryEventReceiver(final TWidget widget) {
assert (secondaryEventReceiver == null);
assert (secondaryEventHandler == null);
- assert (widget instanceof TMessageBox);
+ assert ((widget instanceof TMessageBox)
+ || (widget instanceof TFileOpenBox));
secondaryEventReceiver = widget;
secondaryEventHandler = new WidgetEventHandler(this, false);
(new Thread(secondaryEventHandler)).start();
// secondary thread locks again. When it gives up, we have the
// single lock back.
boolean oldLock = unlockHandleEvent();
- assert (oldLock == true);
+ assert (oldLock);
while (secondaryEventReceiver != null) {
synchronized (primaryEventHandler) {
synchronized (windows) {
int z = window.getZ();
window.setZ(-1);
+ window.onUnfocus();
Collections.sort(windows);
windows.remove(0);
TWindow activeWindow = null;
w.setZ(w.getZ() - 1);
if (w.getZ() == 0) {
w.setActive(true);
+ w.onFocus();
assert (activeWindow == null);
activeWindow = w;
} else {
- w.setActive(false);
+ if (w.isActive()) {
+ w.setActive(false);
+ w.onUnfocus();
+ }
}
}
}
// Swap z/active between active window and the next in the list
int activeWindowI = -1;
for (int i = 0; i < windows.size(); i++) {
- if (windows.get(i).getActive()) {
+ if (windows.get(i).isActive()) {
activeWindowI = i;
break;
}
}
windows.get(activeWindowI).setActive(false);
windows.get(activeWindowI).setZ(windows.get(nextWindowI).getZ());
+ windows.get(activeWindowI).onUnfocus();
windows.get(nextWindowI).setZ(0);
windows.get(nextWindowI).setActive(true);
+ windows.get(nextWindowI).onFocus();
} // synchronized (windows)
assert (window.isModal());
}
for (TWindow w: windows) {
- w.setActive(false);
+ if (w.isActive()) {
+ w.setActive(false);
+ w.onUnfocus();
+ }
w.setZ(w.getZ() + 1);
}
windows.add(window);
- window.setActive(true);
window.setZ(0);
+ window.setActive(true);
+ window.onFocus();
}
}
// See if they hit the menu bar
if ((mouse.getType() == TMouseEvent.Type.MOUSE_DOWN)
- && (mouse.getMouse1())
+ && (mouse.isMouse1())
&& (!modalWindowActive())
&& (mouse.getAbsoluteY() == 0)
) {
// See if they hit the menu bar
if ((mouse.getType() == TMouseEvent.Type.MOUSE_MOTION)
- && (mouse.getMouse1())
+ && (mouse.isMouse1())
&& (activeMenu != null)
&& (mouse.getAbsoluteY() == 0)
) {
}
// We will be switching to another window
- assert (windows.get(0).getActive());
- assert (!window.getActive());
+ assert (windows.get(0).isActive());
+ assert (!window.isActive());
+ windows.get(0).onUnfocus();
windows.get(0).setActive(false);
windows.get(0).setZ(window.getZ());
window.setZ(0);
window.setActive(true);
+ window.onFocus();
return;
}
}
// Default: only menu shortcuts
// Process Alt-F, Alt-E, etc. menu shortcut keys
- if (!keypress.getKey().getIsKey()
- && keypress.getKey().getAlt()
- && !keypress.getKey().getCtrl()
+ if (!keypress.getKey().isFnKey()
+ && keypress.getKey().isAlt()
+ && !keypress.getKey().isCtrl()
&& (activeMenu == null)
) {
for (TMenu menu: menus) {
if (Character.toLowerCase(menu.getMnemonic().getShortcut())
- == Character.toLowerCase(keypress.getKey().getCh())
+ == Character.toLowerCase(keypress.getKey().getChar())
) {
activeMenu = menu;
menu.setActive(true);
}
/**
- * Add a keyboard accelerator to the global hash.
+ * Add a menu item to the global list. If it has a keyboard accelerator,
+ * that will be added the global hash.
*
- * @param item menu item this accelerator relates to
- * @param keypress keypress that will dispatch a TMenuEvent
+ * @param item the menu item
*/
- public final void addAccelerator(final TMenuItem item,
- final TKeypress keypress) {
+ public final void addMenuItem(final TMenuItem item) {
+ menuItems.add(item);
+
+ TKeypress key = item.getKey();
+ if (key != null) {
+ synchronized (accelerators) {
+ assert (accelerators.get(key) == null);
+ accelerators.put(key.toLowerCase(), item);
+ }
+ }
+ }
- synchronized (accelerators) {
- assert (accelerators.get(keypress) == null);
- accelerators.put(keypress, item);
+ /**
+ * Disable one menu item.
+ *
+ * @param id the menu item ID
+ */
+ public final void disableMenuItem(final int id) {
+ for (TMenuItem item: menuItems) {
+ if (item.getId() == id) {
+ item.setEnabled(false);
+ }
+ }
+ }
+
+ /**
+ * Disable the range of menu items with ID's between lower and upper,
+ * inclusive.
+ *
+ * @param lower the lowest menu item ID
+ * @param upper the highest menu item ID
+ */
+ public final void disableMenuItems(final int lower, final int upper) {
+ for (TMenuItem item: menuItems) {
+ if ((item.getId() >= lower) && (item.getId() <= upper)) {
+ item.setEnabled(false);
+ }
+ }
+ }
+
+ /**
+ * Enable one menu item.
+ *
+ * @param id the menu item ID
+ */
+ public final void enableMenuItem(final int id) {
+ for (TMenuItem item: menuItems) {
+ if (item.getId() == id) {
+ item.setEnabled(true);
+ }
+ }
+ }
+
+ /**
+ * Enable the range of menu items with ID's between lower and upper,
+ * inclusive.
+ *
+ * @param lower the lowest menu item ID
+ * @param upper the highest menu item ID
+ */
+ public final void enableMenuItems(final int lower, final int upper) {
+ for (TMenuItem item: menuItems) {
+ if ((item.getId() >= lower) && (item.getId() <= upper)) {
+ item.setEnabled(true);
+ }
}
}
return new TTerminalWindow(this, x, y, flags);
}
+ /**
+ * Convenience function to spawn an file open box.
+ *
+ * @param path path of selected file
+ * @return the result of the new file open box
+ * @throws IOException if java.io operation throws
+ */
+ public final String fileOpenBox(final String path) throws IOException {
+
+ TFileOpenBox box = new TFileOpenBox(this, path, TFileOpenBox.Type.OPEN);
+ return box.getFilename();
+ }
+
+ /**
+ * Convenience function to spawn an file open box.
+ *
+ * @param path path of selected file
+ * @param type one of the Type constants
+ * @return the result of the new file open box
+ * @throws IOException if java.io operation throws
+ */
+ public final String fileOpenBox(final String path,
+ final TFileOpenBox.Type type) throws IOException {
+
+ TFileOpenBox box = new TFileOpenBox(this, path, type);
+ return box.getFilename();
+ }
+
}