src/jexer/TTerminalWindow.java

   1 /*
   2  * Jexer - Java Text User Interface
   3  *
   4  * The MIT License (MIT)
   5  *
   6  * Copyright (C) 2019 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;
  30
  31 import java.io.IOException;
  32 import java.lang.reflect.Field;
  33 import java.text.MessageFormat;
  34 import java.util.ArrayList;
  35 import java.util.List;
  36 import java.util.Map;
  37 import java.util.ResourceBundle;
  38
  39 import jexer.bits.Cell;
  40 import jexer.bits.CellAttributes;
  41 import jexer.event.TKeypressEvent;
  42 import jexer.event.TMenuEvent;
  43 import jexer.event.TMouseEvent;
  44 import jexer.event.TResizeEvent;
  45 import jexer.menu.TMenu;
  46 import jexer.tterminal.DisplayLine;
  47 import jexer.tterminal.DisplayListener;
  48 import jexer.tterminal.ECMA48;
  49 import static jexer.TKeypress.*;
  50
  51 /**
  52  * TTerminalWindow exposes a ECMA-48 / ANSI X3.64 style terminal in a window.
  53  */
  54 public class TTerminalWindow extends TScrollableWindow
  55                              implements DisplayListener {
  56
  57
  58     /**
  59      * Translated strings.
  60      */
  61     private static final ResourceBundle i18n = ResourceBundle.getBundle(TTerminalWindow.class.getName());
  62
  63     // ------------------------------------------------------------------------
  64     // Variables --------------------------------------------------------------
  65     // ------------------------------------------------------------------------
  66
  67     /**
  68      * The emulator.
  69      */
  70     private ECMA48 emulator;
  71
  72     /**
  73      * The Process created by the shell spawning constructor.
  74      */
  75     private Process shell;
  76
  77     /**
  78      * If true, we are using the ptypipe utility to support dynamic window
  79      * resizing.  ptypipe is available at
  80      * https://gitlab.com/klamonte/ptypipe .
  81      */
  82     private boolean ptypipe = false;
  83
  84     /**
  85      * If true, close the window when the shell exits.
  86      */
  87     private boolean closeOnExit = false;
  88
  89     // ------------------------------------------------------------------------
  90     // Constructors -----------------------------------------------------------
  91     // ------------------------------------------------------------------------
  92
  93     /**
  94      * Public constructor spawns a custom command line.
  95      *
  96      * @param application TApplication that manages this window
  97      * @param x column relative to parent
  98      * @param y row relative to parent
  99      * @param commandLine the command line to execute
 100      */
 101     public TTerminalWindow(final TApplication application, final int x,
 102         final int y, final String commandLine) {
 103
 104         this(application, x, y, RESIZABLE, commandLine.split("\\s+"),
 105             System.getProperty("jexer.TTerminal.closeOnExit",
 106                 "false").equals("true"));
 107     }
 108
 109     /**
 110      * Public constructor spawns a custom command line.
 111      *
 112      * @param application TApplication that manages this window
 113      * @param x column relative to parent
 114      * @param y row relative to parent
 115      * @param commandLine the command line to execute
 116      * @param closeOnExit if true, close the window when the command exits
 117      */
 118     public TTerminalWindow(final TApplication application, final int x,
 119         final int y, final String commandLine, final boolean closeOnExit) {
 120
 121         this(application, x, y, RESIZABLE, commandLine.split("\\s+"),
 122             closeOnExit);
 123     }
 124
 125     /**
 126      * Public constructor spawns a custom command line.
 127      *
 128      * @param application TApplication that manages this window
 129      * @param x column relative to parent
 130      * @param y row relative to parent
 131      * @param flags mask of CENTERED, MODAL, or RESIZABLE
 132      * @param command the command line to execute
 133      */
 134     public TTerminalWindow(final TApplication application, final int x,
 135         final int y, final int flags, final String [] command) {
 136
 137         this(application, x, y, flags, command,
 138             System.getProperty("jexer.TTerminal.closeOnExit",
 139                 "false").equals("true"));
 140     }
 141
 142     /**
 143      * Public constructor spawns a custom command line.
 144      *
 145      * @param application TApplication that manages this window
 146      * @param x column relative to parent
 147      * @param y row relative to parent
 148      * @param flags mask of CENTERED, MODAL, or RESIZABLE
 149      * @param command the command line to execute
 150      * @param closeOnExit if true, close the window when the command exits
 151      */
 152     public TTerminalWindow(final TApplication application, final int x,
 153         final int y, final int flags, final String [] command,
 154         final boolean closeOnExit) {
 155
 156         super(application, i18n.getString("windowTitle"), x, y,
 157             80 + 2, 24 + 2, flags);
 158
 159         this.closeOnExit = closeOnExit;
 160
 161         String [] fullCommand;
 162
 163         // Spawn a shell and pass its I/O to the other constructor.
 164         if ((System.getProperty("jexer.TTerminal.ptypipe") != null)
 165             && (System.getProperty("jexer.TTerminal.ptypipe").
 166                 equals("true"))
 167         ) {
 168             ptypipe = true;
 169             fullCommand = new String[command.length + 1];
 170             fullCommand[0] = "ptypipe";
 171             System.arraycopy(command, 0, fullCommand, 1, command.length);
 172         } else if (System.getProperty("os.name").startsWith("Windows")) {
 173             fullCommand = new String[3];
 174             fullCommand[0] = "cmd";
 175             fullCommand[1] = "/c";
 176             fullCommand[2] = stringArrayToString(command);
 177         } else if (System.getProperty("os.name").startsWith("Mac")) {
 178             fullCommand = new String[6];
 179             fullCommand[0] = "script";
 180             fullCommand[1] = "-q";
 181             fullCommand[2] = "-F";
 182             fullCommand[3] = "/dev/null";
 183             fullCommand[4] = "-c";
 184             fullCommand[5] = stringArrayToString(command);
 185         } else {
 186             // Default: behave like Linux
 187             fullCommand = new String[5];
 188             fullCommand[0] = "script";
 189             fullCommand[1] = "-fqe";
 190             fullCommand[2] = "/dev/null";
 191             fullCommand[3] = "-c";
 192             fullCommand[4] = stringArrayToString(command);
 193         }
 194         spawnShell(fullCommand);
 195     }
 196
 197     /**
 198      * Public constructor spawns a shell.
 199      *
 200      * @param application TApplication that manages this window
 201      * @param x column relative to parent
 202      * @param y row relative to parent
 203      * @param flags mask of CENTERED, MODAL, or RESIZABLE
 204      */
 205     public TTerminalWindow(final TApplication application, final int x,
 206         final int y, final int flags) {
 207
 208         this(application, x, y, flags,
 209             System.getProperty("jexer.TTerminal.closeOnExit",
 210                 "false").equals("true"));
 211
 212     }
 213
 214     /**
 215      * Public constructor spawns a shell.
 216      *
 217      * @param application TApplication that manages this window
 218      * @param x column relative to parent
 219      * @param y row relative to parent
 220      * @param flags mask of CENTERED, MODAL, or RESIZABLE
 221      * @param closeOnExit if true, close the window when the shell exits
 222      */
 223     public TTerminalWindow(final TApplication application, final int x,
 224         final int y, final int flags, final boolean closeOnExit) {
 225
 226         super(application, i18n.getString("windowTitle"), x, y,
 227             80 + 2, 24 + 2, flags);
 228
 229         this.closeOnExit = closeOnExit;
 230
 231         String cmdShellWindows = "cmd.exe";
 232
 233         // You cannot run a login shell in a bare Process interactively, due
 234         // to libc's behavior of buffering when stdin/stdout aren't a tty.
 235         // Use 'script' instead to run a shell in a pty.  And because BSD and
 236         // GNU differ on the '-f' vs '-F' flags, we need two different
 237         // commands.  Lovely.
 238         String cmdShellGNU = "script -fqe /dev/null";
 239         String cmdShellBSD = "script -q -F /dev/null";
 240
 241         // ptypipe is another solution that permits dynamic window resizing.
 242         String cmdShellPtypipe = "ptypipe /bin/bash --login";
 243
 244         // Spawn a shell and pass its I/O to the other constructor.
 245         if ((System.getProperty("jexer.TTerminal.ptypipe") != null)
 246             && (System.getProperty("jexer.TTerminal.ptypipe").
 247                 equals("true"))
 248         ) {
 249             ptypipe = true;
 250             spawnShell(cmdShellPtypipe.split("\\s+"));
 251         } else if (System.getProperty("os.name").startsWith("Windows")) {
 252             spawnShell(cmdShellWindows.split("\\s+"));
 253         } else if (System.getProperty("os.name").startsWith("Mac")) {
 254             spawnShell(cmdShellBSD.split("\\s+"));
 255         } else if (System.getProperty("os.name").startsWith("Linux")) {
 256             spawnShell(cmdShellGNU.split("\\s+"));
 257         } else {
 258             // When all else fails, assume GNU.
 259             spawnShell(cmdShellGNU.split("\\s+"));
 260         }
 261     }
 262
 263     // ------------------------------------------------------------------------
 264     // TScrollableWindow ------------------------------------------------------
 265     // ------------------------------------------------------------------------
 266
 267     /**
 268      * Draw the display buffer.
 269      */
 270     @Override
 271     public void draw() {
 272         // Synchronize against the emulator so we don't stomp on its reader
 273         // thread.
 274         synchronized (emulator) {
 275
 276             // Update the scroll bars
 277             reflowData();
 278
 279             // Draw the box using my superclass
 280             super.draw();
 281
 282             List<DisplayLine> scrollback = emulator.getScrollbackBuffer();
 283             List<DisplayLine> display = emulator.getDisplayBuffer();
 284
 285             // Put together the visible rows
 286             int visibleHeight = getHeight() - 2;
 287             int visibleBottom = scrollback.size() + display.size()
 288                 + getVerticalValue();
 289             assert (visibleBottom >= 0);
 290
 291             List<DisplayLine> preceedingBlankLines = new ArrayList<DisplayLine>();
 292             int visibleTop = visibleBottom - visibleHeight;
 293             if (visibleTop < 0) {
 294                 for (int i = visibleTop; i < 0; i++) {
 295                     preceedingBlankLines.add(emulator.getBlankDisplayLine());
 296                 }
 297                 visibleTop = 0;
 298             }
 299             assert (visibleTop >= 0);
 300
 301             List<DisplayLine> displayLines = new ArrayList<DisplayLine>();
 302             displayLines.addAll(scrollback);
 303             displayLines.addAll(display);
 304
 305             List<DisplayLine> visibleLines = new ArrayList<DisplayLine>();
 306             visibleLines.addAll(preceedingBlankLines);
 307             visibleLines.addAll(displayLines.subList(visibleTop,
 308                     visibleBottom));
 309
 310             visibleHeight -= visibleLines.size();
 311             assert (visibleHeight >= 0);
 312
 313             // Now draw the emulator screen
 314             int row = 1;
 315             for (DisplayLine line: visibleLines) {
 316                 int widthMax = emulator.getWidth();
 317                 if (line.isDoubleWidth()) {
 318                     widthMax /= 2;
 319                 }
 320                 if (widthMax > getWidth() - 2) {
 321                     widthMax = getWidth() - 2;
 322                 }
 323                 for (int i = 0; i < widthMax; i++) {
 324                     Cell ch = line.charAt(i);
 325                     Cell newCell = new Cell();
 326                     newCell.setTo(ch);
 327                     boolean reverse = line.isReverseColor() ^ ch.isReverse();
 328                     newCell.setReverse(false);
 329                     if (reverse) {
 330                         if (ch.getForeColorRGB() < 0) {
 331                             newCell.setBackColor(ch.getForeColor());
 332                             newCell.setBackColorRGB(-1);
 333                         } else {
 334                             newCell.setBackColorRGB(ch.getForeColorRGB());
 335                         }
 336                         if (ch.getBackColorRGB() < 0) {
 337                             newCell.setForeColor(ch.getBackColor());
 338                             newCell.setForeColorRGB(-1);
 339                         } else {
 340                             newCell.setForeColorRGB(ch.getBackColorRGB());
 341                         }
 342                     }
 343                     if (line.isDoubleWidth()) {
 344                         putCharXY((i * 2) + 1, row, newCell);
 345                         putCharXY((i * 2) + 2, row, ' ', newCell);
 346                     } else {
 347                         putCharXY(i + 1, row, newCell);
 348                     }
 349                 }
 350                 row++;
 351                 if (row == getHeight() - 1) {
 352                     // Don't overwrite the box edge
 353                     break;
 354                 }
 355             }
 356             CellAttributes background = new CellAttributes();
 357             // Fill in the blank lines on bottom
 358             for (int i = 0; i < visibleHeight; i++) {
 359                 hLineXY(1, i + row, getWidth() - 2, ' ', background);
 360             }
 361
 362         } // synchronized (emulator)
 363
 364     }
 365
 366     /**
 367      * Handle window close.
 368      */
 369     @Override
 370     public void onClose() {
 371         emulator.close();
 372         if (shell != null) {
 373             terminateShellChildProcess();
 374             shell.destroy();
 375             shell = null;
 376         }
 377     }
 378
 379     /**
 380      * Handle window/screen resize events.
 381      *
 382      * @param resize resize event
 383      */
 384     @Override
 385     public void onResize(final TResizeEvent resize) {
 386
 387         // Synchronize against the emulator so we don't stomp on its reader
 388         // thread.
 389         synchronized (emulator) {
 390
 391             if (resize.getType() == TResizeEvent.Type.WIDGET) {
 392                 // Resize the scroll bars
 393                 reflowData();
 394                 placeScrollbars();
 395
 396                 // Get out of scrollback
 397                 setVerticalValue(0);
 398
 399                 if (ptypipe) {
 400                     emulator.setWidth(getWidth() - 2);
 401                     emulator.setHeight(getHeight() - 2);
 402
 403                     emulator.writeRemote("\033[8;" + (getHeight() - 2) + ";" +
 404                         (getWidth() - 2) + "t");
 405                 }
 406             }
 407             return;
 408
 409         } // synchronized (emulator)
 410     }
 411
 412     /**
 413      * Resize scrollbars for a new width/height.
 414      */
 415     @Override
 416     public void reflowData() {
 417
 418         // Synchronize against the emulator so we don't stomp on its reader
 419         // thread.
 420         synchronized (emulator) {
 421
 422             // Pull cursor information
 423             readEmulatorState();
 424
 425             // Vertical scrollbar
 426             setTopValue(getHeight() - 2
 427                 - (emulator.getScrollbackBuffer().size()
 428                     + emulator.getDisplayBuffer().size()));
 429             setVerticalBigChange(getHeight() - 2);
 430
 431         } // synchronized (emulator)
 432     }
 433
 434     /**
 435      * Handle keystrokes.
 436      *
 437      * @param keypress keystroke event
 438      */
 439     @Override
 440     public void onKeypress(final TKeypressEvent keypress) {
 441
 442         // Scrollback up/down
 443         if (keypress.equals(kbShiftPgUp)
 444             || keypress.equals(kbCtrlPgUp)
 445             || keypress.equals(kbAltPgUp)
 446         ) {
 447             bigVerticalDecrement();
 448             return;
 449         }
 450         if (keypress.equals(kbShiftPgDn)
 451             || keypress.equals(kbCtrlPgDn)
 452             || keypress.equals(kbAltPgDn)
 453         ) {
 454             bigVerticalIncrement();
 455             return;
 456         }
 457
 458         // Synchronize against the emulator so we don't stomp on its reader
 459         // thread.
 460         synchronized (emulator) {
 461             if (emulator.isReading()) {
 462                 // Get out of scrollback
 463                 setVerticalValue(0);
 464                 emulator.keypress(keypress.getKey());
 465
 466                 // UGLY HACK TIME!  cmd.exe needs CRLF, not just CR, so if
 467                 // this is kBEnter then also send kbCtrlJ.
 468                 if (System.getProperty("os.name").startsWith("Windows")) {
 469                     if (keypress.equals(kbEnter)) {
 470                         emulator.keypress(kbCtrlJ);
 471                     }
 472                 }
 473
 474                 readEmulatorState();
 475                 return;
 476             }
 477         }
 478
 479         // Process is closed, honor "normal" TUI keystrokes
 480         super.onKeypress(keypress);
 481     }
 482
 483     /**
 484      * Handle mouse press events.
 485      *
 486      * @param mouse mouse button press event
 487      */
 488     @Override
 489     public void onMouseDown(final TMouseEvent mouse) {
 490         if (inWindowMove || inWindowResize) {
 491             // TWindow needs to deal with this.
 492             super.onMouseDown(mouse);
 493             return;
 494         }
 495
 496         if (mouse.isMouseWheelUp()) {
 497             verticalDecrement();
 498             return;
 499         }
 500         if (mouse.isMouseWheelDown()) {
 501             verticalIncrement();
 502             return;
 503         }
 504         if (mouseOnEmulator(mouse)) {
 505             synchronized (emulator) {
 506                 mouse.setX(mouse.getX() - 1);
 507                 mouse.setY(mouse.getY() - 1);
 508                 emulator.mouse(mouse);
 509                 readEmulatorState();
 510                 return;
 511             }
 512         }
 513
 514         // Emulator didn't consume it, pass it on
 515         super.onMouseDown(mouse);
 516     }
 517
 518     /**
 519      * Handle mouse release events.
 520      *
 521      * @param mouse mouse button release event
 522      */
 523     @Override
 524     public void onMouseUp(final TMouseEvent mouse) {
 525         if (inWindowMove || inWindowResize) {
 526             // TWindow needs to deal with this.
 527             super.onMouseUp(mouse);
 528             return;
 529         }
 530
 531         if (mouseOnEmulator(mouse)) {
 532             synchronized (emulator) {
 533                 mouse.setX(mouse.getX() - 1);
 534                 mouse.setY(mouse.getY() - 1);
 535                 emulator.mouse(mouse);
 536                 readEmulatorState();
 537                 return;
 538             }
 539         }
 540
 541         // Emulator didn't consume it, pass it on
 542         super.onMouseUp(mouse);
 543     }
 544
 545     /**
 546      * Handle mouse motion events.
 547      *
 548      * @param mouse mouse motion event
 549      */
 550     @Override
 551     public void onMouseMotion(final TMouseEvent mouse) {
 552         if (inWindowMove || inWindowResize) {
 553             // TWindow needs to deal with this.
 554             super.onMouseMotion(mouse);
 555             return;
 556         }
 557
 558         if (mouseOnEmulator(mouse)) {
 559             synchronized (emulator) {
 560                 mouse.setX(mouse.getX() - 1);
 561                 mouse.setY(mouse.getY() - 1);
 562                 emulator.mouse(mouse);
 563                 readEmulatorState();
 564                 return;
 565             }
 566         }
 567
 568         // Emulator didn't consume it, pass it on
 569         super.onMouseMotion(mouse);
 570     }
 571
 572     // ------------------------------------------------------------------------
 573     // TTerminalWindow --------------------------------------------------------
 574     // ------------------------------------------------------------------------
 575
 576     /**
 577      * Claim the keystrokes the emulator will need.
 578      */
 579     private void addShortcutKeys() {
 580         addShortcutKeypress(kbCtrlA);
 581         addShortcutKeypress(kbCtrlB);
 582         addShortcutKeypress(kbCtrlC);
 583         addShortcutKeypress(kbCtrlD);
 584         addShortcutKeypress(kbCtrlE);
 585         addShortcutKeypress(kbCtrlF);
 586         addShortcutKeypress(kbCtrlG);
 587         addShortcutKeypress(kbCtrlH);
 588         addShortcutKeypress(kbCtrlU);
 589         addShortcutKeypress(kbCtrlJ);
 590         addShortcutKeypress(kbCtrlK);
 591         addShortcutKeypress(kbCtrlL);
 592         addShortcutKeypress(kbCtrlM);
 593         addShortcutKeypress(kbCtrlN);
 594         addShortcutKeypress(kbCtrlO);
 595         addShortcutKeypress(kbCtrlP);
 596         addShortcutKeypress(kbCtrlQ);
 597         addShortcutKeypress(kbCtrlR);
 598         addShortcutKeypress(kbCtrlS);
 599         addShortcutKeypress(kbCtrlT);
 600         addShortcutKeypress(kbCtrlU);
 601         addShortcutKeypress(kbCtrlV);
 602         addShortcutKeypress(kbCtrlW);
 603         addShortcutKeypress(kbCtrlX);
 604         addShortcutKeypress(kbCtrlY);
 605         addShortcutKeypress(kbCtrlZ);
 606         addShortcutKeypress(kbF1);
 607         addShortcutKeypress(kbF2);
 608         addShortcutKeypress(kbF3);
 609         addShortcutKeypress(kbF4);
 610         addShortcutKeypress(kbF5);
 611         addShortcutKeypress(kbF6);
 612         addShortcutKeypress(kbF7);
 613         addShortcutKeypress(kbF8);
 614         addShortcutKeypress(kbF9);
 615         addShortcutKeypress(kbF10);
 616         addShortcutKeypress(kbF11);
 617         addShortcutKeypress(kbF12);
 618         addShortcutKeypress(kbAltA);
 619         addShortcutKeypress(kbAltB);
 620         addShortcutKeypress(kbAltC);
 621         addShortcutKeypress(kbAltD);
 622         addShortcutKeypress(kbAltE);
 623         addShortcutKeypress(kbAltF);
 624         addShortcutKeypress(kbAltG);
 625         addShortcutKeypress(kbAltH);
 626         addShortcutKeypress(kbAltU);
 627         addShortcutKeypress(kbAltJ);
 628         addShortcutKeypress(kbAltK);
 629         addShortcutKeypress(kbAltL);
 630         addShortcutKeypress(kbAltM);
 631         addShortcutKeypress(kbAltN);
 632         addShortcutKeypress(kbAltO);
 633         addShortcutKeypress(kbAltP);
 634         addShortcutKeypress(kbAltQ);
 635         addShortcutKeypress(kbAltR);
 636         addShortcutKeypress(kbAltS);
 637         addShortcutKeypress(kbAltT);
 638         addShortcutKeypress(kbAltU);
 639         addShortcutKeypress(kbAltV);
 640         addShortcutKeypress(kbAltW);
 641         addShortcutKeypress(kbAltX);
 642         addShortcutKeypress(kbAltY);
 643         addShortcutKeypress(kbAltZ);
 644     }
 645
 646     /**
 647      * Convert a string array to a whitespace-separated string.
 648      *
 649      * @param array the string array
 650      * @return a single string
 651      */
 652     private String stringArrayToString(final String [] array) {
 653         StringBuilder sb = new StringBuilder(array[0].length());
 654         for (int i = 0; i < array.length; i++) {
 655             sb.append(array[i]);
 656             if (i < array.length - 1) {
 657                 sb.append(' ');
 658             }
 659         }
 660         return sb.toString();
 661     }
 662
 663     /**
 664      * Spawn the shell.
 665      *
 666      * @param command the command line to execute
 667      */
 668     private void spawnShell(final String [] command) {
 669
 670         /*
 671         System.err.printf("spawnShell(): '%s'\n",
 672             stringArrayToString(command));
 673         */
 674
 675         vScroller = new TVScroller(this, getWidth() - 2, 0, getHeight() - 2);
 676         setBottomValue(0);
 677
 678         // Assume XTERM
 679         ECMA48.DeviceType deviceType = ECMA48.DeviceType.XTERM;
 680
 681         try {
 682             ProcessBuilder pb = new ProcessBuilder(command);
 683             Map<String, String> env = pb.environment();
 684             env.put("TERM", ECMA48.deviceTypeTerm(deviceType));
 685             env.put("LANG", ECMA48.deviceTypeLang(deviceType, "en"));
 686             env.put("COLUMNS", "80");
 687             env.put("LINES", "24");
 688             pb.redirectErrorStream(true);
 689             shell = pb.start();
 690             emulator = new ECMA48(deviceType, shell.getInputStream(),
 691                 shell.getOutputStream(), this);
 692         } catch (IOException e) {
 693             messageBox(i18n.getString("errorLaunchingShellTitle"),
 694                 MessageFormat.format(i18n.getString("errorLaunchingShellText"),
 695                     e.getMessage()));
 696         }
 697
 698         // Setup the scroll bars
 699         onResize(new TResizeEvent(TResizeEvent.Type.WIDGET, getWidth(),
 700                 getHeight()));
 701
 702         // Claim the keystrokes the emulator will need.
 703         addShortcutKeys();
 704
 705         // Add shortcut text
 706         newStatusBar(i18n.getString("statusBarRunning"));
 707     }
 708
 709     /**
 710      * Terminate the child of the 'script' process used on POSIX.  This may
 711      * or may not work.
 712      */
 713     private void terminateShellChildProcess() {
 714         int pid = -1;
 715         if (shell.getClass().getName().equals("java.lang.UNIXProcess")) {
 716             /* get the PID on unix/linux systems */
 717             try {
 718                 Field field = shell.getClass().getDeclaredField("pid");
 719                 field.setAccessible(true);
 720                 pid = field.getInt(shell);
 721             } catch (Throwable e) {
 722                 // SQUASH, this didn't work.  Just bail out quietly.
 723                 return;
 724             }
 725         }
 726         if (pid != -1) {
 727             // shell.destroy() works successfully at killing this side of
 728             // 'script'.  But we need to make sure the other side (child
 729             // process) is also killed.
 730             String [] cmdKillIt = {
 731                 "pkill", "-P", Integer.toString(pid)
 732             };
 733             try {
 734                 Runtime.getRuntime().exec(cmdKillIt);
 735             } catch (Throwable e) {
 736                 // SQUASH, this didn't work.  Just bail out quietly.
 737                 return;
 738             }
 739         }
 740     }
 741
 742     /**
 743      * Called by emulator when fresh data has come in.
 744      */
 745     public void displayChanged() {
 746         getApplication().postEvent(new TMenuEvent(TMenu.MID_REPAINT));
 747     }
 748
 749     /**
 750      * Function to call to obtain the display width.
 751      *
 752      * @return the number of columns in the display
 753      */
 754     public int getDisplayWidth() {
 755         if (ptypipe) {
 756             return getWidth() - 2;
 757         }
 758         return 80;
 759     }
 760
 761     /**
 762      * Function to call to obtain the display height.
 763      *
 764      * @return the number of rows in the display
 765      */
 766     public int getDisplayHeight() {
 767         if (ptypipe) {
 768             return getHeight() - 2;
 769         }
 770         return 24;
 771     }
 772
 773     /**
 774      * Hook for subclasses to be notified of the shell termination.
 775      */
 776     public void onShellExit() {
 777         if (closeOnExit) {
 778             close();
 779         }
 780         getApplication().postEvent(new TMenuEvent(TMenu.MID_REPAINT));
 781     }
 782
 783     /**
 784      * Copy out variables from the emulator that TTerminal has to expose on
 785      * screen.
 786      */
 787     private void readEmulatorState() {
 788         // Synchronize against the emulator so we don't stomp on its reader
 789         // thread.
 790         synchronized (emulator) {
 791             setHiddenMouse(emulator.hasHiddenMousePointer());
 792
 793             setCursorX(emulator.getCursorX() + 1);
 794             setCursorY(emulator.getCursorY() + 1
 795                 + (getHeight() - 2 - emulator.getHeight())
 796                 - getVerticalValue());
 797             setCursorVisible(emulator.isCursorVisible());
 798             if (getCursorX() > getWidth() - 2) {
 799                 setCursorVisible(false);
 800             }
 801             if ((getCursorY() > getHeight() - 2) || (getCursorY() < 0)) {
 802                 setCursorVisible(false);
 803             }
 804             if (emulator.getScreenTitle().length() > 0) {
 805                 // Only update the title if the shell is still alive
 806                 if (shell != null) {
 807                     setTitle(emulator.getScreenTitle());
 808                 }
 809             }
 810
 811             // Check to see if the shell has died.
 812             if (!emulator.isReading() && (shell != null)) {
 813                 try {
 814                     int rc = shell.exitValue();
 815                     // The emulator exited on its own, all is fine
 816                     setTitle(MessageFormat.format(i18n.
 817                             getString("windowTitleCompleted"), getTitle(), rc));
 818                     shell = null;
 819                     emulator.close();
 820                     clearShortcutKeypresses();
 821                     statusBar.setText(MessageFormat.format(i18n.
 822                             getString("statusBarCompleted"), rc));
 823                     onShellExit();
 824                 } catch (IllegalThreadStateException e) {
 825                     // The emulator thread has exited, but the shell Process
 826                     // hasn't figured that out yet.  Do nothing, we will see
 827                     // this in a future tick.
 828                 }
 829             } else if (emulator.isReading() && (shell != null)) {
 830                 // The shell might be dead, let's check
 831                 try {
 832                     int rc = shell.exitValue();
 833                     // If we got here, the shell died.
 834                     setTitle(MessageFormat.format(i18n.
 835                             getString("windowTitleCompleted"), getTitle(), rc));
 836                     shell = null;
 837                     emulator.close();
 838                     clearShortcutKeypresses();
 839                     statusBar.setText(MessageFormat.format(i18n.
 840                             getString("statusBarCompleted"), rc));
 841                     onShellExit();
 842                 } catch (IllegalThreadStateException e) {
 843                     // The shell is still running, do nothing.
 844                 }
 845             }
 846
 847         } // synchronized (emulator)
 848     }
 849
 850     /**
 851      * Check if a mouse press/release/motion event coordinate is over the
 852      * emulator.
 853      *
 854      * @param mouse a mouse-based event
 855      * @return whether or not the mouse is on the emulator
 856      */
 857     private boolean mouseOnEmulator(final TMouseEvent mouse) {
 858
 859         synchronized (emulator) {
 860             if (!emulator.isReading()) {
 861                 return false;
 862             }
 863         }
 864
 865         if ((mouse.getAbsoluteX() >= getAbsoluteX() + 1)
 866             && (mouse.getAbsoluteX() <  getAbsoluteX() + getWidth() - 1)
 867             && (mouse.getAbsoluteY() >= getAbsoluteY() + 1)
 868             && (mouse.getAbsoluteY() <  getAbsoluteY() + getHeight() - 1)
 869         ) {
 870             return true;
 871         }
 872         return false;
 873     }
 874
 875 }