src/jexer/io/SwingTerminal.java

   1 /**
   2  * Jexer - Java Text User Interface
   3  *
   4  * License: LGPLv3 or later
   5  *
   6  * This module is licensed under the GNU Lesser General Public License
   7  * Version 3.  Please see the file "COPYING" in this directory for more
   8  * information about the GNU Lesser General Public License Version 3.
   9  *
  10  *     Copyright (C) 2015  Kevin Lamonte
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public License
  14  * as published by the Free Software Foundation; either version 3 of
  15  * the License, or (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful, but
  18  * WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with this program; if not, see
  24  * http://www.gnu.org/licenses/, or write to the Free Software
  25  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  26  * 02110-1301 USA
  27  *
  28  * @author Kevin Lamonte [kevin.lamonte@gmail.com]
  29  * @version 1
  30  */
  31 package jexer.io;
  32
  33 import java.awt.event.ComponentEvent;
  34 import java.awt.event.ComponentListener;
  35 import java.awt.event.KeyEvent;
  36 import java.awt.event.KeyListener;
  37 import java.awt.event.MouseEvent;
  38 import java.awt.event.MouseListener;
  39 import java.awt.event.MouseMotionListener;
  40 import java.awt.event.MouseWheelEvent;
  41 import java.awt.event.MouseWheelListener;
  42 import java.awt.event.WindowEvent;
  43 import java.awt.event.WindowListener;
  44 import java.util.List;
  45 import java.util.LinkedList;
  46
  47 import jexer.TKeypress;
  48 import jexer.event.TCommandEvent;
  49 import jexer.event.TInputEvent;
  50 import jexer.event.TKeypressEvent;
  51 import jexer.event.TMouseEvent;
  52 import jexer.event.TResizeEvent;
  53 import jexer.session.SessionInfo;
  54 import jexer.session.SwingSessionInfo;
  55 import static jexer.TCommand.*;
  56 import static jexer.TKeypress.*;
  57
  58 /**
  59  * This class reads keystrokes and mouse events from an Swing JFrame.
  60  */
  61 public final class SwingTerminal implements ComponentListener, KeyListener,
  62                                MouseListener, MouseMotionListener,
  63                                MouseWheelListener, WindowListener {
  64
  65     /**
  66      * The backend Screen.
  67      */
  68     private SwingScreen screen;
  69
  70     /**
  71      * The session information.
  72      */
  73     private SwingSessionInfo sessionInfo;
  74
  75     /**
  76      * Getter for sessionInfo.
  77      *
  78      * @return the SessionInfo
  79      */
  80     public SessionInfo getSessionInfo() {
  81         return sessionInfo;
  82     }
  83
  84     /**
  85      * The listening object that run() wakes up on new input.
  86      */
  87     private Object listener;
  88
  89     /**
  90      * The event queue, filled up by a thread reading on input.
  91      */
  92     private List<TInputEvent> eventQueue;
  93
  94     /**
  95      * The last reported mouse X position.
  96      */
  97     private int oldMouseX = -1;
  98
  99     /**
 100      * The last reported mouse Y position.
 101      */
 102     private int oldMouseY = -1;
 103
 104     /**
 105      * true if mouse1 was down.  Used to report mouse1 on the release event.
 106      */
 107     private boolean mouse1 = false;
 108
 109     /**
 110      * true if mouse2 was down.  Used to report mouse2 on the release event.
 111      */
 112     private boolean mouse2 = false;
 113
 114     /**
 115      * true if mouse3 was down.  Used to report mouse3 on the release event.
 116      */
 117     private boolean mouse3 = false;
 118
 119     /**
 120      * Check if there are events in the queue.
 121      *
 122      * @return if true, getEvents() has something to return to the backend
 123      */
 124     public boolean hasEvents() {
 125         synchronized (eventQueue) {
 126             return (eventQueue.size() > 0);
 127         }
 128     }
 129
 130     /**
 131      * Constructor sets up state for getEvent().
 132      *
 133      * @param listener the object this backend needs to wake up when new
 134      * input comes in
 135      * @param screen the top-level Swing frame
 136      */
 137     public SwingTerminal(final Object listener, final SwingScreen screen) {
 138         this.listener    = listener;
 139         this.screen      = screen;
 140         mouse1           = false;
 141         mouse2           = false;
 142         mouse3           = false;
 143         sessionInfo      = screen.getSessionInfo();
 144         eventQueue       = new LinkedList<TInputEvent>();
 145
 146         screen.frame.addKeyListener(this);
 147         screen.frame.addWindowListener(this);
 148         screen.frame.addComponentListener(this);
 149         screen.frame.addMouseListener(this);
 150         screen.frame.addMouseMotionListener(this);
 151         screen.frame.addMouseWheelListener(this);
 152     }
 153
 154     /**
 155      * Restore terminal to normal state.
 156      */
 157     public void shutdown() {
 158         // System.err.println("=== shutdown() ==="); System.err.flush();
 159         screen.frame.dispose();
 160     }
 161
 162     /**
 163      * Return any events in the IO queue.
 164      *
 165      * @param queue list to append new events to
 166      */
 167     public void getEvents(final List<TInputEvent> queue) {
 168         synchronized (eventQueue) {
 169             if (eventQueue.size() > 0) {
 170                 synchronized (queue) {
 171                     queue.addAll(eventQueue);
 172                 }
 173                 eventQueue.clear();
 174             }
 175         }
 176     }
 177
 178     /**
 179      * Pass Swing keystrokes into the event queue.
 180      *
 181      * @param key keystroke received
 182      */
 183     @Override
 184     public void keyReleased(final KeyEvent key) {
 185         // Ignore release events
 186     }
 187
 188     /**
 189      * Pass Swing keystrokes into the event queue.
 190      *
 191      * @param key keystroke received
 192      */
 193     @Override
 194     public void keyTyped(final KeyEvent key) {
 195         // Ignore typed events
 196     }
 197
 198     /**
 199      * Pass Swing keystrokes into the event queue.
 200      *
 201      * @param key keystroke received
 202      */
 203     @Override
 204     public void keyPressed(final KeyEvent key) {
 205         boolean alt = false;
 206         boolean shift = false;
 207         boolean ctrl = false;
 208         char ch = ' ';
 209         boolean isKey = false;
 210         if (key.isActionKey()) {
 211             isKey = true;
 212         } else {
 213             ch = key.getKeyChar();
 214         }
 215         alt = key.isAltDown();
 216         ctrl = key.isControlDown();
 217         shift = key.isShiftDown();
 218
 219         /*
 220         System.err.printf("Swing Key: %s\n", key);
 221         System.err.printf("   isKey: %s\n", isKey);
 222         System.err.printf("   alt: %s\n", alt);
 223         System.err.printf("   ctrl: %s\n", ctrl);
 224         System.err.printf("   shift: %s\n", shift);
 225         System.err.printf("   ch: %s\n", ch);
 226         */
 227
 228         // Special case: not return the bare modifier presses
 229         switch (key.getKeyCode()) {
 230         case KeyEvent.VK_ALT:
 231             return;
 232         case KeyEvent.VK_ALT_GRAPH:
 233             return;
 234         case KeyEvent.VK_CONTROL:
 235             return;
 236         case KeyEvent.VK_SHIFT:
 237             return;
 238         case KeyEvent.VK_META:
 239             return;
 240         default:
 241             break;
 242         }
 243
 244         TKeypress keypress = null;
 245         if (isKey) {
 246             switch (key.getKeyCode()) {
 247             case KeyEvent.VK_F1:
 248                 keypress = new TKeypress(true, TKeypress.F1, ' ',
 249                     alt, ctrl, shift);
 250                 break;
 251             case KeyEvent.VK_F2:
 252                 keypress = new TKeypress(true, TKeypress.F2, ' ',
 253                     alt, ctrl, shift);
 254                 break;
 255             case KeyEvent.VK_F3:
 256                 keypress = new TKeypress(true, TKeypress.F3, ' ',
 257                     alt, ctrl, shift);
 258                 break;
 259             case KeyEvent.VK_F4:
 260                 keypress = new TKeypress(true, TKeypress.F4, ' ',
 261                     alt, ctrl, shift);
 262                 break;
 263             case KeyEvent.VK_F5:
 264                 keypress = new TKeypress(true, TKeypress.F5, ' ',
 265                     alt, ctrl, shift);
 266                 break;
 267             case KeyEvent.VK_F6:
 268                 keypress = new TKeypress(true, TKeypress.F6, ' ',
 269                     alt, ctrl, shift);
 270                 break;
 271             case KeyEvent.VK_F7:
 272                 keypress = new TKeypress(true, TKeypress.F7, ' ',
 273                     alt, ctrl, shift);
 274                 break;
 275             case KeyEvent.VK_F8:
 276                 keypress = new TKeypress(true, TKeypress.F8, ' ',
 277                     alt, ctrl, shift);
 278                 break;
 279             case KeyEvent.VK_F9:
 280                 keypress = new TKeypress(true, TKeypress.F9, ' ',
 281                     alt, ctrl, shift);
 282                 break;
 283             case KeyEvent.VK_F10:
 284                 keypress = new TKeypress(true, TKeypress.F10, ' ',
 285                     alt, ctrl, shift);
 286                 break;
 287             case KeyEvent.VK_F11:
 288                 keypress = new TKeypress(true, TKeypress.F11, ' ',
 289                     alt, ctrl, shift);
 290                 break;
 291             case KeyEvent.VK_F12:
 292                 keypress = new TKeypress(true, TKeypress.F12, ' ',
 293                     alt, ctrl, shift);
 294                 break;
 295             case KeyEvent.VK_HOME:
 296                 keypress = new TKeypress(true, TKeypress.HOME, ' ',
 297                     alt, ctrl, shift);
 298                 break;
 299             case KeyEvent.VK_END:
 300                 keypress = new TKeypress(true, TKeypress.END, ' ',
 301                     alt, ctrl, shift);
 302                 break;
 303             case KeyEvent.VK_PAGE_UP:
 304                 keypress = new TKeypress(true, TKeypress.PGUP, ' ',
 305                     alt, ctrl, shift);
 306                 break;
 307             case KeyEvent.VK_PAGE_DOWN:
 308                 keypress = new TKeypress(true, TKeypress.PGDN, ' ',
 309                     alt, ctrl, shift);
 310                 break;
 311             case KeyEvent.VK_INSERT:
 312                 keypress = new TKeypress(true, TKeypress.INS, ' ',
 313                     alt, ctrl, shift);
 314                 break;
 315             case KeyEvent.VK_DELETE:
 316                 keypress = new TKeypress(true, TKeypress.DEL, ' ',
 317                     alt, ctrl, shift);
 318                 break;
 319             case KeyEvent.VK_RIGHT:
 320                 keypress = new TKeypress(true, TKeypress.RIGHT, ' ',
 321                     alt, ctrl, shift);
 322                 break;
 323             case KeyEvent.VK_LEFT:
 324                 keypress = new TKeypress(true, TKeypress.LEFT, ' ',
 325                     alt, ctrl, shift);
 326                 break;
 327             case KeyEvent.VK_UP:
 328                 keypress = new TKeypress(true, TKeypress.UP, ' ',
 329                     alt, ctrl, shift);
 330                 break;
 331             case KeyEvent.VK_DOWN:
 332                 keypress = new TKeypress(true, TKeypress.DOWN, ' ',
 333                     alt, ctrl, shift);
 334                 break;
 335             case KeyEvent.VK_TAB:
 336                 // Special case: distinguish TAB vs BTAB
 337                 if (shift) {
 338                     keypress = kbShiftTab;
 339                 } else {
 340                     keypress = kbTab;
 341                 }
 342                 break;
 343             case KeyEvent.VK_ENTER:
 344                 keypress = new TKeypress(true, TKeypress.ENTER, ' ',
 345                     alt, ctrl, shift);
 346                 break;
 347             case KeyEvent.VK_ESCAPE:
 348                 keypress = new TKeypress(true, TKeypress.ESC, ' ',
 349                     alt, ctrl, shift);
 350                 break;
 351             case KeyEvent.VK_BACK_SPACE:
 352                 // Special case: return it as kbBackspace (Ctrl-H)
 353                 keypress = new TKeypress(false, 0, 'H', false, true, false);
 354                 break;
 355             default:
 356                 // Unsupported, ignore
 357                 return;
 358             }
 359         }
 360
 361         if (keypress == null) {
 362             switch (ch) {
 363             case 0x08:
 364                 keypress = kbBackspace;
 365                 break;
 366             case 0x0A:
 367                 keypress = kbEnter;
 368                 break;
 369             case 0x1B:
 370                 keypress = kbEsc;
 371                 break;
 372             case 0x0D:
 373                 keypress = kbEnter;
 374                 break;
 375             case 0x09:
 376                 if (shift) {
 377                     keypress = kbShiftTab;
 378                 } else {
 379                     keypress = kbTab;
 380                 }
 381                 break;
 382             case 0x7F:
 383                 keypress = kbDel;
 384                 break;
 385             default:
 386                 if (!alt && ctrl && !shift) {
 387                     ch = KeyEvent.getKeyText(key.getKeyCode()).charAt(0);
 388                 }
 389                 // Not a special key, put it together
 390                 keypress = new TKeypress(false, 0, ch, alt, ctrl, shift);
 391             }
 392         }
 393
 394         // Save it and we are done.
 395         synchronized (eventQueue) {
 396             eventQueue.add(new TKeypressEvent(keypress));
 397         }
 398         synchronized (listener) {
 399             listener.notifyAll();
 400         }
 401     }
 402
 403     /**
 404      * Pass window events into the event queue.
 405      *
 406      * @param event window event received
 407      */
 408     @Override
 409     public void windowActivated(final WindowEvent event) {
 410         // Force a total repaint
 411         synchronized (screen) {
 412             screen.clearPhysical();
 413         }
 414     }
 415
 416     /**
 417      * Pass window events into the event queue.
 418      *
 419      * @param event window event received
 420      */
 421     @Override
 422     public void windowClosed(final WindowEvent event) {
 423         // Ignore
 424     }
 425
 426     /**
 427      * Pass window events into the event queue.
 428      *
 429      * @param event window event received
 430      */
 431     @Override
 432     public void windowClosing(final WindowEvent event) {
 433         // Drop a cmAbort and walk away
 434         synchronized (eventQueue) {
 435             eventQueue.add(new TCommandEvent(cmAbort));
 436         }
 437         synchronized (listener) {
 438             listener.notifyAll();
 439         }
 440     }
 441
 442     /**
 443      * Pass window events into the event queue.
 444      *
 445      * @param event window event received
 446      */
 447     @Override
 448     public void windowDeactivated(final WindowEvent event) {
 449         // Ignore
 450     }
 451
 452     /**
 453      * Pass window events into the event queue.
 454      *
 455      * @param event window event received
 456      */
 457     @Override
 458     public void windowDeiconified(final WindowEvent event) {
 459         // Ignore
 460     }
 461
 462     /**
 463      * Pass window events into the event queue.
 464      *
 465      * @param event window event received
 466      */
 467     @Override
 468     public void windowIconified(final WindowEvent event) {
 469         // Ignore
 470     }
 471
 472     /**
 473      * Pass window events into the event queue.
 474      *
 475      * @param event window event received
 476      */
 477     @Override
 478     public void windowOpened(final WindowEvent event) {
 479         // Ignore
 480     }
 481
 482     /**
 483      * Pass component events into the event queue.
 484      *
 485      * @param event component event received
 486      */
 487     @Override
 488     public void componentHidden(final ComponentEvent event) {
 489         // Ignore
 490     }
 491
 492     /**
 493      * Pass component events into the event queue.
 494      *
 495      * @param event component event received
 496      */
 497     @Override
 498     public void componentShown(final ComponentEvent event) {
 499         // Ignore
 500     }
 501
 502     /**
 503      * Pass component events into the event queue.
 504      *
 505      * @param event component event received
 506      */
 507     @Override
 508     public void componentMoved(final ComponentEvent event) {
 509         // Ignore
 510     }
 511
 512     /**
 513      * Pass component events into the event queue.
 514      *
 515      * @param event component event received
 516      */
 517     @Override
 518     public void componentResized(final ComponentEvent event) {
 519         // Drop a new TResizeEvent into the queue
 520         sessionInfo.queryWindowSize();
 521         synchronized (eventQueue) {
 522             TResizeEvent windowResize = new TResizeEvent(TResizeEvent.Type.SCREEN,
 523                 sessionInfo.getWindowWidth(), sessionInfo.getWindowHeight());
 524             eventQueue.add(windowResize);
 525         }
 526         synchronized (listener) {
 527             listener.notifyAll();
 528         }
 529     }
 530
 531     /**
 532      * Pass mouse events into the event queue.
 533      *
 534      * @param mouse mouse event received
 535      */
 536     @Override
 537     public void mouseDragged(final MouseEvent mouse) {
 538         int modifiers = mouse.getModifiersEx();
 539         boolean eventMouse1 = false;
 540         boolean eventMouse2 = false;
 541         boolean eventMouse3 = false;
 542         if ((modifiers & MouseEvent.BUTTON1_DOWN_MASK) != 0) {
 543             eventMouse1 = true;
 544         }
 545         if ((modifiers & MouseEvent.BUTTON2_DOWN_MASK) != 0) {
 546             eventMouse2 = true;
 547         }
 548         if ((modifiers & MouseEvent.BUTTON3_DOWN_MASK) != 0) {
 549             eventMouse3 = true;
 550         }
 551         mouse1 = eventMouse1;
 552         mouse2 = eventMouse2;
 553         mouse3 = eventMouse3;
 554         int x = screen.textColumn(mouse.getX());
 555         int y = screen.textRow(mouse.getY());
 556
 557         TMouseEvent mouseEvent = new TMouseEvent(TMouseEvent.Type.MOUSE_MOTION,
 558             x, y, x, y, mouse1, mouse2, mouse3, false, false);
 559
 560         synchronized (eventQueue) {
 561             eventQueue.add(mouseEvent);
 562         }
 563         synchronized (listener) {
 564             listener.notifyAll();
 565         }
 566     }
 567
 568     /**
 569      * Pass mouse events into the event queue.
 570      *
 571      * @param mouse mouse event received
 572      */
 573     @Override
 574     public void mouseMoved(final MouseEvent mouse) {
 575         int x = screen.textColumn(mouse.getX());
 576         int y = screen.textRow(mouse.getY());
 577         if ((x == oldMouseX) && (y == oldMouseY)) {
 578             // Bail out, we've moved some pixels but not a whole text cell.
 579             return;
 580         }
 581         oldMouseX = x;
 582         oldMouseY = y;
 583
 584         TMouseEvent mouseEvent = new TMouseEvent(TMouseEvent.Type.MOUSE_MOTION,
 585             x, y, x, y, mouse1, mouse2, mouse3, false, false);
 586
 587         synchronized (eventQueue) {
 588             eventQueue.add(mouseEvent);
 589         }
 590         synchronized (listener) {
 591             listener.notifyAll();
 592         }
 593     }
 594
 595     /**
 596      * Pass mouse events into the event queue.
 597      *
 598      * @param mouse mouse event received
 599      */
 600     @Override
 601     public void mouseClicked(final MouseEvent mouse) {
 602         // Ignore
 603     }
 604
 605     /**
 606      * Pass mouse events into the event queue.
 607      *
 608      * @param mouse mouse event received
 609      */
 610     @Override
 611     public void mouseEntered(final MouseEvent mouse) {
 612         // Ignore
 613     }
 614
 615     /**
 616      * Pass mouse events into the event queue.
 617      *
 618      * @param mouse mouse event received
 619      */
 620     @Override
 621     public void mouseExited(final MouseEvent mouse) {
 622         // Ignore
 623     }
 624
 625     /**
 626      * Pass mouse events into the event queue.
 627      *
 628      * @param mouse mouse event received
 629      */
 630     @Override
 631     public void mousePressed(final MouseEvent mouse) {
 632         int modifiers = mouse.getModifiersEx();
 633         boolean eventMouse1 = false;
 634         boolean eventMouse2 = false;
 635         boolean eventMouse3 = false;
 636         if ((modifiers & MouseEvent.BUTTON1_DOWN_MASK) != 0) {
 637             eventMouse1 = true;
 638         }
 639         if ((modifiers & MouseEvent.BUTTON2_DOWN_MASK) != 0) {
 640             eventMouse2 = true;
 641         }
 642         if ((modifiers & MouseEvent.BUTTON3_DOWN_MASK) != 0) {
 643             eventMouse3 = true;
 644         }
 645         mouse1 = eventMouse1;
 646         mouse2 = eventMouse2;
 647         mouse3 = eventMouse3;
 648         int x = screen.textColumn(mouse.getX());
 649         int y = screen.textRow(mouse.getY());
 650
 651         TMouseEvent mouseEvent = new TMouseEvent(TMouseEvent.Type.MOUSE_DOWN,
 652             x, y, x, y, mouse1, mouse2, mouse3, false, false);
 653
 654         synchronized (eventQueue) {
 655             eventQueue.add(mouseEvent);
 656         }
 657         synchronized (listener) {
 658             listener.notifyAll();
 659         }
 660     }
 661
 662     /**
 663      * Pass mouse events into the event queue.
 664      *
 665      * @param mouse mouse event received
 666      */
 667     @Override
 668     public void mouseReleased(final MouseEvent mouse) {
 669         int modifiers = mouse.getModifiersEx();
 670         boolean eventMouse1 = false;
 671         boolean eventMouse2 = false;
 672         boolean eventMouse3 = false;
 673         if ((modifiers & MouseEvent.BUTTON1_DOWN_MASK) != 0) {
 674             eventMouse1 = true;
 675         }
 676         if ((modifiers & MouseEvent.BUTTON2_DOWN_MASK) != 0) {
 677             eventMouse2 = true;
 678         }
 679         if ((modifiers & MouseEvent.BUTTON3_DOWN_MASK) != 0) {
 680             eventMouse3 = true;
 681         }
 682         if (mouse1) {
 683             mouse1 = false;
 684             eventMouse1 = true;
 685         }
 686         if (mouse2) {
 687             mouse2 = false;
 688             eventMouse2 = true;
 689         }
 690         if (mouse3) {
 691             mouse3 = false;
 692             eventMouse3 = true;
 693         }
 694         int x = screen.textColumn(mouse.getX());
 695         int y = screen.textRow(mouse.getY());
 696
 697         TMouseEvent mouseEvent = new TMouseEvent(TMouseEvent.Type.MOUSE_UP,
 698             x, y, x, y, eventMouse1, eventMouse2, eventMouse3, false, false);
 699
 700         synchronized (eventQueue) {
 701             eventQueue.add(mouseEvent);
 702         }
 703         synchronized (listener) {
 704             listener.notifyAll();
 705         }
 706     }
 707
 708     /**
 709      * Pass mouse events into the event queue.
 710      *
 711      * @param mouse mouse event received
 712      */
 713     @Override
 714     public void mouseWheelMoved(final MouseWheelEvent mouse) {
 715         int modifiers = mouse.getModifiersEx();
 716         boolean eventMouse1 = false;
 717         boolean eventMouse2 = false;
 718         boolean eventMouse3 = false;
 719         boolean mouseWheelUp = false;
 720         boolean mouseWheelDown = false;
 721         if ((modifiers & MouseEvent.BUTTON1_DOWN_MASK) != 0) {
 722             eventMouse1 = true;
 723         }
 724         if ((modifiers & MouseEvent.BUTTON2_DOWN_MASK) != 0) {
 725             eventMouse2 = true;
 726         }
 727         if ((modifiers & MouseEvent.BUTTON3_DOWN_MASK) != 0) {
 728             eventMouse3 = true;
 729         }
 730         mouse1 = eventMouse1;
 731         mouse2 = eventMouse2;
 732         mouse3 = eventMouse3;
 733         int x = screen.textColumn(mouse.getX());
 734         int y = screen.textRow(mouse.getY());
 735         if (mouse.getWheelRotation() > 0) {
 736             mouseWheelDown = true;
 737         }
 738         if (mouse.getWheelRotation() < 0) {
 739             mouseWheelUp = true;
 740         }
 741
 742         TMouseEvent mouseEvent = new TMouseEvent(TMouseEvent.Type.MOUSE_DOWN,
 743             x, y, x, y, mouse1, mouse2, mouse3, mouseWheelUp, mouseWheelDown);
 744
 745         synchronized (eventQueue) {
 746             eventQueue.add(mouseEvent);
 747         }
 748         synchronized (listener) {
 749             listener.notifyAll();
 750         }
 751     }
 752
 753 }