src/jexer/backend/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      * Reset the blink timer.
 662      */
 663     private void resetBlinkTimer() {
 664         // See if it is time to flip the blink time.
 665         long nowTime = (new Date()).getTime();
 666         lastBlinkTime = nowTime;
 667         cursorBlinkVisible = true;
 668     }
 669
 670     /**
 671      * Paint redraws the whole screen.
 672      *
 673      * @param gr the Swing Graphics context
 674      */
 675     public void paint(final Graphics gr) {
 676
 677         if (gotFontDimensions == false) {
 678             // Lazy-load the text width/height
 679             // System.err.println("calling getFontDimensions...");
 680             getFontDimensions(gr);
 681             /*
 682             System.err.println("textWidth " + textWidth +
 683                 " textHeight " + textHeight);
 684             System.err.println("FONT: " + swing.getFont() + " font " + font);
 685              */
 686             // resizeToScreen();
 687         }
 688
 689         // See if it is time to flip the blink time.
 690         long nowTime = (new Date()).getTime();
 691         if (nowTime > blinkMillis + lastBlinkTime) {
 692             lastBlinkTime = nowTime;
 693             cursorBlinkVisible = !cursorBlinkVisible;
 694         }
 695
 696         int xCellMin = 0;
 697         int xCellMax = width;
 698         int yCellMin = 0;
 699         int yCellMax = height;
 700
 701         Rectangle bounds = gr.getClipBounds();
 702         if (bounds != null) {
 703             // Only update what is in the bounds
 704             xCellMin = textColumn(bounds.x);
 705             xCellMax = textColumn(bounds.x + bounds.width);
 706             if (xCellMax > width) {
 707                 xCellMax = width;
 708             }
 709             if (xCellMin >= xCellMax) {
 710                 xCellMin = xCellMax - 2;
 711             }
 712             if (xCellMin < 0) {
 713                 xCellMin = 0;
 714             }
 715             yCellMin = textRow(bounds.y);
 716             yCellMax = textRow(bounds.y + bounds.height);
 717             if (yCellMax > height) {
 718                 yCellMax = height;
 719             }
 720             if (yCellMin >= yCellMax) {
 721                 yCellMin = yCellMax - 2;
 722             }
 723             if (yCellMin < 0) {
 724                 yCellMin = 0;
 725             }
 726         } else {
 727             // We need a total repaint
 728             reallyCleared = true;
 729         }
 730
 731         // Prevent updates to the screen's data from the TApplication
 732         // threads.
 733         synchronized (this) {
 734
 735             /*
 736             System.err.printf("bounds %s X %d %d Y %d %d\n",
 737                  bounds, xCellMin, xCellMax, yCellMin, yCellMax);
 738             */
 739
 740             for (int y = yCellMin; y < yCellMax; y++) {
 741                 for (int x = xCellMin; x < xCellMax; x++) {
 742
 743                     int xPixel = x * textWidth + left;
 744                     int yPixel = y * textHeight + top;
 745
 746                     Cell lCell = logical[x][y];
 747                     Cell pCell = physical[x][y];
 748
 749                     if (!lCell.equals(pCell)
 750                         || lCell.isBlink()
 751                         || reallyCleared
 752                         || (swing.getFrame() == null)) {
 753
 754                         drawGlyph(gr, lCell, xPixel, yPixel);
 755
 756                         // Physical is always updated
 757                         physical[x][y].setTo(lCell);
 758                     }
 759                 }
 760             }
 761             drawCursor(gr);
 762
 763             dirty = false;
 764             reallyCleared = false;
 765         } // synchronized (this)
 766     }
 767
 768     /**
 769      * Restore terminal to normal state.
 770      */
 771     public void shutdown() {
 772         swing.dispose();
 773     }
 774
 775     /**
 776      * Push the logical screen to the physical device.
 777      */
 778     @Override
 779     public void flushPhysical() {
 780
 781         /*
 782         System.err.printf("flushPhysical(): reallyCleared %s dirty %s\n",
 783             reallyCleared, dirty);
 784         */
 785
 786         // If reallyCleared is set, we have to draw everything.
 787         if ((swing.getFrame() != null)
 788             && (swing.getBufferStrategy() != null)
 789             && (reallyCleared == true)
 790         ) {
 791             // Triple-buffering: we have to redraw everything on this thread.
 792             Graphics gr = swing.getBufferStrategy().getDrawGraphics();
 793             swing.paint(gr);
 794             gr.dispose();
 795             swing.getBufferStrategy().show();
 796             // sync() doesn't seem to help the tearing for me.
 797             // Toolkit.getDefaultToolkit().sync();
 798             return;
 799         } else if (((swing.getFrame() != null)
 800                 && (swing.getBufferStrategy() == null))
 801             || (reallyCleared == true)
 802         ) {
 803             // Repaint everything on the Swing thread.
 804             // System.err.println("REPAINT ALL");
 805             swing.repaint();
 806             return;
 807         }
 808
 809         // Do nothing if nothing happened.
 810         if (!dirty) {
 811             return;
 812         }
 813
 814         if ((swing.getFrame() != null) && (swing.getBufferStrategy() != null)) {
 815             // See if it is time to flip the blink time.
 816             long nowTime = (new Date()).getTime();
 817             if (nowTime > blinkMillis + lastBlinkTime) {
 818                 lastBlinkTime = nowTime;
 819                 cursorBlinkVisible = !cursorBlinkVisible;
 820             }
 821
 822             Graphics gr = swing.getBufferStrategy().getDrawGraphics();
 823
 824             synchronized (this) {
 825                 for (int y = 0; y < height; y++) {
 826                     for (int x = 0; x < width; x++) {
 827                         Cell lCell = logical[x][y];
 828                         Cell pCell = physical[x][y];
 829
 830                         int xPixel = x * textWidth + left;
 831                         int yPixel = y * textHeight + top;
 832
 833                         if (!lCell.equals(pCell)
 834                             || ((x == cursorX)
 835                                 && (y == cursorY)
 836                                 && cursorVisible)
 837                             || (lCell.isBlink())
 838                         ) {
 839                             drawGlyph(gr, lCell, xPixel, yPixel);
 840                             physical[x][y].setTo(lCell);
 841                         }
 842                     }
 843                 }
 844                 drawCursor(gr);
 845             } // synchronized (this)
 846
 847             gr.dispose();
 848             swing.getBufferStrategy().show();
 849             // sync() doesn't seem to help the tearing for me.
 850             // Toolkit.getDefaultToolkit().sync();
 851             return;
 852         }
 853
 854         // Swing thread version: request a repaint, but limit it to the area
 855         // that has changed.
 856
 857         // Find the minimum-size damaged region.
 858         int xMin = swing.getWidth();
 859         int xMax = 0;
 860         int yMin = swing.getHeight();
 861         int yMax = 0;
 862
 863         synchronized (this) {
 864             for (int y = 0; y < height; y++) {
 865                 for (int x = 0; x < width; x++) {
 866                     Cell lCell = logical[x][y];
 867                     Cell pCell = physical[x][y];
 868
 869                     int xPixel = x * textWidth + left;
 870                     int yPixel = y * textHeight + top;
 871
 872                     if (!lCell.equals(pCell)
 873                         || ((x == cursorX)
 874                             && (y == cursorY)
 875                             && cursorVisible)
 876                         || lCell.isBlink()
 877                     ) {
 878                         if (xPixel < xMin) {
 879                             xMin = xPixel;
 880                         }
 881                         if (xPixel + textWidth > xMax) {
 882                             xMax = xPixel + textWidth;
 883                         }
 884                         if (yPixel < yMin) {
 885                             yMin = yPixel;
 886                         }
 887                         if (yPixel + textHeight > yMax) {
 888                             yMax = yPixel + textHeight;
 889                         }
 890                     }
 891                 }
 892             }
 893         }
 894         if (xMin + textWidth >= xMax) {
 895             xMax += textWidth;
 896         }
 897         if (yMin + textHeight >= yMax) {
 898             yMax += textHeight;
 899         }
 900
 901         // Repaint the desired area
 902         /*
 903         System.err.printf("REPAINT X %d %d Y %d %d\n", xMin, xMax,
 904             yMin, yMax);
 905         */
 906
 907         if ((swing.getFrame() != null) && (swing.getBufferStrategy() != null)) {
 908             // This path should never be taken, but is left here for
 909             // completeness.
 910             Graphics gr = swing.getBufferStrategy().getDrawGraphics();
 911             Rectangle bounds = new Rectangle(xMin, yMin, xMax - xMin,
 912                 yMax - yMin);
 913             gr.setClip(bounds);
 914             swing.paint(gr);
 915             gr.dispose();
 916             swing.getBufferStrategy().show();
 917             // sync() doesn't seem to help the tearing for me.
 918             // Toolkit.getDefaultToolkit().sync();
 919         } else {
 920             // Repaint on the Swing thread.
 921             swing.repaint(xMin, yMin, xMax - xMin, yMax - yMin);
 922         }
 923     }
 924
 925     /**
 926      * Put the cursor at (x,y).
 927      *
 928      * @param visible if true, the cursor should be visible
 929      * @param x column coordinate to put the cursor on
 930      * @param y row coordinate to put the cursor on
 931      */
 932     @Override
 933     public void putCursor(final boolean visible, final int x, final int y) {
 934
 935         if ((visible == cursorVisible) && ((x == cursorX) && (y == cursorY))) {
 936             // See if it is time to flip the blink time.
 937             long nowTime = (new Date()).getTime();
 938             if (nowTime < blinkMillis + lastBlinkTime) {
 939                 // Nothing has changed, so don't do anything.
 940                 return;
 941             }
 942         }
 943
 944         if (cursorVisible
 945             && (cursorY <= height - 1)
 946             && (cursorX <= width - 1)
 947         ) {
 948             // Make the current cursor position dirty
 949             if (physical[cursorX][cursorY].getChar() == 'Q') {
 950                 physical[cursorX][cursorY].setChar('X');
 951             } else {
 952                 physical[cursorX][cursorY].setChar('Q');
 953             }
 954         }
 955
 956         super.putCursor(visible, x, y);
 957     }
 958
 959     /**
 960      * Convert pixel column position to text cell column position.
 961      *
 962      * @param x pixel column position
 963      * @return text cell column position
 964      */
 965     public int textColumn(final int x) {
 966         return ((x - left) / textWidth);
 967     }
 968
 969     /**
 970      * Convert pixel row position to text cell row position.
 971      *
 972      * @param y pixel row position
 973      * @return text cell row position
 974      */
 975     public int textRow(final int y) {
 976         return ((y - top) / textHeight);
 977     }
 978
 979     /**
 980      * Set the window title.
 981      *
 982      * @param title the new title
 983      */
 984     public void setTitle(final String title) {
 985         swing.setTitle(title);
 986     }
 987
 988     // ------------------------------------------------------------------------
 989     // TerminalReader ---------------------------------------------------------
 990     // ------------------------------------------------------------------------
 991
 992     /**
 993      * The session information.
 994      */
 995     private SwingSessionInfo sessionInfo;
 996
 997     /**
 998      * Getter for sessionInfo.
 999      *
1000      * @return the SessionInfo
1001      */
1002     public SessionInfo getSessionInfo() {
1003         return sessionInfo;
1004     }
1005
1006     /**
1007      * The listening object that run() wakes up on new input.
1008      */
1009     private Object listener;
1010
1011     /**
1012      * Set listener to a different Object.
1013      *
1014      * @param listener the new listening object that run() wakes up on new
1015      * input
1016      */
1017     public void setListener(final Object listener) {
1018         this.listener = listener;
1019     }
1020
1021     /**
1022      * The event queue, filled up by a thread reading on input.
1023      */
1024     private List<TInputEvent> eventQueue;
1025
1026     /**
1027      * The last reported mouse X position.
1028      */
1029     private int oldMouseX = -1;
1030
1031     /**
1032      * The last reported mouse Y position.
1033      */
1034     private int oldMouseY = -1;
1035
1036     /**
1037      * true if mouse1 was down.  Used to report mouse1 on the release event.
1038      */
1039     private boolean mouse1 = false;
1040
1041     /**
1042      * true if mouse2 was down.  Used to report mouse2 on the release event.
1043      */
1044     private boolean mouse2 = false;
1045
1046     /**
1047      * true if mouse3 was down.  Used to report mouse3 on the release event.
1048      */
1049     private boolean mouse3 = false;
1050
1051     /**
1052      * Public constructor creates a new JFrame to render to.
1053      *
1054      * @param windowWidth the number of text columns to start with
1055      * @param windowHeight the number of text rows to start with
1056      * @param fontSize the size in points.  Good values to pick are: 16, 20,
1057      * 22, and 24.
1058      * @param listener the object this backend needs to wake up when new
1059      * input comes in
1060      */
1061     public SwingTerminal(final int windowWidth, final int windowHeight,
1062         final int fontSize, final Object listener) {
1063
1064         this.fontSize = fontSize;
1065
1066         setDOSColors();
1067
1068         // Figure out my cursor style.
1069         String cursorStyleString = System.getProperty(
1070             "jexer.Swing.cursorStyle", "underline").toLowerCase();
1071         if (cursorStyleString.equals("underline")) {
1072             cursorStyle = CursorStyle.UNDERLINE;
1073         } else if (cursorStyleString.equals("outline")) {
1074             cursorStyle = CursorStyle.OUTLINE;
1075         } else if (cursorStyleString.equals("block")) {
1076             cursorStyle = CursorStyle.BLOCK;
1077         }
1078
1079         // Pull the system property for triple buffering.
1080         if (System.getProperty("jexer.Swing.tripleBuffer") != null) {
1081             if (System.getProperty("jexer.Swing.tripleBuffer").equals("true")) {
1082                 SwingComponent.tripleBuffer = true;
1083             } else {
1084                 SwingComponent.tripleBuffer = false;
1085             }
1086         }
1087
1088         try {
1089             SwingUtilities.invokeAndWait(new Runnable() {
1090                 public void run() {
1091
1092                     JFrame frame = new JFrame() {
1093
1094                         /**
1095                          * Serializable version.
1096                          */
1097                         private static final long serialVersionUID = 1;
1098
1099                         /**
1100                          * The code that performs the actual drawing.
1101                          */
1102                         public SwingTerminal screen = null;
1103
1104                         /*
1105                          * Anonymous class initializer saves the screen
1106                          * reference, so that paint() and the like call out
1107                          * to SwingTerminal.
1108                          */
1109                         {
1110                             this.screen = SwingTerminal.this;
1111                         }
1112
1113                         /**
1114                          * Update redraws the whole screen.
1115                          *
1116                          * @param gr the Swing Graphics context
1117                          */
1118                         @Override
1119                         public void update(final Graphics gr) {
1120                             // The default update clears the area.  Don't do
1121                             // that, instead just paint it directly.
1122                             paint(gr);
1123                         }
1124
1125                         /**
1126                          * Paint redraws the whole screen.
1127                          *
1128                          * @param gr the Swing Graphics context
1129                          */
1130                         @Override
1131                         public void paint(final Graphics gr) {
1132                             if (screen != null) {
1133                                 screen.paint(gr);
1134                             }
1135                         }
1136                     };
1137
1138                     // Get the Swing component
1139                     SwingTerminal.this.swing = new SwingComponent(frame);
1140
1141                     // Hang onto top and left for drawing.
1142                     Insets insets = SwingTerminal.this.swing.getInsets();
1143                     SwingTerminal.this.left = insets.left;
1144                     SwingTerminal.this.top = insets.top;
1145
1146                     // Load the font so that we can set sessionInfo.
1147                     getDefaultFont();
1148
1149                     // Get the default cols x rows and set component size
1150                     // accordingly.
1151                     SwingTerminal.this.sessionInfo =
1152                         new SwingSessionInfo(SwingTerminal.this.swing,
1153                             SwingTerminal.this.textWidth,
1154                             SwingTerminal.this.textHeight,
1155                             windowWidth, windowHeight);
1156
1157                     SwingTerminal.this.setDimensions(sessionInfo.getWindowWidth(),
1158                         sessionInfo.getWindowHeight());
1159
1160                     SwingTerminal.this.resizeToScreen();
1161                     SwingTerminal.this.swing.setVisible(true);
1162                 }
1163             });
1164         } catch (Exception e) {
1165             e.printStackTrace();
1166         }
1167
1168         this.listener    = listener;
1169         mouse1           = false;
1170         mouse2           = false;
1171         mouse3           = false;
1172         eventQueue       = new LinkedList<TInputEvent>();
1173
1174         // Add listeners to Swing.
1175         swing.addKeyListener(this);
1176         swing.addWindowListener(this);
1177         swing.addComponentListener(this);
1178         swing.addMouseListener(this);
1179         swing.addMouseMotionListener(this);
1180         swing.addMouseWheelListener(this);
1181     }
1182
1183     /**
1184      * Public constructor renders to an existing JComponent.
1185      *
1186      * @param component the Swing component to render to
1187      * @param windowWidth the number of text columns to start with
1188      * @param windowHeight the number of text rows to start with
1189      * @param fontSize the size in points.  Good values to pick are: 16, 20,
1190      * 22, and 24.
1191      * @param listener the object this backend needs to wake up when new
1192      * input comes in
1193      */
1194     public SwingTerminal(final JComponent component, final int windowWidth,
1195         final int windowHeight, final int fontSize, final Object listener) {
1196
1197         this.fontSize = fontSize;
1198
1199         setDOSColors();
1200
1201         // Figure out my cursor style.
1202         String cursorStyleString = System.getProperty(
1203             "jexer.Swing.cursorStyle", "underline").toLowerCase();
1204         if (cursorStyleString.equals("underline")) {
1205             cursorStyle = CursorStyle.UNDERLINE;
1206         } else if (cursorStyleString.equals("outline")) {
1207             cursorStyle = CursorStyle.OUTLINE;
1208         } else if (cursorStyleString.equals("block")) {
1209             cursorStyle = CursorStyle.BLOCK;
1210         }
1211
1212         try {
1213             SwingUtilities.invokeAndWait(new Runnable() {
1214                 public void run() {
1215
1216                     JComponent newComponent = new JComponent() {
1217
1218                         /**
1219                          * Serializable version.
1220                          */
1221                         private static final long serialVersionUID = 1;
1222
1223                         /**
1224                          * The code that performs the actual drawing.
1225                          */
1226                         public SwingTerminal screen = null;
1227
1228                         /*
1229                          * Anonymous class initializer saves the screen
1230                          * reference, so that paint() and the like call out
1231                          * to SwingTerminal.
1232                          */
1233                         {
1234                             this.screen = SwingTerminal.this;
1235                         }
1236
1237                         /**
1238                          * Update redraws the whole screen.
1239                          *
1240                          * @param gr the Swing Graphics context
1241                          */
1242                         @Override
1243                         public void update(final Graphics gr) {
1244                             // The default update clears the area.  Don't do
1245                             // that, instead just paint it directly.
1246                             paint(gr);
1247                         }
1248
1249                         /**
1250                          * Paint redraws the whole screen.
1251                          *
1252                          * @param gr the Swing Graphics context
1253                          */
1254                         @Override
1255                         public void paint(final Graphics gr) {
1256                             if (screen != null) {
1257                                 screen.paint(gr);
1258                             }
1259                         }
1260                     };
1261                     component.setLayout(new BorderLayout());
1262                     component.add(newComponent);
1263
1264                     // Get the Swing component
1265                     SwingTerminal.this.swing = new SwingComponent(component);
1266
1267                     // Hang onto top and left for drawing.
1268                     Insets insets = SwingTerminal.this.swing.getInsets();
1269                     SwingTerminal.this.left = insets.left;
1270                     SwingTerminal.this.top = insets.top;
1271
1272                     // Load the font so that we can set sessionInfo.
1273                     getDefaultFont();
1274
1275                     // Get the default cols x rows and set component size
1276                     // accordingly.
1277                     SwingTerminal.this.sessionInfo =
1278                         new SwingSessionInfo(SwingTerminal.this.swing,
1279                             SwingTerminal.this.textWidth,
1280                             SwingTerminal.this.textHeight);
1281                 }
1282             });
1283         } catch (Exception e) {
1284             e.printStackTrace();
1285         }
1286
1287         this.listener    = listener;
1288         mouse1           = false;
1289         mouse2           = false;
1290         mouse3           = false;
1291         eventQueue       = new LinkedList<TInputEvent>();
1292
1293         // Add listeners to Swing.
1294         swing.addKeyListener(this);
1295         swing.addWindowListener(this);
1296         swing.addComponentListener(this);
1297         swing.addMouseListener(this);
1298         swing.addMouseMotionListener(this);
1299         swing.addMouseWheelListener(this);
1300     }
1301
1302     /**
1303      * Check if there are events in the queue.
1304      *
1305      * @return if true, getEvents() has something to return to the backend
1306      */
1307     public boolean hasEvents() {
1308         synchronized (eventQueue) {
1309             return (eventQueue.size() > 0);
1310         }
1311     }
1312
1313     /**
1314      * Return any events in the IO queue.
1315      *
1316      * @param queue list to append new events to
1317      */
1318     public void getEvents(final List<TInputEvent> queue) {
1319         synchronized (eventQueue) {
1320             if (eventQueue.size() > 0) {
1321                 synchronized (queue) {
1322                     queue.addAll(eventQueue);
1323                 }
1324                 eventQueue.clear();
1325             }
1326         }
1327     }
1328
1329     /**
1330      * Restore terminal to normal state.
1331      */
1332     public void closeTerminal() {
1333         shutdown();
1334     }
1335
1336     /**
1337      * Pass Swing keystrokes into the event queue.
1338      *
1339      * @param key keystroke received
1340      */
1341     public void keyReleased(final KeyEvent key) {
1342         // Ignore release events
1343     }
1344
1345     /**
1346      * Pass Swing keystrokes into the event queue.
1347      *
1348      * @param key keystroke received
1349      */
1350     public void keyTyped(final KeyEvent key) {
1351         // Ignore typed events
1352     }
1353
1354     /**
1355      * Pass Swing keystrokes into the event queue.
1356      *
1357      * @param key keystroke received
1358      */
1359     public void keyPressed(final KeyEvent key) {
1360         boolean alt = false;
1361         boolean shift = false;
1362         boolean ctrl = false;
1363         char ch = ' ';
1364         boolean isKey = false;
1365         if (key.isActionKey()) {
1366             isKey = true;
1367         } else {
1368             ch = key.getKeyChar();
1369         }
1370         alt = key.isAltDown();
1371         ctrl = key.isControlDown();
1372         shift = key.isShiftDown();
1373
1374         /*
1375         System.err.printf("Swing Key: %s\n", key);
1376         System.err.printf("   isKey: %s\n", isKey);
1377         System.err.printf("   alt: %s\n", alt);
1378         System.err.printf("   ctrl: %s\n", ctrl);
1379         System.err.printf("   shift: %s\n", shift);
1380         System.err.printf("   ch: %s\n", ch);
1381         */
1382
1383         // Special case: not return the bare modifier presses
1384         switch (key.getKeyCode()) {
1385         case KeyEvent.VK_ALT:
1386             return;
1387         case KeyEvent.VK_ALT_GRAPH:
1388             return;
1389         case KeyEvent.VK_CONTROL:
1390             return;
1391         case KeyEvent.VK_SHIFT:
1392             return;
1393         case KeyEvent.VK_META:
1394             return;
1395         default:
1396             break;
1397         }
1398
1399         TKeypress keypress = null;
1400         if (isKey) {
1401             switch (key.getKeyCode()) {
1402             case KeyEvent.VK_F1:
1403                 keypress = new TKeypress(true, TKeypress.F1, ' ',
1404                     alt, ctrl, shift);
1405                 break;
1406             case KeyEvent.VK_F2:
1407                 keypress = new TKeypress(true, TKeypress.F2, ' ',
1408                     alt, ctrl, shift);
1409                 break;
1410             case KeyEvent.VK_F3:
1411                 keypress = new TKeypress(true, TKeypress.F3, ' ',
1412                     alt, ctrl, shift);
1413                 break;
1414             case KeyEvent.VK_F4:
1415                 keypress = new TKeypress(true, TKeypress.F4, ' ',
1416                     alt, ctrl, shift);
1417                 break;
1418             case KeyEvent.VK_F5:
1419                 keypress = new TKeypress(true, TKeypress.F5, ' ',
1420                     alt, ctrl, shift);
1421                 break;
1422             case KeyEvent.VK_F6:
1423                 keypress = new TKeypress(true, TKeypress.F6, ' ',
1424                     alt, ctrl, shift);
1425                 break;
1426             case KeyEvent.VK_F7:
1427                 keypress = new TKeypress(true, TKeypress.F7, ' ',
1428                     alt, ctrl, shift);
1429                 break;
1430             case KeyEvent.VK_F8:
1431                 keypress = new TKeypress(true, TKeypress.F8, ' ',
1432                     alt, ctrl, shift);
1433                 break;
1434             case KeyEvent.VK_F9:
1435                 keypress = new TKeypress(true, TKeypress.F9, ' ',
1436                     alt, ctrl, shift);
1437                 break;
1438             case KeyEvent.VK_F10:
1439                 keypress = new TKeypress(true, TKeypress.F10, ' ',
1440                     alt, ctrl, shift);
1441                 break;
1442             case KeyEvent.VK_F11:
1443                 keypress = new TKeypress(true, TKeypress.F11, ' ',
1444                     alt, ctrl, shift);
1445                 break;
1446             case KeyEvent.VK_F12:
1447                 keypress = new TKeypress(true, TKeypress.F12, ' ',
1448                     alt, ctrl, shift);
1449                 break;
1450             case KeyEvent.VK_HOME:
1451                 keypress = new TKeypress(true, TKeypress.HOME, ' ',
1452                     alt, ctrl, shift);
1453                 break;
1454             case KeyEvent.VK_END:
1455                 keypress = new TKeypress(true, TKeypress.END, ' ',
1456                     alt, ctrl, shift);
1457                 break;
1458             case KeyEvent.VK_PAGE_UP:
1459                 keypress = new TKeypress(true, TKeypress.PGUP, ' ',
1460                     alt, ctrl, shift);
1461                 break;
1462             case KeyEvent.VK_PAGE_DOWN:
1463                 keypress = new TKeypress(true, TKeypress.PGDN, ' ',
1464                     alt, ctrl, shift);
1465                 break;
1466             case KeyEvent.VK_INSERT:
1467                 keypress = new TKeypress(true, TKeypress.INS, ' ',
1468                     alt, ctrl, shift);
1469                 break;
1470             case KeyEvent.VK_DELETE:
1471                 keypress = new TKeypress(true, TKeypress.DEL, ' ',
1472                     alt, ctrl, shift);
1473                 break;
1474             case KeyEvent.VK_RIGHT:
1475                 keypress = new TKeypress(true, TKeypress.RIGHT, ' ',
1476                     alt, ctrl, shift);
1477                 break;
1478             case KeyEvent.VK_LEFT:
1479                 keypress = new TKeypress(true, TKeypress.LEFT, ' ',
1480                     alt, ctrl, shift);
1481                 break;
1482             case KeyEvent.VK_UP:
1483                 keypress = new TKeypress(true, TKeypress.UP, ' ',
1484                     alt, ctrl, shift);
1485                 break;
1486             case KeyEvent.VK_DOWN:
1487                 keypress = new TKeypress(true, TKeypress.DOWN, ' ',
1488                     alt, ctrl, shift);
1489                 break;
1490             case KeyEvent.VK_TAB:
1491                 // Special case: distinguish TAB vs BTAB
1492                 if (shift) {
1493                     keypress = kbShiftTab;
1494                 } else {
1495                     keypress = kbTab;
1496                 }
1497                 break;
1498             case KeyEvent.VK_ENTER:
1499                 keypress = new TKeypress(true, TKeypress.ENTER, ' ',
1500                     alt, ctrl, shift);
1501                 break;
1502             case KeyEvent.VK_ESCAPE:
1503                 keypress = new TKeypress(true, TKeypress.ESC, ' ',
1504                     alt, ctrl, shift);
1505                 break;
1506             case KeyEvent.VK_BACK_SPACE:
1507                 // Special case: return it as kbBackspace (Ctrl-H)
1508                 keypress = new TKeypress(false, 0, 'H', false, true, false);
1509                 break;
1510             default:
1511                 // Unsupported, ignore
1512                 return;
1513             }
1514         }
1515
1516         if (keypress == null) {
1517             switch (ch) {
1518             case 0x08:
1519                 keypress = kbBackspace;
1520                 break;
1521             case 0x0A:
1522                 keypress = kbEnter;
1523                 break;
1524             case 0x1B:
1525                 keypress = kbEsc;
1526                 break;
1527             case 0x0D:
1528                 keypress = kbEnter;
1529                 break;
1530             case 0x09:
1531                 if (shift) {
1532                     keypress = kbShiftTab;
1533                 } else {
1534                     keypress = kbTab;
1535                 }
1536                 break;
1537             case 0x7F:
1538                 keypress = kbDel;
1539                 break;
1540             default:
1541                 if (!alt && ctrl && !shift) {
1542                     ch = KeyEvent.getKeyText(key.getKeyCode()).charAt(0);
1543                 }
1544                 // Not a special key, put it together
1545                 keypress = new TKeypress(false, 0, ch, alt, ctrl, shift);
1546             }
1547         }
1548
1549         // Save it and we are done.
1550         synchronized (eventQueue) {
1551             eventQueue.add(new TKeypressEvent(keypress));
1552             resetBlinkTimer();
1553         }
1554         if (listener != null) {
1555             synchronized (listener) {
1556                 listener.notifyAll();
1557             }
1558         }
1559     }
1560
1561     /**
1562      * Pass window events into the event queue.
1563      *
1564      * @param event window event received
1565      */
1566     public void windowActivated(final WindowEvent event) {
1567         // Force a total repaint
1568         synchronized (this) {
1569             clearPhysical();
1570         }
1571     }
1572
1573     /**
1574      * Pass window events into the event queue.
1575      *
1576      * @param event window event received
1577      */
1578     public void windowClosed(final WindowEvent event) {
1579         // Ignore
1580     }
1581
1582     /**
1583      * Pass window events into the event queue.
1584      *
1585      * @param event window event received
1586      */
1587     public void windowClosing(final WindowEvent event) {
1588         // Drop a cmAbort and walk away
1589         synchronized (eventQueue) {
1590             eventQueue.add(new TCommandEvent(cmAbort));
1591             resetBlinkTimer();
1592         }
1593         if (listener != null) {
1594             synchronized (listener) {
1595                 listener.notifyAll();
1596             }
1597         }
1598     }
1599
1600     /**
1601      * Pass window events into the event queue.
1602      *
1603      * @param event window event received
1604      */
1605     public void windowDeactivated(final WindowEvent event) {
1606         // Ignore
1607     }
1608
1609     /**
1610      * Pass window events into the event queue.
1611      *
1612      * @param event window event received
1613      */
1614     public void windowDeiconified(final WindowEvent event) {
1615         // Ignore
1616     }
1617
1618     /**
1619      * Pass window events into the event queue.
1620      *
1621      * @param event window event received
1622      */
1623     public void windowIconified(final WindowEvent event) {
1624         // Ignore
1625     }
1626
1627     /**
1628      * Pass window events into the event queue.
1629      *
1630      * @param event window event received
1631      */
1632     public void windowOpened(final WindowEvent event) {
1633         // Ignore
1634     }
1635
1636     /**
1637      * Pass component events into the event queue.
1638      *
1639      * @param event component event received
1640      */
1641     public void componentHidden(final ComponentEvent event) {
1642         // Ignore
1643     }
1644
1645     /**
1646      * Pass component events into the event queue.
1647      *
1648      * @param event component event received
1649      */
1650     public void componentShown(final ComponentEvent event) {
1651         // Ignore
1652     }
1653
1654     /**
1655      * Pass component events into the event queue.
1656      *
1657      * @param event component event received
1658      */
1659     public void componentMoved(final ComponentEvent event) {
1660         // Ignore
1661     }
1662
1663     /**
1664      * Pass component events into the event queue.
1665      *
1666      * @param event component event received
1667      */
1668     public void componentResized(final ComponentEvent event) {
1669         if (gotFontDimensions == false) {
1670             // We are still waiting to get font information.  Don't pass a
1671             // resize event up.
1672             // System.err.println("size " + swing.getComponent().getSize());
1673             return;
1674         }
1675
1676         // Drop a new TResizeEvent into the queue
1677         sessionInfo.queryWindowSize();
1678         synchronized (eventQueue) {
1679             TResizeEvent windowResize = new TResizeEvent(TResizeEvent.Type.SCREEN,
1680                 sessionInfo.getWindowWidth(), sessionInfo.getWindowHeight());
1681             eventQueue.add(windowResize);
1682             resetBlinkTimer();
1683         }
1684         if (listener != null) {
1685             synchronized (listener) {
1686                 listener.notifyAll();
1687             }
1688         }
1689     }
1690
1691     /**
1692      * Pass mouse events into the event queue.
1693      *
1694      * @param mouse mouse event received
1695      */
1696     public void mouseDragged(final MouseEvent mouse) {
1697         int modifiers = mouse.getModifiersEx();
1698         boolean eventMouse1 = false;
1699         boolean eventMouse2 = false;
1700         boolean eventMouse3 = false;
1701         if ((modifiers & MouseEvent.BUTTON1_DOWN_MASK) != 0) {
1702             eventMouse1 = true;
1703         }
1704         if ((modifiers & MouseEvent.BUTTON2_DOWN_MASK) != 0) {
1705             eventMouse2 = true;
1706         }
1707         if ((modifiers & MouseEvent.BUTTON3_DOWN_MASK) != 0) {
1708             eventMouse3 = true;
1709         }
1710         mouse1 = eventMouse1;
1711         mouse2 = eventMouse2;
1712         mouse3 = eventMouse3;
1713         int x = textColumn(mouse.getX());
1714         int y = textRow(mouse.getY());
1715
1716         TMouseEvent mouseEvent = new TMouseEvent(TMouseEvent.Type.MOUSE_MOTION,
1717             x, y, x, y, mouse1, mouse2, mouse3, false, false);
1718
1719         synchronized (eventQueue) {
1720             eventQueue.add(mouseEvent);
1721             resetBlinkTimer();
1722         }
1723         if (listener != null) {
1724             synchronized (listener) {
1725                 listener.notifyAll();
1726             }
1727         }
1728     }
1729
1730     /**
1731      * Pass mouse events into the event queue.
1732      *
1733      * @param mouse mouse event received
1734      */
1735     public void mouseMoved(final MouseEvent mouse) {
1736         int x = textColumn(mouse.getX());
1737         int y = textRow(mouse.getY());
1738         if ((x == oldMouseX) && (y == oldMouseY)) {
1739             // Bail out, we've moved some pixels but not a whole text cell.
1740             return;
1741         }
1742         oldMouseX = x;
1743         oldMouseY = y;
1744
1745         TMouseEvent mouseEvent = new TMouseEvent(TMouseEvent.Type.MOUSE_MOTION,
1746             x, y, x, y, mouse1, mouse2, mouse3, false, false);
1747
1748         synchronized (eventQueue) {
1749             eventQueue.add(mouseEvent);
1750             resetBlinkTimer();
1751         }
1752         if (listener != null) {
1753             synchronized (listener) {
1754                 listener.notifyAll();
1755             }
1756         }
1757     }
1758
1759     /**
1760      * Pass mouse events into the event queue.
1761      *
1762      * @param mouse mouse event received
1763      */
1764     public void mouseClicked(final MouseEvent mouse) {
1765         // Ignore
1766     }
1767
1768     /**
1769      * Pass mouse events into the event queue.
1770      *
1771      * @param mouse mouse event received
1772      */
1773     public void mouseEntered(final MouseEvent mouse) {
1774         // Ignore
1775     }
1776
1777     /**
1778      * Pass mouse events into the event queue.
1779      *
1780      * @param mouse mouse event received
1781      */
1782     public void mouseExited(final MouseEvent mouse) {
1783         // Ignore
1784     }
1785
1786     /**
1787      * Pass mouse events into the event queue.
1788      *
1789      * @param mouse mouse event received
1790      */
1791     public void mousePressed(final MouseEvent mouse) {
1792         int modifiers = mouse.getModifiersEx();
1793         boolean eventMouse1 = false;
1794         boolean eventMouse2 = false;
1795         boolean eventMouse3 = false;
1796         if ((modifiers & MouseEvent.BUTTON1_DOWN_MASK) != 0) {
1797             eventMouse1 = true;
1798         }
1799         if ((modifiers & MouseEvent.BUTTON2_DOWN_MASK) != 0) {
1800             eventMouse2 = true;
1801         }
1802         if ((modifiers & MouseEvent.BUTTON3_DOWN_MASK) != 0) {
1803             eventMouse3 = true;
1804         }
1805         mouse1 = eventMouse1;
1806         mouse2 = eventMouse2;
1807         mouse3 = eventMouse3;
1808         int x = textColumn(mouse.getX());
1809         int y = textRow(mouse.getY());
1810
1811         TMouseEvent mouseEvent = new TMouseEvent(TMouseEvent.Type.MOUSE_DOWN,
1812             x, y, x, y, mouse1, mouse2, mouse3, false, false);
1813
1814         synchronized (eventQueue) {
1815             eventQueue.add(mouseEvent);
1816             resetBlinkTimer();
1817         }
1818         if (listener != null) {
1819             synchronized (listener) {
1820                 listener.notifyAll();
1821             }
1822         }
1823     }
1824
1825     /**
1826      * Pass mouse events into the event queue.
1827      *
1828      * @param mouse mouse event received
1829      */
1830     public void mouseReleased(final MouseEvent mouse) {
1831         int modifiers = mouse.getModifiersEx();
1832         boolean eventMouse1 = false;
1833         boolean eventMouse2 = false;
1834         boolean eventMouse3 = false;
1835         if ((modifiers & MouseEvent.BUTTON1_DOWN_MASK) != 0) {
1836             eventMouse1 = true;
1837         }
1838         if ((modifiers & MouseEvent.BUTTON2_DOWN_MASK) != 0) {
1839             eventMouse2 = true;
1840         }
1841         if ((modifiers & MouseEvent.BUTTON3_DOWN_MASK) != 0) {
1842             eventMouse3 = true;
1843         }
1844         if (mouse1) {
1845             mouse1 = false;
1846             eventMouse1 = true;
1847         }
1848         if (mouse2) {
1849             mouse2 = false;
1850             eventMouse2 = true;
1851         }
1852         if (mouse3) {
1853             mouse3 = false;
1854             eventMouse3 = true;
1855         }
1856         int x = textColumn(mouse.getX());
1857         int y = textRow(mouse.getY());
1858
1859         TMouseEvent mouseEvent = new TMouseEvent(TMouseEvent.Type.MOUSE_UP,
1860             x, y, x, y, eventMouse1, eventMouse2, eventMouse3, false, false);
1861
1862         synchronized (eventQueue) {
1863             eventQueue.add(mouseEvent);
1864             resetBlinkTimer();
1865         }
1866         if (listener != null) {
1867             synchronized (listener) {
1868                 listener.notifyAll();
1869             }
1870         }
1871     }
1872
1873     /**
1874      * Pass mouse events into the event queue.
1875      *
1876      * @param mouse mouse event received
1877      */
1878     public void mouseWheelMoved(final MouseWheelEvent mouse) {
1879         int modifiers = mouse.getModifiersEx();
1880         boolean eventMouse1 = false;
1881         boolean eventMouse2 = false;
1882         boolean eventMouse3 = false;
1883         boolean mouseWheelUp = false;
1884         boolean mouseWheelDown = false;
1885         if ((modifiers & MouseEvent.BUTTON1_DOWN_MASK) != 0) {
1886             eventMouse1 = true;
1887         }
1888         if ((modifiers & MouseEvent.BUTTON2_DOWN_MASK) != 0) {
1889             eventMouse2 = true;
1890         }
1891         if ((modifiers & MouseEvent.BUTTON3_DOWN_MASK) != 0) {
1892             eventMouse3 = true;
1893         }
1894         mouse1 = eventMouse1;
1895         mouse2 = eventMouse2;
1896         mouse3 = eventMouse3;
1897         int x = textColumn(mouse.getX());
1898         int y = textRow(mouse.getY());
1899         if (mouse.getWheelRotation() > 0) {
1900             mouseWheelDown = true;
1901         }
1902         if (mouse.getWheelRotation() < 0) {
1903             mouseWheelUp = true;
1904         }
1905
1906         TMouseEvent mouseEvent = new TMouseEvent(TMouseEvent.Type.MOUSE_DOWN,
1907             x, y, x, y, mouse1, mouse2, mouse3, mouseWheelUp, mouseWheelDown);
1908
1909         synchronized (eventQueue) {
1910             eventQueue.add(mouseEvent);
1911             resetBlinkTimer();
1912         }
1913         if (listener != null) {
1914             synchronized (listener) {
1915                 listener.notifyAll();
1916             }
1917         }
1918     }
1919
1920 }