src/jexer/TWindow.java

   1 /*
   2  * Jexer - Java Text User Interface
   3  *
   4  * The MIT License (MIT)
   5  *
   6  * Copyright (C) 2019 Kevin Lamonte
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included in
  16  * all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  21  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  23  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  24  * DEALINGS IN THE SOFTWARE.
  25  *
  26  * @author Kevin Lamonte [kevin.lamonte@gmail.com]
  27  * @version 1
  28  */
  29 package jexer;
  30
  31 import java.util.HashSet;
  32 import java.util.Set;
  33
  34 import jexer.backend.Screen;
  35 import jexer.bits.CellAttributes;
  36 import jexer.bits.GraphicsChars;
  37 import jexer.bits.StringUtils;
  38 import jexer.event.TCommandEvent;
  39 import jexer.event.TKeypressEvent;
  40 import jexer.event.TMenuEvent;
  41 import jexer.event.TMouseEvent;
  42 import jexer.event.TResizeEvent;
  43 import jexer.menu.TMenu;
  44 import static jexer.TCommand.*;
  45 import static jexer.TKeypress.*;
  46
  47 /**
  48  * TWindow is the top-level container and drawing surface for other widgets.
  49  */
  50 public class TWindow extends TWidget {
  51
  52     // ------------------------------------------------------------------------
  53     // Constants --------------------------------------------------------------
  54     // ------------------------------------------------------------------------
  55
  56     /**
  57      * Window is resizable (default yes).
  58      */
  59     public static final int RESIZABLE   = 0x01;
  60
  61     /**
  62      * Window is modal (default no).
  63      */
  64     public static final int MODAL       = 0x02;
  65
  66     /**
  67      * Window is centered (default no).
  68      */
  69     public static final int CENTERED    = 0x04;
  70
  71     /**
  72      * Window has no close box (default no).  Window can still be closed via
  73      * TApplication.closeWindow() and TWindow.close().
  74      */
  75     public static final int NOCLOSEBOX  = 0x08;
  76
  77     /**
  78      * Window has no maximize box (default no).
  79      */
  80     public static final int NOZOOMBOX   = 0x10;
  81
  82     /**
  83      * Window is placed at absolute position (no smart placement) (default
  84      * no).
  85      */
  86     public static final int ABSOLUTEXY  = 0x20;
  87
  88     /**
  89      * Hitting the closebox with the mouse calls TApplication.hideWindow()
  90      * rather than TApplication.closeWindow() (default no).
  91      */
  92     public static final int HIDEONCLOSE = 0x40;
  93
  94     /**
  95      * Menus cannot be used when this window is active (default no).
  96      */
  97     public static final int OVERRIDEMENU        = 0x80;
  98
  99     // ------------------------------------------------------------------------
 100     // Variables --------------------------------------------------------------
 101     // ------------------------------------------------------------------------
 102
 103     /**
 104      * Window flags.  Note package private access.
 105      */
 106     int flags = RESIZABLE;
 107
 108     /**
 109      * Window title.
 110      */
 111     private String title = "";
 112
 113     /**
 114      * Window's parent TApplication.
 115      */
 116     private TApplication application;
 117
 118     /**
 119      * Z order.  Lower number means more in-front.
 120      */
 121     private int z = 0;
 122
 123     /**
 124      * Window's keyboard shortcuts.  Any key in this set will be passed to
 125      * the window directly rather than processed through the menu
 126      * accelerators.
 127      */
 128     private Set<TKeypress> keyboardShortcuts = new HashSet<TKeypress>();
 129
 130     /**
 131      * If true, then the user clicked on the title bar and is moving the
 132      * window.
 133      */
 134     protected boolean inWindowMove = false;
 135
 136     /**
 137      * If true, then the user clicked on the bottom right corner and is
 138      * resizing the window.
 139      */
 140     protected boolean inWindowResize = false;
 141
 142     /**
 143      * If true, then the user selected "Size/Move" (or hit Ctrl-F5) and is
 144      * resizing/moving the window via the keyboard.
 145      */
 146     protected boolean inKeyboardResize = false;
 147
 148     /**
 149      * If true, this window is maximized.
 150      */
 151     private boolean maximized = false;
 152
 153     /**
 154      * Remember mouse state.
 155      */
 156     protected TMouseEvent mouse;
 157
 158     // For moving the window.  resizing also uses moveWindowMouseX/Y
 159     private int moveWindowMouseX;
 160     private int moveWindowMouseY;
 161     private int oldWindowX;
 162     private int oldWindowY;
 163
 164     // Resizing
 165     private int resizeWindowWidth;
 166     private int resizeWindowHeight;
 167     private int minimumWindowWidth = 10;
 168     private int minimumWindowHeight = 2;
 169     private int maximumWindowWidth = -1;
 170     private int maximumWindowHeight = -1;
 171
 172     // For maximize/restore
 173     private int restoreWindowWidth;
 174     private int restoreWindowHeight;
 175     private int restoreWindowX;
 176     private int restoreWindowY;
 177
 178     /**
 179      * Hidden flag.  A hidden window will still have its onIdle() called, and
 180      * will also have onClose() called at application exit.  Note package
 181      * private access: TApplication will force hidden false if a modal window
 182      * is active.
 183      */
 184     boolean hidden = false;
 185
 186     /**
 187      * A window may have a status bar associated with it.  TApplication will
 188      * draw this status bar last, and will also route events to it first
 189      * before the window.
 190      */
 191     protected TStatusBar statusBar = null;
 192
 193     /**
 194      * A window may request that TApplication NOT draw the mouse cursor over
 195      * it by setting this to true.  This is currently only used within Jexer
 196      * by TTerminalWindow so that only the bottom-most instance of nested
 197      * Jexer's draws the mouse within its application window.  But perhaps
 198      * other applications can use it, so public getter/setter is provided.
 199      */
 200     private boolean hideMouse = false;
 201
 202     // ------------------------------------------------------------------------
 203     // Constructors -----------------------------------------------------------
 204     // ------------------------------------------------------------------------
 205
 206     /**
 207      * Public constructor.  Window will be located at (0, 0).
 208      *
 209      * @param application TApplication that manages this window
 210      * @param title window title, will be centered along the top border
 211      * @param width width of window
 212      * @param height height of window
 213      */
 214     public TWindow(final TApplication application, final String title,
 215         final int width, final int height) {
 216
 217         this(application, title, 0, 0, width, height, RESIZABLE);
 218     }
 219
 220     /**
 221      * Public constructor.  Window will be located at (0, 0).
 222      *
 223      * @param application TApplication that manages this window
 224      * @param title window title, will be centered along the top border
 225      * @param width width of window
 226      * @param height height of window
 227      * @param flags bitmask of RESIZABLE, CENTERED, or MODAL
 228      */
 229     public TWindow(final TApplication application, final String title,
 230         final int width, final int height, final int flags) {
 231
 232         this(application, title, 0, 0, width, height, flags);
 233     }
 234
 235     /**
 236      * Public constructor.
 237      *
 238      * @param application TApplication that manages this window
 239      * @param title window title, will be centered along the top border
 240      * @param x column relative to parent
 241      * @param y row relative to parent
 242      * @param width width of window
 243      * @param height height of window
 244      */
 245     public TWindow(final TApplication application, final String title,
 246         final int x, final int y, final int width, final int height) {
 247
 248         this(application, title, x, y, width, height, RESIZABLE);
 249     }
 250
 251     /**
 252      * Public constructor.
 253      *
 254      * @param application TApplication that manages this window
 255      * @param title window title, will be centered along the top border
 256      * @param x column relative to parent
 257      * @param y row relative to parent
 258      * @param width width of window
 259      * @param height height of window
 260      * @param flags mask of RESIZABLE, CENTERED, or MODAL
 261      */
 262     public TWindow(final TApplication application, final String title,
 263         final int x, final int y, final int width, final int height,
 264         final int flags) {
 265
 266         super();
 267
 268         // I am my own window and parent
 269         setupForTWindow(this, x, y + application.getDesktopTop(),
 270             width, height);
 271
 272         // Save fields
 273         this.title       = title;
 274         this.application = application;
 275         this.flags       = flags;
 276
 277         // Minimum width/height are 10 and 2
 278         assert (width >= 10);
 279         assert (getHeight() >= 2);
 280
 281         // MODAL implies CENTERED
 282         if (isModal()) {
 283             this.flags |= CENTERED;
 284         }
 285
 286         // Center window if specified
 287         center();
 288
 289         // Add me to the application
 290         application.addWindowToApplication(this);
 291     }
 292
 293     // ------------------------------------------------------------------------
 294     // Event handlers ---------------------------------------------------------
 295     // ------------------------------------------------------------------------
 296
 297     /**
 298      * Returns true if the mouse is currently on the close button.
 299      *
 300      * @return true if mouse is currently on the close button
 301      */
 302     protected boolean mouseOnClose() {
 303         if ((flags & NOCLOSEBOX) != 0) {
 304             return false;
 305         }
 306         if ((mouse != null)
 307             && (mouse.getAbsoluteY() == getY())
 308             && (mouse.getAbsoluteX() == getX() + 3)
 309         ) {
 310             return true;
 311         }
 312         return false;
 313     }
 314
 315     /**
 316      * Returns true if the mouse is currently on the maximize/restore button.
 317      *
 318      * @return true if the mouse is currently on the maximize/restore button
 319      */
 320     protected boolean mouseOnMaximize() {
 321         if ((flags & NOZOOMBOX) != 0) {
 322             return false;
 323         }
 324         if ((mouse != null)
 325             && !isModal()
 326             && (mouse.getAbsoluteY() == getY())
 327             && (mouse.getAbsoluteX() == getX() + getWidth() - 4)
 328         ) {
 329             return true;
 330         }
 331         return false;
 332     }
 333
 334     /**
 335      * Returns true if the mouse is currently on the resizable lower right
 336      * corner.
 337      *
 338      * @return true if the mouse is currently on the resizable lower right
 339      * corner
 340      */
 341     protected boolean mouseOnResize() {
 342         if (((flags & RESIZABLE) != 0)
 343             && !isModal()
 344             && (mouse != null)
 345             && (mouse.getAbsoluteY() == getY() + getHeight() - 1)
 346             && ((mouse.getAbsoluteX() == getX() + getWidth() - 1)
 347                 || (mouse.getAbsoluteX() == getX() + getWidth() - 2))
 348         ) {
 349             return true;
 350         }
 351         return false;
 352     }
 353
 354     /**
 355      * Subclasses should override this method to perform any user prompting
 356      * before they are offscreen.  Note that unlike other windowing toolkits,
 357      * windows can NOT use this function in some manner to avoid being
 358      * closed.  This is called by application.closeWindow().
 359      */
 360     protected void onPreClose() {
 361         // Default: do nothing.
 362     }
 363
 364     /**
 365      * Subclasses should override this method to cleanup resources.  This is
 366      * called by application.closeWindow().
 367      */
 368     protected void onClose() {
 369         // Default: perform widget-specific cleanup.
 370         for (TWidget w: getChildren()) {
 371             w.close();
 372         }
 373     }
 374
 375     /**
 376      * Called by application.switchWindow() when this window gets the
 377      * focus, and also by application.addWindow().
 378      */
 379     protected void onFocus() {
 380         // Default: do nothing
 381     }
 382
 383     /**
 384      * Called by application.switchWindow() when another window gets the
 385      * focus.
 386      */
 387     protected void onUnfocus() {
 388         // Default: do nothing
 389     }
 390
 391     /**
 392      * Called by application.hideWindow().
 393      */
 394     protected void onHide() {
 395         // Default: do nothing
 396     }
 397
 398     /**
 399      * Called by application.showWindow().
 400      */
 401     protected void onShow() {
 402         // Default: do nothing
 403     }
 404
 405     /**
 406      * Handle mouse button presses.
 407      *
 408      * @param mouse mouse button event
 409      */
 410     @Override
 411     public void onMouseDown(final TMouseEvent mouse) {
 412         this.mouse = mouse;
 413
 414         inKeyboardResize = false;
 415         inWindowMove = false;
 416         inWindowResize = false;
 417
 418         if ((mouse.getAbsoluteY() == getY())
 419             && mouse.isMouse1()
 420             && (getX() <= mouse.getAbsoluteX())
 421             && (mouse.getAbsoluteX() < getX() + getWidth())
 422             && !mouseOnClose()
 423             && !mouseOnMaximize()
 424         ) {
 425             // Begin moving window
 426             inWindowMove = true;
 427             moveWindowMouseX = mouse.getAbsoluteX();
 428             moveWindowMouseY = mouse.getAbsoluteY();
 429             oldWindowX = getX();
 430             oldWindowY = getY();
 431             if (maximized) {
 432                 maximized = false;
 433             }
 434             return;
 435         }
 436         if (mouseOnResize()) {
 437             // Begin window resize
 438             inWindowResize = true;
 439             moveWindowMouseX = mouse.getAbsoluteX();
 440             moveWindowMouseY = mouse.getAbsoluteY();
 441             resizeWindowWidth = getWidth();
 442             resizeWindowHeight = getHeight();
 443             if (maximized) {
 444                 maximized = false;
 445             }
 446             return;
 447         }
 448
 449         // Give the shortcut bar a shot at this.
 450         if (statusBar != null) {
 451             if (statusBar.statusBarMouseDown(mouse)) {
 452                 return;
 453             }
 454         }
 455
 456         // I didn't take it, pass it on to my children
 457         super.onMouseDown(mouse);
 458     }
 459
 460     /**
 461      * Handle mouse button releases.
 462      *
 463      * @param mouse mouse button release event
 464      */
 465     @Override
 466     public void onMouseUp(final TMouseEvent mouse) {
 467         this.mouse = mouse;
 468
 469         if ((inWindowMove) && (mouse.isMouse1())) {
 470             // Stop moving window
 471             inWindowMove = false;
 472             return;
 473         }
 474
 475         if ((inWindowResize) && (mouse.isMouse1())) {
 476             // Stop resizing window
 477             inWindowResize = false;
 478             return;
 479         }
 480
 481         if (mouse.isMouse1() && mouseOnClose()) {
 482             if ((flags & HIDEONCLOSE) == 0) {
 483                 // Close window
 484                 application.closeWindow(this);
 485             } else {
 486                 // Hide window
 487                 application.hideWindow(this);
 488             }
 489             return;
 490         }
 491
 492         if ((mouse.getAbsoluteY() == getY())
 493             && mouse.isMouse1()
 494             && mouseOnMaximize()) {
 495             if (maximized) {
 496                 // Restore
 497                 restore();
 498             } else {
 499                 // Maximize
 500                 maximize();
 501             }
 502             // Pass a resize event to my children
 503             onResize(new TResizeEvent(TResizeEvent.Type.WIDGET,
 504                     getWidth(), getHeight()));
 505             return;
 506         }
 507
 508         // Give the shortcut bar a shot at this.
 509         if (statusBar != null) {
 510             if (statusBar.statusBarMouseUp(mouse)) {
 511                 return;
 512             }
 513         }
 514
 515         // I didn't take it, pass it on to my children
 516         super.onMouseUp(mouse);
 517     }
 518
 519     /**
 520      * Handle mouse movements.
 521      *
 522      * @param mouse mouse motion event
 523      */
 524     @Override
 525     public void onMouseMotion(final TMouseEvent mouse) {
 526         this.mouse = mouse;
 527
 528         if (inWindowMove) {
 529             // Move window over
 530             setX(oldWindowX + (mouse.getAbsoluteX() - moveWindowMouseX));
 531             setY(oldWindowY + (mouse.getAbsoluteY() - moveWindowMouseY));
 532             // Don't cover up the menu bar
 533             if (getY() < application.getDesktopTop()) {
 534                 setY(application.getDesktopTop());
 535             }
 536             // Don't go below the status bar
 537             if (getY() >= application.getDesktopBottom()) {
 538                 setY(application.getDesktopBottom() - 1);
 539             }
 540             return;
 541         }
 542
 543         if (inWindowResize) {
 544             // Do not permit resizing below the status line
 545             if (mouse.getAbsoluteY() == application.getDesktopBottom()) {
 546                 inWindowResize = false;
 547                 return;
 548             }
 549
 550             // Move window over
 551             setWidth(resizeWindowWidth + (mouse.getAbsoluteX()
 552                     - moveWindowMouseX));
 553             setHeight(resizeWindowHeight + (mouse.getAbsoluteY()
 554                     - moveWindowMouseY));
 555             if (getX() + getWidth() > getScreen().getWidth()) {
 556                 setWidth(getScreen().getWidth() - getX());
 557             }
 558             if (getY() + getHeight() > application.getDesktopBottom()) {
 559                 setY(application.getDesktopBottom() - getHeight() + 1);
 560             }
 561             // Don't cover up the menu bar
 562             if (getY() < application.getDesktopTop()) {
 563                 setY(application.getDesktopTop());
 564             }
 565
 566             // Keep within min/max bounds
 567             if (getWidth() < minimumWindowWidth) {
 568                 setWidth(minimumWindowWidth);
 569                 inWindowResize = false;
 570             }
 571             if (getHeight() < minimumWindowHeight) {
 572                 setHeight(minimumWindowHeight);
 573                 inWindowResize = false;
 574             }
 575             if ((maximumWindowWidth > 0)
 576                 && (getWidth() > maximumWindowWidth)
 577             ) {
 578                 setWidth(maximumWindowWidth);
 579                 inWindowResize = false;
 580             }
 581             if ((maximumWindowHeight > 0)
 582                 && (getHeight() > maximumWindowHeight)
 583             ) {
 584                 setHeight(maximumWindowHeight);
 585                 inWindowResize = false;
 586             }
 587
 588             // Pass a resize event to my children
 589             onResize(new TResizeEvent(TResizeEvent.Type.WIDGET,
 590                     getWidth(), getHeight()));
 591             return;
 592         }
 593
 594         // Give the shortcut bar a shot at this.
 595         if (statusBar != null) {
 596             statusBar.statusBarMouseMotion(mouse);
 597         }
 598
 599         // I didn't take it, pass it on to my children
 600         super.onMouseMotion(mouse);
 601     }
 602
 603     /**
 604      * Handle keystrokes.
 605      *
 606      * @param keypress keystroke event
 607      */
 608     @Override
 609     public void onKeypress(final TKeypressEvent keypress) {
 610
 611         if (inWindowMove || inWindowResize) {
 612             // ESC or ENTER - Exit size/move
 613             if (keypress.equals(kbEsc) || keypress.equals(kbEnter)) {
 614                 inWindowMove = false;
 615                 inWindowResize = false;
 616                 return;
 617             }
 618         }
 619
 620         if (inKeyboardResize) {
 621
 622             // ESC or ENTER - Exit size/move
 623             if (keypress.equals(kbEsc) || keypress.equals(kbEnter)) {
 624                 inKeyboardResize = false;
 625             }
 626
 627             if (keypress.equals(kbLeft)) {
 628                 if (getX() > 0) {
 629                     setX(getX() - 1);
 630                 }
 631             }
 632             if (keypress.equals(kbRight)) {
 633                 if (getX() < getScreen().getWidth() - 1) {
 634                     setX(getX() + 1);
 635                 }
 636             }
 637             if (keypress.equals(kbDown)) {
 638                 if (getY() < application.getDesktopBottom() - 1) {
 639                     setY(getY() + 1);
 640                 }
 641             }
 642             if (keypress.equals(kbUp)) {
 643                 if (getY() > 1) {
 644                     setY(getY() - 1);
 645                 }
 646             }
 647
 648             /*
 649              * Only permit keyboard resizing if the window was RESIZABLE.
 650              */
 651             if ((flags & RESIZABLE) != 0) {
 652
 653                 if (keypress.equals(kbShiftLeft)) {
 654                     if ((getWidth() > minimumWindowWidth)
 655                         || (minimumWindowWidth <= 0)
 656                     ) {
 657                         setWidth(getWidth() - 1);
 658                     }
 659                 }
 660                 if (keypress.equals(kbShiftRight)) {
 661                     if ((getWidth() < maximumWindowWidth)
 662                         || (maximumWindowWidth <= 0)
 663                     ) {
 664                         setWidth(getWidth() + 1);
 665                     }
 666                 }
 667                 if (keypress.equals(kbShiftUp)) {
 668                     if ((getHeight() > minimumWindowHeight)
 669                         || (minimumWindowHeight <= 0)
 670                     ) {
 671                         setHeight(getHeight() - 1);
 672                     }
 673                 }
 674                 if (keypress.equals(kbShiftDown)) {
 675                     if ((getHeight() < maximumWindowHeight)
 676                         || (maximumWindowHeight <= 0)
 677                     ) {
 678                         setHeight(getHeight() + 1);
 679                     }
 680                 }
 681
 682                 // Pass a resize event to my children
 683                 onResize(new TResizeEvent(TResizeEvent.Type.WIDGET,
 684                         getWidth(), getHeight()));
 685
 686             } // if ((flags & RESIZABLE) != 0)
 687
 688             return;
 689         }
 690
 691         // Give the shortcut bar a shot at this.
 692         if (statusBar != null) {
 693             if (statusBar.statusBarKeypress(keypress)) {
 694                 return;
 695             }
 696         }
 697
 698         // These keystrokes will typically not be seen unless a subclass
 699         // overrides onMenu() due to how TApplication dispatches
 700         // accelerators.
 701
 702         if (!(this instanceof TDesktop)) {
 703
 704             // Ctrl-W - close window
 705             if (keypress.equals(kbCtrlW)) {
 706                 if ((flags & NOCLOSEBOX) == 0) {
 707                     if ((flags & HIDEONCLOSE) == 0) {
 708                         // Close window
 709                         application.closeWindow(this);
 710                     } else {
 711                         // Hide window
 712                         application.hideWindow(this);
 713                     }
 714                 }
 715                 return;
 716             }
 717
 718             // F6 - behave like Alt-TAB
 719             if (keypress.equals(kbF6)) {
 720                 application.switchWindow(true);
 721                 return;
 722             }
 723
 724             // Shift-F6 - behave like Shift-Alt-TAB
 725             if (keypress.equals(kbShiftF6)) {
 726                 application.switchWindow(false);
 727                 return;
 728             }
 729
 730             // F5 - zoom
 731             if (keypress.equals(kbF5) && ((flags & NOZOOMBOX) == 0)) {
 732                 if (maximized) {
 733                     restore();
 734                 } else {
 735                     maximize();
 736                 }
 737             }
 738
 739             // Ctrl-F5 - size/move
 740             if (keypress.equals(kbCtrlF5)) {
 741                 inKeyboardResize = !inKeyboardResize;
 742             }
 743
 744         } // if (!(this instanceof TDesktop))
 745
 746         // I didn't take it, pass it on to my children
 747         super.onKeypress(keypress);
 748     }
 749
 750     /**
 751      * Handle posted command events.
 752      *
 753      * @param command command event
 754      */
 755     @Override
 756     public void onCommand(final TCommandEvent command) {
 757
 758         // These commands will typically not be seen unless a subclass
 759         // overrides onMenu() due to how TApplication dispatches
 760         // accelerators.
 761
 762         if (!(this instanceof TDesktop)) {
 763
 764             if (command.equals(cmWindowClose)) {
 765                 if ((flags & NOCLOSEBOX) == 0) {
 766                     if ((flags & HIDEONCLOSE) == 0) {
 767                         // Close window
 768                         application.closeWindow(this);
 769                     } else {
 770                         // Hide window
 771                         application.hideWindow(this);
 772                     }
 773                 }
 774                 return;
 775             }
 776
 777             if (command.equals(cmWindowNext)) {
 778                 application.switchWindow(true);
 779                 return;
 780             }
 781
 782             if (command.equals(cmWindowPrevious)) {
 783                 application.switchWindow(false);
 784                 return;
 785             }
 786
 787             if (command.equals(cmWindowMove)) {
 788                 inKeyboardResize = true;
 789                 return;
 790             }
 791
 792             if (command.equals(cmWindowZoom) && ((flags & NOZOOMBOX) == 0)) {
 793                 if (maximized) {
 794                     restore();
 795                 } else {
 796                     maximize();
 797                 }
 798             }
 799
 800         } // if (!(this instanceof TDesktop))
 801
 802         // I didn't take it, pass it on to my children
 803         super.onCommand(command);
 804     }
 805
 806     /**
 807      * Handle posted menu events.
 808      *
 809      * @param menu menu event
 810      */
 811     @Override
 812     public void onMenu(final TMenuEvent menu) {
 813
 814         if (!(this instanceof TDesktop)) {
 815
 816             if (menu.getId() == TMenu.MID_WINDOW_CLOSE) {
 817                 if ((flags & NOCLOSEBOX) == 0) {
 818                     if ((flags & HIDEONCLOSE) == 0) {
 819                         // Close window
 820                         application.closeWindow(this);
 821                     } else {
 822                         // Hide window
 823                         application.hideWindow(this);
 824                     }
 825                 }
 826                 return;
 827             }
 828
 829             if (menu.getId() == TMenu.MID_WINDOW_NEXT) {
 830                 application.switchWindow(true);
 831                 return;
 832             }
 833
 834             if (menu.getId() == TMenu.MID_WINDOW_PREVIOUS) {
 835                 application.switchWindow(false);
 836                 return;
 837             }
 838
 839             if (menu.getId() == TMenu.MID_WINDOW_MOVE) {
 840                 inKeyboardResize = true;
 841                 return;
 842             }
 843
 844             if ((menu.getId() == TMenu.MID_WINDOW_ZOOM)
 845                 && ((flags & NOZOOMBOX) == 0)
 846             ) {
 847                 if (maximized) {
 848                     restore();
 849                 } else {
 850                     maximize();
 851                 }
 852                 return;
 853             }
 854
 855         } // if (!(this instanceof TDesktop))
 856
 857         // I didn't take it, pass it on to my children
 858         super.onMenu(menu);
 859     }
 860
 861     /**
 862      * Method that subclasses can override to handle window/screen resize
 863      * events.
 864      *
 865      * @param resize resize event
 866      */
 867     @Override
 868     public void onResize(final TResizeEvent resize) {
 869         if (resize.getType() == TResizeEvent.Type.WIDGET) {
 870             if (getChildren().size() == 1) {
 871                 TWidget child = getChildren().get(0);
 872                 if ((child instanceof TSplitPane)
 873                     || (child instanceof TPanel)
 874                 ) {
 875                     if (this instanceof TDesktop) {
 876                         child.onResize(new TResizeEvent(
 877                             TResizeEvent.Type.WIDGET,
 878                             resize.getWidth(), resize.getHeight()));
 879                     } else {
 880                         child.onResize(new TResizeEvent(
 881                             TResizeEvent.Type.WIDGET,
 882                             resize.getWidth() - 2, resize.getHeight() - 2));
 883                     }
 884                 }
 885                 return;
 886             }
 887         }
 888
 889         // Pass on to TWidget.
 890         super.onResize(resize);
 891     }
 892
 893     // ------------------------------------------------------------------------
 894     // TWidget ----------------------------------------------------------------
 895     // ------------------------------------------------------------------------
 896
 897     /**
 898      * Get this TWindow's parent TApplication.
 899      *
 900      * @return this TWindow's parent TApplication
 901      */
 902     @Override
 903     public final TApplication getApplication() {
 904         return application;
 905     }
 906
 907     /**
 908      * Get the Screen.
 909      *
 910      * @return the Screen
 911      */
 912     @Override
 913     public final Screen getScreen() {
 914         return application.getScreen();
 915     }
 916
 917     /**
 918      * Called by TApplication.drawChildren() to render on screen.
 919      */
 920     @Override
 921     public void draw() {
 922         // Draw the box and background first.
 923         CellAttributes border = getBorder();
 924         CellAttributes background = getBackground();
 925         int borderType = getBorderType();
 926
 927         drawBox(0, 0, getWidth(), getHeight(), border, background, borderType,
 928             true);
 929
 930         // Draw the title
 931         int titleLength = StringUtils.width(title);
 932         int titleLeft = (getWidth() - titleLength - 2) / 2;
 933         putCharXY(titleLeft, 0, ' ', border);
 934         putStringXY(titleLeft + 1, 0, title, border);
 935         putCharXY(titleLeft + titleLength + 1, 0, ' ', border);
 936
 937         if (isActive()) {
 938
 939             // Draw the close button
 940             if ((flags & NOCLOSEBOX) == 0) {
 941                 putCharXY(2, 0, '[', border);
 942                 putCharXY(4, 0, ']', border);
 943                 if (mouseOnClose() && mouse.isMouse1()) {
 944                     putCharXY(3, 0, GraphicsChars.CP437[0x0F],
 945                         getBorderControls());
 946                 } else {
 947                     putCharXY(3, 0, GraphicsChars.CP437[0xFE],
 948                         getBorderControls());
 949                 }
 950             }
 951
 952             // Draw the maximize button
 953             if (!isModal() && ((flags & NOZOOMBOX) == 0)) {
 954
 955                 putCharXY(getWidth() - 5, 0, '[', border);
 956                 putCharXY(getWidth() - 3, 0, ']', border);
 957                 if (mouseOnMaximize() && mouse.isMouse1()) {
 958                     putCharXY(getWidth() - 4, 0, GraphicsChars.CP437[0x0F],
 959                         getBorderControls());
 960                 } else {
 961                     if (maximized) {
 962                         putCharXY(getWidth() - 4, 0, GraphicsChars.CP437[0x12],
 963                             getBorderControls());
 964                     } else {
 965                         putCharXY(getWidth() - 4, 0, GraphicsChars.UPARROW,
 966                             getBorderControls());
 967                     }
 968                 }
 969
 970                 // Draw the resize corner
 971                 if ((flags & RESIZABLE) != 0) {
 972                     putCharXY(getWidth() - 2, getHeight() - 1,
 973                         GraphicsChars.SINGLE_BAR, getBorderControls());
 974                     putCharXY(getWidth() - 1, getHeight() - 1,
 975                         GraphicsChars.LRCORNER, getBorderControls());
 976                 }
 977             }
 978         }
 979     }
 980
 981     // ------------------------------------------------------------------------
 982     // TWindow ----------------------------------------------------------------
 983     // ------------------------------------------------------------------------
 984
 985     /**
 986      * Get window title.
 987      *
 988      * @return window title
 989      */
 990     public final String getTitle() {
 991         return title;
 992     }
 993
 994     /**
 995      * Set window title.
 996      *
 997      * @param title new window title
 998      */
 999     public final void setTitle(final String title) {
1000         this.title = title;
1001     }
1002
1003     /**
1004      * Get Z order.  Lower number means more in-front.
1005      *
1006      * @return Z value.  Lower number means more in-front.
1007      */
1008     public final int getZ() {
1009         return z;
1010     }
1011
1012     /**
1013      * Set Z order.  Lower number means more in-front.
1014      *
1015      * @param z the new Z value.  Lower number means more in-front.
1016      */
1017     public final void setZ(final int z) {
1018         this.z = z;
1019     }
1020
1021     /**
1022      * Add a keypress to be overridden for this window.
1023      *
1024      * @param key the key to start taking control of
1025      */
1026     protected void addShortcutKeypress(final TKeypress key) {
1027         keyboardShortcuts.add(key);
1028     }
1029
1030     /**
1031      * Remove a keypress to be overridden for this window.
1032      *
1033      * @param key the key to stop taking control of
1034      */
1035     protected void removeShortcutKeypress(final TKeypress key) {
1036         keyboardShortcuts.remove(key);
1037     }
1038
1039     /**
1040      * Remove all keypresses to be overridden for this window.
1041      */
1042     protected void clearShortcutKeypresses() {
1043         keyboardShortcuts.clear();
1044     }
1045
1046     /**
1047      * Determine if a keypress is overridden for this window.
1048      *
1049      * @param key the key to check
1050      * @return true if this window wants to process this key on its own
1051      */
1052     public boolean isShortcutKeypress(final TKeypress key) {
1053         return keyboardShortcuts.contains(key);
1054     }
1055
1056     /**
1057      * Get the window's status bar, or null if it does not have one.
1058      *
1059      * @return the status bar, or null
1060      */
1061     public TStatusBar getStatusBar() {
1062         return statusBar;
1063     }
1064
1065     /**
1066      * Set the window's status bar to a new one.
1067      *
1068      * @param text the status bar text
1069      * @return the status bar
1070      */
1071     public TStatusBar newStatusBar(final String text) {
1072         statusBar = new TStatusBar(this, text);
1073         return statusBar;
1074     }
1075
1076     /**
1077      * Set the maximum width for this window.
1078      *
1079      * @param maximumWindowWidth new maximum width
1080      */
1081     public final void setMaximumWindowWidth(final int maximumWindowWidth) {
1082         if ((maximumWindowWidth != -1)
1083             && (maximumWindowWidth < minimumWindowWidth + 1)
1084         ) {
1085             throw new IllegalArgumentException("Maximum window width cannot " +
1086                 "be smaller than minimum window width + 1");
1087         }
1088         this.maximumWindowWidth = maximumWindowWidth;
1089     }
1090
1091     /**
1092      * Set the minimum width for this window.
1093      *
1094      * @param minimumWindowWidth new minimum width
1095      */
1096     public final void setMinimumWindowWidth(final int minimumWindowWidth) {
1097         if ((maximumWindowWidth != -1)
1098             && (minimumWindowWidth > maximumWindowWidth - 1)
1099         ) {
1100             throw new IllegalArgumentException("Minimum window width cannot " +
1101                 "be larger than maximum window width - 1");
1102         }
1103         this.minimumWindowWidth = minimumWindowWidth;
1104     }
1105
1106     /**
1107      * Set the maximum height for this window.
1108      *
1109      * @param maximumWindowHeight new maximum height
1110      */
1111     public final void setMaximumWindowHeight(final int maximumWindowHeight) {
1112         if ((maximumWindowHeight != -1)
1113             && (maximumWindowHeight < minimumWindowHeight + 1)
1114         ) {
1115             throw new IllegalArgumentException("Maximum window height cannot " +
1116                 "be smaller than minimum window height + 1");
1117         }
1118         this.maximumWindowHeight = maximumWindowHeight;
1119     }
1120
1121     /**
1122      * Set the minimum height for this window.
1123      *
1124      * @param minimumWindowHeight new minimum height
1125      */
1126     public final void setMinimumWindowHeight(final int minimumWindowHeight) {
1127         if ((maximumWindowHeight != -1)
1128             && (minimumWindowHeight > maximumWindowHeight - 1)
1129         ) {
1130             throw new IllegalArgumentException("Minimum window height cannot " +
1131                 "be larger than maximum window height - 1");
1132         }
1133         this.minimumWindowHeight = minimumWindowHeight;
1134     }
1135
1136     /**
1137      * Recenter the window on-screen.
1138      */
1139     public final void center() {
1140         if ((flags & CENTERED) != 0) {
1141             if (getWidth() < getScreen().getWidth()) {
1142                 setX((getScreen().getWidth() - getWidth()) / 2);
1143             } else {
1144                 setX(0);
1145             }
1146             setY(((application.getDesktopBottom()
1147                     - application.getDesktopTop()) - getHeight()) / 2);
1148             if (getY() < 0) {
1149                 setY(0);
1150             }
1151             setY(getY() + application.getDesktopTop());
1152         }
1153     }
1154
1155     /**
1156      * Maximize window.
1157      */
1158     public void maximize() {
1159         if (maximized) {
1160             return;
1161         }
1162
1163         restoreWindowWidth = getWidth();
1164         restoreWindowHeight = getHeight();
1165         restoreWindowX = getX();
1166         restoreWindowY = getY();
1167         setWidth(getScreen().getWidth());
1168         setHeight(application.getDesktopBottom() - application.getDesktopTop());
1169         setX(0);
1170         setY(application.getDesktopTop());
1171         maximized = true;
1172
1173         onResize(new TResizeEvent(TResizeEvent.Type.WIDGET, getWidth(),
1174                 getHeight()));
1175     }
1176
1177     /**
1178      * Restore (unmaximize) window.
1179      */
1180     public void restore() {
1181         if (!maximized) {
1182             return;
1183         }
1184
1185         setWidth(restoreWindowWidth);
1186         setHeight(restoreWindowHeight);
1187         setX(restoreWindowX);
1188         setY(restoreWindowY);
1189         maximized = false;
1190
1191         onResize(new TResizeEvent(TResizeEvent.Type.WIDGET, getWidth(),
1192                 getHeight()));
1193     }
1194
1195     /**
1196      * Returns true if this window is hidden.
1197      *
1198      * @return true if this window is hidden, false if the window is shown
1199      */
1200     public final boolean isHidden() {
1201         return hidden;
1202     }
1203
1204     /**
1205      * Returns true if this window is shown.
1206      *
1207      * @return true if this window is shown, false if the window is hidden
1208      */
1209     public final boolean isShown() {
1210         return !hidden;
1211     }
1212
1213     /**
1214      * Hide window.  A hidden window will still have its onIdle() called, and
1215      * will also have onClose() called at application exit.  Hidden windows
1216      * will not receive any other events.
1217      */
1218     public void hide() {
1219         application.hideWindow(this);
1220     }
1221
1222     /**
1223      * Show window.
1224      */
1225     public void show() {
1226         application.showWindow(this);
1227     }
1228
1229     /**
1230      * Activate window (bring to top and receive events).
1231      */
1232     @Override
1233     public void activate() {
1234         application.activateWindow(this);
1235     }
1236
1237     /**
1238      * Close window.  Note that windows without a close box can still be
1239      * closed by calling the close() method.
1240      */
1241     @Override
1242     public void close() {
1243         application.closeWindow(this);
1244     }
1245
1246     /**
1247      * See if this window is undergoing any movement/resize/etc.
1248      *
1249      * @return true if the window is moving
1250      */
1251     public boolean inMovements() {
1252         if (inWindowResize || inWindowMove || inKeyboardResize) {
1253             return true;
1254         }
1255         return false;
1256     }
1257
1258     /**
1259      * Stop any pending movement/resize/etc.
1260      */
1261     public void stopMovements() {
1262         inWindowResize = false;
1263         inWindowMove = false;
1264         inKeyboardResize = false;
1265     }
1266
1267     /**
1268      * Returns true if this window is modal.
1269      *
1270      * @return true if this window is modal
1271      */
1272     public final boolean isModal() {
1273         if ((flags & MODAL) == 0) {
1274             return false;
1275         }
1276         return true;
1277     }
1278
1279     /**
1280      * Returns true if this window has a close box.
1281      *
1282      * @return true if this window has a close box
1283      */
1284     public final boolean hasCloseBox() {
1285         if ((flags & NOCLOSEBOX) != 0) {
1286             return true;
1287         }
1288         return false;
1289     }
1290
1291     /**
1292      * Returns true if this window has a maximize/zoom box.
1293      *
1294      * @return true if this window has a maximize/zoom box
1295      */
1296     public final boolean hasZoomBox() {
1297         if ((flags & NOZOOMBOX) != 0) {
1298             return true;
1299         }
1300         return false;
1301     }
1302
1303     /**
1304      * Returns true if this window does not want menus to work while it is
1305      * visible.
1306      *
1307      * @return true if this window does not want menus to work while it is
1308      * visible
1309      */
1310     public final boolean hasOverriddenMenu() {
1311         if ((flags & OVERRIDEMENU) != 0) {
1312             return true;
1313         }
1314         return false;
1315     }
1316
1317     /**
1318      * Retrieve the background color.
1319      *
1320      * @return the background color
1321      */
1322     public CellAttributes getBackground() {
1323         if (!isModal()
1324             && (inWindowMove || inWindowResize || inKeyboardResize)
1325         ) {
1326             assert (isActive());
1327             return getTheme().getColor("twindow.background.windowmove");
1328         } else if (isModal() && inWindowMove) {
1329             assert (isActive());
1330             return getTheme().getColor("twindow.background.modal");
1331         } else if (isModal()) {
1332             if (isActive()) {
1333                 return getTheme().getColor("twindow.background.modal");
1334             }
1335             return getTheme().getColor("twindow.background.modal.inactive");
1336         } else if (isActive()) {
1337             assert (!isModal());
1338             return getTheme().getColor("twindow.background");
1339         } else {
1340             assert (!isModal());
1341             return getTheme().getColor("twindow.background.inactive");
1342         }
1343     }
1344
1345     /**
1346      * Retrieve the border color.
1347      *
1348      * @return the border color
1349      */
1350     public CellAttributes getBorder() {
1351         if (!isModal()
1352             && (inWindowMove || inWindowResize || inKeyboardResize)
1353         ) {
1354             if (!isActive()) {
1355                 // The user's terminal never passed a mouse up event, and now
1356                 // another window is active but we never finished a drag.
1357                 inWindowMove = false;
1358                 inWindowResize = false;
1359                 inKeyboardResize = false;
1360                 return getTheme().getColor("twindow.border.inactive");
1361             }
1362
1363             return getTheme().getColor("twindow.border.windowmove");
1364         } else if (isModal() && inWindowMove) {
1365             assert (isActive());
1366             return getTheme().getColor("twindow.border.modal.windowmove");
1367         } else if (isModal()) {
1368             if (isActive()) {
1369                 return getTheme().getColor("twindow.border.modal");
1370             } else {
1371                 return getTheme().getColor("twindow.border.modal.inactive");
1372             }
1373         } else if (isActive()) {
1374             assert (!isModal());
1375             return getTheme().getColor("twindow.border");
1376         } else {
1377             assert (!isModal());
1378             return getTheme().getColor("twindow.border.inactive");
1379         }
1380     }
1381
1382     /**
1383      * Retrieve the color used by the window movement/sizing controls.
1384      *
1385      * @return the color used by the zoom box, resize bar, and close box
1386      */
1387     public CellAttributes getBorderControls() {
1388         if (isModal()) {
1389             return getTheme().getColor("twindow.border.modal.windowmove");
1390         }
1391         return getTheme().getColor("twindow.border.windowmove");
1392     }
1393
1394     /**
1395      * Retrieve the border line type.
1396      *
1397      * @return the border line type
1398      */
1399     private int getBorderType() {
1400         if (!isModal()
1401             && (inWindowMove || inWindowResize || inKeyboardResize)
1402         ) {
1403             assert (isActive());
1404             return 1;
1405         } else if (isModal() && inWindowMove) {
1406             assert (isActive());
1407             return 1;
1408         } else if (isModal()) {
1409             if (isActive()) {
1410                 return 2;
1411             } else {
1412                 return 1;
1413             }
1414         } else if (isActive()) {
1415             return 2;
1416         } else {
1417             return 1;
1418         }
1419     }
1420
1421     /**
1422      * Returns true if this window does not want the application-wide mouse
1423      * cursor drawn over it.
1424      *
1425      * @return true if this window does not want the application-wide mouse
1426      * cursor drawn over it
1427      */
1428     public boolean hasHiddenMouse() {
1429         return hideMouse;
1430     }
1431
1432     /**
1433      * Set request to prevent the application-wide mouse cursor from being
1434      * drawn over this window.
1435      *
1436      * @param hideMouse if true, this window does not want the
1437      * application-wide mouse cursor drawn over it
1438      */
1439     public final void setHiddenMouse(final boolean hideMouse) {
1440         this.hideMouse = hideMouse;
1441     }
1442
1443     /**
1444      * Generate a human-readable string for this window.
1445      *
1446      * @return a human-readable string
1447      */
1448     @Override
1449     public String toString() {
1450         return String.format("%s(%8x) \'%s\' position (%d, %d) geometry %dx%d" +
1451             " hidden %s modal %s", getClass().getName(), hashCode(), title,
1452             getX(), getY(), getWidth(), getHeight(), hidden, isModal());
1453     }
1454
1455 }