import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
+import java.util.Map;
import jexer.bits.CellAttributes;
import jexer.bits.ColorTheme;
import jexer.event.TMouseEvent;
import jexer.event.TResizeEvent;
import jexer.backend.Backend;
+import jexer.backend.AWTBackend;
import jexer.backend.ECMA48Backend;
import jexer.io.Screen;
import jexer.menu.TMenu;
*/
public class TApplication {
+ /**
+ * WidgetEventHandler is the main event consumer loop. There are at most
+ * two such threads in existence: the primary for normal case and a
+ * secondary that is used for TMessageBox, TInputBox, and similar.
+ */
+ private class WidgetEventHandler implements Runnable {
+ /**
+ * The main application.
+ */
+ private TApplication application;
+
+ /**
+ * Whether or not this WidgetEventHandler is the primary or secondary
+ * thread.
+ */
+ private boolean primary = true;
+
+ /**
+ * Public constructor.
+ *
+ * @param application the main application
+ * @param primary if true, this is the primary event handler thread
+ */
+ public WidgetEventHandler(final TApplication application,
+ final boolean primary) {
+
+ this.application = application;
+ this.primary = primary;
+ }
+
+ /**
+ * The consumer loop.
+ */
+ public void run() {
+
+ // Loop forever
+ while (!application.quit) {
+
+ // Wait until application notifies me
+ while (!application.quit) {
+ try {
+ synchronized (application.drainEventQueue) {
+ if (application.drainEventQueue.size() > 0) {
+ break;
+ }
+ }
+ synchronized (application) {
+ application.wait();
+ if ((!primary)
+ && (application.secondaryEventReceiver == null)
+ ) {
+ // Secondary thread, time to exit
+ return;
+ }
+ break;
+ }
+ } catch (InterruptedException e) {
+ // SQUASH
+ }
+ }
+
+ // Pull all events off the queue
+ for (;;) {
+ TInputEvent event = null;
+ synchronized (application.drainEventQueue) {
+ if (application.drainEventQueue.size() == 0) {
+ break;
+ }
+ event = application.drainEventQueue.remove(0);
+ }
+ if (primary) {
+ primaryHandleEvent(event);
+ } else {
+ secondaryHandleEvent(event);
+ }
+ if ((!primary)
+ && (application.secondaryEventReceiver == null)
+ ) {
+ // Secondary thread, time to exit
+ return;
+ }
+ }
+ } // while (true) (main runnable loop)
+ }
+ }
+
+ /**
+ * The primary event handler thread.
+ */
+ private WidgetEventHandler primaryEventHandler;
+
+ /**
+ * The secondary event handler thread.
+ */
+ private WidgetEventHandler secondaryEventHandler;
+
+ /**
+ * The widget receiving events from the secondary event handler thread.
+ */
+ private TWidget secondaryEventReceiver;
+
/**
* Access to the physical screen, keyboard, and mouse.
*/
private int mouseY;
/**
- * Event queue that will be drained by either primary or secondary Fiber.
+ * Event queue that is filled by run().
*/
- private List<TInputEvent> eventQueue;
+ private List<TInputEvent> fillEventQueue;
+
+ /**
+ * Event queue that will be drained by either primary or secondary
+ * Thread.
+ */
+ private List<TInputEvent> drainEventQueue;
/**
* Top-level menus in this application.
*/
private TMenu activeMenu = null;
+ /**
+ * Active keyboard accelerators.
+ */
+ private Map<TKeypress, TMenuItem> accelerators;
+
/**
* Windows and widgets pull colors from this ColorTheme.
*/
*/
private List<TWindow> windows;
+ /**
+ * Timers that are being ticked.
+ */
+ private List<TTimer> timers;
+
/**
* When true, exit the application.
*/
public TApplication(final InputStream input,
final OutputStream output) throws UnsupportedEncodingException {
- backend = new ECMA48Backend(input, output);
- theme = new ColorTheme();
- desktopBottom = getScreen().getHeight() - 1;
- eventQueue = new LinkedList<TInputEvent>();
- windows = new LinkedList<TWindow>();
- menus = new LinkedList<TMenu>();
- subMenus = new LinkedList<TMenu>();
+ // AWT is the default backend on Windows unless explicitly overridden
+ // by jexer.AWT.
+ boolean useAWT = false;
+ if (System.getProperty("os.name").startsWith("Windows")) {
+ useAWT = true;
+ }
+ if (System.getProperty("jexer.AWT") != null) {
+ if (System.getProperty("jexer.AWT", "false").equals("true")) {
+ useAWT = true;
+ } else {
+ useAWT = false;
+ }
+ }
+
+
+ if (useAWT) {
+ backend = new AWTBackend();
+ } else {
+ backend = new ECMA48Backend(input, output);
+ }
+ theme = new ColorTheme();
+ desktopBottom = getScreen().getHeight() - 1;
+ fillEventQueue = new ArrayList<TInputEvent>();
+ drainEventQueue = new ArrayList<TInputEvent>();
+ windows = new LinkedList<TWindow>();
+ menus = new LinkedList<TMenu>();
+ subMenus = new LinkedList<TMenu>();
+ timers = new LinkedList<TTimer>();
+ accelerators = new HashMap<TKeypress, TMenuItem>();
+
+ // Setup the main consumer thread
+ primaryEventHandler = new WidgetEventHandler(this, true);
+ (new Thread(primaryEventHandler)).start();
}
/**
* Run this application until it exits.
*/
public final void run() {
- List<TInputEvent> events = new LinkedList<TInputEvent>();
-
while (!quit) {
// Timeout is in milliseconds, so default timeout after 1 second
// of inactivity.
int timeout = getSleepTime(1000);
- if (eventQueue.size() > 0) {
- // Do not wait if there are definitely events waiting to be
- // processed or a screen redraw to do.
- timeout = 0;
+ // See if there are any definitely events waiting to be processed
+ // or a screen redraw to do. If so, do not wait if there is no
+ // I/O coming in.
+ synchronized (drainEventQueue) {
+ if (drainEventQueue.size() > 0) {
+ timeout = 0;
+ }
+ }
+ synchronized (fillEventQueue) {
+ if (fillEventQueue.size() > 0) {
+ timeout = 0;
+ }
}
- // Pull any pending input events
- backend.getEvents(events, timeout);
- metaHandleEvents(events);
- events.clear();
+ // Pull any pending I/O events
+ backend.getEvents(fillEventQueue, timeout);
+
+ // Dispatch each event to the appropriate handler, one at a time.
+ for (;;) {
+ TInputEvent event = null;
+ synchronized (fillEventQueue) {
+ if (fillEventQueue.size() == 0) {
+ break;
+ }
+ event = fillEventQueue.remove(0);
+ }
+ metaHandleEvent(event);
+ }
// Process timers and call doIdle()'s
doIdle();
// Update the screen
- drawAll();
- }
-
- /*
-
- // Shutdown the fibers
- eventQueue.length = 0;
- if (secondaryEventFiber !is null) {
- assert(secondaryEventReceiver !is null);
- secondaryEventReceiver = null;
- if (secondaryEventFiber.state == Fiber.State.HOLD) {
- // Wake up the secondary handler so that it can exit.
- secondaryEventFiber.call();
+ synchronized (getScreen()) {
+ drawAll();
}
}
- if (primaryEventFiber.state == Fiber.State.HOLD) {
- // Wake up the primary handler so that it can exit.
- primaryEventFiber.call();
+ // Shutdown the consumer threads
+ synchronized (this) {
+ this.notifyAll();
}
- */
backend.shutdown();
}
/**
* Peek at certain application-level events, add to eventQueue, and wake
- * up the consuming Fiber.
+ * up the consuming Thread.
*
- * @param events the input events to consume
+ * @param event the input event to consume
*/
- private void metaHandleEvents(final List<TInputEvent> events) {
-
- for (TInputEvent event: events) {
+ private void metaHandleEvent(final TInputEvent event) {
- /*
- System.err.printf(String.format("metaHandleEvents event: %s\n",
- event)); System.err.flush();
- */
-
- if (quit) {
- // Do no more processing if the application is already trying
- // to exit.
- return;
- }
-
- // DEBUG
- if (event instanceof TKeypressEvent) {
- TKeypressEvent keypress = (TKeypressEvent) event;
- if (keypress.equals(kbAltX)) {
- quit = true;
- return;
- }
- }
- // DEBUG
-
- // Special application-wide events -------------------------------
+ /*
+ System.err.printf(String.format("metaHandleEvents event: %s\n",
+ event)); System.err.flush();
+ */
- // Abort everything
- if (event instanceof TCommandEvent) {
- TCommandEvent command = (TCommandEvent) event;
- if (command.getCmd().equals(cmAbort)) {
- quit = true;
- return;
- }
- }
+ if (quit) {
+ // Do no more processing if the application is already trying
+ // to exit.
+ return;
+ }
- // Screen resize
- if (event instanceof TResizeEvent) {
- TResizeEvent resize = (TResizeEvent) event;
- getScreen().setDimensions(resize.getWidth(),
- resize.getHeight());
- desktopBottom = getScreen().getHeight() - 1;
- repaint = true;
- mouseX = 0;
- mouseY = 0;
- continue;
- }
+ // Special application-wide events -------------------------------
- // Peek at the mouse position
- if (event instanceof TMouseEvent) {
- TMouseEvent mouse = (TMouseEvent) event;
- if ((mouseX != mouse.getX()) || (mouseY != mouse.getY())) {
- mouseX = mouse.getX();
- mouseY = mouse.getY();
- drawMouse();
- }
+ // Abort everything
+ if (event instanceof TCommandEvent) {
+ TCommandEvent command = (TCommandEvent) event;
+ if (command.getCmd().equals(cmAbort)) {
+ quit = true;
+ return;
}
+ }
- // TODO: change to two separate threads
- primaryHandleEvent(event);
-
- /*
-
- // Put into the main queue
- addEvent(event);
-
- // Have one of the two consumer Fibers peel the events off
- // the queue.
- if (secondaryEventFiber !is null) {
- assert(secondaryEventFiber.state == Fiber.State.HOLD);
-
- // Wake up the secondary handler for these events
- secondaryEventFiber.call();
- } else {
- assert(primaryEventFiber.state == Fiber.State.HOLD);
+ // Screen resize
+ if (event instanceof TResizeEvent) {
+ TResizeEvent resize = (TResizeEvent) event;
+ getScreen().setDimensions(resize.getWidth(),
+ resize.getHeight());
+ desktopBottom = getScreen().getHeight() - 1;
+ repaint = true;
+ mouseX = 0;
+ mouseY = 0;
+ return;
+ }
- // Wake up the primary handler for these events
- primaryEventFiber.call();
+ // Peek at the mouse position
+ if (event instanceof TMouseEvent) {
+ TMouseEvent mouse = (TMouseEvent) event;
+ if ((mouseX != mouse.getX()) || (mouseY != mouse.getY())) {
+ mouseX = mouse.getX();
+ mouseY = mouse.getY();
+ drawMouse();
}
- */
+ }
- } // for (TInputEvent event: events)
+ // Put into the main queue
+ synchronized (drainEventQueue) {
+ drainEventQueue.add(event);
+ }
+ // Wake all threads: primary thread will either be consuming events
+ // again or waiting in yield(), and secondary thread will either not
+ // exist or consuming events.
+ synchronized (this) {
+ this.notifyAll();
+ }
}
/**
return;
}
- /*
- TODO
-
if (event instanceof TKeypressEvent) {
TKeypressEvent keypress = (TKeypressEvent) event;
+
// See if this key matches an accelerator, and if so dispatch the
// menu event.
TKeypress keypressLowercase = keypress.getKey().toLowerCase();
- TMenuItem item = accelerators.get(keypressLowercase);
+ TMenuItem item = null;
+ synchronized (accelerators) {
+ item = accelerators.get(keypressLowercase);
+ }
if (item != null) {
// Let the menu item dispatch
item.dispatch();
}
}
}
- */
if (event instanceof TCommandEvent) {
if (onCommand((TCommandEvent) event)) {
* @see #primaryHandleEvent(TInputEvent event)
*/
private void secondaryHandleEvent(final TInputEvent event) {
- // TODO
+ secondaryEventReceiver.handleEvent(event);
+ }
+
+ /**
+ * Enable a widget to override the primary event thread.
+ *
+ * @param widget widget that will receive events
+ */
+ public final void enableSecondaryEventReceiver(final TWidget widget) {
+ assert (secondaryEventReceiver == null);
+ assert (secondaryEventHandler == null);
+ assert (widget instanceof TMessageBox);
+ secondaryEventReceiver = widget;
+ secondaryEventHandler = new WidgetEventHandler(this, false);
+ (new Thread(secondaryEventHandler)).start();
+
+ // Refresh
+ repaint = true;
+ }
+
+ /**
+ * Yield to the secondary thread.
+ */
+ public final void yield() {
+ assert (secondaryEventReceiver != null);
+ while (secondaryEventReceiver != null) {
+ synchronized (this) {
+ try {
+ this.wait();
+ } catch (InterruptedException e) {
+ // SQUASH
+ }
+ }
+ }
}
/**
* Do stuff when there is no user input.
*/
private void doIdle() {
- /*
- TODO
// Now run any timers that have timed out
- auto now = Clock.currTime;
- TTimer [] keepTimers;
- foreach (t; timers) {
- if (t.nextTick < now) {
- t.tick();
- if (t.recurring == true) {
- keepTimers ~= t;
+ 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 ~= t;
+ keepTimers.add(timer);
}
}
timers = keepTimers;
// Call onIdle's
- foreach (w; windows) {
- w.onIdle();
+ for (TWindow window: windows) {
+ window.onIdle();
}
- */
}
/**
* @return number of milliseconds between now and the next timer event
*/
protected int getSleepTime(final int timeout) {
- /*
- auto now = Clock.currTime;
- auto sleepTime = dur!("msecs")(timeout);
- foreach (t; timers) {
- if (t.nextTick < now) {
+ Date now = new Date();
+ long sleepTime = timeout;
+ for (TTimer timer: timers) {
+ if (timer.getNextTick().getTime() < now.getTime()) {
return 0;
}
- if ((t.nextTick > now) &&
- ((t.nextTick - now) < sleepTime)
+ if ((timer.getNextTick().getTime() > now.getTime())
+ && ((timer.getNextTick().getTime() - now.getTime()) < sleepTime)
) {
- sleepTime = t.nextTick - now;
+ sleepTime = timer.getNextTick().getTime() - now.getTime();
}
}
- assert(sleepTime.total!("msecs")() >= 0);
- return cast(uint)sleepTime.total!("msecs")();
- */
- // TODO: fix timers. Until then, come back after 250 millis.
- return 250;
+ assert (sleepTime >= 0);
+ return (int)sleepTime;
}
/**
// Refresh screen
repaint = true;
- /*
- TODO
-
-
// Check if we are closing a TMessageBox or similar
- if (secondaryEventReceiver !is null) {
- assert(secondaryEventFiber !is null);
+ if (secondaryEventReceiver != null) {
+ assert (secondaryEventHandler != null);
// Do not send events to the secondaryEventReceiver anymore, the
// window is closed.
secondaryEventReceiver = null;
- // Special case: if this is called while executing on a
- // secondaryEventFiber, call it so that widgetEventHandler() can
- // terminate.
- if (secondaryEventFiber.state == Fiber.State.HOLD) {
- secondaryEventFiber.call();
- }
- secondaryEventFiber = null;
-
- // Unfreeze the logic in handleEvent()
- if (primaryEventFiber.state == Fiber.State.HOLD) {
- primaryEventFiber.call();
+ // Wake all threads: primary thread will be consuming events
+ // again, and secondary thread will exit.
+ synchronized (this) {
+ this.notifyAll();
}
}
- */
}
/**
* @return if true, this event was consumed
*/
protected boolean onCommand(final TCommandEvent command) {
- /*
- TODO
// Default: handle cmExit
if (command.equals(cmExit)) {
if (messageBox("Confirmation", "Exit application?",
- TMessageBox.Type.YESNO).result == TMessageBox.Result.YES) {
+ TMessageBox.Type.YESNO).getResult() == TMessageBox.Result.YES) {
quit = true;
}
repaint = true;
return true;
}
+ /*
+ TODO
if (command.equals(cmShell)) {
openTerminal(0, 0, TWindow.Flag.RESIZABLE);
repaint = true;
return true;
}
+ */
if (command.equals(cmTile)) {
tileWindows();
repaint = true;
return true;
}
- */
+
return false;
}
*/
protected boolean onMenu(final TMenuEvent menu) {
- /*
- TODO
// Default: handle MID_EXIT
- if (menu.id == TMenu.MID_EXIT) {
+ if (menu.getId() == TMenu.MID_EXIT) {
if (messageBox("Confirmation", "Exit application?",
- TMessageBox.Type.YESNO).result == TMessageBox.Result.YES) {
+ TMessageBox.Type.YESNO).getResult() == TMessageBox.Result.YES) {
quit = true;
}
// System.err.printf("onMenu MID_EXIT result: quit = %s\n", quit);
return true;
}
+ /*
+ TODO
if (menu.id == TMenu.MID_SHELL) {
openTerminal(0, 0, TWindow.Flag.RESIZABLE);
repaint = true;
return true;
}
+ */
- if (menu.id == TMenu.MID_TILE) {
+ if (menu.getId() == TMenu.MID_TILE) {
tileWindows();
repaint = true;
return true;
}
- if (menu.id == TMenu.MID_CASCADE) {
+ if (menu.getId() == TMenu.MID_CASCADE) {
cascadeWindows();
repaint = true;
return true;
}
- if (menu.id == TMenu.MID_CLOSE_ALL) {
+ if (menu.getId() == TMenu.MID_CLOSE_ALL) {
closeAllWindows();
repaint = true;
return true;
}
- */
return false;
}
*/
public final void addAccelerator(final TMenuItem item,
final TKeypress keypress) {
- /*
- TODO
- assert((keypress in accelerators) is null);
- accelerators[keypress] = item;
- */
+
+ // System.err.printf("addAccelerator: key %s item %s\n", keypress, item);
+
+ synchronized (accelerators) {
+ assert (accelerators.get(keypress) == null);
+ accelerators.put(keypress, item);
+ }
}
/**
* @param event new event to add to the queue
*/
public final void addMenuEvent(final TInputEvent event) {
- /*
- TODO - synchronize correctly
- eventQueue ~= event;
- */
+ synchronized (fillEventQueue) {
+ fillEventQueue.add(event);
+ }
closeMenu();
}
subMenus.add(menu);
}
+ /**
+ * Convenience function to add a top-level menu.
+ *
+ * @param title menu title
+ * @return the new menu
+ */
+ public final TMenu addMenu(final String title) {
+ int x = 0;
+ int y = 0;
+ TMenu menu = new TMenu(this, x, y, title);
+ menus.add(menu);
+ recomputeMenuX();
+ return menu;
+ }
+
+ /**
+ * 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();
+ fileMenu.addDefaultItem(TMenu.MID_SHELL);
+ fileMenu.addDefaultItem(TMenu.MID_EXIT);
+ return fileMenu;
+ }
+
+ /**
+ * Convenience function to add a default "Edit" menu.
+ *
+ * @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);
+ return editMenu;
+ }
+
+ /**
+ * Convenience function to add a default "Window" menu.
+ *
+ * @return the new menu
+ */
+ public final TMenu addWindowMenu() {
+ TMenu windowMenu = addMenu("&Window");
+ windowMenu.addDefaultItem(TMenu.MID_TILE);
+ windowMenu.addDefaultItem(TMenu.MID_CASCADE);
+ windowMenu.addDefaultItem(TMenu.MID_CLOSE_ALL);
+ windowMenu.addSeparator();
+ windowMenu.addDefaultItem(TMenu.MID_WINDOW_MOVE);
+ windowMenu.addDefaultItem(TMenu.MID_WINDOW_ZOOM);
+ windowMenu.addDefaultItem(TMenu.MID_WINDOW_NEXT);
+ windowMenu.addDefaultItem(TMenu.MID_WINDOW_PREVIOUS);
+ windowMenu.addDefaultItem(TMenu.MID_WINDOW_CLOSE);
+ return windowMenu;
+ }
+
+ /**
+ * Close all open windows.
+ */
+ private void closeAllWindows() {
+ // Don't do anything if we are in the menu
+ if (activeMenu != null) {
+ return;
+ }
+ for (TWindow window: windows) {
+ closeWindow(window);
+ }
+ }
+
+ /**
+ * Re-layout the open windows as non-overlapping tiles. This produces
+ * almost the same results as Turbo Pascal 7.0's IDE.
+ */
+ private void tileWindows() {
+ // Don't do anything if we are in the menu
+ if (activeMenu != null) {
+ return;
+ }
+ int z = windows.size();
+ if (z == 0) {
+ return;
+ }
+ int a = 0;
+ int b = 0;
+ a = (int)(Math.sqrt(z));
+ int c = 0;
+ while (c < a) {
+ b = (z - c) / a;
+ if (((a * b) + c) == z) {
+ break;
+ }
+ c++;
+ }
+ assert (a > 0);
+ assert (b > 0);
+ assert (c < a);
+ int newWidth = (getScreen().getWidth() / a);
+ int newHeight1 = ((getScreen().getHeight() - 1) / b);
+ int newHeight2 = ((getScreen().getHeight() - 1) / (b + c));
+ // System.err.printf("Z %s a %s b %s c %s newWidth %s newHeight1 %s newHeight2 %s",
+ // z, a, b, c, newWidth, newHeight1, newHeight2);
+
+ List<TWindow> sorted = new LinkedList<TWindow>(windows);
+ Collections.sort(sorted);
+ Collections.reverse(sorted);
+ for (int i = 0; i < sorted.size(); i++) {
+ int logicalX = i / b;
+ int logicalY = i % b;
+ if (i >= ((a - 1) * b)) {
+ logicalX = a - 1;
+ logicalY = i - ((a - 1) * b);
+ }
+
+ TWindow w = sorted.get(i);
+ w.setX(logicalX * newWidth);
+ w.setWidth(newWidth);
+ if (i >= ((a - 1) * b)) {
+ w.setY((logicalY * newHeight2) + 1);
+ w.setHeight(newHeight2);
+ } else {
+ w.setY((logicalY * newHeight1) + 1);
+ w.setHeight(newHeight1);
+ }
+ }
+ }
+
+ /**
+ * Re-layout the open windows as overlapping cascaded windows.
+ */
+ private void cascadeWindows() {
+ // Don't do anything if we are in the menu
+ if (activeMenu != null) {
+ return;
+ }
+ int x = 0;
+ int y = 1;
+ List<TWindow> sorted = new LinkedList<TWindow>(windows);
+ Collections.sort(sorted);
+ Collections.reverse(sorted);
+ for (TWindow window: sorted) {
+ window.setX(x);
+ window.setY(y);
+ x++;
+ y++;
+ if (x > getScreen().getWidth()) {
+ x = 0;
+ }
+ if (y >= getScreen().getHeight()) {
+ y = 1;
+ }
+ }
+ }
+
+ /**
+ * Convenience function to add a timer.
+ *
+ * @param duration number of milliseconds to wait between ticks
+ * @param recurring if true, re-schedule this timer after every tick
+ * @param action function to call when button is pressed
+ * @return the timer
+ */
+ public final TTimer addTimer(final long duration, final boolean recurring,
+ final TAction action) {
+
+ TTimer timer = new TTimer(duration, recurring, action);
+ synchronized (timers) {
+ timers.add(timer);
+ }
+ return timer;
+ }
+
+ /**
+ * Convenience function to remove a timer.
+ *
+ * @param timer timer to remove
+ */
+ public final void removeTimer(final TTimer timer) {
+ synchronized (timers) {
+ timers.remove(timer);
+ }
+ }
+
+ /**
+ * Convenience function to spawn a message box.
+ *
+ * @param title window title, will be centered along the top border
+ * @param caption message to display. Use embedded newlines to get a
+ * multi-line box.
+ * @return the new message box
+ */
+ public final TMessageBox messageBox(final String title,
+ final String caption) {
+
+ return new TMessageBox(this, title, caption, TMessageBox.Type.OK);
+ }
+
+ /**
+ * Convenience function to spawn a message box.
+ *
+ * @param title window title, will be centered along the top border
+ * @param caption message to display. Use embedded newlines to get a
+ * multi-line box.
+ * @param type one of the TMessageBox.Type constants. Default is
+ * Type.OK.
+ * @return the new message box
+ */
+ public final TMessageBox messageBox(final String title,
+ final String caption, final TMessageBox.Type type) {
+
+ return new TMessageBox(this, title, caption, type);
+ }
+
+ /**
+ * Convenience function to spawn an input box.
+ *
+ * @param title window title, will be centered along the top border
+ * @param caption message to display. Use embedded newlines to get a
+ * multi-line box.
+ * @return the new input box
+ */
+ public final TInputBox inputBox(final String title, final String caption) {
+
+ return new TInputBox(this, title, caption);
+ }
+
+ /**
+ * Convenience function to spawn an input box.
+ *
+ * @param title window title, will be centered along the top border
+ * @param caption message to display. Use embedded newlines to get a
+ * multi-line box.
+ * @param text initial text to seed the field with
+ * @return the new input box
+ */
+ public final TInputBox inputBox(final String title, final String caption,
+ final String text) {
+
+ return new TInputBox(this, title, caption, text);
+ }
+
}
git://git.nikiroo.be / fanfix.git / blobdiff