+ // 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, 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()) {
+ ((TWindow) 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();
+ ((TWindow) menu).drawChildren();
+ }
+ getScreen().resetClipping();
+
+ // 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
+ if (debugThreads) {
+ System.err.printf("%d %s restoreImage() %d %d\n",
+ System.currentTimeMillis(), Thread.currentThread(),
+ oldDrawnMouseX, oldDrawnMouseY);
+ }
+ oldDrawnMouseCell = getScreen().getCharXY(mouseX, mouseY);
+ if ((images.size() > 0) && (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);
+ }
+ }
+ invertCell(mouseX, mouseY);
+ oldDrawnMouseX = mouseX;
+ oldDrawnMouseY = mouseY;
+
+ // Place the cursor if it is visible
+ if (!menuIsActive) {
+ TWidget activeWidget = null;
+ if (sorted.size() > 0) {
+ activeWidget = sorted.get(sorted.size() - 1).getActiveChild();
+ if (activeWidget.isCursorVisible()) {
+ if ((activeWidget.getCursorAbsoluteY() < desktopBottom)
+ && (activeWidget.getCursorAbsoluteY() > desktopTop)
+ ) {
+ 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;
+ }
+ }
+ }
+ }
+
+ // Kill the cursor
+ if (!cursor) {
+ getScreen().hideCursor();
+ }
+
+ // Flush the screen contents
+ if ((images.size() > 0) || getScreen().isDirty()) {
+ if (debugThreads) {
+ System.err.printf("%d %s backend.flushScreen()\n",
+ System.currentTimeMillis(), Thread.currentThread());
+ }
+ backend.flushScreen();
+ }
+
+ repaint = false;
+ }
+
+ /**
+ * Force this application to exit.
+ */
+ public void exit() {
+ quit = true;
+ synchronized (this) {
+ this.notify();
+ }
+ }
+
+ /**
+ * Subclasses can use this hook to cleanup resources. Called as the last
+ * step of TApplication.run().
+ */
+ public void onExit() {
+ // Default does nothing.
+ }
+
+ // ------------------------------------------------------------------------
+ // TWindow management -----------------------------------------------------
+ // ------------------------------------------------------------------------
+
+ /**
+ * Return the total number of windows.
+ *
+ * @return the total number of windows
+ */
+ public final int windowCount() {
+ return windows.size();
+ }
+
+ /**
+ * Return the number of windows that are showing.
+ *
+ * @return the number of windows that are showing on screen
+ */
+ public final int shownWindowCount() {
+ int n = 0;
+ for (TWindow w: windows) {
+ if (w.isShown()) {
+ n++;
+ }
+ }
+ return n;
+ }
+
+ /**
+ * Return the number of windows that are hidden.
+ *
+ * @return the number of windows that are hidden
+ */
+ public final int hiddenWindowCount() {
+ int n = 0;
+ for (TWindow w: windows) {
+ if (w.isHidden()) {
+ n++;
+ }
+ }
+ return n;
+ }
+
+ /**
+ * Check if a window instance is in this application's window list.
+ *
+ * @param window window to look for
+ * @return true if this window is in the list
+ */
+ public final boolean hasWindow(final TWindow window) {
+ if (windows.size() == 0) {
+ return false;
+ }
+ for (TWindow w: windows) {
+ if (w == window) {
+ assert (window.getApplication() == this);
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Activate a window: bring it to the top and have it receive events.
+ *
+ * @param window the window to become the new active window
+ */
+ public void activateWindow(final TWindow window) {
+ if (hasWindow(window) == false) {
+ /*
+ * Someone has a handle to a window I don't have. Ignore this
+ * request.
+ */
+ return;
+ }
+
+ // 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));
+ if (activeWindow == null) {
+ activeWindow = window;
+ window.setZ(0);
+ activeWindow.setActive(true);
+ activeWindow.onFocus();
+ }
+
+ assert (window.isActive());
+ assert (activeWindow == window);
+ return;
+ }
+
+ if (activeWindow == window) {
+ assert (window.isActive());
+
+ // Window is already active, do nothing.
+ return;
+ }
+
+ assert (!window.isActive());
+ if (activeWindow != null) {
+ // TODO: see if this assertion is really necessary.
+ // assert (activeWindow.getZ() == 0);
+
+ activeWindow.setActive(false);
+
+ // Increment every window Z that is on top of window
+ for (TWindow w: windows) {
+ if (w == window) {
+ continue;
+ }
+ if (w.getZ() < window.getZ()) {
+ w.setZ(w.getZ() + 1);
+ }
+ }
+
+ // Unset activeWindow now before unfocus, so that a window
+ // lifecycle change inside onUnfocus() doesn't call
+ // switchWindow() and lead to a stack overflow.
+ TWindow oldActiveWindow = activeWindow;
+ activeWindow = null;
+ oldActiveWindow.onUnfocus();
+ }
+ activeWindow = window;
+ activeWindow.setZ(0);
+ activeWindow.setActive(true);
+ activeWindow.onFocus();
+ return;
+ }
+
+ /**
+ * Hide a window.
+ *
+ * @param window the window to hide
+ */
+ public void hideWindow(final TWindow window) {
+ if (hasWindow(window) == false) {
+ /*
+ * Someone has a handle to a window I don't have. Ignore this
+ * request.
+ */
+ return;
+ }
+
+ // 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) {
+ if (window == activeWindow) {
+ if (shownWindowCount() > 1) {
+ switchWindow(true);
+ } else {
+ activeWindow = null;
+ window.setActive(false);
+ window.onUnfocus();
+ }
+ }
+ window.hidden = true;
+ window.onHide();
+ }
+ }
+
+ /**
+ * Show a window.
+ *
+ * @param window the window to show
+ */
+ public void showWindow(final TWindow window) {
+ if (hasWindow(window) == false) {
+ /*
+ * Someone has a handle to a window I don't have. Ignore this
+ * request.
+ */
+ return;
+ }
+
+ // 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) {
+ 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.
+ *
+ * @param window the window to remove
+ */
+ public final void closeWindow(final TWindow window) {
+ if (hasWindow(window) == false) {
+ /*
+ * Someone has a handle to a window I don't have. Ignore this
+ * request.
+ */
+ return;
+ }
+
+ // Let window know that it is about to be closed, while it is still
+ // visible on screen.
+ window.onPreClose();
+
+ synchronized (windows) {
+ // Whatever window might be moving/dragging, stop it now.
+ for (TWindow w: windows) {
+ if (w.inMovements()) {
+ w.stopMovements();
+ }
+ }
+
+ int z = window.getZ();
+ window.setZ(-1);
+ window.onUnfocus();
+ windows.remove(window);
+ Collections.sort(windows);
+ activeWindow = null;
+ int newZ = 0;
+ boolean foundNextWindow = false;
+
+ for (TWindow w: windows) {
+ w.setZ(newZ);
+ newZ++;
+
+ // Do not activate a hidden window.
+ if (w.isHidden()) {
+ continue;
+ }
+
+ if (foundNextWindow == false) {
+ foundNextWindow = true;
+ w.setActive(true);
+ w.onFocus();
+ assert (activeWindow == null);
+ activeWindow = w;
+ continue;
+ }
+
+ if (w.isActive()) {
+ w.setActive(false);
+ w.onUnfocus();
+ }
+ }
+ }
+
+ // Perform window cleanup
+ window.onClose();
+
+ // Check if we are closing a TMessageBox or similar
+ if (secondaryEventReceiver != null) {
+ assert (secondaryEventHandler != null);
+
+ // Do not send events to the secondaryEventReceiver anymore, the
+ // window is closed.
+ secondaryEventReceiver = null;
+
+ // Wake the secondary thread, it will wake the primary as it
+ // exits.
+ synchronized (secondaryEventHandler) {
+ secondaryEventHandler.notify();
+ }
+ }
+
+ // Permit desktop to be active if it is the only thing left.
+ if (desktop != null) {
+ if (windows.size() == 0) {
+ desktop.setActive(true);
+ }
+ }
+ }
+
+ /**
+ * Switch to the next window.
+ *
+ * @param forward if true, then switch to the next window in the list,
+ * otherwise switch to the previous window in the list
+ */
+ public final void switchWindow(final boolean forward) {
+ // Only switch if there are multiple visible windows
+ if (shownWindowCount() < 2) {
+ return;
+ }
+ assert (activeWindow != null);
+
+ synchronized (windows) {
+ // Whatever window might be moving/dragging, stop it now.
+ for (TWindow w: windows) {
+ if (w.inMovements()) {
+ w.stopMovements();
+ }
+ }
+
+ // 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;
+ } else {
+ assert (!windows.get(0).isActive());
+ }
+ }
+ 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;
+ }
+ }
+
+ if (windows.get(nextWindowI).isShown()) {
+ activateWindow(windows.get(nextWindowI));
+ break;
+ }
+ }
+ } // synchronized (windows)
+
+ }
+
+ /**
+ * Add a window to my window list and make it active. Note package
+ * private access.
+ *
+ * @param window new window to add
+ */
+ final void addWindowToApplication(final TWindow window) {
+
+ // Do not add menu windows to the window list.
+ if (window instanceof TMenu) {
+ return;
+ }
+
+ // Do not add the desktop to the window list.
+ if (window instanceof TDesktop) {
+ return;
+ }
+
+ 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.
+ if (modalWindowActive()) {
+ window.flags |= TWindow.MODAL;
+ window.flags |= TWindow.CENTERED;
+ window.hidden = false;
+ }
+ if (window.isShown()) {
+ for (TWindow w: windows) {
+ if (w.isActive()) {
+ w.setActive(false);
+ w.onUnfocus();
+ }
+ w.setZ(w.getZ() + 1);
+ }
+ }
+ windows.add(window);
+ if (window.isShown()) {
+ activeWindow = window;
+ activeWindow.setZ(0);
+ activeWindow.setActive(true);
+ activeWindow.onFocus();
+ }
+
+ if (((window.flags & TWindow.CENTERED) == 0)
+ && ((window.flags & TWindow.ABSOLUTEXY) == 0)
+ && (smartWindowPlacement == true)
+ ) {
+
+ doSmartPlacement(window);
+ }
+ }
+
+ // Desktop cannot be active over any other window.
+ if (desktop != null) {
+ desktop.setActive(false);
+ }
+ }
+
+ /**
+ * Check if there is a system-modal window on top.
+ *
+ * @return true if the active window is modal
+ */
+ private boolean modalWindowActive() {
+ if (windows.size() == 0) {
+ return false;
+ }
+
+ for (TWindow w: windows) {
+ if (w.isModal()) {
+ return true;
+ }
+ }
+
+ 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() {
+ if (activeWindow != null) {
+ if (activeWindow.hasOverriddenMenu()) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Close all open windows.
+ */
+ 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));
+ }
+ }
+
+ /**
+ * 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;
+ }
+ 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));
+
+ List<TWindow> sorted = new ArrayList<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);
+ int oldWidth = w.getWidth();
+ int oldHeight = w.getHeight();
+
+ 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 ((w.getWidth() != oldWidth)
+ || (w.getHeight() != oldHeight)
+ ) {
+ w.onResize(new TResizeEvent(TResizeEvent.Type.WIDGET,
+ w.getWidth(), w.getHeight()));
+ }
+ }
+ }
+ }
+
+ /**
+ * 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 ArrayList<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.