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 }