#34 call onResize() when window size is changed
[nikiroo-utils.git] / src / jexer / backend / LogicalScreen.java
1 /*
2 * Jexer - Java Text User Interface
3 *
4 * The MIT License (MIT)
5 *
6 * Copyright (C) 2017 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.backend;
30
31 import jexer.bits.Cell;
32 import jexer.bits.CellAttributes;
33 import jexer.bits.GraphicsChars;
34
35 /**
36 * A logical screen composed of a 2D array of Cells.
37 */
38 public class LogicalScreen implements Screen {
39
40 // ------------------------------------------------------------------------
41 // Variables --------------------------------------------------------------
42 // ------------------------------------------------------------------------
43
44 /**
45 * Width of the visible window.
46 */
47 protected int width;
48
49 /**
50 * Height of the visible window.
51 */
52 protected int height;
53
54 /**
55 * Drawing offset for x.
56 */
57 private int offsetX;
58
59 /**
60 * Drawing offset for y.
61 */
62 private int offsetY;
63
64 /**
65 * Ignore anything drawn right of clipRight.
66 */
67 private int clipRight;
68
69 /**
70 * Ignore anything drawn below clipBottom.
71 */
72 private int clipBottom;
73
74 /**
75 * Ignore anything drawn left of clipLeft.
76 */
77 private int clipLeft;
78
79 /**
80 * Ignore anything drawn above clipTop.
81 */
82 private int clipTop;
83
84 /**
85 * The physical screen last sent out on flush().
86 */
87 protected Cell [][] physical;
88
89 /**
90 * The logical screen being rendered to.
91 */
92 protected Cell [][] logical;
93
94 /**
95 * Set if the user explicitly wants to redraw everything starting with a
96 * ECMATerminal.clearAll().
97 */
98 protected boolean reallyCleared;
99
100 /**
101 * If true, the cursor is visible and should be placed onscreen at
102 * (cursorX, cursorY) during a call to flushPhysical().
103 */
104 protected boolean cursorVisible;
105
106 /**
107 * Cursor X position if visible.
108 */
109 protected int cursorX;
110
111 /**
112 * Cursor Y position if visible.
113 */
114 protected int cursorY;
115
116 // ------------------------------------------------------------------------
117 // Constructors -----------------------------------------------------------
118 // ------------------------------------------------------------------------
119
120 /**
121 * Public constructor. Sets everything to not-bold, white-on-black.
122 */
123 protected LogicalScreen() {
124 offsetX = 0;
125 offsetY = 0;
126 width = 80;
127 height = 24;
128 logical = null;
129 physical = null;
130 reallocate(width, height);
131 }
132
133 // ------------------------------------------------------------------------
134 // Screen -----------------------------------------------------------------
135 // ------------------------------------------------------------------------
136
137 /**
138 * Set drawing offset for x.
139 *
140 * @param offsetX new drawing offset
141 */
142 public final void setOffsetX(final int offsetX) {
143 this.offsetX = offsetX;
144 }
145
146 /**
147 * Set drawing offset for y.
148 *
149 * @param offsetY new drawing offset
150 */
151 public final void setOffsetY(final int offsetY) {
152 this.offsetY = offsetY;
153 }
154
155 /**
156 * Get right drawing clipping boundary.
157 *
158 * @return drawing boundary
159 */
160 public final int getClipRight() {
161 return clipRight;
162 }
163
164 /**
165 * Set right drawing clipping boundary.
166 *
167 * @param clipRight new boundary
168 */
169 public final void setClipRight(final int clipRight) {
170 this.clipRight = clipRight;
171 }
172
173 /**
174 * Get bottom drawing clipping boundary.
175 *
176 * @return drawing boundary
177 */
178 public final int getClipBottom() {
179 return clipBottom;
180 }
181
182 /**
183 * Set bottom drawing clipping boundary.
184 *
185 * @param clipBottom new boundary
186 */
187 public final void setClipBottom(final int clipBottom) {
188 this.clipBottom = clipBottom;
189 }
190
191 /**
192 * Get left drawing clipping boundary.
193 *
194 * @return drawing boundary
195 */
196 public final int getClipLeft() {
197 return clipLeft;
198 }
199
200 /**
201 * Set left drawing clipping boundary.
202 *
203 * @param clipLeft new boundary
204 */
205 public final void setClipLeft(final int clipLeft) {
206 this.clipLeft = clipLeft;
207 }
208
209 /**
210 * Get top drawing clipping boundary.
211 *
212 * @return drawing boundary
213 */
214 public final int getClipTop() {
215 return clipTop;
216 }
217
218 /**
219 * Set top drawing clipping boundary.
220 *
221 * @param clipTop new boundary
222 */
223 public final void setClipTop(final int clipTop) {
224 this.clipTop = clipTop;
225 }
226
227 /**
228 * Get dirty flag.
229 *
230 * @return if true, the logical screen is not in sync with the physical
231 * screen
232 */
233 public final boolean isDirty() {
234 for (int x = 0; x < width; x++) {
235 for (int y = 0; y < height; y++) {
236 if (!logical[x][y].equals(physical[x][y])) {
237 return true;
238 }
239 if (logical[x][y].isBlink()) {
240 // Blinking screens are always dirty. There is
241 // opportunity for a Netscape blink tag joke here...
242 return true;
243 }
244 }
245 }
246
247 return false;
248 }
249
250 /**
251 * Get the attributes at one location.
252 *
253 * @param x column coordinate. 0 is the left-most column.
254 * @param y row coordinate. 0 is the top-most row.
255 * @return attributes at (x, y)
256 */
257 public final CellAttributes getAttrXY(final int x, final int y) {
258 CellAttributes attr = new CellAttributes();
259 if ((x >= 0) && (x < width) && (y >= 0) && (y < height)) {
260 attr.setTo(logical[x][y]);
261 }
262 return attr;
263 }
264
265 /**
266 * Get the cell at one location.
267 *
268 * @param x column coordinate. 0 is the left-most column.
269 * @param y row coordinate. 0 is the top-most row.
270 * @return the character + attributes
271 */
272 public Cell getCharXY(final int x, final int y) {
273 Cell cell = new Cell();
274 if ((x >= 0) && (x < width) && (y >= 0) && (y < height)) {
275 cell.setTo(logical[x][y]);
276 }
277 return cell;
278 }
279
280 /**
281 * Set the attributes at one location.
282 *
283 * @param x column coordinate. 0 is the left-most column.
284 * @param y row coordinate. 0 is the top-most row.
285 * @param attr attributes to use (bold, foreColor, backColor)
286 */
287 public final void putAttrXY(final int x, final int y,
288 final CellAttributes attr) {
289
290 putAttrXY(x, y, attr, true);
291 }
292
293 /**
294 * Set the attributes at one location.
295 *
296 * @param x column coordinate. 0 is the left-most column.
297 * @param y row coordinate. 0 is the top-most row.
298 * @param attr attributes to use (bold, foreColor, backColor)
299 * @param clip if true, honor clipping/offset
300 */
301 public final void putAttrXY(final int x, final int y,
302 final CellAttributes attr, final boolean clip) {
303
304 int X = x;
305 int Y = y;
306
307 if (clip) {
308 if ((x < clipLeft)
309 || (x >= clipRight)
310 || (y < clipTop)
311 || (y >= clipBottom)
312 ) {
313 return;
314 }
315 X += offsetX;
316 Y += offsetY;
317 }
318
319 if ((X >= 0) && (X < width) && (Y >= 0) && (Y < height)) {
320 logical[X][Y].setTo(attr);
321
322 // If this happens to be the cursor position, make the position
323 // dirty.
324 if ((cursorX == X) && (cursorY == Y)) {
325 if (physical[cursorX][cursorY].getChar() == 'Q') {
326 physical[cursorX][cursorY].setChar('X');
327 } else {
328 physical[cursorX][cursorY].setChar('Q');
329 }
330 }
331 }
332 }
333
334 /**
335 * Fill the entire screen with one character with attributes.
336 *
337 * @param ch character to draw
338 * @param attr attributes to use (bold, foreColor, backColor)
339 */
340 public final void putAll(final char ch, final CellAttributes attr) {
341
342 for (int x = 0; x < width; x++) {
343 for (int y = 0; y < height; y++) {
344 putCharXY(x, y, ch, attr);
345 }
346 }
347 }
348
349 /**
350 * Render one character with attributes.
351 *
352 * @param x column coordinate. 0 is the left-most column.
353 * @param y row coordinate. 0 is the top-most row.
354 * @param ch character + attributes to draw
355 */
356 public final void putCharXY(final int x, final int y, final Cell ch) {
357 putCharXY(x, y, ch.getChar(), ch);
358 }
359
360 /**
361 * Render one character with attributes.
362 *
363 * @param x column coordinate. 0 is the left-most column.
364 * @param y row coordinate. 0 is the top-most row.
365 * @param ch character to draw
366 * @param attr attributes to use (bold, foreColor, backColor)
367 */
368 public final void putCharXY(final int x, final int y, final char ch,
369 final CellAttributes attr) {
370
371 if ((x < clipLeft)
372 || (x >= clipRight)
373 || (y < clipTop)
374 || (y >= clipBottom)
375 ) {
376 return;
377 }
378
379 int X = x + offsetX;
380 int Y = y + offsetY;
381
382 // System.err.printf("putCharXY: %d, %d, %c\n", X, Y, ch);
383
384 if ((X >= 0) && (X < width) && (Y >= 0) && (Y < height)) {
385
386 // Do not put control characters on the display
387 assert (ch >= 0x20);
388 assert (ch != 0x7F);
389
390 logical[X][Y].setTo(attr);
391 logical[X][Y].setChar(ch);
392
393 // If this happens to be the cursor position, make the position
394 // dirty.
395 if ((cursorX == X) && (cursorY == Y)) {
396 if (physical[cursorX][cursorY].getChar() == 'Q') {
397 physical[cursorX][cursorY].setChar('X');
398 } else {
399 physical[cursorX][cursorY].setChar('Q');
400 }
401 }
402 }
403 }
404
405 /**
406 * Render one character without changing the underlying attributes.
407 *
408 * @param x column coordinate. 0 is the left-most column.
409 * @param y row coordinate. 0 is the top-most row.
410 * @param ch character to draw
411 */
412 public final void putCharXY(final int x, final int y, final char ch) {
413
414 if ((x < clipLeft)
415 || (x >= clipRight)
416 || (y < clipTop)
417 || (y >= clipBottom)
418 ) {
419 return;
420 }
421
422 int X = x + offsetX;
423 int Y = y + offsetY;
424
425 // System.err.printf("putCharXY: %d, %d, %c\n", X, Y, ch);
426
427 if ((X >= 0) && (X < width) && (Y >= 0) && (Y < height)) {
428 logical[X][Y].setChar(ch);
429
430 // If this happens to be the cursor position, make the position
431 // dirty.
432 if ((cursorX == X) && (cursorY == Y)) {
433 if (physical[cursorX][cursorY].getChar() == 'Q') {
434 physical[cursorX][cursorY].setChar('X');
435 } else {
436 physical[cursorX][cursorY].setChar('Q');
437 }
438 }
439 }
440 }
441
442 /**
443 * Render a string. Does not wrap if the string exceeds the line.
444 *
445 * @param x column coordinate. 0 is the left-most column.
446 * @param y row coordinate. 0 is the top-most row.
447 * @param str string to draw
448 * @param attr attributes to use (bold, foreColor, backColor)
449 */
450 public final void putStringXY(final int x, final int y, final String str,
451 final CellAttributes attr) {
452
453 int i = x;
454 for (int j = 0; j < str.length(); j++) {
455 char ch = str.charAt(j);
456 putCharXY(i, y, ch, attr);
457 i++;
458 if (i == width) {
459 break;
460 }
461 }
462 }
463
464 /**
465 * Render a string without changing the underlying attribute. Does not
466 * wrap if the string exceeds the line.
467 *
468 * @param x column coordinate. 0 is the left-most column.
469 * @param y row coordinate. 0 is the top-most row.
470 * @param str string to draw
471 */
472 public final void putStringXY(final int x, final int y, final String str) {
473
474 int i = x;
475 for (int j = 0; j < str.length(); j++) {
476 char ch = str.charAt(j);
477 putCharXY(i, y, ch);
478 i++;
479 if (i == width) {
480 break;
481 }
482 }
483 }
484
485 /**
486 * Draw a vertical line from (x, y) to (x, y + n).
487 *
488 * @param x column coordinate. 0 is the left-most column.
489 * @param y row coordinate. 0 is the top-most row.
490 * @param n number of characters to draw
491 * @param ch character to draw
492 * @param attr attributes to use (bold, foreColor, backColor)
493 */
494 public final void vLineXY(final int x, final int y, final int n,
495 final char ch, final CellAttributes attr) {
496
497 for (int i = y; i < y + n; i++) {
498 putCharXY(x, i, ch, attr);
499 }
500 }
501
502 /**
503 * Draw a horizontal line from (x, y) to (x + n, y).
504 *
505 * @param x column coordinate. 0 is the left-most column.
506 * @param y row coordinate. 0 is the top-most row.
507 * @param n number of characters to draw
508 * @param ch character to draw
509 * @param attr attributes to use (bold, foreColor, backColor)
510 */
511 public final void hLineXY(final int x, final int y, final int n,
512 final char ch, final CellAttributes attr) {
513
514 for (int i = x; i < x + n; i++) {
515 putCharXY(i, y, ch, attr);
516 }
517 }
518
519 /**
520 * Change the width. Everything on-screen will be destroyed and must be
521 * redrawn.
522 *
523 * @param width new screen width
524 */
525 public final synchronized void setWidth(final int width) {
526 reallocate(width, this.height);
527 }
528
529 /**
530 * Change the height. Everything on-screen will be destroyed and must be
531 * redrawn.
532 *
533 * @param height new screen height
534 */
535 public final synchronized void setHeight(final int height) {
536 reallocate(this.width, height);
537 }
538
539 /**
540 * Change the width and height. Everything on-screen will be destroyed
541 * and must be redrawn.
542 *
543 * @param width new screen width
544 * @param height new screen height
545 */
546 public final void setDimensions(final int width, final int height) {
547 reallocate(width, height);
548 }
549
550 /**
551 * Get the height.
552 *
553 * @return current screen height
554 */
555 public final synchronized int getHeight() {
556 return this.height;
557 }
558
559 /**
560 * Get the width.
561 *
562 * @return current screen width
563 */
564 public final synchronized int getWidth() {
565 return this.width;
566 }
567
568 /**
569 * Reset screen to not-bold, white-on-black. Also flushes the offset and
570 * clip variables.
571 */
572 public final synchronized void reset() {
573 for (int row = 0; row < height; row++) {
574 for (int col = 0; col < width; col++) {
575 logical[col][row].reset();
576 }
577 }
578 resetClipping();
579 }
580
581 /**
582 * Flush the offset and clip variables.
583 */
584 public final void resetClipping() {
585 offsetX = 0;
586 offsetY = 0;
587 clipLeft = 0;
588 clipTop = 0;
589 clipRight = width;
590 clipBottom = height;
591 }
592
593 /**
594 * Clear the logical screen.
595 */
596 public final void clear() {
597 reset();
598 }
599
600 /**
601 * Draw a box with a border and empty background.
602 *
603 * @param left left column of box. 0 is the left-most row.
604 * @param top top row of the box. 0 is the top-most row.
605 * @param right right column of box
606 * @param bottom bottom row of the box
607 * @param border attributes to use for the border
608 * @param background attributes to use for the background
609 */
610 public final void drawBox(final int left, final int top,
611 final int right, final int bottom,
612 final CellAttributes border, final CellAttributes background) {
613
614 drawBox(left, top, right, bottom, border, background, 1, false);
615 }
616
617 /**
618 * Draw a box with a border and empty background.
619 *
620 * @param left left column of box. 0 is the left-most row.
621 * @param top top row of the box. 0 is the top-most row.
622 * @param right right column of box
623 * @param bottom bottom row of the box
624 * @param border attributes to use for the border
625 * @param background attributes to use for the background
626 * @param borderType if 1, draw a single-line border; if 2, draw a
627 * double-line border; if 3, draw double-line top/bottom edges and
628 * single-line left/right edges (like Qmodem)
629 * @param shadow if true, draw a "shadow" on the box
630 */
631 public final void drawBox(final int left, final int top,
632 final int right, final int bottom,
633 final CellAttributes border, final CellAttributes background,
634 final int borderType, final boolean shadow) {
635
636 int boxWidth = right - left;
637 int boxHeight = bottom - top;
638
639 char cTopLeft;
640 char cTopRight;
641 char cBottomLeft;
642 char cBottomRight;
643 char cHSide;
644 char cVSide;
645
646 switch (borderType) {
647 case 1:
648 cTopLeft = GraphicsChars.ULCORNER;
649 cTopRight = GraphicsChars.URCORNER;
650 cBottomLeft = GraphicsChars.LLCORNER;
651 cBottomRight = GraphicsChars.LRCORNER;
652 cHSide = GraphicsChars.SINGLE_BAR;
653 cVSide = GraphicsChars.WINDOW_SIDE;
654 break;
655
656 case 2:
657 cTopLeft = GraphicsChars.WINDOW_LEFT_TOP_DOUBLE;
658 cTopRight = GraphicsChars.WINDOW_RIGHT_TOP_DOUBLE;
659 cBottomLeft = GraphicsChars.WINDOW_LEFT_BOTTOM_DOUBLE;
660 cBottomRight = GraphicsChars.WINDOW_RIGHT_BOTTOM_DOUBLE;
661 cHSide = GraphicsChars.DOUBLE_BAR;
662 cVSide = GraphicsChars.WINDOW_SIDE_DOUBLE;
663 break;
664
665 case 3:
666 cTopLeft = GraphicsChars.WINDOW_LEFT_TOP;
667 cTopRight = GraphicsChars.WINDOW_RIGHT_TOP;
668 cBottomLeft = GraphicsChars.WINDOW_LEFT_BOTTOM;
669 cBottomRight = GraphicsChars.WINDOW_RIGHT_BOTTOM;
670 cHSide = GraphicsChars.WINDOW_TOP;
671 cVSide = GraphicsChars.WINDOW_SIDE;
672 break;
673 default:
674 throw new IllegalArgumentException("Invalid border type: "
675 + borderType);
676 }
677
678 // Place the corner characters
679 putCharXY(left, top, cTopLeft, border);
680 putCharXY(left + boxWidth - 1, top, cTopRight, border);
681 putCharXY(left, top + boxHeight - 1, cBottomLeft, border);
682 putCharXY(left + boxWidth - 1, top + boxHeight - 1, cBottomRight,
683 border);
684
685 // Draw the box lines
686 hLineXY(left + 1, top, boxWidth - 2, cHSide, border);
687 vLineXY(left, top + 1, boxHeight - 2, cVSide, border);
688 hLineXY(left + 1, top + boxHeight - 1, boxWidth - 2, cHSide, border);
689 vLineXY(left + boxWidth - 1, top + 1, boxHeight - 2, cVSide, border);
690
691 // Fill in the interior background
692 for (int i = 1; i < boxHeight - 1; i++) {
693 hLineXY(1 + left, i + top, boxWidth - 2, ' ', background);
694 }
695
696 if (shadow) {
697 // Draw a shadow
698 drawBoxShadow(left, top, right, bottom);
699 }
700 }
701
702 /**
703 * Draw a box shadow.
704 *
705 * @param left left column of box. 0 is the left-most row.
706 * @param top top row of the box. 0 is the top-most row.
707 * @param right right column of box
708 * @param bottom bottom row of the box
709 */
710 public final void drawBoxShadow(final int left, final int top,
711 final int right, final int bottom) {
712
713 int boxTop = top;
714 int boxLeft = left;
715 int boxWidth = right - left;
716 int boxHeight = bottom - top;
717 CellAttributes shadowAttr = new CellAttributes();
718
719 // Shadows do not honor clipping but they DO honor offset.
720 int oldClipRight = clipRight;
721 int oldClipBottom = clipBottom;
722 /*
723 clipRight = boxWidth + 2;
724 clipBottom = boxHeight + 1;
725 */
726 clipRight = width;
727 clipBottom = height;
728
729 for (int i = 0; i < boxHeight; i++) {
730 putAttrXY(boxLeft + boxWidth, boxTop + 1 + i, shadowAttr);
731 putAttrXY(boxLeft + boxWidth + 1, boxTop + 1 + i, shadowAttr);
732 }
733 for (int i = 0; i < boxWidth; i++) {
734 putAttrXY(boxLeft + 2 + i, boxTop + boxHeight, shadowAttr);
735 }
736 clipRight = oldClipRight;
737 clipBottom = oldClipBottom;
738 }
739
740 /**
741 * Default implementation does nothing.
742 */
743 public void flushPhysical() {}
744
745 /**
746 * Put the cursor at (x,y).
747 *
748 * @param visible if true, the cursor should be visible
749 * @param x column coordinate to put the cursor on
750 * @param y row coordinate to put the cursor on
751 */
752 public void putCursor(final boolean visible, final int x, final int y) {
753 if ((cursorY >= 0)
754 && (cursorX >= 0)
755 && (cursorY <= height - 1)
756 && (cursorX <= width - 1)
757 ) {
758 // Make the current cursor position dirty
759 if (physical[cursorX][cursorY].getChar() == 'Q') {
760 physical[cursorX][cursorY].setChar('X');
761 } else {
762 physical[cursorX][cursorY].setChar('Q');
763 }
764 }
765
766 cursorVisible = visible;
767 cursorX = x;
768 cursorY = y;
769 }
770
771 /**
772 * Hide the cursor.
773 */
774 public final void hideCursor() {
775 cursorVisible = false;
776 }
777
778 /**
779 * Get the cursor visibility.
780 *
781 * @return true if the cursor is visible
782 */
783 public boolean isCursorVisible() {
784 return cursorVisible;
785 }
786
787 /**
788 * Get the cursor X position.
789 *
790 * @return the cursor x column position
791 */
792 public int getCursorX() {
793 return cursorX;
794 }
795
796 /**
797 * Get the cursor Y position.
798 *
799 * @return the cursor y row position
800 */
801 public int getCursorY() {
802 return cursorY;
803 }
804
805 /**
806 * Set the window title. Default implementation does nothing.
807 *
808 * @param title the new title
809 */
810 public void setTitle(final String title) {}
811
812 // ------------------------------------------------------------------------
813 // LogicalScreen ----------------------------------------------------------
814 // ------------------------------------------------------------------------
815
816 /**
817 * Reallocate screen buffers.
818 *
819 * @param width new width
820 * @param height new height
821 */
822 private synchronized void reallocate(final int width, final int height) {
823 if (logical != null) {
824 for (int row = 0; row < this.height; row++) {
825 for (int col = 0; col < this.width; col++) {
826 logical[col][row] = null;
827 }
828 }
829 logical = null;
830 }
831 logical = new Cell[width][height];
832 if (physical != null) {
833 for (int row = 0; row < this.height; row++) {
834 for (int col = 0; col < this.width; col++) {
835 physical[col][row] = null;
836 }
837 }
838 physical = null;
839 }
840 physical = new Cell[width][height];
841
842 for (int row = 0; row < height; row++) {
843 for (int col = 0; col < width; col++) {
844 physical[col][row] = new Cell();
845 logical[col][row] = new Cell();
846 }
847 }
848
849 this.width = width;
850 this.height = height;
851
852 clipLeft = 0;
853 clipTop = 0;
854 clipRight = width;
855 clipBottom = height;
856
857 reallyCleared = true;
858 }
859
860 /**
861 * Clear the physical screen.
862 */
863 public final void clearPhysical() {
864 for (int row = 0; row < height; row++) {
865 for (int col = 0; col < width; col++) {
866 physical[col][row].reset();
867 }
868 }
869 }
870
871 }