-/**
+/*
* Jexer - Java Text User Interface
*
- * License: LGPLv3 or later
- *
- * This module is licensed under the GNU Lesser General Public License
- * Version 3. Please see the file "COPYING" in this directory for more
- * information about the GNU Lesser General Public License Version 3.
+ * The MIT License (MIT)
*
- * Copyright (C) 2015 Kevin Lamonte
+ * Copyright (C) 2017 Kevin Lamonte
*
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation; either version 3 of
- * the License, or (at your option) any later version.
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
*
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
*
- * You should have received a copy of the GNU Lesser General Public
- * License along with this program; if not, see
- * http://www.gnu.org/licenses/, or write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*
* @author Kevin Lamonte [kevin.lamonte@gmail.com]
* @version 1
package jexer;
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.util.Collections;
import java.util.Date;
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;
import jexer.menu.TMenuItem;
import static jexer.TCommand.*;
+import static jexer.TKeypress.*;
/**
* TApplication sets up a full Text User Interface application.
*/
-public class TApplication {
+public class TApplication implements Runnable {
+
+ // ------------------------------------------------------------------------
+ // Public constants -------------------------------------------------------
+ // ------------------------------------------------------------------------
/**
* If true, emit thread stuff to System.err.
*/
private static final boolean debugEvents = false;
+ /**
+ * If true, do "smart placement" on new windows that are not specified to
+ * be centered.
+ */
+ private static final boolean smartWindowPlacement = true;
+
+ /**
+ * 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
+ }
+
+ // ------------------------------------------------------------------------
+ // Primary/secondary event handlers ---------------------------------------
+ // ------------------------------------------------------------------------
+
/**
* 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");
lockoutHandleEvent = false;
}
+ // ------------------------------------------------------------------------
+ // TApplication attributes ------------------------------------------------
+ // ------------------------------------------------------------------------
+
/**
* Access to the physical screen, keyboard, and mouse.
*/
private Backend backend;
+ /**
+ * Get the Backend.
+ *
+ * @return the Backend
+ */
+ public final Backend getBackend() {
+ return backend;
+ }
+
/**
* Get the Screen.
*
*/
private Map<TKeypress, TMenuItem> accelerators;
+ /**
+ * All menu items.
+ */
+ private List<TMenuItem> menuItems;
+
/**
* Windows and widgets pull colors from this ColorTheme.
*/
return desktopBottom;
}
+ // ------------------------------------------------------------------------
+ // General behavior -------------------------------------------------------
+ // ------------------------------------------------------------------------
+
+ /**
+ * Display the about dialog.
+ */
+ protected void showAboutDialog() {
+ messageBox("About", "Jexer Version " +
+ this.getClass().getPackage().getImplementationVersion(),
+ TMessageBox.Type.OK);
+ }
+
+ // ------------------------------------------------------------------------
+ // Constructors -----------------------------------------------------------
+ // ------------------------------------------------------------------------
+
/**
* 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. The backend type will be BackendType.ECMA48.
+ *
+ * @param input the InputStream underlying 'reader'. Its available()
+ * method is used to determine if reader.read() will block or not.
+ * @param reader a Reader connected to the remote user.
+ * @param writer a PrintWriter connected to the remote user.
+ * @param setRawMode if true, set System.in into raw mode with stty.
+ * This should in general not be used. It is here solely for Demo3,
+ * which uses System.in.
+ * @throws IllegalArgumentException if input, reader, or writer are null.
+ */
+ public TApplication(final InputStream input, final Reader reader,
+ final PrintWriter writer, final boolean setRawMode) {
+
+ backend = new ECMA48Backend(this, input, reader, writer, setRawMode);
+ TApplicationImpl();
+ }
- if (useAWT) {
- backend = new AWTBackend(this);
- } else {
- backend = new ECMA48Backend(this, input, output);
- }
+ /**
+ * Public constructor. The backend type will be BackendType.ECMA48.
+ *
+ * @param input the InputStream underlying 'reader'. Its available()
+ * method is used to determine if reader.read() will block or not.
+ * @param reader a Reader connected to the remote user.
+ * @param writer a PrintWriter connected to the remote user.
+ * @throws IllegalArgumentException if input, reader, or writer are null.
+ */
+ public TApplication(final InputStream input, final Reader reader,
+ final PrintWriter writer) {
+
+ this(input, reader, writer, false);
+ }
+
+ /**
+ * 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();
+ }
+
+ /**
+ * 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);
(new Thread(primaryEventHandler)).start();
}
+ // ------------------------------------------------------------------------
+ // Screen refresh loop ----------------------------------------------------
+ // ------------------------------------------------------------------------
+
/**
* Invert the cell color at a position. This is used to track the mouse.
*
* @param y row position
*/
private void invertCell(final int x, final int y) {
- synchronized (getScreen()) {
- CellAttributes attr = getScreen().getAttrXY(x, y);
- attr.setForeColor(attr.getForeColor().invert());
- attr.setBackColor(attr.getBackColor().invert());
- getScreen().putAttrXY(x, y, attr, false);
+ 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.
*/
- public final void drawAll() {
+ 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.
oldMouseX = mouseX;
oldMouseY = mouseY;
}
+ if (getScreen().isDirty()) {
+ backend.flushScreen();
+ }
+ return;
}
- if (getScreen().isDirty()) {
- backend.flushScreen();
- }
- return;
}
if (debugThreads) {
// 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) {
window.drawChildren();
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");
+ 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().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();
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.visibleCursor()) {
+ if (activeWidget.isCursorVisible()) {
getScreen().putCursor(true, activeWidget.getCursorAbsoluteX(),
activeWidget.getCursorAbsoluteY());
cursor = true;
}
// Flush the screen contents
- backend.flushScreen();
+ if (getScreen().isDirty()) {
+ backend.flushScreen();
+ }
repaint = false;
}
+ // ------------------------------------------------------------------------
+ // Main loop --------------------------------------------------------------
+ // ------------------------------------------------------------------------
+
/**
* 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) {
// wait until either the backend or the consumer threads have
// something to do.
try {
+ if (debugThreads) {
+ System.err.println("sleep " + timeout + " millis");
+ }
synchronized (this) {
this.wait(timeout);
}
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;
}
if (event instanceof TKeypressEvent) {
TKeypressEvent keypress = (TKeypressEvent) event;
- // See if this key matches an accelerator, and if so dispatch the
- // menu event.
- TKeypress keypressLowercase = keypress.getKey().toLowerCase();
- TMenuItem item = null;
- synchronized (accelerators) {
- item = accelerators.get(keypressLowercase);
+ // 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;
+ for (TWindow window: windows) {
+ if (window.isActive()) {
+ if (window.isShortcutKeypress(keypress.getKey())) {
+ // We do not process this key, it will be passed to
+ // the window instead.
+ windowWillShortcut = true;
+ }
+ }
}
- if (item != null) {
- if (item.getEnabled()) {
- // Let the menu item dispatch
- item.dispatch();
+
+ if (!windowWillShortcut && !modalWindowActive()) {
+ TKeypress keypressLowercase = keypress.getKey().toLowerCase();
+ TMenuItem item = null;
+ synchronized (accelerators) {
+ item = accelerators.get(keypressLowercase);
+ }
+ if (item != null) {
+ if (item.isEnabled()) {
+ // Let the menu item dispatch
+ item.dispatch();
+ return;
+ }
+ }
+
+ // Handle the keypress
+ if (onKeypress(keypress)) {
return;
}
}
- // Handle the keypress
- if (onKeypress(keypress)) {
- return;
- }
}
if (event instanceof TCommandEvent) {
// 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) {
}
}
- /**
- * Get the amount of time I can sleep before missing a Timer tick.
- *
- * @param timeout = initial (maximum) timeout in millis
- * @return number of milliseconds between now and the next timer event
- */
- private long getSleepTime(final long timeout) {
- 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;
- }
- }
- assert (sleepTime >= 0);
- assert (sleepTime <= timeout);
- return sleepTime;
- }
+ // ------------------------------------------------------------------------
+ // TWindow management -----------------------------------------------------
+ // ------------------------------------------------------------------------
/**
* Close window. Note that the window's destructor is NOT called by this
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)
* @param window new window to add
*/
public final void addWindow(final TWindow window) {
+
+ // Do not add menu windows to the window list.
+ if (window instanceof TMenu) {
+ return;
+ }
+
synchronized (windows) {
- // Do not allow a modal window to spawn a non-modal window
- if ((windows.size() > 0) && (windows.get(0).isModal())) {
- assert (window.isModal());
+ // 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.
+ if (modalWindowActive()) {
+ window.flags |= TWindow.MODAL;
+ window.flags |= TWindow.CENTERED;
}
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();
+
+ if (((window.flags & TWindow.CENTERED) == 0)
+ && smartWindowPlacement) {
+
+ doSmartPlacement(window);
+ }
}
}
if (windows.size() == 0) {
return false;
}
- return windows.get(windows.size() - 1).isModal();
- }
- /**
- * Check if a mouse event would hit either the active menu or any open
- * sub-menus.
- *
- * @param mouse mouse event
- * @return true if the mouse would hit the active menu or an open
- * sub-menu
- */
- private boolean mouseOnMenu(final TMouseEvent mouse) {
- assert (activeMenu != null);
- List<TMenu> menus = new LinkedList<TMenu>(subMenus);
- Collections.reverse(menus);
- for (TMenu menu: menus) {
- if (menu.mouseWouldHit(mouse)) {
+ for (TWindow w: windows) {
+ if (w.isModal()) {
return true;
}
}
- return activeMenu.mouseWouldHit(mouse);
+
+ return false;
}
/**
- * See if we need to switch window or activate the menu based on
- * a mouse click.
- *
- * @param mouse mouse event
+ * Close all open windows.
*/
- private void checkSwitchFocus(final TMouseEvent mouse) {
-
- if ((mouse.getType() == TMouseEvent.Type.MOUSE_DOWN)
- && (activeMenu != null)
- && (mouse.getAbsoluteY() != 0)
- && (!mouseOnMenu(mouse))
- ) {
- // They clicked outside the active menu, turn it off
- activeMenu.setActive(false);
- activeMenu = null;
- for (TMenu menu: subMenus) {
- menu.setActive(false);
- }
- subMenus.clear();
- // Continue checks
+ private void closeAllWindows() {
+ // Don't do anything if we are in the menu
+ if (activeMenu != null) {
+ return;
}
+ while (windows.size() > 0) {
+ closeWindow(windows.get(0));
+ }
+ }
- // See if they hit the menu bar
- if ((mouse.getType() == TMouseEvent.Type.MOUSE_DOWN)
- && (mouse.getMouse1())
- && (!modalWindowActive())
- && (mouse.getAbsoluteY() == 0)
- ) {
-
- for (TMenu menu: subMenus) {
- menu.setActive(false);
+ /**
+ * 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() {
+ synchronized (windows) {
+ // Don't do anything if we are in the menu
+ if (activeMenu != null) {
+ return;
}
- subMenus.clear();
-
- // They selected the menu, go activate it
- for (TMenu menu: menus) {
- if ((mouse.getAbsoluteX() >= menu.getX())
- && (mouse.getAbsoluteX() < menu.getX()
- + menu.getTitle().length() + 2)
- ) {
- menu.setActive(true);
- activeMenu = menu;
- } else {
- menu.setActive(false);
+ 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++;
}
- return;
- }
-
- // See if they hit the menu bar
- if ((mouse.getType() == TMouseEvent.Type.MOUSE_MOTION)
- && (mouse.getMouse1())
- && (activeMenu != null)
- && (mouse.getAbsoluteY() == 0)
- ) {
+ 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));
- TMenu oldMenu = activeMenu;
- for (TMenu menu: subMenus) {
+ 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() {
+ synchronized (windows) {
+ // 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;
+ }
+ }
+ }
+ }
+
+ /**
+ * Place a window to minimize its overlap with other windows.
+ *
+ * @param window the window to place
+ */
+ public final void doSmartPlacement(final TWindow window) {
+ // This is a pretty dumb algorithm, but seems to work. The hardest
+ // part is computing these "overlap" values seeking a minimum average
+ // overlap.
+ int xMin = 0;
+ int yMin = desktopTop;
+ int xMax = getScreen().getWidth() - window.getWidth() + 1;
+ int yMax = desktopBottom - window.getHeight() + 1;
+ if (xMax < xMin) {
+ xMax = xMin;
+ }
+ if (yMax < yMin) {
+ yMax = yMin;
+ }
+
+ if ((xMin == xMax) && (yMin == yMax)) {
+ // No work to do, bail out.
+ return;
+ }
+
+ // Compute the overlap matrix without the new window.
+ int width = getScreen().getWidth();
+ int height = getScreen().getHeight();
+ int overlapMatrix[][] = new int[width][height];
+ for (TWindow w: windows) {
+ if (window == w) {
+ continue;
+ }
+ for (int x = w.getX(); x < w.getX() + w.getWidth(); x++) {
+ if (x == width) {
+ continue;
+ }
+ for (int y = w.getY(); y < w.getY() + w.getHeight(); y++) {
+ if (y == height) {
+ continue;
+ }
+ overlapMatrix[x][y]++;
+ }
+ }
+ }
+
+ long oldOverlapTotal = 0;
+ long oldOverlapN = 0;
+ for (int x = 0; x < width; x++) {
+ for (int y = 0; y < height; y++) {
+ oldOverlapTotal += overlapMatrix[x][y];
+ if (overlapMatrix[x][y] > 0) {
+ oldOverlapN++;
+ }
+ }
+ }
+
+
+ double oldOverlapAvg = (double) oldOverlapTotal / (double) oldOverlapN;
+ boolean first = true;
+ int windowX = window.getX();
+ int windowY = window.getY();
+
+ // For each possible (x, y) position for the new window, compute a
+ // new overlap matrix.
+ for (int x = xMin; x < xMax; x++) {
+ for (int y = yMin; y < yMax; y++) {
+
+ // Start with the matrix minus this window.
+ int newMatrix[][] = new int[width][height];
+ for (int mx = 0; mx < width; mx++) {
+ for (int my = 0; my < height; my++) {
+ newMatrix[mx][my] = overlapMatrix[mx][my];
+ }
+ }
+
+ // Add this window's values to the new overlap matrix.
+ long newOverlapTotal = 0;
+ long newOverlapN = 0;
+ // Start by adding each new cell.
+ for (int wx = x; wx < x + window.getWidth(); wx++) {
+ if (wx == width) {
+ continue;
+ }
+ for (int wy = y; wy < y + window.getHeight(); wy++) {
+ if (wy == height) {
+ continue;
+ }
+ newMatrix[wx][wy]++;
+ }
+ }
+ // Now figure out the new value for total coverage.
+ for (int mx = 0; mx < width; mx++) {
+ for (int my = 0; my < height; my++) {
+ newOverlapTotal += newMatrix[x][y];
+ if (newMatrix[mx][my] > 0) {
+ newOverlapN++;
+ }
+ }
+ }
+ double newOverlapAvg = (double) newOverlapTotal / (double) newOverlapN;
+
+ if (first) {
+ // First time: just record what we got.
+ oldOverlapAvg = newOverlapAvg;
+ first = false;
+ } else {
+ // All other times: pick a new best (x, y) and save the
+ // overlap value.
+ if (newOverlapAvg < oldOverlapAvg) {
+ windowX = x;
+ windowY = y;
+ oldOverlapAvg = newOverlapAvg;
+ }
+ }
+
+ } // for (int x = xMin; x < xMax; x++)
+
+ } // for (int y = yMin; y < yMax; y++)
+
+ // Finally, set the window's new coordinates.
+ window.setX(windowX);
+ window.setY(windowY);
+ }
+
+ // ------------------------------------------------------------------------
+ // TMenu management -------------------------------------------------------
+ // ------------------------------------------------------------------------
+
+ /**
+ * Check if a mouse event would hit either the active menu or any open
+ * sub-menus.
+ *
+ * @param mouse mouse event
+ * @return true if the mouse would hit the active menu or an open
+ * sub-menu
+ */
+ private boolean mouseOnMenu(final TMouseEvent mouse) {
+ assert (activeMenu != null);
+ List<TMenu> menus = new LinkedList<TMenu>(subMenus);
+ Collections.reverse(menus);
+ for (TMenu menu: menus) {
+ if (menu.mouseWouldHit(mouse)) {
+ return true;
+ }
+ }
+ return activeMenu.mouseWouldHit(mouse);
+ }
+
+ /**
+ * See if we need to switch window or activate the menu based on
+ * a mouse click.
+ *
+ * @param mouse mouse event
+ */
+ private void checkSwitchFocus(final TMouseEvent mouse) {
+
+ if ((mouse.getType() == TMouseEvent.Type.MOUSE_DOWN)
+ && (activeMenu != null)
+ && (mouse.getAbsoluteY() != 0)
+ && (!mouseOnMenu(mouse))
+ ) {
+ // They clicked outside the active menu, turn it off
+ activeMenu.setActive(false);
+ activeMenu = null;
+ for (TMenu menu: subMenus) {
+ menu.setActive(false);
+ }
+ subMenus.clear();
+ // Continue checks
+ }
+
+ // See if they hit the menu bar
+ if ((mouse.getType() == TMouseEvent.Type.MOUSE_DOWN)
+ && (mouse.isMouse1())
+ && (!modalWindowActive())
+ && (mouse.getAbsoluteY() == 0)
+ ) {
+
+ for (TMenu menu: subMenus) {
+ menu.setActive(false);
+ }
+ subMenus.clear();
+
+ // They selected the menu, go activate it
+ for (TMenu menu: menus) {
+ if ((mouse.getAbsoluteX() >= menu.getX())
+ && (mouse.getAbsoluteX() < menu.getX()
+ + menu.getTitle().length() + 2)
+ ) {
+ menu.setActive(true);
+ activeMenu = menu;
+ } else {
+ menu.setActive(false);
+ }
+ }
+ return;
+ }
+
+ // See if they hit the menu bar
+ if ((mouse.getType() == TMouseEvent.Type.MOUSE_MOTION)
+ && (mouse.isMouse1())
+ && (activeMenu != null)
+ && (mouse.getAbsoluteY() == 0)
+ ) {
+
+ TMenu oldMenu = activeMenu;
+ for (TMenu menu: subMenus) {
menu.setActive(false);
}
subMenus.clear();
}
// 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;
}
}
}
/**
- * Method that TApplication subclasses can override to handle menu or
- * posted command events.
+ * Add a menu item to the global list. If it has a keyboard accelerator,
+ * that will be added the global hash.
*
- * @param command command event
- * @return if true, this event was consumed
+ * @param item the menu item
*/
- 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;
- }
+ public final void addMenuItem(final TMenuItem item) {
+ menuItems.add(item);
- if (command.equals(cmTile)) {
- tileWindows();
- return true;
- }
- if (command.equals(cmCascade)) {
- cascadeWindows();
- return true;
- }
- if (command.equals(cmCloseAll)) {
- closeAllWindows();
- return true;
+ TKeypress key = item.getKey();
+ if (key != null) {
+ synchronized (accelerators) {
+ assert (accelerators.get(key) == null);
+ accelerators.put(key.toLowerCase(), item);
+ }
}
-
- return false;
}
/**
- * Method that TApplication subclasses can override to handle menu
- * events.
+ * Disable one menu item.
*
- * @param menu menu event
- * @return if true, this event was consumed
+ * @param id the menu item ID
*/
- 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;
+ public final void disableMenuItem(final int id) {
+ for (TMenuItem item: menuItems) {
+ if (item.getId() == id) {
+ item.setEnabled(false);
}
- 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;
+ /**
+ * 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);
+ }
}
- return false;
}
/**
- * Method that TApplication subclasses can override to handle keystrokes.
+ * Enable one menu item.
*
- * @param keypress keystroke event
- * @return if true, this event was consumed
+ * @param id the menu item ID
*/
- protected boolean onKeypress(final TKeypressEvent keypress) {
- // Default: only menu shortcuts
-
- // Process Alt-F, Alt-E, etc. menu shortcut keys
- if (!keypress.getKey().getIsKey()
- && keypress.getKey().getAlt()
- && !keypress.getKey().getCtrl()
- && (activeMenu == null)
- ) {
-
- assert (subMenus.size() == 0);
-
- for (TMenu menu: menus) {
- if (Character.toLowerCase(menu.getMnemonic().getShortcut())
- == Character.toLowerCase(keypress.getKey().getCh())
- ) {
- activeMenu = menu;
- menu.setActive(true);
- return true;
- }
+ public final void enableMenuItem(final int id) {
+ for (TMenuItem item: menuItems) {
+ if (item.getId() == id) {
+ item.setEnabled(true);
}
}
-
- return false;
}
/**
- * Add a keyboard accelerator to the global hash.
+ * Enable the range of menu items with ID's between lower and upper,
+ * inclusive.
*
- * @param item menu item this accelerator relates to
- * @param keypress keypress that will dispatch a TMenuEvent
+ * @param lower the lowest menu item ID
+ * @param upper the highest menu item ID
*/
- public final void addAccelerator(final TMenuItem item,
- final TKeypress keypress) {
-
- synchronized (accelerators) {
- assert (accelerators.get(keypress) == null);
- accelerators.put(keypress, item);
+ public final void enableMenuItems(final int lower, final int upper) {
+ for (TMenuItem item: menuItems) {
+ if ((item.getId() >= lower) && (item.getId() <= upper)) {
+ item.setEnabled(true);
+ }
}
}
*
* @param event new event to add to the queue
*/
- public final void addMenuEvent(final TInputEvent event) {
+ public final void postMenuEvent(final TInputEvent event) {
synchronized (fillEventQueue) {
fillEventQueue.add(event);
}
fileMenu.addSeparator();
fileMenu.addDefaultItem(TMenu.MID_SHELL);
fileMenu.addDefaultItem(TMenu.MID_EXIT);
+ TStatusBar statusBar = fileMenu.newStatusBar("File-management " +
+ "commands (Open, Save, Print, etc.)");
+ statusBar.addShortcutKeypress(kbF1, cmHelp, "Help");
return fileMenu;
}
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");
return editMenu;
}
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");
return windowMenu;
}
/**
- * Close all open windows.
+ * Convenience function to add a default "Help" menu.
+ *
+ * @return the new menu
*/
- private void closeAllWindows() {
- // Don't do anything if we are in the menu
- if (activeMenu != null) {
- return;
- }
+ public final TMenu addHelpMenu() {
+ TMenu helpMenu = addMenu("&Help");
+ helpMenu.addDefaultItem(TMenu.MID_HELP_CONTENTS);
+ helpMenu.addDefaultItem(TMenu.MID_HELP_INDEX);
+ helpMenu.addDefaultItem(TMenu.MID_HELP_SEARCH);
+ helpMenu.addDefaultItem(TMenu.MID_HELP_PREVIOUS);
+ helpMenu.addDefaultItem(TMenu.MID_HELP_HELP);
+ 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");
+ return helpMenu;
+ }
- synchronized (windows) {
- for (TWindow window: windows) {
- closeWindow(window);
+ // ------------------------------------------------------------------------
+ // 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;
}
/**
- * Re-layout the open windows as non-overlapping tiles. This produces
- * almost the same results as Turbo Pascal 7.0's IDE.
+ * Method that TApplication subclasses can override to handle menu
+ * events.
+ *
+ * @param menu menu event
+ * @return if true, this event was consumed
*/
- private void tileWindows() {
- synchronized (windows) {
- // 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++;
+ 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;
}
- 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));
+ return true;
+ }
- 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);
- }
+ if (menu.getId() == TMenu.MID_SHELL) {
+ openTerminal(0, 0, TWindow.RESIZABLE);
+ return true;
+ }
- 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);
+ 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.
+ *
+ * @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()
+ ) {
+
+ 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;
}
+ // ------------------------------------------------------------------------
+ // TTimer management ------------------------------------------------------
+ // ------------------------------------------------------------------------
+
/**
- * Re-layout the open windows as overlapping cascaded windows.
+ * Get the amount of time I can sleep before missing a Timer tick.
+ *
+ * @param timeout = initial (maximum) timeout in millis
+ * @return number of milliseconds between now and the next timer event
*/
- private void cascadeWindows() {
- synchronized (windows) {
- // Don't do anything if we are in the menu
- if (activeMenu != null) {
- return;
+ private long getSleepTime(final long timeout) {
+ 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;
}
- 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;
- }
+
+ long timeDifference = nextTickTime - nowTime;
+ if (timeDifference < sleepTime) {
+ sleepTime = timeDifference;
}
}
+ assert (sleepTime >= 0);
+ assert (sleepTime <= timeout);
+ return sleepTime;
}
/**
}
}
+ // ------------------------------------------------------------------------
+ // Other TWindow constructors ---------------------------------------------
+ // ------------------------------------------------------------------------
+
/**
* Convenience function to spawn a message box.
*
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();
+ }
+
}