6e902195fa59d40a8306fc1f27a713440992c364
[fanfix.git] / SwingTerminal.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 java.awt.BorderLayout;
32 import java.awt.Color;
33 import java.awt.Font;
34 import java.awt.FontMetrics;
35 import java.awt.Graphics2D;
36 import java.awt.Graphics;
37 import java.awt.Insets;
38 import java.awt.Rectangle;
39 import java.awt.event.ComponentEvent;
40 import java.awt.event.ComponentListener;
41 import java.awt.event.KeyEvent;
42 import java.awt.event.KeyListener;
43 import java.awt.event.MouseEvent;
44 import java.awt.event.MouseListener;
45 import java.awt.event.MouseMotionListener;
46 import java.awt.event.MouseWheelEvent;
47 import java.awt.event.MouseWheelListener;
48 import java.awt.event.WindowEvent;
49 import java.awt.event.WindowListener;
50 import java.awt.geom.Rectangle2D;
51 import java.awt.image.BufferedImage;
52 import java.io.InputStream;
53 import java.util.Date;
54 import java.util.HashMap;
55 import java.util.LinkedList;
56 import java.util.List;
57 import javax.swing.JComponent;
58 import javax.swing.JFrame;
59 import javax.swing.SwingUtilities;
60
61 import jexer.TKeypress;
62 import jexer.bits.Cell;
63 import jexer.bits.CellAttributes;
64 import jexer.event.TCommandEvent;
65 import jexer.event.TInputEvent;
66 import jexer.event.TKeypressEvent;
67 import jexer.event.TMouseEvent;
68 import jexer.event.TResizeEvent;
69 import static jexer.TCommand.*;
70 import static jexer.TKeypress.*;
71
72 /**
73 * This Screen backend reads keystrokes and mouse events and draws to either
74 * a Java Swing JFrame (potentially triple-buffered) or a JComponent.
75 *
76 * This class is a bit of an inversion of typical GUI classes. It performs
77 * all of the drawing logic from SwingTerminal (which is not a Swing class),
78 * and uses a SwingComponent wrapper class to call the JFrame or JComponent
79 * methods.
80 */
81 public final class SwingTerminal extends LogicalScreen
82 implements TerminalReader,
83 ComponentListener, KeyListener,
84 MouseListener, MouseMotionListener,
85 MouseWheelListener, WindowListener {
86
87 /**
88 * The Swing component or frame to draw to.
89 */
90 private SwingComponent swing;
91
92 // ------------------------------------------------------------------------
93 // Screen -----------------------------------------------------------------
94 // ------------------------------------------------------------------------
95
96 /**
97 * Cursor style to draw.
98 */
99 public enum CursorStyle {
100 /**
101 * Use an underscore for the cursor.
102 */
103 UNDERLINE,
104
105 /**
106 * Use a solid block for the cursor.
107 */
108 BLOCK,
109
110 /**
111 * Use an outlined block for the cursor.
112 */
113 OUTLINE
114 }
115
116 /**
117 * A cache of previously-rendered glyphs for blinking text, when it is
118 * not visible.
119 */
120 private HashMap<Cell, BufferedImage> glyphCacheBlink;
121
122 /**
123 * A cache of previously-rendered glyphs for non-blinking, or
124 * blinking-and-visible, text.
125 */
126 private HashMap<Cell, BufferedImage> glyphCache;
127
128 // Colors to map DOS colors to AWT colors.
129 private static Color MYBLACK;
130 private static Color MYRED;
131 private static Color MYGREEN;
132 private static Color MYYELLOW;
133 private static Color MYBLUE;
134 private static Color MYMAGENTA;
135 private static Color MYCYAN;
136 private static Color MYWHITE;
137 private static Color MYBOLD_BLACK;
138 private static Color MYBOLD_RED;
139 private static Color MYBOLD_GREEN;
140 private static Color MYBOLD_YELLOW;
141 private static Color MYBOLD_BLUE;
142 private static Color MYBOLD_MAGENTA;
143 private static Color MYBOLD_CYAN;
144 private static Color MYBOLD_WHITE;
145
146 /**
147 * When true, all the MYBLACK, MYRED, etc. colors are set.
148 */
149 private static boolean dosColors = false;
150
151 /**
152 * Setup Swing colors to match DOS color palette.
153 */
154 private static void setDOSColors() {
155 if (dosColors) {
156 return;
157 }
158 MYBLACK = new Color(0x00, 0x00, 0x00);
159 MYRED = new Color(0xa8, 0x00, 0x00);
160 MYGREEN = new Color(0x00, 0xa8, 0x00);
161 MYYELLOW = new Color(0xa8, 0x54, 0x00);
162 MYBLUE = new Color(0x00, 0x00, 0xa8);
163 MYMAGENTA = new Color(0xa8, 0x00, 0xa8);
164 MYCYAN = new Color(0x00, 0xa8, 0xa8);
165 MYWHITE = new Color(0xa8, 0xa8, 0xa8);
166 MYBOLD_BLACK = new Color(0x54, 0x54, 0x54);
167 MYBOLD_RED = new Color(0xfc, 0x54, 0x54);
168 MYBOLD_GREEN = new Color(0x54, 0xfc, 0x54);
169 MYBOLD_YELLOW = new Color(0xfc, 0xfc, 0x54);
170 MYBOLD_BLUE = new Color(0x54, 0x54, 0xfc);
171 MYBOLD_MAGENTA = new Color(0xfc, 0x54, 0xfc);
172 MYBOLD_CYAN = new Color(0x54, 0xfc, 0xfc);
173 MYBOLD_WHITE = new Color(0xfc, 0xfc, 0xfc);
174
175 dosColors = true;
176 }
177
178 /**
179 * The terminus font resource filename.
180 */
181 private static final String FONTFILE = "terminus-ttf-4.39/TerminusTTF-Bold-4.39.ttf";
182
183 /**
184 * If true, we were successful getting Terminus.
185 */
186 private boolean gotTerminus = false;
187
188 /**
189 * If true, we were successful at getting the font dimensions.
190 */
191 private boolean gotFontDimensions = false;
192
193 /**
194 * The currently selected font.
195 */
196 private Font font = null;
197
198 /**
199 * The currently selected font size in points.
200 */
201 private int fontSize = 16;
202
203 /**
204 * Width of a character cell in pixels.
205 */
206 private int textWidth = 1;
207
208 /**
209 * Height of a character cell in pixels.
210 */
211 private int textHeight = 1;
212
213 /**
214 * Descent of a character cell in pixels.
215 */
216 private int maxDescent = 0;
217
218 /**
219 * System-dependent Y adjustment for text in the character cell.
220 */
221 private int textAdjustY = 0;
222
223 /**
224 * System-dependent X adjustment for text in the character cell.
225 */
226 private int textAdjustX = 0;
227
228 /**
229 * Top pixel absolute location.
230 */
231 private int top = 30;
232
233 /**
234 * Left pixel absolute location.
235 */
236 private int left = 30;
237
238 /**
239 * The cursor style to draw.
240 */
241 private CursorStyle cursorStyle = CursorStyle.UNDERLINE;
242
243 /**
244 * The number of millis to wait before switching the blink from
245 * visible to invisible.
246 */
247 private long blinkMillis = 500;
248
249 /**
250 * If true, the cursor should be visible right now based on the blink
251 * time.
252 */
253 private boolean cursorBlinkVisible = true;
254
255 /**
256 * The time that the blink last flipped from visible to invisible or
257 * from invisible to visible.
258 */
259 private long lastBlinkTime = 0;
260
261 /**
262 * Get the font size in points.
263 *
264 * @return font size in points
265 */
266 public int getFontSize() {
267 return fontSize;
268 }
269
270 /**
271 * Set the font size in points.
272 *
273 * @param fontSize font size in points
274 */
275 public void setFontSize(final int fontSize) {
276 this.fontSize = fontSize;
277 Font newFont = font.deriveFont((float) fontSize);
278 setFont(newFont);
279 }
280
281 /**
282 * Set to a new font, and resize the screen to match its dimensions.
283 *
284 * @param font the new font
285 */
286 public void setFont(final Font font) {
287 this.font = font;
288 getFontDimensions();
289 swing.setFont(font);
290 glyphCacheBlink = new HashMap<Cell, BufferedImage>();
291 glyphCache = new HashMap<Cell, BufferedImage>();
292 resizeToScreen();
293 }
294
295 /**
296 * Set the font to Terminus, the best all-around font for both CP437 and
297 * ISO8859-1.
298 */
299 public void getDefaultFont() {
300 try {
301 ClassLoader loader = Thread.currentThread().
302 getContextClassLoader();
303 InputStream in = loader.getResourceAsStream(FONTFILE);
304 Font terminusRoot = Font.createFont(Font.TRUETYPE_FONT, in);
305 Font terminus = terminusRoot.deriveFont(Font.PLAIN, fontSize);
306 gotTerminus = true;
307 font = terminus;
308 } catch (Exception e) {
309 e.printStackTrace();
310 font = new Font(Font.MONOSPACED, Font.PLAIN, fontSize);
311 }
312
313 setFont(font);
314 }
315
316 /**
317 * Convert a CellAttributes foreground color to an Swing Color.
318 *
319 * @param attr the text attributes
320 * @return the Swing Color
321 */
322 private Color attrToForegroundColor(final CellAttributes attr) {
323 if (attr.isBold()) {
324 if (attr.getForeColor().equals(jexer.bits.Color.BLACK)) {
325 return MYBOLD_BLACK;
326 } else if (attr.getForeColor().equals(jexer.bits.Color.RED)) {
327 return MYBOLD_RED;
328 } else if (attr.getForeColor().equals(jexer.bits.Color.BLUE)) {
329 return MYBOLD_BLUE;
330 } else if (attr.getForeColor().equals(jexer.bits.Color.GREEN)) {
331 return MYBOLD_GREEN;
332 } else if (attr.getForeColor().equals(jexer.bits.Color.YELLOW)) {
333 return MYBOLD_YELLOW;
334 } else if (attr.getForeColor().equals(jexer.bits.Color.CYAN)) {
335 return MYBOLD_CYAN;
336 } else if (attr.getForeColor().equals(jexer.bits.Color.MAGENTA)) {
337 return MYBOLD_MAGENTA;
338 } else if (attr.getForeColor().equals(jexer.bits.Color.WHITE)) {
339 return MYBOLD_WHITE;
340 }
341 } else {
342 if (attr.getForeColor().equals(jexer.bits.Color.BLACK)) {
343 return MYBLACK;
344 } else if (attr.getForeColor().equals(jexer.bits.Color.RED)) {
345 return MYRED;
346 } else if (attr.getForeColor().equals(jexer.bits.Color.BLUE)) {
347 return MYBLUE;
348 } else if (attr.getForeColor().equals(jexer.bits.Color.GREEN)) {
349 return MYGREEN;
350 } else if (attr.getForeColor().equals(jexer.bits.Color.YELLOW)) {
351 return MYYELLOW;
352 } else if (attr.getForeColor().equals(jexer.bits.Color.CYAN)) {
353 return MYCYAN;
354 } else if (attr.getForeColor().equals(jexer.bits.Color.MAGENTA)) {
355 return MYMAGENTA;
356 } else if (attr.getForeColor().equals(jexer.bits.Color.WHITE)) {
357 return MYWHITE;
358 }
359 }
360 throw new IllegalArgumentException("Invalid color: " +
361 attr.getForeColor().getValue());
362 }
363
364 /**
365 * Convert a CellAttributes background color to an Swing Color.
366 *
367 * @param attr the text attributes
368 * @return the Swing Color
369 */
370 private Color attrToBackgroundColor(final CellAttributes attr) {
371 if (attr.getBackColor().equals(jexer.bits.Color.BLACK)) {
372 return MYBLACK;
373 } else if (attr.getBackColor().equals(jexer.bits.Color.RED)) {
374 return MYRED;
375 } else if (attr.getBackColor().equals(jexer.bits.Color.BLUE)) {
376 return MYBLUE;
377 } else if (attr.getBackColor().equals(jexer.bits.Color.GREEN)) {
378 return MYGREEN;
379 } else if (attr.getBackColor().equals(jexer.bits.Color.YELLOW)) {
380 return MYYELLOW;
381 } else if (attr.getBackColor().equals(jexer.bits.Color.CYAN)) {
382 return MYCYAN;
383 } else if (attr.getBackColor().equals(jexer.bits.Color.MAGENTA)) {
384 return MYMAGENTA;
385 } else if (attr.getBackColor().equals(jexer.bits.Color.WHITE)) {
386 return MYWHITE;
387 }
388 throw new IllegalArgumentException("Invalid color: " +
389 attr.getBackColor().getValue());
390 }
391
392 /**
393 * Figure out what textAdjustX and textAdjustY should be, based on the
394 * location of a vertical bar (to find textAdjustY) and a horizontal bar
395 * (to find textAdjustX).
396 *
397 * @return true if textAdjustX and textAdjustY were guessed at correctly
398 */
399 private boolean getFontAdjustments() {
400 BufferedImage image = null;
401
402 // What SHOULD happen is that the topmost/leftmost white pixel is at
403 // position (gr2x, gr2y). But it might also be off by a pixel in
404 // either direction.
405
406 Graphics2D gr2 = null;
407 int gr2x = 3;
408 int gr2y = 3;
409 image = new BufferedImage(textWidth * 2, textHeight * 2,
410 BufferedImage.TYPE_INT_ARGB);
411
412 gr2 = image.createGraphics();
413 gr2.setFont(swing.getFont());
414 gr2.setColor(java.awt.Color.BLACK);
415 gr2.fillRect(0, 0, textWidth * 2, textHeight * 2);
416 gr2.setColor(java.awt.Color.WHITE);
417 char [] chars = new char[1];
418 chars[0] = jexer.bits.GraphicsChars.VERTICAL_BAR;
419 gr2.drawChars(chars, 0, 1, gr2x, gr2y + textHeight - maxDescent);
420 gr2.dispose();
421
422 for (int x = 0; x < textWidth; x++) {
423 for (int y = 0; y < textHeight; y++) {
424
425 /*
426 System.err.println("X: " + x + " Y: " + y + " " +
427 image.getRGB(x, y));
428 */
429
430 if ((image.getRGB(x, y) & 0xFFFFFF) != 0) {
431 textAdjustY = (gr2y - y);
432
433 // System.err.println("textAdjustY: " + textAdjustY);
434 x = textWidth;
435 break;
436 }
437 }
438 }
439
440 gr2 = image.createGraphics();
441 gr2.setFont(swing.getFont());
442 gr2.setColor(java.awt.Color.BLACK);
443 gr2.fillRect(0, 0, textWidth * 2, textHeight * 2);
444 gr2.setColor(java.awt.Color.WHITE);
445 chars[0] = jexer.bits.GraphicsChars.SINGLE_BAR;
446 gr2.drawChars(chars, 0, 1, gr2x, gr2y + textHeight - maxDescent);
447 gr2.dispose();
448
449 for (int x = 0; x < textWidth; x++) {
450 for (int y = 0; y < textHeight; y++) {
451
452 /*
453 System.err.println("X: " + x + " Y: " + y + " " +
454 image.getRGB(x, y));
455 */
456
457 if ((image.getRGB(x, y) & 0xFFFFFF) != 0) {
458 textAdjustX = (gr2x - x);
459
460 // System.err.println("textAdjustX: " + textAdjustX);
461 return true;
462 }
463 }
464 }
465
466 // Something weird happened, don't rely on this function.
467 // System.err.println("getFontAdjustments: false");
468 return false;
469 }
470
471 /**
472 * Figure out my font dimensions. This code path works OK for the JFrame
473 * case, and can be called immediately after JFrame creation.
474 */
475 private void getFontDimensions() {
476 swing.setFont(font);
477 Graphics gr = swing.getGraphics();
478 if (gr == null) {
479 return;
480 }
481 getFontDimensions(gr);
482 }
483
484 /**
485 * Figure out my font dimensions. This code path is needed to lazy-load
486 * the information inside paint().
487 *
488 * @param gr Graphics object to use
489 */
490 private void getFontDimensions(final Graphics gr) {
491 swing.setFont(font);
492 FontMetrics fm = gr.getFontMetrics();
493 maxDescent = fm.getMaxDescent();
494 Rectangle2D bounds = fm.getMaxCharBounds(gr);
495 int leading = fm.getLeading();
496 textWidth = (int)Math.round(bounds.getWidth());
497 // textHeight = (int)Math.round(bounds.getHeight()) - maxDescent;
498
499 // This produces the same number, but works better for ugly
500 // monospace.
501 textHeight = fm.getMaxAscent() + maxDescent - leading;
502
503 if (gotTerminus == true) {
504 textHeight++;
505 }
506
507 if (getFontAdjustments() == false) {
508 // We were unable to programmatically determine textAdjustX and
509 // textAdjustY, so try some guesses based on VM vendor.
510 String runtime = System.getProperty("java.runtime.name");
511 if ((runtime != null) && (runtime.contains("Java(TM)"))) {
512 textAdjustY = -1;
513 textAdjustX = 0;
514 }
515 }
516
517 if (sessionInfo != null) {
518 sessionInfo.setTextCellDimensions(textWidth, textHeight);
519 }
520 gotFontDimensions = true;
521 }
522
523 /**
524 * Resize to font dimensions.
525 */
526 public void resizeToScreen() {
527 swing.setDimensions(textWidth * width, textHeight * height);
528 }
529
530 /**
531 * Draw one glyph to the screen.
532 *
533 * @param gr the Swing Graphics context
534 * @param cell the Cell to draw
535 * @param xPixel the x-coordinate to render to. 0 means the
536 * left-most pixel column.
537 * @param yPixel the y-coordinate to render to. 0 means the top-most
538 * pixel row.
539 */
540 private void drawGlyph(final Graphics gr, final Cell cell,
541 final int xPixel, final int yPixel) {
542
543 /*
544 System.err.println("drawGlyph(): " + xPixel + " " + yPixel +
545 " " + cell);
546 */
547
548 BufferedImage image = null;
549 if (cell.isBlink() && !cursorBlinkVisible) {
550 image = glyphCacheBlink.get(cell);
551 } else {
552 image = glyphCache.get(cell);
553 }
554 if (image != null) {
555 if (swing.getFrame() != null) {
556 gr.drawImage(image, xPixel, yPixel, swing.getFrame());
557 } else {
558 gr.drawImage(image, xPixel, yPixel, swing.getComponent());
559 }
560 return;
561 }
562
563 // Generate glyph and draw it.
564 Graphics2D gr2 = null;
565 int gr2x = xPixel;
566 int gr2y = yPixel;
567 if ((SwingComponent.tripleBuffer) && (swing.getFrame() != null)) {
568 image = new BufferedImage(textWidth, textHeight,
569 BufferedImage.TYPE_INT_ARGB);
570 gr2 = image.createGraphics();
571 gr2.setFont(swing.getFont());
572 gr2x = 0;
573 gr2y = 0;
574 } else {
575 gr2 = (Graphics2D) gr;
576 }
577
578 Cell cellColor = new Cell();
579 cellColor.setTo(cell);
580
581 // Check for reverse
582 if (cell.isReverse()) {
583 cellColor.setForeColor(cell.getBackColor());
584 cellColor.setBackColor(cell.getForeColor());
585 }
586
587 // Draw the background rectangle, then the foreground character.
588 gr2.setColor(attrToBackgroundColor(cellColor));
589 gr2.fillRect(gr2x, gr2y, textWidth, textHeight);
590
591 // Handle blink and underline
592 if (!cell.isBlink()
593 || (cell.isBlink() && cursorBlinkVisible)
594 ) {
595 gr2.setColor(attrToForegroundColor(cellColor));
596 char [] chars = new char[1];
597 chars[0] = cell.getChar();
598 gr2.drawChars(chars, 0, 1, gr2x + textAdjustX,
599 gr2y + textHeight - maxDescent + textAdjustY);
600
601 if (cell.isUnderline()) {
602 gr2.fillRect(gr2x, gr2y + textHeight - 2, textWidth, 2);
603 }
604 }
605
606 if ((SwingComponent.tripleBuffer) && (swing.getFrame() != null)) {
607 gr2.dispose();
608
609 // We need a new key that will not be mutated by
610 // invertCell().
611 Cell key = new Cell();
612 key.setTo(cell);
613 if (cell.isBlink() && !cursorBlinkVisible) {
614 glyphCacheBlink.put(key, image);
615 } else {
616 glyphCache.put(key, image);
617 }
618
619 if (swing.getFrame() != null) {
620 gr.drawImage(image, xPixel, yPixel, swing.getFrame());
621 } else {
622 gr.drawImage(image, xPixel, yPixel, swing.getComponent());
623 }
624 }
625
626 }
627
628 /**
629 * Check if the cursor is visible, and if so draw it.
630 *
631 * @param gr the Swing Graphics context
632 */
633 private void drawCursor(final Graphics gr) {
634
635 if (cursorVisible
636 && (cursorY <= height - 1)
637 && (cursorX <= width - 1)
638 && cursorBlinkVisible
639 ) {
640 int xPixel = cursorX * textWidth + left;
641 int yPixel = cursorY * textHeight + top;
642 Cell lCell = logical[cursorX][cursorY];
643 gr.setColor(attrToForegroundColor(lCell));
644 switch (cursorStyle) {
645 default:
646 // Fall through...
647 case UNDERLINE:
648 gr.fillRect(xPixel, yPixel + textHeight - 2, textWidth, 2);
649 break;
650 case BLOCK:
651 gr.fillRect(xPixel, yPixel, textWidth, textHeight);
652 break;
653 case OUTLINE:
654 gr.drawRect(xPixel, yPixel, textWidth - 1, textHeight - 1);
655 break;
656 }
657 }
658 }
659
660 /**
661 * Paint redraws the whole screen.
662 *
663 * @param gr the Swing Graphics context
664 */
665 public void paint(final Graphics gr) {
666
667 if (gotFontDimensions == false) {
668 // Lazy-load the text width/height
669 // System.err.println("calling getFontDimensions...");
670 getFontDimensions(gr);
671 /*
672 System.err.println("textWidth " + textWidth +
673 " textHeight " + textHeight);
674 System.err.println("FONT: " + swing.getFont() + " font " + font);
675 */
676 // resizeToScreen();
677 }
678
679 // See if it is time to flip the blink time.
680 long nowTime = (new Date()).getTime();
681 if (nowTime > blinkMillis + lastBlinkTime) {
682 lastBlinkTime = nowTime;
683 cursorBlinkVisible = !cursorBlinkVisible;
684 }
685
686 int xCellMin = 0;
687 int xCellMax = width;
688 int yCellMin = 0;
689 int yCellMax = height;
690
691 Rectangle bounds = gr.getClipBounds();
692 if (bounds != null) {
693 // Only update what is in the bounds
694 xCellMin = textColumn(bounds.x);
695 xCellMax = textColumn(bounds.x + bounds.width);
696 if (xCellMax > width) {
697 xCellMax = width;
698 }
699 if (xCellMin >= xCellMax) {
700 xCellMin = xCellMax - 2;
701 }
702 if (xCellMin < 0) {
703 xCellMin = 0;
704 }
705 yCellMin = textRow(bounds.y);
706 yCellMax = textRow(bounds.y + bounds.height);
707 if (yCellMax > height) {
708 yCellMax = height;
709 }
710 if (yCellMin >= yCellMax) {
711 yCellMin = yCellMax - 2;
712 }
713 if (yCellMin < 0) {
714 yCellMin = 0;
715 }
716 } else {
717 // We need a total repaint
718 reallyCleared = true;
719 }
720
721 // Prevent updates to the screen's data from the TApplication
722 // threads.
723 synchronized (this) {
724
725 /*
726 System.err.printf("bounds %s X %d %d Y %d %d\n",
727 bounds, xCellMin, xCellMax, yCellMin, yCellMax);
728 */
729
730 for (int y = yCellMin; y < yCellMax; y++) {
731 for (int x = xCellMin; x < xCellMax; x++) {
732
733 int xPixel = x * textWidth + left;
734 int yPixel = y * textHeight + top;
735
736 Cell lCell = logical[x][y];
737 Cell pCell = physical[x][y];
738
739 if (!lCell.equals(pCell)
740 || lCell.isBlink()
741 || reallyCleared
742 || (swing.getFrame() == null)) {
743
744 drawGlyph(gr, lCell, xPixel, yPixel);
745
746 // Physical is always updated
747 physical[x][y].setTo(lCell);
748 }
749 }
750 }
751 drawCursor(gr);
752
753 dirty = false;
754 reallyCleared = false;
755 } // synchronized (this)
756 }
757
758 /**
759 * Restore terminal to normal state.
760 */
761 public void shutdown() {
762 swing.dispose();
763 }
764
765 /**
766 * Push the logical screen to the physical device.
767 */
768 @Override
769 public void flushPhysical() {
770
771 /*
772 System.err.printf("flushPhysical(): reallyCleared %s dirty %s\n",
773 reallyCleared, dirty);
774 */
775
776 // If reallyCleared is set, we have to draw everything.
777 if ((swing.getFrame() != null)
778 && (swing.getBufferStrategy() != null)
779 && (reallyCleared == true)
780 ) {
781 // Triple-buffering: we have to redraw everything on this thread.
782 Graphics gr = swing.getBufferStrategy().getDrawGraphics();
783 swing.paint(gr);
784 gr.dispose();
785 swing.getBufferStrategy().show();
786 // sync() doesn't seem to help the tearing for me.
787 // Toolkit.getDefaultToolkit().sync();
788 return;
789 } else if (((swing.getFrame() != null)
790 && (swing.getBufferStrategy() == null))
791 || (reallyCleared == true)
792 ) {
793 // Repaint everything on the Swing thread.
794 // System.err.println("REPAINT ALL");
795 swing.repaint();
796 return;
797 }
798
799 // Do nothing if nothing happened.
800 if (!dirty) {
801 return;
802 }
803
804 if ((swing.getFrame() != null) && (swing.getBufferStrategy() != null)) {
805 // See if it is time to flip the blink time.
806 long nowTime = (new Date()).getTime();
807 if (nowTime > blinkMillis + lastBlinkTime) {
808 lastBlinkTime = nowTime;
809 cursorBlinkVisible = !cursorBlinkVisible;
810 }
811
812 Graphics gr = swing.getBufferStrategy().getDrawGraphics();
813
814 synchronized (this) {
815 for (int y = 0; y < height; y++) {
816 for (int x = 0; x < width; x++) {
817 Cell lCell = logical[x][y];
818 Cell pCell = physical[x][y];
819
820 int xPixel = x * textWidth + left;
821 int yPixel = y * textHeight + top;
822
823 if (!lCell.equals(pCell)
824 || ((x == cursorX)
825 && (y == cursorY)
826 && cursorVisible)
827 || (lCell.isBlink())
828 ) {
829 drawGlyph(gr, lCell, xPixel, yPixel);
830 physical[x][y].setTo(lCell);
831 }
832 }
833 }
834 drawCursor(gr);
835 } // synchronized (this)
836
837 gr.dispose();
838 swing.getBufferStrategy().show();
839 // sync() doesn't seem to help the tearing for me.
840 // Toolkit.getDefaultToolkit().sync();
841 return;
842 }
843
844 // Swing thread version: request a repaint, but limit it to the area
845 // that has changed.
846
847 // Find the minimum-size damaged region.
848 int xMin = swing.getWidth();
849 int xMax = 0;
850 int yMin = swing.getHeight();
851 int yMax = 0;
852
853 synchronized (this) {
854 for (int y = 0; y < height; y++) {
855 for (int x = 0; x < width; x++) {
856 Cell lCell = logical[x][y];
857 Cell pCell = physical[x][y];
858
859 int xPixel = x * textWidth + left;
860 int yPixel = y * textHeight + top;
861
862 if (!lCell.equals(pCell)
863 || ((x == cursorX)
864 && (y == cursorY)
865 && cursorVisible)
866 || lCell.isBlink()
867 ) {
868 if (xPixel < xMin) {
869 xMin = xPixel;
870 }
871 if (xPixel + textWidth > xMax) {
872 xMax = xPixel + textWidth;
873 }
874 if (yPixel < yMin) {
875 yMin = yPixel;
876 }
877 if (yPixel + textHeight > yMax) {
878 yMax = yPixel + textHeight;
879 }
880 }
881 }
882 }
883 }
884 if (xMin + textWidth >= xMax) {
885 xMax += textWidth;
886 }
887 if (yMin + textHeight >= yMax) {
888 yMax += textHeight;
889 }
890
891 // Repaint the desired area
892 /*
893 System.err.printf("REPAINT X %d %d Y %d %d\n", xMin, xMax,
894 yMin, yMax);
895 */
896
897 if ((swing.getFrame() != null) && (swing.getBufferStrategy() != null)) {
898 // This path should never be taken, but is left here for
899 // completeness.
900 Graphics gr = swing.getBufferStrategy().getDrawGraphics();
901 Rectangle bounds = new Rectangle(xMin, yMin, xMax - xMin,
902 yMax - yMin);
903 gr.setClip(bounds);
904 swing.paint(gr);
905 gr.dispose();
906 swing.getBufferStrategy().show();
907 // sync() doesn't seem to help the tearing for me.
908 // Toolkit.getDefaultToolkit().sync();
909 } else {
910 // Repaint on the Swing thread.
911 swing.repaint(xMin, yMin, xMax - xMin, yMax - yMin);
912 }
913 }
914
915 /**
916 * Put the cursor at (x,y).
917 *
918 * @param visible if true, the cursor should be visible
919 * @param x column coordinate to put the cursor on
920 * @param y row coordinate to put the cursor on
921 */
922 @Override
923 public void putCursor(final boolean visible, final int x, final int y) {
924
925 if ((visible == cursorVisible) && ((x == cursorX) && (y == cursorY))) {
926 // See if it is time to flip the blink time.
927 long nowTime = (new Date()).getTime();
928 if (nowTime < blinkMillis + lastBlinkTime) {
929 // Nothing has changed, so don't do anything.
930 return;
931 }
932 }
933
934 if (cursorVisible
935 && (cursorY <= height - 1)
936 && (cursorX <= width - 1)
937 ) {
938 // Make the current cursor position dirty
939 if (physical[cursorX][cursorY].getChar() == 'Q') {
940 physical[cursorX][cursorY].setChar('X');
941 } else {
942 physical[cursorX][cursorY].setChar('Q');
943 }
944 }
945
946 super.putCursor(visible, x, y);
947 }
948
949 /**
950 * Convert pixel column position to text cell column position.
951 *
952 * @param x pixel column position
953 * @return text cell column position
954 */
955 public int textColumn(final int x) {
956 return ((x - left) / textWidth);
957 }
958
959 /**
960 * Convert pixel row position to text cell row position.
961 *
962 * @param y pixel row position
963 * @return text cell row position
964 */
965 public int textRow(final int y) {
966 return ((y - top) / textHeight);
967 }
968
969 /**
970 * Set the window title.
971 *
972 * @param title the new title
973 */
974 public void setTitle(final String title) {
975 swing.setTitle(title);
976 }
977
978 // ------------------------------------------------------------------------
979 // TerminalReader ---------------------------------------------------------
980 // ------------------------------------------------------------------------
981
982 /**
983 * The session information.
984 */
985 private SwingSessionInfo sessionInfo;
986
987 /**
988 * Getter for sessionInfo.
989 *
990 * @return the SessionInfo
991 */
992 public SessionInfo getSessionInfo() {
993 return sessionInfo;
994 }
995
996 /**
997 * The listening object that run() wakes up on new input.
998 */
999 private Object listener;
1000
1001 /**
1002 * Set listener to a different Object.
1003 *
1004 * @param listener the new listening object that run() wakes up on new
1005 * input
1006 */
1007 public void setListener(final Object listener) {
1008 this.listener = listener;
1009 }
1010
1011 /**
1012 * The event queue, filled up by a thread reading on input.
1013 */
1014 private List<TInputEvent> eventQueue;
1015
1016 /**
1017 * The last reported mouse X position.
1018 */
1019 private int oldMouseX = -1;
1020
1021 /**
1022 * The last reported mouse Y position.
1023 */
1024 private int oldMouseY = -1;
1025
1026 /**
1027 * true if mouse1 was down. Used to report mouse1 on the release event.
1028 */
1029 private boolean mouse1 = false;
1030
1031 /**
1032 * true if mouse2 was down. Used to report mouse2 on the release event.
1033 */
1034 private boolean mouse2 = false;
1035
1036 /**
1037 * true if mouse3 was down. Used to report mouse3 on the release event.
1038 */
1039 private boolean mouse3 = false;
1040
1041 /**
1042 * Public constructor creates a new JFrame to render to.
1043 *
1044 * @param windowWidth the number of text columns to start with
1045 * @param windowHeight the number of text rows to start with
1046 * @param fontSize the size in points. Good values to pick are: 16, 20,
1047 * 22, and 24.
1048 * @param listener the object this backend needs to wake up when new
1049 * input comes in
1050 */
1051 public SwingTerminal(final int windowWidth, final int windowHeight,
1052 final int fontSize, final Object listener) {
1053
1054 this.fontSize = fontSize;
1055
1056 setDOSColors();
1057
1058 // Figure out my cursor style.
1059 String cursorStyleString = System.getProperty(
1060 "jexer.Swing.cursorStyle", "underline").toLowerCase();
1061 if (cursorStyleString.equals("underline")) {
1062 cursorStyle = CursorStyle.UNDERLINE;
1063 } else if (cursorStyleString.equals("outline")) {
1064 cursorStyle = CursorStyle.OUTLINE;
1065 } else if (cursorStyleString.equals("block")) {
1066 cursorStyle = CursorStyle.BLOCK;
1067 }
1068
1069 // Pull the system property for triple buffering.
1070 if (System.getProperty("jexer.Swing.tripleBuffer") != null) {
1071 if (System.getProperty("jexer.Swing.tripleBuffer").equals("true")) {
1072 SwingComponent.tripleBuffer = true;
1073 } else {
1074 SwingComponent.tripleBuffer = false;
1075 }
1076 }
1077
1078 try {
1079 SwingUtilities.invokeAndWait(new Runnable() {
1080 public void run() {
1081
1082 JFrame frame = new JFrame() {
1083
1084 /**
1085 * Serializable version.
1086 */
1087 private static final long serialVersionUID = 1;
1088
1089 /**
1090 * The code that performs the actual drawing.
1091 */
1092 public SwingTerminal screen = null;
1093
1094 /*
1095 * Anonymous class initializer saves the screen
1096 * reference, so that paint() and the like call out
1097 * to SwingTerminal.
1098 */
1099 {
1100 this.screen = SwingTerminal.this;
1101 }
1102
1103 /**
1104 * Update redraws the whole screen.
1105 *
1106 * @param gr the Swing Graphics context
1107 */
1108 @Override
1109 public void update(final Graphics gr) {
1110 // The default update clears the area. Don't do
1111 // that, instead just paint it directly.
1112 paint(gr);
1113 }
1114
1115 /**
1116 * Paint redraws the whole screen.
1117 *
1118 * @param gr the Swing Graphics context
1119 */
1120 @Override
1121 public void paint(final Graphics gr) {
1122 if (screen != null) {
1123 screen.paint(gr);
1124 }
1125 }
1126 };
1127
1128 // Get the Swing component
1129 SwingTerminal.this.swing = new SwingComponent(frame);
1130
1131 // Hang onto top and left for drawing.
1132 Insets insets = SwingTerminal.this.swing.getInsets();
1133 SwingTerminal.this.left = insets.left;
1134 SwingTerminal.this.top = insets.top;
1135
1136 // Load the font so that we can set sessionInfo.
1137 getDefaultFont();
1138
1139 // Get the default cols x rows and set component size
1140 // accordingly.
1141 SwingTerminal.this.sessionInfo =
1142 new SwingSessionInfo(SwingTerminal.this.swing,
1143 SwingTerminal.this.textWidth,
1144 SwingTerminal.this.textHeight,
1145 windowWidth, windowHeight);
1146
1147 SwingTerminal.this.setDimensions(sessionInfo.getWindowWidth(),
1148 sessionInfo.getWindowHeight());
1149
1150 SwingTerminal.this.resizeToScreen();
1151 SwingTerminal.this.swing.setVisible(true);
1152 }
1153 });
1154 } catch (Exception e) {
1155 e.printStackTrace();
1156 }
1157
1158 this.listener = listener;
1159 mouse1 = false;
1160 mouse2 = false;
1161 mouse3 = false;
1162 eventQueue = new LinkedList<TInputEvent>();
1163
1164 // Add listeners to Swing.
1165 swing.addKeyListener(this);
1166 swing.addWindowListener(this);
1167 swing.addComponentListener(this);
1168 swing.addMouseListener(this);
1169 swing.addMouseMotionListener(this);
1170 swing.addMouseWheelListener(this);
1171 }
1172
1173 /**
1174 * Public constructor renders to an existing JComponent.
1175 *
1176 * @param component the Swing component to render to
1177 * @param windowWidth the number of text columns to start with
1178 * @param windowHeight the number of text rows to start with
1179 * @param fontSize the size in points. Good values to pick are: 16, 20,
1180 * 22, and 24.
1181 * @param listener the object this backend needs to wake up when new
1182 * input comes in
1183 */
1184 public SwingTerminal(final JComponent component, final int windowWidth,
1185 final int windowHeight, final int fontSize, final Object listener) {
1186
1187 this.fontSize = fontSize;
1188
1189 setDOSColors();
1190
1191 // Figure out my cursor style.
1192 String cursorStyleString = System.getProperty(
1193 "jexer.Swing.cursorStyle", "underline").toLowerCase();
1194 if (cursorStyleString.equals("underline")) {
1195 cursorStyle = CursorStyle.UNDERLINE;
1196 } else if (cursorStyleString.equals("outline")) {
1197 cursorStyle = CursorStyle.OUTLINE;
1198 } else if (cursorStyleString.equals("block")) {
1199 cursorStyle = CursorStyle.BLOCK;
1200 }
1201
1202 try {
1203 SwingUtilities.invokeAndWait(new Runnable() {
1204 public void run() {
1205
1206 JComponent newComponent = new JComponent() {
1207
1208 /**
1209 * Serializable version.
1210 */
1211 private static final long serialVersionUID = 1;
1212
1213 /**
1214 * The code that performs the actual drawing.
1215 */
1216 public SwingTerminal screen = null;
1217
1218 /*
1219 * Anonymous class initializer saves the screen
1220 * reference, so that paint() and the like call out
1221 * to SwingTerminal.
1222 */
1223 {
1224 this.screen = SwingTerminal.this;
1225 }
1226
1227 /**
1228 * Update redraws the whole screen.
1229 *
1230 * @param gr the Swing Graphics context
1231 */
1232 @Override
1233 public void update(final Graphics gr) {
1234 // The default update clears the area. Don't do
1235 // that, instead just paint it directly.
1236 paint(gr);
1237 }
1238
1239 /**
1240 * Paint redraws the whole screen.
1241 *
1242 * @param gr the Swing Graphics context
1243 */
1244 @Override
1245 public void paint(final Graphics gr) {
1246 if (screen != null) {
1247 screen.paint(gr);
1248 }
1249 }
1250 };
1251 component.setLayout(new BorderLayout());
1252 component.add(newComponent);
1253
1254 // Get the Swing component
1255 SwingTerminal.this.swing = new SwingComponent(component);
1256
1257 // Hang onto top and left for drawing.
1258 Insets insets = SwingTerminal.this.swing.getInsets();
1259 SwingTerminal.this.left = insets.left;
1260 SwingTerminal.this.top = insets.top;
1261
1262 // Load the font so that we can set sessionInfo.
1263 getDefaultFont();
1264
1265 // Get the default cols x rows and set component size
1266 // accordingly.
1267 SwingTerminal.this.sessionInfo =
1268 new SwingSessionInfo(SwingTerminal.this.swing,
1269 SwingTerminal.this.textWidth,
1270 SwingTerminal.this.textHeight);
1271 }
1272 });
1273 } catch (Exception e) {
1274 e.printStackTrace();
1275 }
1276
1277 this.listener = listener;
1278 mouse1 = false;
1279 mouse2 = false;
1280 mouse3 = false;
1281 eventQueue = new LinkedList<TInputEvent>();
1282
1283 // Add listeners to Swing.
1284 swing.addKeyListener(this);
1285 swing.addWindowListener(this);
1286 swing.addComponentListener(this);
1287 swing.addMouseListener(this);
1288 swing.addMouseMotionListener(this);
1289 swing.addMouseWheelListener(this);
1290 }
1291
1292 /**
1293 * Check if there are events in the queue.
1294 *
1295 * @return if true, getEvents() has something to return to the backend
1296 */
1297 public boolean hasEvents() {
1298 synchronized (eventQueue) {
1299 return (eventQueue.size() > 0);
1300 }
1301 }
1302
1303 /**
1304 * Return any events in the IO queue.
1305 *
1306 * @param queue list to append new events to
1307 */
1308 public void getEvents(final List<TInputEvent> queue) {
1309 synchronized (eventQueue) {
1310 if (eventQueue.size() > 0) {
1311 synchronized (queue) {
1312 queue.addAll(eventQueue);
1313 }
1314 eventQueue.clear();
1315 }
1316 }
1317 }
1318
1319 /**
1320 * Restore terminal to normal state.
1321 */
1322 public void closeTerminal() {
1323 shutdown();
1324 }
1325
1326 /**
1327 * Pass Swing keystrokes into the event queue.
1328 *
1329 * @param key keystroke received
1330 */
1331 public void keyReleased(final KeyEvent key) {
1332 // Ignore release events
1333 }
1334
1335 /**
1336 * Pass Swing keystrokes into the event queue.
1337 *
1338 * @param key keystroke received
1339 */
1340 public void keyTyped(final KeyEvent key) {
1341 // Ignore typed events
1342 }
1343
1344 /**
1345 * Pass Swing keystrokes into the event queue.
1346 *
1347 * @param key keystroke received
1348 */
1349 public void keyPressed(final KeyEvent key) {
1350 boolean alt = false;
1351 boolean shift = false;
1352 boolean ctrl = false;
1353 char ch = ' ';
1354 boolean isKey = false;
1355 if (key.isActionKey()) {
1356 isKey = true;
1357 } else {
1358 ch = key.getKeyChar();
1359 }
1360 alt = key.isAltDown();
1361 ctrl = key.isControlDown();
1362 shift = key.isShiftDown();
1363
1364 /*
1365 System.err.printf("Swing Key: %s\n", key);
1366 System.err.printf(" isKey: %s\n", isKey);
1367 System.err.printf(" alt: %s\n", alt);
1368 System.err.printf(" ctrl: %s\n", ctrl);
1369 System.err.printf(" shift: %s\n", shift);
1370 System.err.printf(" ch: %s\n", ch);
1371 */
1372
1373 // Special case: not return the bare modifier presses
1374 switch (key.getKeyCode()) {
1375 case KeyEvent.VK_ALT:
1376 return;
1377 case KeyEvent.VK_ALT_GRAPH:
1378 return;
1379 case KeyEvent.VK_CONTROL:
1380 return;
1381 case KeyEvent.VK_SHIFT:
1382 return;
1383 case KeyEvent.VK_META:
1384 return;
1385 default:
1386 break;
1387 }
1388
1389 TKeypress keypress = null;
1390 if (isKey) {
1391 switch (key.getKeyCode()) {
1392 case KeyEvent.VK_F1:
1393 keypress = new TKeypress(true, TKeypress.F1, ' ',
1394 alt, ctrl, shift);
1395 break;
1396 case KeyEvent.VK_F2:
1397 keypress = new TKeypress(true, TKeypress.F2, ' ',
1398 alt, ctrl, shift);
1399 break;
1400 case KeyEvent.VK_F3:
1401 keypress = new TKeypress(true, TKeypress.F3, ' ',
1402 alt, ctrl, shift);
1403 break;
1404 case KeyEvent.VK_F4:
1405 keypress = new TKeypress(true, TKeypress.F4, ' ',
1406 alt, ctrl, shift);
1407 break;
1408 case KeyEvent.VK_F5:
1409 keypress = new TKeypress(true, TKeypress.F5, ' ',
1410 alt, ctrl, shift);
1411 break;
1412 case KeyEvent.VK_F6:
1413 keypress = new TKeypress(true, TKeypress.F6, ' ',
1414 alt, ctrl, shift);
1415 break;
1416 case KeyEvent.VK_F7:
1417 keypress = new TKeypress(true, TKeypress.F7, ' ',
1418 alt, ctrl, shift);
1419 break;
1420 case KeyEvent.VK_F8:
1421 keypress = new TKeypress(true, TKeypress.F8, ' ',
1422 alt, ctrl, shift);
1423 break;
1424 case KeyEvent.VK_F9:
1425 keypress = new TKeypress(true, TKeypress.F9, ' ',
1426 alt, ctrl, shift);
1427 break;
1428 case KeyEvent.VK_F10:
1429 keypress = new TKeypress(true, TKeypress.F10, ' ',
1430 alt, ctrl, shift);
1431 break;
1432 case KeyEvent.VK_F11:
1433 keypress = new TKeypress(true, TKeypress.F11, ' ',
1434 alt, ctrl, shift);
1435 break;
1436 case KeyEvent.VK_F12:
1437 keypress = new TKeypress(true, TKeypress.F12, ' ',
1438 alt, ctrl, shift);
1439 break;
1440 case KeyEvent.VK_HOME:
1441 keypress = new TKeypress(true, TKeypress.HOME, ' ',
1442 alt, ctrl, shift);
1443 break;
1444 case KeyEvent.VK_END:
1445 keypress = new TKeypress(true, TKeypress.END, ' ',
1446 alt, ctrl, shift);
1447 break;
1448 case KeyEvent.VK_PAGE_UP:
1449 keypress = new TKeypress(true, TKeypress.PGUP, ' ',
1450 alt, ctrl, shift);
1451 break;
1452 case KeyEvent.VK_PAGE_DOWN:
1453 keypress = new TKeypress(true, TKeypress.PGDN, ' ',
1454 alt, ctrl, shift);
1455 break;
1456 case KeyEvent.VK_INSERT:
1457 keypress = new TKeypress(true, TKeypress.INS, ' ',
1458 alt, ctrl, shift);
1459 break;
1460 case KeyEvent.VK_DELETE:
1461 keypress = new TKeypress(true, TKeypress.DEL, ' ',
1462 alt, ctrl, shift);
1463 break;
1464 case KeyEvent.VK_RIGHT:
1465 keypress = new TKeypress(true, TKeypress.RIGHT, ' ',
1466 alt, ctrl, shift);
1467 break;
1468 case KeyEvent.VK_LEFT:
1469 keypress = new TKeypress(true, TKeypress.LEFT, ' ',
1470 alt, ctrl, shift);
1471 break;
1472 case KeyEvent.VK_UP:
1473 keypress = new TKeypress(true, TKeypress.UP, ' ',
1474 alt, ctrl, shift);
1475 break;
1476 case KeyEvent.VK_DOWN:
1477 keypress = new TKeypress(true, TKeypress.DOWN, ' ',
1478 alt, ctrl, shift);
1479 break;
1480 case KeyEvent.VK_TAB:
1481 // Special case: distinguish TAB vs BTAB
1482 if (shift) {
1483 keypress = kbShiftTab;
1484 } else {
1485 keypress = kbTab;
1486 }
1487 break;
1488 case KeyEvent.VK_ENTER:
1489 keypress = new TKeypress(true, TKeypress.ENTER, ' ',
1490 alt, ctrl, shift);
1491 break;
1492 case KeyEvent.VK_ESCAPE:
1493 keypress = new TKeypress(true, TKeypress.ESC, ' ',
1494 alt, ctrl, shift);
1495 break;
1496 case KeyEvent.VK_BACK_SPACE:
1497 // Special case: return it as kbBackspace (Ctrl-H)
1498 keypress = new TKeypress(false, 0, 'H', false, true, false);
1499 break;
1500 default:
1501 // Unsupported, ignore
1502 return;
1503 }
1504 }
1505
1506 if (keypress == null) {
1507 switch (ch) {
1508 case 0x08:
1509 keypress = kbBackspace;
1510 break;
1511 case 0x0A:
1512 keypress = kbEnter;
1513 break;
1514 case 0x1B:
1515 keypress = kbEsc;
1516 break;
1517 case 0x0D:
1518 keypress = kbEnter;
1519 break;
1520 case 0x09:
1521 if (shift) {
1522 keypress = kbShiftTab;
1523 } else {
1524 keypress = kbTab;
1525 }
1526 break;
1527 case 0x7F:
1528 keypress = kbDel;
1529 break;
1530 default:
1531 if (!alt && ctrl && !shift) {
1532 ch = KeyEvent.getKeyText(key.getKeyCode()).charAt(0);
1533 }
1534 // Not a special key, put it together
1535 keypress = new TKeypress(false, 0, ch, alt, ctrl, shift);
1536 }
1537 }
1538
1539 // Save it and we are done.
1540 synchronized (eventQueue) {
1541 eventQueue.add(new TKeypressEvent(keypress));
1542 }
1543 if (listener != null) {
1544 synchronized (listener) {
1545 listener.notifyAll();
1546 }
1547 }
1548 }
1549
1550 /**
1551 * Pass window events into the event queue.
1552 *
1553 * @param event window event received
1554 */
1555 public void windowActivated(final WindowEvent event) {
1556 // Force a total repaint
1557 synchronized (this) {
1558 clearPhysical();
1559 }
1560 }
1561
1562 /**
1563 * Pass window events into the event queue.
1564 *
1565 * @param event window event received
1566 */
1567 public void windowClosed(final WindowEvent event) {
1568 // Ignore
1569 }
1570
1571 /**
1572 * Pass window events into the event queue.
1573 *
1574 * @param event window event received
1575 */
1576 public void windowClosing(final WindowEvent event) {
1577 // Drop a cmAbort and walk away
1578 synchronized (eventQueue) {
1579 eventQueue.add(new TCommandEvent(cmAbort));
1580 }
1581 if (listener != null) {
1582 synchronized (listener) {
1583 listener.notifyAll();
1584 }
1585 }
1586 }
1587
1588 /**
1589 * Pass window events into the event queue.
1590 *
1591 * @param event window event received
1592 */
1593 public void windowDeactivated(final WindowEvent event) {
1594 // Ignore
1595 }
1596
1597 /**
1598 * Pass window events into the event queue.
1599 *
1600 * @param event window event received
1601 */
1602 public void windowDeiconified(final WindowEvent event) {
1603 // Ignore
1604 }
1605
1606 /**
1607 * Pass window events into the event queue.
1608 *
1609 * @param event window event received
1610 */
1611 public void windowIconified(final WindowEvent event) {
1612 // Ignore
1613 }
1614
1615 /**
1616 * Pass window events into the event queue.
1617 *
1618 * @param event window event received
1619 */
1620 public void windowOpened(final WindowEvent event) {
1621 // Ignore
1622 }
1623
1624 /**
1625 * Pass component events into the event queue.
1626 *
1627 * @param event component event received
1628 */
1629 public void componentHidden(final ComponentEvent event) {
1630 // Ignore
1631 }
1632
1633 /**
1634 * Pass component events into the event queue.
1635 *
1636 * @param event component event received
1637 */
1638 public void componentShown(final ComponentEvent event) {
1639 // Ignore
1640 }
1641
1642 /**
1643 * Pass component events into the event queue.
1644 *
1645 * @param event component event received
1646 */
1647 public void componentMoved(final ComponentEvent event) {
1648 // Ignore
1649 }
1650
1651 /**
1652 * Pass component events into the event queue.
1653 *
1654 * @param event component event received
1655 */
1656 public void componentResized(final ComponentEvent event) {
1657 if (gotFontDimensions == false) {
1658 // We are still waiting to get font information. Don't pass a
1659 // resize event up.
1660 // System.err.println("size " + swing.getComponent().getSize());
1661 return;
1662 }
1663
1664 // Drop a new TResizeEvent into the queue
1665 sessionInfo.queryWindowSize();
1666 synchronized (eventQueue) {
1667 TResizeEvent windowResize = new TResizeEvent(TResizeEvent.Type.SCREEN,
1668 sessionInfo.getWindowWidth(), sessionInfo.getWindowHeight());
1669 eventQueue.add(windowResize);
1670 }
1671 if (listener != null) {
1672 synchronized (listener) {
1673 listener.notifyAll();
1674 }
1675 }
1676 }
1677
1678 /**
1679 * Pass mouse events into the event queue.
1680 *
1681 * @param mouse mouse event received
1682 */
1683 public void mouseDragged(final MouseEvent mouse) {
1684 int modifiers = mouse.getModifiersEx();
1685 boolean eventMouse1 = false;
1686 boolean eventMouse2 = false;
1687 boolean eventMouse3 = false;
1688 if ((modifiers & MouseEvent.BUTTON1_DOWN_MASK) != 0) {
1689 eventMouse1 = true;
1690 }
1691 if ((modifiers & MouseEvent.BUTTON2_DOWN_MASK) != 0) {
1692 eventMouse2 = true;
1693 }
1694 if ((modifiers & MouseEvent.BUTTON3_DOWN_MASK) != 0) {
1695 eventMouse3 = true;
1696 }
1697 mouse1 = eventMouse1;
1698 mouse2 = eventMouse2;
1699 mouse3 = eventMouse3;
1700 int x = textColumn(mouse.getX());
1701 int y = textRow(mouse.getY());
1702
1703 TMouseEvent mouseEvent = new TMouseEvent(TMouseEvent.Type.MOUSE_MOTION,
1704 x, y, x, y, mouse1, mouse2, mouse3, false, false);
1705
1706 synchronized (eventQueue) {
1707 eventQueue.add(mouseEvent);
1708 }
1709 if (listener != null) {
1710 synchronized (listener) {
1711 listener.notifyAll();
1712 }
1713 }
1714 }
1715
1716 /**
1717 * Pass mouse events into the event queue.
1718 *
1719 * @param mouse mouse event received
1720 */
1721 public void mouseMoved(final MouseEvent mouse) {
1722 int x = textColumn(mouse.getX());
1723 int y = textRow(mouse.getY());
1724 if ((x == oldMouseX) && (y == oldMouseY)) {
1725 // Bail out, we've moved some pixels but not a whole text cell.
1726 return;
1727 }
1728 oldMouseX = x;
1729 oldMouseY = y;
1730
1731 TMouseEvent mouseEvent = new TMouseEvent(TMouseEvent.Type.MOUSE_MOTION,
1732 x, y, x, y, mouse1, mouse2, mouse3, false, false);
1733
1734 synchronized (eventQueue) {
1735 eventQueue.add(mouseEvent);
1736 }
1737 if (listener != null) {
1738 synchronized (listener) {
1739 listener.notifyAll();
1740 }
1741 }
1742 }
1743
1744 /**
1745 * Pass mouse events into the event queue.
1746 *
1747 * @param mouse mouse event received
1748 */
1749 public void mouseClicked(final MouseEvent mouse) {
1750 // Ignore
1751 }
1752
1753 /**
1754 * Pass mouse events into the event queue.
1755 *
1756 * @param mouse mouse event received
1757 */
1758 public void mouseEntered(final MouseEvent mouse) {
1759 // Ignore
1760 }
1761
1762 /**
1763 * Pass mouse events into the event queue.
1764 *
1765 * @param mouse mouse event received
1766 */
1767 public void mouseExited(final MouseEvent mouse) {
1768 // Ignore
1769 }
1770
1771 /**
1772 * Pass mouse events into the event queue.
1773 *
1774 * @param mouse mouse event received
1775 */
1776 public void mousePressed(final MouseEvent mouse) {
1777 int modifiers = mouse.getModifiersEx();
1778 boolean eventMouse1 = false;
1779 boolean eventMouse2 = false;
1780 boolean eventMouse3 = false;
1781 if ((modifiers & MouseEvent.BUTTON1_DOWN_MASK) != 0) {
1782 eventMouse1 = true;
1783 }
1784 if ((modifiers & MouseEvent.BUTTON2_DOWN_MASK) != 0) {
1785 eventMouse2 = true;
1786 }
1787 if ((modifiers & MouseEvent.BUTTON3_DOWN_MASK) != 0) {
1788 eventMouse3 = true;
1789 }
1790 mouse1 = eventMouse1;
1791 mouse2 = eventMouse2;
1792 mouse3 = eventMouse3;
1793 int x = textColumn(mouse.getX());
1794 int y = textRow(mouse.getY());
1795
1796 TMouseEvent mouseEvent = new TMouseEvent(TMouseEvent.Type.MOUSE_DOWN,
1797 x, y, x, y, mouse1, mouse2, mouse3, false, false);
1798
1799 synchronized (eventQueue) {
1800 eventQueue.add(mouseEvent);
1801 }
1802 if (listener != null) {
1803 synchronized (listener) {
1804 listener.notifyAll();
1805 }
1806 }
1807 }
1808
1809 /**
1810 * Pass mouse events into the event queue.
1811 *
1812 * @param mouse mouse event received
1813 */
1814 public void mouseReleased(final MouseEvent mouse) {
1815 int modifiers = mouse.getModifiersEx();
1816 boolean eventMouse1 = false;
1817 boolean eventMouse2 = false;
1818 boolean eventMouse3 = false;
1819 if ((modifiers & MouseEvent.BUTTON1_DOWN_MASK) != 0) {
1820 eventMouse1 = true;
1821 }
1822 if ((modifiers & MouseEvent.BUTTON2_DOWN_MASK) != 0) {
1823 eventMouse2 = true;
1824 }
1825 if ((modifiers & MouseEvent.BUTTON3_DOWN_MASK) != 0) {
1826 eventMouse3 = true;
1827 }
1828 if (mouse1) {
1829 mouse1 = false;
1830 eventMouse1 = true;
1831 }
1832 if (mouse2) {
1833 mouse2 = false;
1834 eventMouse2 = true;
1835 }
1836 if (mouse3) {
1837 mouse3 = false;
1838 eventMouse3 = true;
1839 }
1840 int x = textColumn(mouse.getX());
1841 int y = textRow(mouse.getY());
1842
1843 TMouseEvent mouseEvent = new TMouseEvent(TMouseEvent.Type.MOUSE_UP,
1844 x, y, x, y, eventMouse1, eventMouse2, eventMouse3, false, false);
1845
1846 synchronized (eventQueue) {
1847 eventQueue.add(mouseEvent);
1848 }
1849 if (listener != null) {
1850 synchronized (listener) {
1851 listener.notifyAll();
1852 }
1853 }
1854 }
1855
1856 /**
1857 * Pass mouse events into the event queue.
1858 *
1859 * @param mouse mouse event received
1860 */
1861 public void mouseWheelMoved(final MouseWheelEvent mouse) {
1862 int modifiers = mouse.getModifiersEx();
1863 boolean eventMouse1 = false;
1864 boolean eventMouse2 = false;
1865 boolean eventMouse3 = false;
1866 boolean mouseWheelUp = false;
1867 boolean mouseWheelDown = false;
1868 if ((modifiers & MouseEvent.BUTTON1_DOWN_MASK) != 0) {
1869 eventMouse1 = true;
1870 }
1871 if ((modifiers & MouseEvent.BUTTON2_DOWN_MASK) != 0) {
1872 eventMouse2 = true;
1873 }
1874 if ((modifiers & MouseEvent.BUTTON3_DOWN_MASK) != 0) {
1875 eventMouse3 = true;
1876 }
1877 mouse1 = eventMouse1;
1878 mouse2 = eventMouse2;
1879 mouse3 = eventMouse3;
1880 int x = textColumn(mouse.getX());
1881 int y = textRow(mouse.getY());
1882 if (mouse.getWheelRotation() > 0) {
1883 mouseWheelDown = true;
1884 }
1885 if (mouse.getWheelRotation() < 0) {
1886 mouseWheelUp = true;
1887 }
1888
1889 TMouseEvent mouseEvent = new TMouseEvent(TMouseEvent.Type.MOUSE_DOWN,
1890 x, y, x, y, mouse1, mouse2, mouse3, mouseWheelUp, mouseWheelDown);
1891
1892 synchronized (eventQueue) {
1893 eventQueue.add(mouseEvent);
1894 }
1895 if (listener != null) {
1896 synchronized (listener) {
1897 listener.notifyAll();
1898 }
1899 }
1900 }
1901
1902 }