#5 rgbColors fix
[fanfix.git] / src / jexer / io / SwingScreen.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.io;
30
31 import java.awt.Color;
32 import java.awt.Cursor;
33 import java.awt.Font;
34 import java.awt.FontMetrics;
35 import java.awt.Graphics;
36 import java.awt.Graphics2D;
37 import java.awt.Insets;
38 import java.awt.Point;
39 import java.awt.Rectangle;
40 import java.awt.Toolkit;
41 import java.awt.geom.Rectangle2D;
42 import java.awt.image.BufferedImage;
43 import java.awt.image.BufferStrategy;
44 import java.io.InputStream;
45 import java.util.Date;
46 import java.util.HashMap;
47 import javax.swing.JFrame;
48 import javax.swing.SwingUtilities;
49
50 import jexer.bits.Cell;
51 import jexer.bits.CellAttributes;
52 import jexer.session.SwingSessionInfo;
53
54 /**
55 * This Screen implementation draws to a Java Swing JFrame.
56 */
57 public final class SwingScreen extends Screen {
58
59 /**
60 * If true, use triple buffering thread.
61 */
62 private static boolean tripleBuffer = true;
63
64 /**
65 * Cursor style to draw.
66 */
67 public enum CursorStyle {
68 /**
69 * Use an underscore for the cursor.
70 */
71 UNDERLINE,
72
73 /**
74 * Use a solid block for the cursor.
75 */
76 BLOCK,
77
78 /**
79 * Use an outlined block for the cursor.
80 */
81 OUTLINE
82 }
83
84 private static Color MYBLACK;
85 private static Color MYRED;
86 private static Color MYGREEN;
87 private static Color MYYELLOW;
88 private static Color MYBLUE;
89 private static Color MYMAGENTA;
90 private static Color MYCYAN;
91 private static Color MYWHITE;
92
93 private static Color MYBOLD_BLACK;
94 private static Color MYBOLD_RED;
95 private static Color MYBOLD_GREEN;
96 private static Color MYBOLD_YELLOW;
97 private static Color MYBOLD_BLUE;
98 private static Color MYBOLD_MAGENTA;
99 private static Color MYBOLD_CYAN;
100 private static Color MYBOLD_WHITE;
101
102 private static boolean dosColors = false;
103
104 /**
105 * Setup Swing colors to match DOS color palette.
106 */
107 private static void setDOSColors() {
108 if (dosColors) {
109 return;
110 }
111 MYBLACK = new Color(0x00, 0x00, 0x00);
112 MYRED = new Color(0xa8, 0x00, 0x00);
113 MYGREEN = new Color(0x00, 0xa8, 0x00);
114 MYYELLOW = new Color(0xa8, 0x54, 0x00);
115 MYBLUE = new Color(0x00, 0x00, 0xa8);
116 MYMAGENTA = new Color(0xa8, 0x00, 0xa8);
117 MYCYAN = new Color(0x00, 0xa8, 0xa8);
118 MYWHITE = new Color(0xa8, 0xa8, 0xa8);
119 MYBOLD_BLACK = new Color(0x54, 0x54, 0x54);
120 MYBOLD_RED = new Color(0xfc, 0x54, 0x54);
121 MYBOLD_GREEN = new Color(0x54, 0xfc, 0x54);
122 MYBOLD_YELLOW = new Color(0xfc, 0xfc, 0x54);
123 MYBOLD_BLUE = new Color(0x54, 0x54, 0xfc);
124 MYBOLD_MAGENTA = new Color(0xfc, 0x54, 0xfc);
125 MYBOLD_CYAN = new Color(0x54, 0xfc, 0xfc);
126 MYBOLD_WHITE = new Color(0xfc, 0xfc, 0xfc);
127
128 dosColors = true;
129 }
130
131 /**
132 * SwingFrame is our top-level hook into the Swing system.
133 */
134 class SwingFrame extends JFrame {
135
136 /**
137 * Serializable version.
138 */
139 private static final long serialVersionUID = 1;
140
141 /**
142 * The terminus font resource filename.
143 */
144 private static final String FONTFILE = "terminus-ttf-4.39/TerminusTTF-Bold-4.39.ttf";
145
146 /**
147 * The BufferStrategy object needed for triple-buffering.
148 */
149 private BufferStrategy bufferStrategy;
150
151 /**
152 * A cache of previously-rendered glyphs for blinking text, when it
153 * is not visible.
154 */
155 private HashMap<Cell, BufferedImage> glyphCacheBlink;
156
157 /**
158 * A cache of previously-rendered glyphs for non-blinking, or
159 * blinking-and-visible, text.
160 */
161 private HashMap<Cell, BufferedImage> glyphCache;
162
163 /**
164 * The TUI Screen data.
165 */
166 SwingScreen screen;
167
168 /**
169 * If true, we were successful getting Terminus.
170 */
171 private boolean gotTerminus = false;
172
173 /**
174 * Width of a character cell.
175 */
176 private int textWidth = 1;
177
178 /**
179 * Height of a character cell.
180 */
181 private int textHeight = 1;
182
183 /**
184 * Descent of a character cell.
185 */
186 private int maxDescent = 0;
187
188 /**
189 * System-dependent Y adjustment for text in the character cell.
190 */
191 private int textAdjustY = 0;
192
193 /**
194 * System-dependent X adjustment for text in the character cell.
195 */
196 private int textAdjustX = 0;
197
198 /**
199 * Top pixel absolute location.
200 */
201 private int top = 30;
202
203 /**
204 * Left pixel absolute location.
205 */
206 private int left = 30;
207
208 /**
209 * The cursor style to draw.
210 */
211 private CursorStyle cursorStyle = CursorStyle.UNDERLINE;
212
213 /**
214 * The number of millis to wait before switching the blink from
215 * visible to invisible.
216 */
217 private long blinkMillis = 500;
218
219 /**
220 * If true, the cursor should be visible right now based on the blink
221 * time.
222 */
223 private boolean cursorBlinkVisible = true;
224
225 /**
226 * The time that the blink last flipped from visible to invisible or
227 * from invisible to visible.
228 */
229 private long lastBlinkTime = 0;
230
231 /**
232 * Convert a CellAttributes foreground color to an Swing Color.
233 *
234 * @param attr the text attributes
235 * @return the Swing Color
236 */
237 private Color attrToForegroundColor(final CellAttributes attr) {
238 if (attr.isBold()) {
239 if (attr.getForeColor().equals(jexer.bits.Color.BLACK)) {
240 return MYBOLD_BLACK;
241 } else if (attr.getForeColor().equals(jexer.bits.Color.RED)) {
242 return MYBOLD_RED;
243 } else if (attr.getForeColor().equals(jexer.bits.Color.BLUE)) {
244 return MYBOLD_BLUE;
245 } else if (attr.getForeColor().equals(jexer.bits.Color.GREEN)) {
246 return MYBOLD_GREEN;
247 } else if (attr.getForeColor().equals(jexer.bits.Color.YELLOW)) {
248 return MYBOLD_YELLOW;
249 } else if (attr.getForeColor().equals(jexer.bits.Color.CYAN)) {
250 return MYBOLD_CYAN;
251 } else if (attr.getForeColor().equals(jexer.bits.Color.MAGENTA)) {
252 return MYBOLD_MAGENTA;
253 } else if (attr.getForeColor().equals(jexer.bits.Color.WHITE)) {
254 return MYBOLD_WHITE;
255 }
256 } else {
257 if (attr.getForeColor().equals(jexer.bits.Color.BLACK)) {
258 return MYBLACK;
259 } else if (attr.getForeColor().equals(jexer.bits.Color.RED)) {
260 return MYRED;
261 } else if (attr.getForeColor().equals(jexer.bits.Color.BLUE)) {
262 return MYBLUE;
263 } else if (attr.getForeColor().equals(jexer.bits.Color.GREEN)) {
264 return MYGREEN;
265 } else if (attr.getForeColor().equals(jexer.bits.Color.YELLOW)) {
266 return MYYELLOW;
267 } else if (attr.getForeColor().equals(jexer.bits.Color.CYAN)) {
268 return MYCYAN;
269 } else if (attr.getForeColor().equals(jexer.bits.Color.MAGENTA)) {
270 return MYMAGENTA;
271 } else if (attr.getForeColor().equals(jexer.bits.Color.WHITE)) {
272 return MYWHITE;
273 }
274 }
275 throw new IllegalArgumentException("Invalid color: " +
276 attr.getForeColor().getValue());
277 }
278
279 /**
280 * Convert a CellAttributes background color to an Swing Color.
281 *
282 * @param attr the text attributes
283 * @return the Swing Color
284 */
285 private Color attrToBackgroundColor(final CellAttributes attr) {
286 if (attr.getBackColor().equals(jexer.bits.Color.BLACK)) {
287 return MYBLACK;
288 } else if (attr.getBackColor().equals(jexer.bits.Color.RED)) {
289 return MYRED;
290 } else if (attr.getBackColor().equals(jexer.bits.Color.BLUE)) {
291 return MYBLUE;
292 } else if (attr.getBackColor().equals(jexer.bits.Color.GREEN)) {
293 return MYGREEN;
294 } else if (attr.getBackColor().equals(jexer.bits.Color.YELLOW)) {
295 return MYYELLOW;
296 } else if (attr.getBackColor().equals(jexer.bits.Color.CYAN)) {
297 return MYCYAN;
298 } else if (attr.getBackColor().equals(jexer.bits.Color.MAGENTA)) {
299 return MYMAGENTA;
300 } else if (attr.getBackColor().equals(jexer.bits.Color.WHITE)) {
301 return MYWHITE;
302 }
303 throw new IllegalArgumentException("Invalid color: " +
304 attr.getBackColor().getValue());
305 }
306
307 /**
308 * Public constructor.
309 *
310 * @param screen the Screen that Backend talks to
311 */
312 public SwingFrame(final SwingScreen screen) {
313 this.screen = screen;
314 setDOSColors();
315
316 // Figure out my cursor style
317 String cursorStyleString = System.getProperty(
318 "jexer.Swing.cursorStyle", "underline").toLowerCase();
319
320 if (cursorStyleString.equals("underline")) {
321 cursorStyle = CursorStyle.UNDERLINE;
322 } else if (cursorStyleString.equals("outline")) {
323 cursorStyle = CursorStyle.OUTLINE;
324 } else if (cursorStyleString.equals("block")) {
325 cursorStyle = CursorStyle.BLOCK;
326 }
327
328 if (System.getProperty("jexer.Swing.tripleBuffer") != null) {
329 if (System.getProperty("jexer.Swing.tripleBuffer").
330 equals("false")) {
331
332 SwingScreen.tripleBuffer = false;
333 }
334 }
335
336 setTitle("Jexer Application");
337 setBackground(Color.black);
338
339 try {
340 // Always try to use Terminus, the one decent font.
341 ClassLoader loader = Thread.currentThread().
342 getContextClassLoader();
343 InputStream in = loader.getResourceAsStream(FONTFILE);
344 Font terminusRoot = Font.createFont(Font.TRUETYPE_FONT, in);
345 Font terminus = terminusRoot.deriveFont(Font.PLAIN, 20);
346 setFont(terminus);
347 gotTerminus = true;
348 } catch (Exception e) {
349 e.printStackTrace();
350 // setFont(new Font("Liberation Mono", Font.PLAIN, 24));
351 setFont(new Font(Font.MONOSPACED, Font.PLAIN, 24));
352 }
353 pack();
354
355 // Kill the X11 cursor
356 // Transparent 16 x 16 pixel cursor image.
357 BufferedImage cursorImg = new BufferedImage(16, 16,
358 BufferedImage.TYPE_INT_ARGB);
359 // Create a new blank cursor.
360 Cursor blankCursor = Toolkit.getDefaultToolkit().createCustomCursor(
361 cursorImg, new Point(0, 0), "blank cursor");
362 setCursor(blankCursor);
363
364 // Be capable of seeing Tab / Shift-Tab
365 setFocusTraversalKeysEnabled(false);
366
367 // Save the text cell width/height
368 getFontDimensions();
369
370 // Cache glyphs as they are rendered
371 glyphCacheBlink = new HashMap<Cell, BufferedImage>();
372 glyphCache = new HashMap<Cell, BufferedImage>();
373
374 // Setup triple-buffering
375 if (SwingScreen.tripleBuffer) {
376 setIgnoreRepaint(true);
377 createBufferStrategy(3);
378 bufferStrategy = getBufferStrategy();
379 }
380 }
381
382 /**
383 * Figure out what textAdjustX and textAdjustY should be, based on
384 * the location of a vertical bar (to find textAdjustY) and a
385 * horizontal bar (to find textAdjustX).
386 *
387 * @return true if textAdjustX and textAdjustY were guessed at
388 * correctly
389 */
390 private boolean getFontAdjustments() {
391 BufferedImage image = null;
392
393 // What SHOULD happen is that the topmost/leftmost white pixel is
394 // at position (gr2x, gr2y). But it might also be off by a pixel
395 // in either direction.
396
397 Graphics2D gr2 = null;
398 int gr2x = 3;
399 int gr2y = 3;
400 image = new BufferedImage(textWidth * 2, textHeight * 2,
401 BufferedImage.TYPE_INT_ARGB);
402
403 gr2 = image.createGraphics();
404 gr2.setFont(getFont());
405 gr2.setColor(java.awt.Color.BLACK);
406 gr2.fillRect(0, 0, textWidth * 2, textHeight * 2);
407 gr2.setColor(java.awt.Color.WHITE);
408 char [] chars = new char[1];
409 chars[0] = jexer.bits.GraphicsChars.VERTICAL_BAR;
410 gr2.drawChars(chars, 0, 1, gr2x, gr2y + textHeight - maxDescent);
411 gr2.dispose();
412
413 for (int x = 0; x < textWidth; x++) {
414 for (int y = 0; y < textHeight; y++) {
415
416 /*
417 System.err.println("X: " + x + " Y: " + y + " " +
418 image.getRGB(x, y));
419 */
420
421 if ((image.getRGB(x, y) & 0xFFFFFF) != 0) {
422 textAdjustY = (gr2y - y);
423
424 // System.err.println("textAdjustY: " + textAdjustY);
425 x = textWidth;
426 break;
427 }
428 }
429 }
430
431 gr2 = image.createGraphics();
432 gr2.setFont(getFont());
433 gr2.setColor(java.awt.Color.BLACK);
434 gr2.fillRect(0, 0, textWidth * 2, textHeight * 2);
435 gr2.setColor(java.awt.Color.WHITE);
436 chars[0] = jexer.bits.GraphicsChars.SINGLE_BAR;
437 gr2.drawChars(chars, 0, 1, gr2x, gr2y + textHeight - maxDescent);
438 gr2.dispose();
439
440 for (int x = 0; x < textWidth; x++) {
441 for (int y = 0; y < textHeight; y++) {
442
443 /*
444 System.err.println("X: " + x + " Y: " + y + " " +
445 image.getRGB(x, y));
446 */
447
448 if ((image.getRGB(x, y) & 0xFFFFFF) != 0) {
449 textAdjustX = (gr2x - x);
450
451 // System.err.println("textAdjustX: " + textAdjustX);
452 return true;
453 }
454 }
455 }
456
457 // Something weird happened, don't rely on this function.
458 // System.err.println("getFontAdjustments: false");
459 return false;
460 }
461
462
463 /**
464 * Figure out my font dimensions.
465 */
466 private void getFontDimensions() {
467 Graphics gr = getGraphics();
468 FontMetrics fm = gr.getFontMetrics();
469 maxDescent = fm.getMaxDescent();
470 Rectangle2D bounds = fm.getMaxCharBounds(gr);
471 int leading = fm.getLeading();
472 textWidth = (int)Math.round(bounds.getWidth());
473 // textHeight = (int)Math.round(bounds.getHeight()) - maxDescent;
474
475 // This produces the same number, but works better for ugly
476 // monospace.
477 textHeight = fm.getMaxAscent() + maxDescent - leading;
478
479 if (gotTerminus == true) {
480 textHeight++;
481 }
482
483 if (getFontAdjustments() == false) {
484 // We were unable to programmatically determine textAdjustX
485 // and textAdjustY, so try some guesses based on operating
486 // system.
487 if (System.getProperty("os.name").startsWith("Windows")) {
488 textAdjustY = -1;
489 textAdjustX = 0;
490 }
491 if (System.getProperty("os.name").startsWith("Mac")) {
492 textAdjustY = -1;
493 textAdjustX = 0;
494 }
495 }
496 }
497
498 /**
499 * Resize to font dimensions.
500 */
501 public void resizeToScreen() {
502 // Figure out the thickness of borders and use that to set the
503 // final size.
504 Insets insets = getInsets();
505 left = insets.left;
506 top = insets.top;
507
508 setSize(textWidth * screen.width + insets.left + insets.right,
509 textHeight * screen.height + insets.top + insets.bottom);
510 }
511
512 /**
513 * Update redraws the whole screen.
514 *
515 * @param gr the Swing Graphics context
516 */
517 @Override
518 public void update(final Graphics gr) {
519 // The default update clears the area. Don't do that, instead
520 // just paint it directly.
521 paint(gr);
522 }
523
524 /**
525 * Draw one glyph to the screen.
526 *
527 * @param gr the Swing Graphics context
528 * @param cell the Cell to draw
529 * @param xPixel the x-coordinate to render to. 0 means the
530 * left-most pixel column.
531 * @param yPixel the y-coordinate to render to. 0 means the top-most
532 * pixel row.
533 */
534 private void drawGlyph(final Graphics gr, final Cell cell,
535 final int xPixel, final int yPixel) {
536
537 BufferedImage image = null;
538 if (cell.isBlink() && !cursorBlinkVisible) {
539 image = glyphCacheBlink.get(cell);
540 } else {
541 image = glyphCache.get(cell);
542 }
543 if (image != null) {
544 gr.drawImage(image, xPixel, yPixel, this);
545 return;
546 }
547
548 // Generate glyph and draw it.
549 Graphics2D gr2 = null;
550 int gr2x = xPixel;
551 int gr2y = yPixel;
552 if (tripleBuffer) {
553 image = new BufferedImage(textWidth, textHeight,
554 BufferedImage.TYPE_INT_ARGB);
555 gr2 = image.createGraphics();
556 gr2.setFont(getFont());
557 gr2x = 0;
558 gr2y = 0;
559 } else {
560 gr2 = (Graphics2D) gr;
561 }
562
563 Cell cellColor = new Cell();
564 cellColor.setTo(cell);
565
566 // Check for reverse
567 if (cell.isReverse()) {
568 cellColor.setForeColor(cell.getBackColor());
569 cellColor.setBackColor(cell.getForeColor());
570 }
571
572 // Draw the background rectangle, then the foreground character.
573 gr2.setColor(attrToBackgroundColor(cellColor));
574 gr2.fillRect(gr2x, gr2y, textWidth, textHeight);
575
576 // Handle blink and underline
577 if (!cell.isBlink()
578 || (cell.isBlink() && cursorBlinkVisible)
579 ) {
580 gr2.setColor(attrToForegroundColor(cellColor));
581 char [] chars = new char[1];
582 chars[0] = cell.getChar();
583 gr2.drawChars(chars, 0, 1, gr2x + textAdjustX,
584 gr2y + textHeight - maxDescent + textAdjustY);
585
586 if (cell.isUnderline()) {
587 gr2.fillRect(gr2x, gr2y + textHeight - 2, textWidth, 2);
588 }
589 }
590
591 if (tripleBuffer) {
592 gr2.dispose();
593
594 // We need a new key that will not be mutated by
595 // invertCell().
596 Cell key = new Cell();
597 key.setTo(cell);
598 if (cell.isBlink() && !cursorBlinkVisible) {
599 glyphCacheBlink.put(key, image);
600 } else {
601 glyphCache.put(key, image);
602 }
603
604 gr.drawImage(image, xPixel, yPixel, this);
605 }
606
607 }
608
609 /**
610 * Check if the cursor is visible, and if so draw it.
611 *
612 * @param gr the Swing Graphics context
613 */
614 private void drawCursor(final Graphics gr) {
615
616 if (cursorVisible
617 && (cursorY <= screen.height - 1)
618 && (cursorX <= screen.width - 1)
619 && cursorBlinkVisible
620 ) {
621 int xPixel = cursorX * textWidth + left;
622 int yPixel = cursorY * textHeight + top;
623 Cell lCell = screen.logical[cursorX][cursorY];
624 gr.setColor(attrToForegroundColor(lCell));
625 switch (cursorStyle) {
626 default:
627 // Fall through...
628 case UNDERLINE:
629 gr.fillRect(xPixel, yPixel + textHeight - 2, textWidth, 2);
630 break;
631 case BLOCK:
632 gr.fillRect(xPixel, yPixel, textWidth, textHeight);
633 break;
634 case OUTLINE:
635 gr.drawRect(xPixel, yPixel, textWidth - 1, textHeight - 1);
636 break;
637 }
638 }
639 }
640
641 /**
642 * Paint redraws the whole screen.
643 *
644 * @param gr the Swing Graphics context
645 */
646 @Override
647 public void paint(final Graphics gr) {
648 // Do nothing until the screen reference has been set.
649 if (screen == null) {
650 return;
651 }
652 if (screen.frame == null) {
653 return;
654 }
655
656 // See if it is time to flip the blink time.
657 long nowTime = (new Date()).getTime();
658 if (nowTime > blinkMillis + lastBlinkTime) {
659 lastBlinkTime = nowTime;
660 cursorBlinkVisible = !cursorBlinkVisible;
661 }
662
663 int xCellMin = 0;
664 int xCellMax = screen.width;
665 int yCellMin = 0;
666 int yCellMax = screen.height;
667
668 Rectangle bounds = gr.getClipBounds();
669 if (bounds != null) {
670 // Only update what is in the bounds
671 xCellMin = screen.textColumn(bounds.x);
672 xCellMax = screen.textColumn(bounds.x + bounds.width);
673 if (xCellMax > screen.width) {
674 xCellMax = screen.width;
675 }
676 if (xCellMin >= xCellMax) {
677 xCellMin = xCellMax - 2;
678 }
679 if (xCellMin < 0) {
680 xCellMin = 0;
681 }
682 yCellMin = screen.textRow(bounds.y);
683 yCellMax = screen.textRow(bounds.y + bounds.height);
684 if (yCellMax > screen.height) {
685 yCellMax = screen.height;
686 }
687 if (yCellMin >= yCellMax) {
688 yCellMin = yCellMax - 2;
689 }
690 if (yCellMin < 0) {
691 yCellMin = 0;
692 }
693 } else {
694 // We need a total repaint
695 reallyCleared = true;
696 }
697
698 // Prevent updates to the screen's data from the TApplication
699 // threads.
700 synchronized (screen) {
701 /*
702 System.err.printf("bounds %s X %d %d Y %d %d\n",
703 bounds, xCellMin, xCellMax, yCellMin, yCellMax);
704 */
705
706 for (int y = yCellMin; y < yCellMax; y++) {
707 for (int x = xCellMin; x < xCellMax; x++) {
708
709 int xPixel = x * textWidth + left;
710 int yPixel = y * textHeight + top;
711
712 Cell lCell = screen.logical[x][y];
713 Cell pCell = screen.physical[x][y];
714
715 if (!lCell.equals(pCell)
716 || lCell.isBlink()
717 || reallyCleared) {
718
719 drawGlyph(gr, lCell, xPixel, yPixel);
720
721 // Physical is always updated
722 physical[x][y].setTo(lCell);
723 }
724 }
725 }
726 drawCursor(gr);
727
728 dirty = false;
729 reallyCleared = false;
730 } // synchronized (screen)
731 }
732
733 } // class SwingFrame
734
735 /**
736 * The raw Swing JFrame. Note package private access.
737 */
738 SwingFrame frame;
739
740 /**
741 * Restore terminal to normal state.
742 */
743 public void shutdown() {
744 frame.dispose();
745 }
746
747 /**
748 * Public constructor.
749 */
750 public SwingScreen() {
751 try {
752 SwingUtilities.invokeAndWait(new Runnable() {
753 public void run() {
754 SwingScreen.this.frame = new SwingFrame(SwingScreen.this);
755 SwingScreen.this.sessionInfo =
756 new SwingSessionInfo(SwingScreen.this.frame,
757 frame.textWidth,
758 frame.textHeight);
759
760 SwingScreen.this.setDimensions(sessionInfo.getWindowWidth(),
761 sessionInfo.getWindowHeight());
762
763 SwingScreen.this.frame.resizeToScreen();
764 SwingScreen.this.frame.setVisible(true);
765 }
766 });
767 } catch (Exception e) {
768 e.printStackTrace();
769 }
770 }
771
772 /**
773 * The sessionInfo.
774 */
775 private SwingSessionInfo sessionInfo;
776
777 /**
778 * Create the SwingSessionInfo. Note package private access.
779 *
780 * @return the sessionInfo
781 */
782 SwingSessionInfo getSessionInfo() {
783 return sessionInfo;
784 }
785
786 /**
787 * Push the logical screen to the physical device.
788 */
789 @Override
790 public void flushPhysical() {
791
792 /*
793 System.err.printf("flushPhysical(): reallyCleared %s dirty %s\n",
794 reallyCleared, dirty);
795 */
796
797 // If reallyCleared is set, we have to draw everything.
798 if ((frame.bufferStrategy != null) && (reallyCleared == true)) {
799 // Triple-buffering: we have to redraw everything on this thread.
800 Graphics gr = frame.bufferStrategy.getDrawGraphics();
801 frame.paint(gr);
802 gr.dispose();
803 frame.bufferStrategy.show();
804 // sync() doesn't seem to help the tearing for me.
805 // Toolkit.getDefaultToolkit().sync();
806 return;
807 } else if ((frame.bufferStrategy == null) && (reallyCleared == true)) {
808 // Repaint everything on the Swing thread.
809 frame.repaint();
810 return;
811 }
812
813 // Do nothing if nothing happened.
814 if (!dirty) {
815 return;
816 }
817
818 if (frame.bufferStrategy != null) {
819 // See if it is time to flip the blink time.
820 long nowTime = (new Date()).getTime();
821 if (nowTime > frame.blinkMillis + frame.lastBlinkTime) {
822 frame.lastBlinkTime = nowTime;
823 frame.cursorBlinkVisible = !frame.cursorBlinkVisible;
824 }
825
826 Graphics gr = frame.bufferStrategy.getDrawGraphics();
827
828 synchronized (this) {
829 for (int y = 0; y < height; y++) {
830 for (int x = 0; x < width; x++) {
831 Cell lCell = logical[x][y];
832 Cell pCell = physical[x][y];
833
834 int xPixel = x * frame.textWidth + frame.left;
835 int yPixel = y * frame.textHeight + frame.top;
836
837 if (!lCell.equals(pCell)
838 || ((x == cursorX)
839 && (y == cursorY)
840 && cursorVisible)
841 || (lCell.isBlink())
842 ) {
843 frame.drawGlyph(gr, lCell, xPixel, yPixel);
844 physical[x][y].setTo(lCell);
845 }
846 }
847 }
848 frame.drawCursor(gr);
849 } // synchronized (this)
850
851 gr.dispose();
852 frame.bufferStrategy.show();
853 // sync() doesn't seem to help the tearing for me.
854 // Toolkit.getDefaultToolkit().sync();
855 return;
856 }
857
858 // Swing thread version: request a repaint, but limit it to the area
859 // that has changed.
860
861 // Find the minimum-size damaged region.
862 int xMin = frame.getWidth();
863 int xMax = 0;
864 int yMin = frame.getHeight();
865 int yMax = 0;
866
867 synchronized (this) {
868 for (int y = 0; y < height; y++) {
869 for (int x = 0; x < width; x++) {
870 Cell lCell = logical[x][y];
871 Cell pCell = physical[x][y];
872
873 int xPixel = x * frame.textWidth + frame.left;
874 int yPixel = y * frame.textHeight + frame.top;
875
876 if (!lCell.equals(pCell)
877 || ((x == cursorX)
878 && (y == cursorY)
879 && cursorVisible)
880 || lCell.isBlink()
881 ) {
882 if (xPixel < xMin) {
883 xMin = xPixel;
884 }
885 if (xPixel + frame.textWidth > xMax) {
886 xMax = xPixel + frame.textWidth;
887 }
888 if (yPixel < yMin) {
889 yMin = yPixel;
890 }
891 if (yPixel + frame.textHeight > yMax) {
892 yMax = yPixel + frame.textHeight;
893 }
894 }
895 }
896 }
897 }
898 if (xMin + frame.textWidth >= xMax) {
899 xMax += frame.textWidth;
900 }
901 if (yMin + frame.textHeight >= yMax) {
902 yMax += frame.textHeight;
903 }
904
905 // Repaint the desired area
906 /*
907 System.err.printf("REPAINT X %d %d Y %d %d\n", xMin, xMax,
908 yMin, yMax);
909 */
910 if (frame.bufferStrategy != null) {
911 // This path should never be taken, but is left here for
912 // completeness.
913 Graphics gr = frame.bufferStrategy.getDrawGraphics();
914 Rectangle bounds = new Rectangle(xMin, yMin, xMax - xMin,
915 yMax - yMin);
916 gr.setClip(bounds);
917 frame.paint(gr);
918 gr.dispose();
919 frame.bufferStrategy.show();
920 // sync() doesn't seem to help the tearing for me.
921 // Toolkit.getDefaultToolkit().sync();
922 } else {
923 // Repaint on the Swing thread.
924 frame.repaint(xMin, yMin, xMax - xMin, yMax - yMin);
925 }
926 }
927
928 /**
929 * Put the cursor at (x,y).
930 *
931 * @param visible if true, the cursor should be visible
932 * @param x column coordinate to put the cursor on
933 * @param y row coordinate to put the cursor on
934 */
935 @Override
936 public void putCursor(final boolean visible, final int x, final int y) {
937
938 if ((visible == cursorVisible) && ((x == cursorX) && (y == cursorY))) {
939 // See if it is time to flip the blink time.
940 long nowTime = (new Date()).getTime();
941 if (nowTime < frame.blinkMillis + frame.lastBlinkTime) {
942 // Nothing has changed, so don't do anything.
943 return;
944 }
945 }
946
947 if (cursorVisible
948 && (cursorY <= height - 1)
949 && (cursorX <= width - 1)
950 ) {
951 // Make the current cursor position dirty
952 if (physical[cursorX][cursorY].getChar() == 'Q') {
953 physical[cursorX][cursorY].setChar('X');
954 } else {
955 physical[cursorX][cursorY].setChar('Q');
956 }
957 }
958
959 super.putCursor(visible, x, y);
960 }
961
962 /**
963 * Convert pixel column position to text cell column position.
964 *
965 * @param x pixel column position
966 * @return text cell column position
967 */
968 public int textColumn(final int x) {
969 return ((x - frame.left) / frame.textWidth);
970 }
971
972 /**
973 * Convert pixel row position to text cell row position.
974 *
975 * @param y pixel row position
976 * @return text cell row position
977 */
978 public int textRow(final int y) {
979 return ((y - frame.top) / frame.textHeight);
980 }
981
982 /**
983 * Set the window title.
984 *
985 * @param title the new title
986 */
987 public void setTitle(final String title) {
988 frame.setTitle(title);
989 }
990
991 }