Merge commit 'edcd53bbbba9f94e21f43fd03d3a2febcc2b1564'
[nikiroo-utils.git] / 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 }