VncCanvas.java

   1 //
   2 //  Copyright (C) 2004 Horizon Wimba.  All Rights Reserved.
   3 //  Copyright (C) 2001-2003 HorizonLive.com, Inc.  All Rights Reserved.
   4 //  Copyright (C) 2001,2002 Constantin Kaplinsky.  All Rights Reserved.
   5 //  Copyright (C) 2000 Tridia Corporation.  All Rights Reserved.
   6 //  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.
   7 //
   8 //  This is free software; you can redistribute it and/or modify
   9 //  it under the terms of the GNU General Public License as published by
  10 //  the Free Software Foundation; either version 2 of the License, or
  11 //  (at your option) any later version.
  12 //
  13 //  This software is distributed in the hope that it will be useful,
  14 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 //  GNU General Public License for more details.
  17 //
  18 //  You should have received a copy of the GNU General Public License
  19 //  along with this software; if not, write to the Free Software
  20 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
  21 //  USA.
  22 //
  23
  24 import java.awt.*;
  25 import java.awt.event.*;
  26 import java.awt.image.*;
  27 import java.io.*;
  28 import java.lang.*;
  29 import java.util.zip.*;
  30
  31
  32 //
  33 // VncCanvas is a subclass of Canvas which draws a VNC desktop on it.
  34 //
  35
  36 class VncCanvas extends Canvas
  37   implements KeyListener, MouseListener, MouseMotionListener {
  38
  39   VncViewer viewer;
  40   RfbProto rfb;
  41   ColorModel cm8, cm24;
  42   Color[] colors;
  43   int bytesPixel;
  44
  45   int maxWidth = 0, maxHeight = 0;
  46   int scalingFactor;
  47   int scaledWidth, scaledHeight;
  48
  49   Image memImage;
  50   Graphics memGraphics;
  51
  52   Image rawPixelsImage;
  53   MemoryImageSource pixelsSource;
  54   byte[] pixels8;
  55   int[] pixels24;
  56
  57   // ZRLE encoder's data.
  58   byte[] zrleBuf;
  59   int zrleBufLen = 0;
  60   byte[] zrleTilePixels8;
  61   int[] zrleTilePixels24;
  62   ZlibInStream zrleInStream;
  63   boolean zrleRecWarningShown = false;
  64
  65   // Zlib encoder's data.
  66   byte[] zlibBuf;
  67   int zlibBufLen = 0;
  68   Inflater zlibInflater;
  69
  70   // Tight encoder's data.
  71   final static int tightZlibBufferSize = 512;
  72   Inflater[] tightInflaters;
  73
  74   // Since JPEG images are loaded asynchronously, we have to remember
  75   // their position in the framebuffer. Also, this jpegRect object is
  76   // used for synchronization between the rfbThread and a JVM's thread
  77   // which decodes and loads JPEG images.
  78   Rectangle jpegRect;
  79
  80   // True if we process keyboard and mouse events.
  81   boolean inputEnabled;
  82
  83   //
  84   // The constructors.
  85   //
  86
  87   public VncCanvas(VncViewer v, int maxWidth_, int maxHeight_)
  88     throws IOException {
  89
  90     viewer = v;
  91     maxWidth = maxWidth_;
  92     maxHeight = maxHeight_;
  93
  94     rfb = viewer.rfb;
  95     scalingFactor = viewer.options.scalingFactor;
  96
  97     tightInflaters = new Inflater[4];
  98
  99     cm8 = new DirectColorModel(8, 7, (7 << 3), (3 << 6));
 100     cm24 = new DirectColorModel(24, 0xFF0000, 0x00FF00, 0x0000FF);
 101
 102     colors = new Color[256];
 103     for (int i = 0; i < 256; i++)
 104       colors[i] = new Color(cm8.getRGB(i));
 105
 106     setPixelFormat();
 107
 108     inputEnabled = false;
 109     if (!viewer.options.viewOnly)
 110       enableInput(true);
 111
 112     // Keyboard listener is enabled even in view-only mode, to catch
 113     // 'r' or 'R' key presses used to request screen update.
 114     addKeyListener(this);
 115   }
 116
 117   public VncCanvas(VncViewer v) throws IOException {
 118     this(v, 0, 0);
 119   }
 120
 121   //
 122   // Callback methods to determine geometry of our Component.
 123   //
 124
 125   public Dimension getPreferredSize() {
 126     return new Dimension(scaledWidth, scaledHeight);
 127   }
 128
 129   public Dimension getMinimumSize() {
 130     return new Dimension(scaledWidth, scaledHeight);
 131   }
 132
 133   public Dimension getMaximumSize() {
 134     return new Dimension(scaledWidth, scaledHeight);
 135   }
 136
 137   //
 138   // All painting is performed here.
 139   //
 140
 141   public void update(Graphics g) {
 142     paint(g);
 143   }
 144
 145   public void paint(Graphics g) {
 146     synchronized(memImage) {
 147       if (rfb.framebufferWidth == scaledWidth) {
 148         g.drawImage(memImage, 0, 0, null);
 149       } else {
 150         paintScaledFrameBuffer(g);
 151       }
 152     }
 153     if (showSoftCursor) {
 154       int x0 = cursorX - hotX, y0 = cursorY - hotY;
 155       Rectangle r = new Rectangle(x0, y0, cursorWidth, cursorHeight);
 156       if (r.intersects(g.getClipBounds())) {
 157         g.drawImage(softCursor, x0, y0, null);
 158       }
 159     }
 160   }
 161
 162   public void paintScaledFrameBuffer(Graphics g) {
 163     g.drawImage(memImage, 0, 0, scaledWidth, scaledHeight, null);
 164   }
 165
 166   //
 167   // Override the ImageObserver interface method to handle drawing of
 168   // JPEG-encoded data.
 169   //
 170
 171   public boolean imageUpdate(Image img, int infoflags,
 172                              int x, int y, int width, int height) {
 173     if ((infoflags & (ALLBITS | ABORT)) == 0) {
 174       return true;              // We need more image data.
 175     } else {
 176       // If the whole image is available, draw it now.
 177       if ((infoflags & ALLBITS) != 0) {
 178         if (jpegRect != null) {
 179           synchronized(jpegRect) {
 180             memGraphics.drawImage(img, jpegRect.x, jpegRect.y, null);
 181             scheduleRepaint(jpegRect.x, jpegRect.y,
 182                             jpegRect.width, jpegRect.height);
 183             jpegRect.notify();
 184           }
 185         }
 186       }
 187       return false;             // All image data was processed.
 188     }
 189   }
 190
 191   //
 192   // Start/stop receiving mouse events. Keyboard events are received
 193   // even in view-only mode, because we want to map the 'r' key to the
 194   // screen refreshing function.
 195   //
 196
 197   public synchronized void enableInput(boolean enable) {
 198     if (enable && !inputEnabled) {
 199       inputEnabled = true;
 200       addMouseListener(this);
 201       addMouseMotionListener(this);
 202       if (viewer.showControls) {
 203         viewer.buttonPanel.enableRemoteAccessControls(true);
 204       }
 205       createSoftCursor();       // scaled cursor
 206     } else if (!enable && inputEnabled) {
 207       inputEnabled = false;
 208       removeMouseListener(this);
 209       removeMouseMotionListener(this);
 210       if (viewer.showControls) {
 211         viewer.buttonPanel.enableRemoteAccessControls(false);
 212       }
 213       createSoftCursor();       // non-scaled cursor
 214     }
 215   }
 216
 217   public void setPixelFormat() throws IOException {
 218     if (viewer.options.eightBitColors) {
 219       rfb.writeSetPixelFormat(8, 8, false, true, 7, 7, 3, 0, 3, 6);
 220       bytesPixel = 1;
 221     } else {
 222       rfb.writeSetPixelFormat(32, 24, false, true, 255, 255, 255, 16, 8, 0);
 223       bytesPixel = 4;
 224     }
 225     updateFramebufferSize();
 226   }
 227
 228   void updateFramebufferSize() {
 229
 230     // Useful shortcuts.
 231     int fbWidth = rfb.framebufferWidth;
 232     int fbHeight = rfb.framebufferHeight;
 233
 234     // Calculate scaling factor for auto scaling.
 235     if (maxWidth > 0 && maxHeight > 0) {
 236       int f1 = maxWidth * 100 / fbWidth;
 237       int f2 = maxHeight * 100 / fbHeight;
 238       scalingFactor = Math.min(f1, f2);
 239       if (scalingFactor > 100)
 240         scalingFactor = 100;
 241       System.out.println("Scaling desktop at " + scalingFactor + "%");
 242     }
 243
 244     // Update scaled framebuffer geometry.
 245     scaledWidth = (fbWidth * scalingFactor + 50) / 100;
 246     scaledHeight = (fbHeight * scalingFactor + 50) / 100;
 247
 248     // Create new off-screen image either if it does not exist, or if
 249     // its geometry should be changed. It's not necessary to replace
 250     // existing image if only pixel format should be changed.
 251     if (memImage == null) {
 252       memImage = viewer.vncContainer.createImage(fbWidth, fbHeight);
 253       memGraphics = memImage.getGraphics();
 254     } else if (memImage.getWidth(null) != fbWidth ||
 255                memImage.getHeight(null) != fbHeight) {
 256       synchronized(memImage) {
 257         memImage = viewer.vncContainer.createImage(fbWidth, fbHeight);
 258         memGraphics = memImage.getGraphics();
 259       }
 260     }
 261
 262     // Images with raw pixels should be re-allocated on every change
 263     // of geometry or pixel format.
 264     if (bytesPixel == 1) {
 265
 266       pixels24 = null;
 267       pixels8 = new byte[fbWidth * fbHeight];
 268
 269       pixelsSource =
 270         new MemoryImageSource(fbWidth, fbHeight, cm8, pixels8, 0, fbWidth);
 271
 272       zrleTilePixels24 = null;
 273       zrleTilePixels8 = new byte[64 * 64];
 274
 275     } else {
 276
 277       pixels8 = null;
 278       pixels24 = new int[fbWidth * fbHeight];
 279
 280       pixelsSource =
 281         new MemoryImageSource(fbWidth, fbHeight, cm24, pixels24, 0, fbWidth);
 282
 283       zrleTilePixels8 = null;
 284       zrleTilePixels24 = new int[64 * 64];
 285
 286     }
 287     pixelsSource.setAnimated(true);
 288     rawPixelsImage = Toolkit.getDefaultToolkit().createImage(pixelsSource);
 289
 290     // Update the size of desktop containers.
 291     if (viewer.inSeparateFrame) {
 292       if (viewer.desktopScrollPane != null)
 293         resizeDesktopFrame();
 294     } else {
 295       setSize(scaledWidth, scaledHeight);
 296     }
 297     viewer.moveFocusToDesktop();
 298   }
 299
 300   void resizeDesktopFrame() {
 301     setSize(scaledWidth, scaledHeight);
 302
 303     // FIXME: Find a better way to determine correct size of a
 304     // ScrollPane.  -- const
 305     Insets insets = viewer.desktopScrollPane.getInsets();
 306     viewer.desktopScrollPane.setSize(scaledWidth +
 307                                      2 * Math.min(insets.left, insets.right),
 308                                      scaledHeight +
 309                                      2 * Math.min(insets.top, insets.bottom));
 310
 311     viewer.vncFrame.pack();
 312
 313     // Try to limit the frame size to the screen size.
 314
 315     Dimension screenSize = viewer.vncFrame.getToolkit().getScreenSize();
 316     Dimension frameSize = viewer.vncFrame.getSize();
 317     Dimension newSize = frameSize;
 318
 319     // Reduce Screen Size by 30 pixels in each direction;
 320     // This is a (poor) attempt to account for
 321     //     1) Menu bar on Macintosh (should really also account for
 322     //        Dock on OSX).  Usually 22px on top of screen.
 323     //     2) Taxkbar on Windows (usually about 28 px on bottom)
 324     //     3) Other obstructions.
 325
 326     screenSize.height -= 30;
 327     screenSize.width  -= 30;
 328
 329     boolean needToResizeFrame = false;
 330     if (frameSize.height > screenSize.height) {
 331       newSize.height = screenSize.height;
 332       needToResizeFrame = true;
 333     }
 334     if (frameSize.width > screenSize.width) {
 335       newSize.width = screenSize.width;
 336       needToResizeFrame = true;
 337     }
 338     if (needToResizeFrame) {
 339       viewer.vncFrame.setSize(newSize);
 340     }
 341
 342     viewer.desktopScrollPane.doLayout();
 343   }
 344
 345   //
 346   // processNormalProtocol() - executed by the rfbThread to deal with the
 347   // RFB socket.
 348   //
 349
 350   public void processNormalProtocol() throws Exception {
 351
 352     // Start/stop session recording if necessary.
 353     viewer.checkRecordingStatus();
 354
 355     rfb.writeFramebufferUpdateRequest(0, 0, rfb.framebufferWidth,
 356                                       rfb.framebufferHeight, false);
 357
 358     //
 359     // main dispatch loop
 360     //
 361
 362     while (true) {
 363
 364       // Read message type from the server.
 365       int msgType = rfb.readServerMessageType();
 366
 367       // Process the message depending on its type.
 368       switch (msgType) {
 369       case RfbProto.FramebufferUpdate:
 370         rfb.readFramebufferUpdate();
 371
 372         boolean cursorPosReceived = false;
 373
 374         for (int i = 0; i < rfb.updateNRects; i++) {
 375           rfb.readFramebufferUpdateRectHdr();
 376           int rx = rfb.updateRectX, ry = rfb.updateRectY;
 377           int rw = rfb.updateRectW, rh = rfb.updateRectH;
 378
 379           if (rfb.updateRectEncoding == rfb.EncodingLastRect)
 380             break;
 381
 382           if (rfb.updateRectEncoding == rfb.EncodingNewFBSize) {
 383             rfb.setFramebufferSize(rw, rh);
 384             updateFramebufferSize();
 385             break;
 386           }
 387
 388           if (rfb.updateRectEncoding == rfb.EncodingXCursor ||
 389               rfb.updateRectEncoding == rfb.EncodingRichCursor) {
 390             handleCursorShapeUpdate(rfb.updateRectEncoding, rx, ry, rw, rh);
 391             continue;
 392           }
 393
 394           if (rfb.updateRectEncoding == rfb.EncodingPointerPos) {
 395             softCursorMove(rx, ry);
 396             cursorPosReceived = true;
 397             continue;
 398           }
 399
 400           rfb.startTiming();
 401
 402           switch (rfb.updateRectEncoding) {
 403           case RfbProto.EncodingRaw:
 404             handleRawRect(rx, ry, rw, rh);
 405             break;
 406           case RfbProto.EncodingCopyRect:
 407             handleCopyRect(rx, ry, rw, rh);
 408             break;
 409           case RfbProto.EncodingRRE:
 410             handleRRERect(rx, ry, rw, rh);
 411             break;
 412           case RfbProto.EncodingCoRRE:
 413             handleCoRRERect(rx, ry, rw, rh);
 414             break;
 415           case RfbProto.EncodingHextile:
 416             handleHextileRect(rx, ry, rw, rh);
 417             break;
 418           case RfbProto.EncodingZRLE:
 419             handleZRLERect(rx, ry, rw, rh);
 420             break;
 421           case RfbProto.EncodingZlib:
 422             handleZlibRect(rx, ry, rw, rh);
 423             break;
 424           case RfbProto.EncodingTight:
 425             handleTightRect(rx, ry, rw, rh);
 426             break;
 427           default:
 428             throw new Exception("Unknown RFB rectangle encoding " +
 429                                 rfb.updateRectEncoding);
 430           }
 431
 432           rfb.stopTiming();
 433         }
 434
 435         boolean fullUpdateNeeded = false;
 436
 437         // Start/stop session recording if necessary. Request full
 438         // update if a new session file was opened.
 439         if (viewer.checkRecordingStatus())
 440           fullUpdateNeeded = true;
 441
 442         // Defer framebuffer update request if necessary. But wake up
 443         // immediately on keyboard or mouse event. Also, don't sleep
 444         // if there is some data to receive, or if the last update
 445         // included a PointerPos message.
 446         if (viewer.deferUpdateRequests > 0 &&
 447             rfb.is.available() == 0 && !cursorPosReceived) {
 448           synchronized(rfb) {
 449             try {
 450               rfb.wait(viewer.deferUpdateRequests);
 451             } catch (InterruptedException e) {
 452             }
 453           }
 454         }
 455
 456         // Before requesting framebuffer update, check if the pixel
 457         // format should be changed. If it should, request full update
 458         // instead of an incremental one.
 459         if (viewer.options.eightBitColors != (bytesPixel == 1)) {
 460           setPixelFormat();
 461           fullUpdateNeeded = true;
 462         }
 463
 464         viewer.autoSelectEncodings();
 465
 466         rfb.writeFramebufferUpdateRequest(0, 0, rfb.framebufferWidth,
 467                                           rfb.framebufferHeight,
 468                                           !fullUpdateNeeded);
 469
 470         break;
 471
 472       case RfbProto.SetColourMapEntries:
 473         throw new Exception("Can't handle SetColourMapEntries message");
 474
 475       case RfbProto.Bell:
 476         Toolkit.getDefaultToolkit().beep();
 477         break;
 478
 479       case RfbProto.ServerCutText:
 480         String s = rfb.readServerCutText();
 481         viewer.clipboard.setCutText(s);
 482         break;
 483
 484       default:
 485         throw new Exception("Unknown RFB message type " + msgType);
 486       }
 487     }
 488   }
 489
 490
 491   //
 492   // Handle a raw rectangle. The second form with paint==false is used
 493   // by the Hextile decoder for raw-encoded tiles.
 494   //
 495
 496   void handleRawRect(int x, int y, int w, int h) throws IOException {
 497     handleRawRect(x, y, w, h, true);
 498   }
 499
 500   void handleRawRect(int x, int y, int w, int h, boolean paint)
 501     throws IOException {
 502
 503     if (bytesPixel == 1) {
 504       for (int dy = y; dy < y + h; dy++) {
 505         rfb.readFully(pixels8, dy * rfb.framebufferWidth + x, w);
 506         if (rfb.rec != null) {
 507           rfb.rec.write(pixels8, dy * rfb.framebufferWidth + x, w);
 508         }
 509       }
 510     } else {
 511       byte[] buf = new byte[w * 4];
 512       int i, offset;
 513       for (int dy = y; dy < y + h; dy++) {
 514         rfb.readFully(buf);
 515         if (rfb.rec != null) {
 516           rfb.rec.write(buf);
 517         }
 518         offset = dy * rfb.framebufferWidth + x;
 519         for (i = 0; i < w; i++) {
 520           pixels24[offset + i] =
 521             (buf[i * 4 + 2] & 0xFF) << 16 |
 522             (buf[i * 4 + 1] & 0xFF) << 8 |
 523             (buf[i * 4] & 0xFF);
 524         }
 525       }
 526     }
 527
 528     handleUpdatedPixels(x, y, w, h);
 529     if (paint)
 530       scheduleRepaint(x, y, w, h);
 531   }
 532
 533   //
 534   // Handle a CopyRect rectangle.
 535   //
 536
 537   void handleCopyRect(int x, int y, int w, int h) throws IOException {
 538
 539     rfb.readCopyRect();
 540     memGraphics.copyArea(rfb.copyRectSrcX, rfb.copyRectSrcY, w, h,
 541                          x - rfb.copyRectSrcX, y - rfb.copyRectSrcY);
 542
 543     scheduleRepaint(x, y, w, h);
 544   }
 545
 546   //
 547   // Handle an RRE-encoded rectangle.
 548   //
 549
 550   void handleRRERect(int x, int y, int w, int h) throws IOException {
 551
 552     int nSubrects = rfb.is.readInt();
 553
 554     byte[] bg_buf = new byte[bytesPixel];
 555     rfb.readFully(bg_buf);
 556     Color pixel;
 557     if (bytesPixel == 1) {
 558       pixel = colors[bg_buf[0] & 0xFF];
 559     } else {
 560       pixel = new Color(bg_buf[2] & 0xFF, bg_buf[1] & 0xFF, bg_buf[0] & 0xFF);
 561     }
 562     memGraphics.setColor(pixel);
 563     memGraphics.fillRect(x, y, w, h);
 564
 565     byte[] buf = new byte[nSubrects * (bytesPixel + 8)];
 566     rfb.readFully(buf);
 567     DataInputStream ds = new DataInputStream(new ByteArrayInputStream(buf));
 568
 569     if (rfb.rec != null) {
 570       rfb.rec.writeIntBE(nSubrects);
 571       rfb.rec.write(bg_buf);
 572       rfb.rec.write(buf);
 573     }
 574
 575     int sx, sy, sw, sh;
 576
 577     for (int j = 0; j < nSubrects; j++) {
 578       if (bytesPixel == 1) {
 579         pixel = colors[ds.readUnsignedByte()];
 580       } else {
 581         ds.skip(4);
 582         pixel = new Color(buf[j*12+2] & 0xFF,
 583                           buf[j*12+1] & 0xFF,
 584                           buf[j*12]   & 0xFF);
 585       }
 586       sx = x + ds.readUnsignedShort();
 587       sy = y + ds.readUnsignedShort();
 588       sw = ds.readUnsignedShort();
 589       sh = ds.readUnsignedShort();
 590
 591       memGraphics.setColor(pixel);
 592       memGraphics.fillRect(sx, sy, sw, sh);
 593     }
 594
 595     scheduleRepaint(x, y, w, h);
 596   }
 597
 598   //
 599   // Handle a CoRRE-encoded rectangle.
 600   //
 601
 602   void handleCoRRERect(int x, int y, int w, int h) throws IOException {
 603     int nSubrects = rfb.is.readInt();
 604
 605     byte[] bg_buf = new byte[bytesPixel];
 606     rfb.readFully(bg_buf);
 607     Color pixel;
 608     if (bytesPixel == 1) {
 609       pixel = colors[bg_buf[0] & 0xFF];
 610     } else {
 611       pixel = new Color(bg_buf[2] & 0xFF, bg_buf[1] & 0xFF, bg_buf[0] & 0xFF);
 612     }
 613     memGraphics.setColor(pixel);
 614     memGraphics.fillRect(x, y, w, h);
 615
 616     byte[] buf = new byte[nSubrects * (bytesPixel + 4)];
 617     rfb.readFully(buf);
 618
 619     if (rfb.rec != null) {
 620       rfb.rec.writeIntBE(nSubrects);
 621       rfb.rec.write(bg_buf);
 622       rfb.rec.write(buf);
 623     }
 624
 625     int sx, sy, sw, sh;
 626     int i = 0;
 627
 628     for (int j = 0; j < nSubrects; j++) {
 629       if (bytesPixel == 1) {
 630         pixel = colors[buf[i++] & 0xFF];
 631       } else {
 632         pixel = new Color(buf[i+2] & 0xFF, buf[i+1] & 0xFF, buf[i] & 0xFF);
 633         i += 4;
 634       }
 635       sx = x + (buf[i++] & 0xFF);
 636       sy = y + (buf[i++] & 0xFF);
 637       sw = buf[i++] & 0xFF;
 638       sh = buf[i++] & 0xFF;
 639
 640       memGraphics.setColor(pixel);
 641       memGraphics.fillRect(sx, sy, sw, sh);
 642     }
 643
 644     scheduleRepaint(x, y, w, h);
 645   }
 646
 647   //
 648   // Handle a Hextile-encoded rectangle.
 649   //
 650
 651   // These colors should be kept between handleHextileSubrect() calls.
 652   private Color hextile_bg, hextile_fg;
 653
 654   void handleHextileRect(int x, int y, int w, int h) throws IOException {
 655
 656     hextile_bg = new Color(0);
 657     hextile_fg = new Color(0);
 658
 659     for (int ty = y; ty < y + h; ty += 16) {
 660       int th = 16;
 661       if (y + h - ty < 16)
 662         th = y + h - ty;
 663
 664       for (int tx = x; tx < x + w; tx += 16) {
 665         int tw = 16;
 666         if (x + w - tx < 16)
 667           tw = x + w - tx;
 668
 669         handleHextileSubrect(tx, ty, tw, th);
 670       }
 671
 672       // Finished with a row of tiles, now let's show it.
 673       scheduleRepaint(x, y, w, h);
 674     }
 675   }
 676
 677   //
 678   // Handle one tile in the Hextile-encoded data.
 679   //
 680
 681   void handleHextileSubrect(int tx, int ty, int tw, int th)
 682     throws IOException {
 683
 684     int subencoding = rfb.is.readUnsignedByte();
 685     if (rfb.rec != null) {
 686       rfb.rec.writeByte(subencoding);
 687     }
 688
 689     // Is it a raw-encoded sub-rectangle?
 690     if ((subencoding & rfb.HextileRaw) != 0) {
 691       handleRawRect(tx, ty, tw, th, false);
 692       return;
 693     }
 694
 695     // Read and draw the background if specified.
 696     byte[] cbuf = new byte[bytesPixel];
 697     if ((subencoding & rfb.HextileBackgroundSpecified) != 0) {
 698       rfb.readFully(cbuf);
 699       if (bytesPixel == 1) {
 700         hextile_bg = colors[cbuf[0] & 0xFF];
 701       } else {
 702         hextile_bg = new Color(cbuf[2] & 0xFF, cbuf[1] & 0xFF, cbuf[0] & 0xFF);
 703       }
 704       if (rfb.rec != null) {
 705         rfb.rec.write(cbuf);
 706       }
 707     }
 708     memGraphics.setColor(hextile_bg);
 709     memGraphics.fillRect(tx, ty, tw, th);
 710
 711     // Read the foreground color if specified.
 712     if ((subencoding & rfb.HextileForegroundSpecified) != 0) {
 713       rfb.readFully(cbuf);
 714       if (bytesPixel == 1) {
 715         hextile_fg = colors[cbuf[0] & 0xFF];
 716       } else {
 717         hextile_fg = new Color(cbuf[2] & 0xFF, cbuf[1] & 0xFF, cbuf[0] & 0xFF);
 718       }
 719       if (rfb.rec != null) {
 720         rfb.rec.write(cbuf);
 721       }
 722     }
 723
 724     // Done with this tile if there is no sub-rectangles.
 725     if ((subencoding & rfb.HextileAnySubrects) == 0)
 726       return;
 727
 728     int nSubrects = rfb.is.readUnsignedByte();
 729     int bufsize = nSubrects * 2;
 730     if ((subencoding & rfb.HextileSubrectsColoured) != 0) {
 731       bufsize += nSubrects * bytesPixel;
 732     }
 733     byte[] buf = new byte[bufsize];
 734     rfb.readFully(buf);
 735     if (rfb.rec != null) {
 736       rfb.rec.writeByte(nSubrects);
 737       rfb.rec.write(buf);
 738     }
 739
 740     int b1, b2, sx, sy, sw, sh;
 741     int i = 0;
 742
 743     if ((subencoding & rfb.HextileSubrectsColoured) == 0) {
 744
 745       // Sub-rectangles are all of the same color.
 746       memGraphics.setColor(hextile_fg);
 747       for (int j = 0; j < nSubrects; j++) {
 748         b1 = buf[i++] & 0xFF;
 749         b2 = buf[i++] & 0xFF;
 750         sx = tx + (b1 >> 4);
 751         sy = ty + (b1 & 0xf);
 752         sw = (b2 >> 4) + 1;
 753         sh = (b2 & 0xf) + 1;
 754         memGraphics.fillRect(sx, sy, sw, sh);
 755       }
 756     } else if (bytesPixel == 1) {
 757
 758       // BGR233 (8-bit color) version for colored sub-rectangles.
 759       for (int j = 0; j < nSubrects; j++) {
 760         hextile_fg = colors[buf[i++] & 0xFF];
 761         b1 = buf[i++] & 0xFF;
 762         b2 = buf[i++] & 0xFF;
 763         sx = tx + (b1 >> 4);
 764         sy = ty + (b1 & 0xf);
 765         sw = (b2 >> 4) + 1;
 766         sh = (b2 & 0xf) + 1;
 767         memGraphics.setColor(hextile_fg);
 768         memGraphics.fillRect(sx, sy, sw, sh);
 769       }
 770
 771     } else {
 772
 773       // Full-color (24-bit) version for colored sub-rectangles.
 774       for (int j = 0; j < nSubrects; j++) {
 775         hextile_fg = new Color(buf[i+2] & 0xFF,
 776                                buf[i+1] & 0xFF,
 777                                buf[i] & 0xFF);
 778         i += 4;
 779         b1 = buf[i++] & 0xFF;
 780         b2 = buf[i++] & 0xFF;
 781         sx = tx + (b1 >> 4);
 782         sy = ty + (b1 & 0xf);
 783         sw = (b2 >> 4) + 1;
 784         sh = (b2 & 0xf) + 1;
 785         memGraphics.setColor(hextile_fg);
 786         memGraphics.fillRect(sx, sy, sw, sh);
 787       }
 788
 789     }
 790   }
 791
 792   //
 793   // Handle a ZRLE-encoded rectangle.
 794   //
 795   // FIXME: Currently, session recording is not fully supported for ZRLE.
 796   //
 797
 798   void handleZRLERect(int x, int y, int w, int h) throws Exception {
 799
 800     if (zrleInStream == null)
 801       zrleInStream = new ZlibInStream();
 802
 803     int nBytes = rfb.is.readInt();
 804     if (nBytes > 64 * 1024 * 1024)
 805       throw new Exception("ZRLE decoder: illegal compressed data size");
 806
 807     if (zrleBuf == null || zrleBufLen < nBytes) {
 808       zrleBufLen = nBytes + 4096;
 809       zrleBuf = new byte[zrleBufLen];
 810     }
 811
 812     // FIXME: Do not wait for all the data before decompression.
 813     rfb.readFully(zrleBuf, 0, nBytes);
 814
 815     if (rfb.rec != null) {
 816       if (rfb.recordFromBeginning) {
 817         rfb.rec.writeIntBE(nBytes);
 818         rfb.rec.write(zrleBuf, 0, nBytes);
 819       } else if (!zrleRecWarningShown) {
 820         System.out.println("Warning: ZRLE session can be recorded" +
 821                            " only from the beginning");
 822         System.out.println("Warning: Recorded file may be corrupted");
 823         zrleRecWarningShown = true;
 824       }
 825     }
 826
 827     zrleInStream.setUnderlying(new MemInStream(zrleBuf, 0, nBytes), nBytes);
 828
 829     for (int ty = y; ty < y+h; ty += 64) {
 830
 831       int th = Math.min(y+h-ty, 64);
 832
 833       for (int tx = x; tx < x+w; tx += 64) {
 834
 835         int tw = Math.min(x+w-tx, 64);
 836
 837         int mode = zrleInStream.readU8();
 838         boolean rle = (mode & 128) != 0;
 839         int palSize = mode & 127;
 840         int[] palette = new int[128];
 841
 842         readZrlePalette(palette, palSize);
 843
 844         if (palSize == 1) {
 845           int pix = palette[0];
 846           Color c = (bytesPixel == 1) ?
 847             colors[pix] : new Color(0xFF000000 | pix);
 848           memGraphics.setColor(c);
 849           memGraphics.fillRect(tx, ty, tw, th);
 850           continue;
 851         }
 852
 853         if (!rle) {
 854           if (palSize == 0) {
 855             readZrleRawPixels(tw, th);
 856           } else {
 857             readZrlePackedPixels(tw, th, palette, palSize);
 858           }
 859         } else {
 860           if (palSize == 0) {
 861             readZrlePlainRLEPixels(tw, th);
 862           } else {
 863             readZrlePackedRLEPixels(tw, th, palette);
 864           }
 865         }
 866         handleUpdatedZrleTile(tx, ty, tw, th);
 867       }
 868     }
 869
 870     zrleInStream.reset();
 871
 872     scheduleRepaint(x, y, w, h);
 873   }
 874
 875   int readPixel(InStream is) throws Exception {
 876     int pix;
 877     if (bytesPixel == 1) {
 878       pix = is.readU8();
 879     } else {
 880       int p1 = is.readU8();
 881       int p2 = is.readU8();
 882       int p3 = is.readU8();
 883       pix = (p3 & 0xFF) << 16 | (p2 & 0xFF) << 8 | (p1 & 0xFF);
 884     }
 885     return pix;
 886   }
 887
 888   void readPixels(InStream is, int[] dst, int count) throws Exception {
 889     int pix;
 890     if (bytesPixel == 1) {
 891       byte[] buf = new byte[count];
 892       is.readBytes(buf, 0, count);
 893       for (int i = 0; i < count; i++) {
 894         dst[i] = (int)buf[i] & 0xFF;
 895       }
 896     } else {
 897       byte[] buf = new byte[count * 3];
 898       is.readBytes(buf, 0, count * 3);
 899       for (int i = 0; i < count; i++) {
 900         dst[i] = ((buf[i*3+2] & 0xFF) << 16 |
 901                   (buf[i*3+1] & 0xFF) << 8 |
 902                   (buf[i*3] & 0xFF));
 903       }
 904     }
 905   }
 906
 907   void readZrlePalette(int[] palette, int palSize) throws Exception {
 908     readPixels(zrleInStream, palette, palSize);
 909   }
 910
 911   void readZrleRawPixels(int tw, int th) throws Exception {
 912     if (bytesPixel == 1) {
 913       zrleInStream.readBytes(zrleTilePixels8, 0, tw * th);
 914     } else {
 915       readPixels(zrleInStream, zrleTilePixels24, tw * th); ///
 916     }
 917   }
 918
 919   void readZrlePackedPixels(int tw, int th, int[] palette, int palSize)
 920     throws Exception {
 921
 922     int bppp = ((palSize > 16) ? 8 :
 923                 ((palSize > 4) ? 4 : ((palSize > 2) ? 2 : 1)));
 924     int ptr = 0;
 925
 926     for (int i = 0; i < th; i++) {
 927       int eol = ptr + tw;
 928       int b = 0;
 929       int nbits = 0;
 930
 931       while (ptr < eol) {
 932         if (nbits == 0) {
 933           b = zrleInStream.readU8();
 934           nbits = 8;
 935         }
 936         nbits -= bppp;
 937         int index = (b >> nbits) & ((1 << bppp) - 1) & 127;
 938         if (bytesPixel == 1) {
 939           zrleTilePixels8[ptr++] = (byte)palette[index];
 940         } else {
 941           zrleTilePixels24[ptr++] = palette[index];
 942         }
 943       }
 944     }
 945   }
 946
 947   void readZrlePlainRLEPixels(int tw, int th) throws Exception {
 948     int ptr = 0;
 949     int end = ptr + tw * th;
 950     while (ptr < end) {
 951       int pix = readPixel(zrleInStream);
 952       int len = 1;
 953       int b;
 954       do {
 955         b = zrleInStream.readU8();
 956         len += b;
 957       } while (b == 255);
 958
 959       if (!(len <= end - ptr))
 960         throw new Exception("ZRLE decoder: assertion failed" +
 961                             " (len <= end-ptr)");
 962
 963       if (bytesPixel == 1) {
 964         while (len-- > 0) zrleTilePixels8[ptr++] = (byte)pix;
 965       } else {
 966         while (len-- > 0) zrleTilePixels24[ptr++] = pix;
 967       }
 968     }
 969   }
 970
 971   void readZrlePackedRLEPixels(int tw, int th, int[] palette)
 972     throws Exception {
 973
 974     int ptr = 0;
 975     int end = ptr + tw * th;
 976     while (ptr < end) {
 977       int index = zrleInStream.readU8();
 978       int len = 1;
 979       if ((index & 128) != 0) {
 980         int b;
 981         do {
 982           b = zrleInStream.readU8();
 983           len += b;
 984         } while (b == 255);
 985
 986         if (!(len <= end - ptr))
 987           throw new Exception("ZRLE decoder: assertion failed" +
 988                               " (len <= end - ptr)");
 989       }
 990
 991       index &= 127;
 992       int pix = palette[index];
 993
 994       if (bytesPixel == 1) {
 995         while (len-- > 0) zrleTilePixels8[ptr++] = (byte)pix;
 996       } else {
 997         while (len-- > 0) zrleTilePixels24[ptr++] = pix;
 998       }
 999     }
1000   }
1001
1002   //
1003   // Copy pixels from zrleTilePixels8 or zrleTilePixels24, then update.
1004   //
1005
1006   void handleUpdatedZrleTile(int x, int y, int w, int h) {
1007     Object src, dst;
1008     if (bytesPixel == 1) {
1009       src = zrleTilePixels8; dst = pixels8;
1010     } else {
1011       src = zrleTilePixels24; dst = pixels24;
1012     }
1013     int offsetSrc = 0;
1014     int offsetDst = (y * rfb.framebufferWidth + x);
1015     for (int j = 0; j < h; j++) {
1016       System.arraycopy(src, offsetSrc, dst, offsetDst, w);
1017       offsetSrc += w;
1018       offsetDst += rfb.framebufferWidth;
1019     }
1020     handleUpdatedPixels(x, y, w, h);
1021   }
1022
1023   //
1024   // Handle a Zlib-encoded rectangle.
1025   //
1026
1027   void handleZlibRect(int x, int y, int w, int h) throws Exception {
1028
1029     int nBytes = rfb.is.readInt();
1030
1031     if (zlibBuf == null || zlibBufLen < nBytes) {
1032       zlibBufLen = nBytes * 2;
1033       zlibBuf = new byte[zlibBufLen];
1034     }
1035
1036     rfb.readFully(zlibBuf, 0, nBytes);
1037
1038     if (rfb.rec != null && rfb.recordFromBeginning) {
1039       rfb.rec.writeIntBE(nBytes);
1040       rfb.rec.write(zlibBuf, 0, nBytes);
1041     }
1042
1043     if (zlibInflater == null) {
1044       zlibInflater = new Inflater();
1045     }
1046     zlibInflater.setInput(zlibBuf, 0, nBytes);
1047
1048     if (bytesPixel == 1) {
1049       for (int dy = y; dy < y + h; dy++) {
1050         zlibInflater.inflate(pixels8, dy * rfb.framebufferWidth + x, w);
1051         if (rfb.rec != null && !rfb.recordFromBeginning)
1052           rfb.rec.write(pixels8, dy * rfb.framebufferWidth + x, w);
1053       }
1054     } else {
1055       byte[] buf = new byte[w * 4];
1056       int i, offset;
1057       for (int dy = y; dy < y + h; dy++) {
1058         zlibInflater.inflate(buf);
1059         offset = dy * rfb.framebufferWidth + x;
1060         for (i = 0; i < w; i++) {
1061           pixels24[offset + i] =
1062             (buf[i * 4 + 2] & 0xFF) << 16 |
1063             (buf[i * 4 + 1] & 0xFF) << 8 |
1064             (buf[i * 4] & 0xFF);
1065         }
1066         if (rfb.rec != null && !rfb.recordFromBeginning)
1067           rfb.rec.write(buf);
1068       }
1069     }
1070
1071     handleUpdatedPixels(x, y, w, h);
1072     scheduleRepaint(x, y, w, h);
1073   }
1074
1075   //
1076   // Handle a Tight-encoded rectangle.
1077   //
1078
1079   void handleTightRect(int x, int y, int w, int h) throws Exception {
1080
1081     int comp_ctl = rfb.is.readUnsignedByte();
1082     if (rfb.rec != null) {
1083       if (rfb.recordFromBeginning ||
1084           comp_ctl == (rfb.TightFill << 4) ||
1085           comp_ctl == (rfb.TightJpeg << 4)) {
1086         // Send data exactly as received.
1087         rfb.rec.writeByte(comp_ctl);
1088       } else {
1089         // Tell the decoder to flush each of the four zlib streams.
1090         rfb.rec.writeByte(comp_ctl | 0x0F);
1091       }
1092     }
1093
1094     // Flush zlib streams if we are told by the server to do so.
1095     for (int stream_id = 0; stream_id < 4; stream_id++) {
1096       if ((comp_ctl & 1) != 0 && tightInflaters[stream_id] != null) {
1097         tightInflaters[stream_id] = null;
1098       }
1099       comp_ctl >>= 1;
1100     }
1101
1102     // Check correctness of subencoding value.
1103     if (comp_ctl > rfb.TightMaxSubencoding) {
1104       throw new Exception("Incorrect tight subencoding: " + comp_ctl);
1105     }
1106
1107     // Handle solid-color rectangles.
1108     if (comp_ctl == rfb.TightFill) {
1109
1110       if (bytesPixel == 1) {
1111         int idx = rfb.is.readUnsignedByte();
1112         memGraphics.setColor(colors[idx]);
1113         if (rfb.rec != null) {
1114           rfb.rec.writeByte(idx);
1115         }
1116       } else {
1117         byte[] buf = new byte[3];
1118         rfb.readFully(buf);
1119         if (rfb.rec != null) {
1120           rfb.rec.write(buf);
1121         }
1122         Color bg = new Color(0xFF000000 | (buf[0] & 0xFF) << 16 |
1123                              (buf[1] & 0xFF) << 8 | (buf[2] & 0xFF));
1124         memGraphics.setColor(bg);
1125       }
1126       memGraphics.fillRect(x, y, w, h);
1127       scheduleRepaint(x, y, w, h);
1128       return;
1129
1130     }
1131
1132     if (comp_ctl == rfb.TightJpeg) {
1133
1134       // Read JPEG data.
1135       byte[] jpegData = new byte[rfb.readCompactLen()];
1136       rfb.readFully(jpegData);
1137       if (rfb.rec != null) {
1138         if (!rfb.recordFromBeginning) {
1139           rfb.recordCompactLen(jpegData.length);
1140         }
1141         rfb.rec.write(jpegData);
1142       }
1143
1144       // Create an Image object from the JPEG data.
1145       Image jpegImage = Toolkit.getDefaultToolkit().createImage(jpegData);
1146
1147       // Remember the rectangle where the image should be drawn.
1148       jpegRect = new Rectangle(x, y, w, h);
1149
1150       // Let the imageUpdate() method do the actual drawing, here just
1151       // wait until the image is fully loaded and drawn.
1152       synchronized(jpegRect) {
1153         Toolkit.getDefaultToolkit().prepareImage(jpegImage, -1, -1, this);
1154         try {
1155           // Wait no longer than three seconds.
1156           jpegRect.wait(3000);
1157         } catch (InterruptedException e) {
1158           throw new Exception("Interrupted while decoding JPEG image");
1159         }
1160       }
1161
1162       // Done, jpegRect is not needed any more.
1163       jpegRect = null;
1164       return;
1165
1166     }
1167
1168     // Read filter id and parameters.
1169     int numColors = 0, rowSize = w;
1170     byte[] palette8 = new byte[2];
1171     int[] palette24 = new int[256];
1172     boolean useGradient = false;
1173     if ((comp_ctl & rfb.TightExplicitFilter) != 0) {
1174       int filter_id = rfb.is.readUnsignedByte();
1175       if (rfb.rec != null) {
1176         rfb.rec.writeByte(filter_id);
1177       }
1178       if (filter_id == rfb.TightFilterPalette) {
1179         numColors = rfb.is.readUnsignedByte() + 1;
1180         if (rfb.rec != null) {
1181           rfb.rec.writeByte(numColors - 1);
1182         }
1183         if (bytesPixel == 1) {
1184           if (numColors != 2) {
1185             throw new Exception("Incorrect tight palette size: " + numColors);
1186           }
1187           rfb.readFully(palette8);
1188           if (rfb.rec != null) {
1189             rfb.rec.write(palette8);
1190           }
1191         } else {
1192           byte[] buf = new byte[numColors * 3];
1193           rfb.readFully(buf);
1194           if (rfb.rec != null) {
1195             rfb.rec.write(buf);
1196           }
1197           for (int i = 0; i < numColors; i++) {
1198             palette24[i] = ((buf[i * 3] & 0xFF) << 16 |
1199                             (buf[i * 3 + 1] & 0xFF) << 8 |
1200                             (buf[i * 3 + 2] & 0xFF));
1201           }
1202         }
1203         if (numColors == 2)
1204           rowSize = (w + 7) / 8;
1205       } else if (filter_id == rfb.TightFilterGradient) {
1206         useGradient = true;
1207       } else if (filter_id != rfb.TightFilterCopy) {
1208         throw new Exception("Incorrect tight filter id: " + filter_id);
1209       }
1210     }
1211     if (numColors == 0 && bytesPixel == 4)
1212       rowSize *= 3;
1213
1214     // Read, optionally uncompress and decode data.
1215     int dataSize = h * rowSize;
1216     if (dataSize < rfb.TightMinToCompress) {
1217       // Data size is small - not compressed with zlib.
1218       if (numColors != 0) {
1219         // Indexed colors.
1220         byte[] indexedData = new byte[dataSize];
1221         rfb.readFully(indexedData);
1222         if (rfb.rec != null) {
1223           rfb.rec.write(indexedData);
1224         }
1225         if (numColors == 2) {
1226           // Two colors.
1227           if (bytesPixel == 1) {
1228             decodeMonoData(x, y, w, h, indexedData, palette8);
1229           } else {
1230             decodeMonoData(x, y, w, h, indexedData, palette24);
1231           }
1232         } else {
1233           // 3..255 colors (assuming bytesPixel == 4).
1234           int i = 0;
1235           for (int dy = y; dy < y + h; dy++) {
1236             for (int dx = x; dx < x + w; dx++) {
1237               pixels24[dy * rfb.framebufferWidth + dx] =
1238                 palette24[indexedData[i++] & 0xFF];
1239             }
1240           }
1241         }
1242       } else if (useGradient) {
1243         // "Gradient"-processed data
1244         byte[] buf = new byte[w * h * 3];
1245         rfb.readFully(buf);
1246         if (rfb.rec != null) {
1247           rfb.rec.write(buf);
1248         }
1249         decodeGradientData(x, y, w, h, buf);
1250       } else {
1251         // Raw truecolor data.
1252         if (bytesPixel == 1) {
1253           for (int dy = y; dy < y + h; dy++) {
1254             rfb.readFully(pixels8, dy * rfb.framebufferWidth + x, w);
1255             if (rfb.rec != null) {
1256               rfb.rec.write(pixels8, dy * rfb.framebufferWidth + x, w);
1257             }
1258           }
1259         } else {
1260           byte[] buf = new byte[w * 3];
1261           int i, offset;
1262           for (int dy = y; dy < y + h; dy++) {
1263             rfb.readFully(buf);
1264             if (rfb.rec != null) {
1265               rfb.rec.write(buf);
1266             }
1267             offset = dy * rfb.framebufferWidth + x;
1268             for (i = 0; i < w; i++) {
1269               pixels24[offset + i] =
1270                 (buf[i * 3] & 0xFF) << 16 |
1271                 (buf[i * 3 + 1] & 0xFF) << 8 |
1272                 (buf[i * 3 + 2] & 0xFF);
1273             }
1274           }
1275         }
1276       }
1277     } else {
1278       // Data was compressed with zlib.
1279       int zlibDataLen = rfb.readCompactLen();
1280       byte[] zlibData = new byte[zlibDataLen];
1281       rfb.readFully(zlibData);
1282       if (rfb.rec != null && rfb.recordFromBeginning) {
1283         rfb.rec.write(zlibData);
1284       }
1285       int stream_id = comp_ctl & 0x03;
1286       if (tightInflaters[stream_id] == null) {
1287         tightInflaters[stream_id] = new Inflater();
1288       }
1289       Inflater myInflater = tightInflaters[stream_id];
1290       myInflater.setInput(zlibData);
1291       byte[] buf = new byte[dataSize];
1292       myInflater.inflate(buf);
1293       if (rfb.rec != null && !rfb.recordFromBeginning) {
1294         rfb.recordCompressedData(buf);
1295       }
1296
1297       if (numColors != 0) {
1298         // Indexed colors.
1299         if (numColors == 2) {
1300           // Two colors.
1301           if (bytesPixel == 1) {
1302             decodeMonoData(x, y, w, h, buf, palette8);
1303           } else {
1304             decodeMonoData(x, y, w, h, buf, palette24);
1305           }
1306         } else {
1307           // More than two colors (assuming bytesPixel == 4).
1308           int i = 0;
1309           for (int dy = y; dy < y + h; dy++) {
1310             for (int dx = x; dx < x + w; dx++) {
1311               pixels24[dy * rfb.framebufferWidth + dx] =
1312                 palette24[buf[i++] & 0xFF];
1313             }
1314           }
1315         }
1316       } else if (useGradient) {
1317         // Compressed "Gradient"-filtered data (assuming bytesPixel == 4).
1318         decodeGradientData(x, y, w, h, buf);
1319       } else {
1320         // Compressed truecolor data.
1321         if (bytesPixel == 1) {
1322           int destOffset = y * rfb.framebufferWidth + x;
1323           for (int dy = 0; dy < h; dy++) {
1324             System.arraycopy(buf, dy * w, pixels8, destOffset, w);
1325             destOffset += rfb.framebufferWidth;
1326           }
1327         } else {
1328           int srcOffset = 0;
1329           int destOffset, i;
1330           for (int dy = 0; dy < h; dy++) {
1331             myInflater.inflate(buf);
1332             destOffset = (y + dy) * rfb.framebufferWidth + x;
1333             for (i = 0; i < w; i++) {
1334               pixels24[destOffset + i] =
1335                 (buf[srcOffset] & 0xFF) << 16 |
1336                 (buf[srcOffset + 1] & 0xFF) << 8 |
1337                 (buf[srcOffset + 2] & 0xFF);
1338               srcOffset += 3;
1339             }
1340           }
1341         }
1342       }
1343     }
1344
1345     handleUpdatedPixels(x, y, w, h);
1346     scheduleRepaint(x, y, w, h);
1347   }
1348
1349   //
1350   // Decode 1bpp-encoded bi-color rectangle (8-bit and 24-bit versions).
1351   //
1352
1353   void decodeMonoData(int x, int y, int w, int h, byte[] src, byte[] palette) {
1354
1355     int dx, dy, n;
1356     int i = y * rfb.framebufferWidth + x;
1357     int rowBytes = (w + 7) / 8;
1358     byte b;
1359
1360     for (dy = 0; dy < h; dy++) {
1361       for (dx = 0; dx < w / 8; dx++) {
1362         b = src[dy*rowBytes+dx];
1363         for (n = 7; n >= 0; n--)
1364           pixels8[i++] = palette[b >> n & 1];
1365       }
1366       for (n = 7; n >= 8 - w % 8; n--) {
1367         pixels8[i++] = palette[src[dy*rowBytes+dx] >> n & 1];
1368       }
1369       i += (rfb.framebufferWidth - w);
1370     }
1371   }
1372
1373   void decodeMonoData(int x, int y, int w, int h, byte[] src, int[] palette) {
1374
1375     int dx, dy, n;
1376     int i = y * rfb.framebufferWidth + x;
1377     int rowBytes = (w + 7) / 8;
1378     byte b;
1379
1380     for (dy = 0; dy < h; dy++) {
1381       for (dx = 0; dx < w / 8; dx++) {
1382         b = src[dy*rowBytes+dx];
1383         for (n = 7; n >= 0; n--)
1384           pixels24[i++] = palette[b >> n & 1];
1385       }
1386       for (n = 7; n >= 8 - w % 8; n--) {
1387         pixels24[i++] = palette[src[dy*rowBytes+dx] >> n & 1];
1388       }
1389       i += (rfb.framebufferWidth - w);
1390     }
1391   }
1392
1393   //
1394   // Decode data processed with the "Gradient" filter.
1395   //
1396
1397   void decodeGradientData (int x, int y, int w, int h, byte[] buf) {
1398
1399     int dx, dy, c;
1400     byte[] prevRow = new byte[w * 3];
1401     byte[] thisRow = new byte[w * 3];
1402     byte[] pix = new byte[3];
1403     int[] est = new int[3];
1404
1405     int offset = y * rfb.framebufferWidth + x;
1406
1407     for (dy = 0; dy < h; dy++) {
1408
1409       /* First pixel in a row */
1410       for (c = 0; c < 3; c++) {
1411         pix[c] = (byte)(prevRow[c] + buf[dy * w * 3 + c]);
1412         thisRow[c] = pix[c];
1413       }
1414       pixels24[offset++] =
1415         (pix[0] & 0xFF) << 16 | (pix[1] & 0xFF) << 8 | (pix[2] & 0xFF);
1416
1417       /* Remaining pixels of a row */
1418       for (dx = 1; dx < w; dx++) {
1419         for (c = 0; c < 3; c++) {
1420           est[c] = ((prevRow[dx * 3 + c] & 0xFF) + (pix[c] & 0xFF) -
1421                     (prevRow[(dx-1) * 3 + c] & 0xFF));
1422           if (est[c] > 0xFF) {
1423             est[c] = 0xFF;
1424           } else if (est[c] < 0x00) {
1425             est[c] = 0x00;
1426           }
1427           pix[c] = (byte)(est[c] + buf[(dy * w + dx) * 3 + c]);
1428           thisRow[dx * 3 + c] = pix[c];
1429         }
1430         pixels24[offset++] =
1431           (pix[0] & 0xFF) << 16 | (pix[1] & 0xFF) << 8 | (pix[2] & 0xFF);
1432       }
1433
1434       System.arraycopy(thisRow, 0, prevRow, 0, w * 3);
1435       offset += (rfb.framebufferWidth - w);
1436     }
1437   }
1438
1439   //
1440   // Display newly updated area of pixels.
1441   //
1442
1443   void handleUpdatedPixels(int x, int y, int w, int h) {
1444
1445     // Draw updated pixels of the off-screen image.
1446     pixelsSource.newPixels(x, y, w, h);
1447     memGraphics.setClip(x, y, w, h);
1448     memGraphics.drawImage(rawPixelsImage, 0, 0, null);
1449     memGraphics.setClip(0, 0, rfb.framebufferWidth, rfb.framebufferHeight);
1450   }
1451
1452   //
1453   // Tell JVM to repaint specified desktop area.
1454   //
1455
1456   void scheduleRepaint(int x, int y, int w, int h) {
1457     // Request repaint, deferred if necessary.
1458     if (rfb.framebufferWidth == scaledWidth) {
1459       repaint(viewer.deferScreenUpdates, x, y, w, h);
1460     } else {
1461       int sx = x * scalingFactor / 100;
1462       int sy = y * scalingFactor / 100;
1463       int sw = ((x + w) * scalingFactor + 49) / 100 - sx + 1;
1464       int sh = ((y + h) * scalingFactor + 49) / 100 - sy + 1;
1465       repaint(viewer.deferScreenUpdates, sx, sy, sw, sh);
1466     }
1467   }
1468
1469   //
1470   // Handle events.
1471   //
1472
1473   public void keyPressed(KeyEvent evt) {
1474     processLocalKeyEvent(evt);
1475   }
1476   public void keyReleased(KeyEvent evt) {
1477     processLocalKeyEvent(evt);
1478   }
1479   public void keyTyped(KeyEvent evt) {
1480     evt.consume();
1481   }
1482
1483   public void mousePressed(MouseEvent evt) {
1484     processLocalMouseEvent(evt, false);
1485   }
1486   public void mouseReleased(MouseEvent evt) {
1487     processLocalMouseEvent(evt, false);
1488   }
1489   public void mouseMoved(MouseEvent evt) {
1490     processLocalMouseEvent(evt, true);
1491   }
1492   public void mouseDragged(MouseEvent evt) {
1493     processLocalMouseEvent(evt, true);
1494   }
1495
1496   public void processLocalKeyEvent(KeyEvent evt) {
1497     if (viewer.rfb != null && rfb.inNormalProtocol) {
1498       if (!inputEnabled) {
1499         if ((evt.getKeyChar() == 'r' || evt.getKeyChar() == 'R') &&
1500             evt.getID() == KeyEvent.KEY_PRESSED ) {
1501           // Request screen update.
1502           try {
1503             rfb.writeFramebufferUpdateRequest(0, 0, rfb.framebufferWidth,
1504                                               rfb.framebufferHeight, false);
1505           } catch (IOException e) {
1506             e.printStackTrace();
1507           }
1508         }
1509       } else {
1510         // Input enabled.
1511         synchronized(rfb) {
1512           try {
1513             rfb.writeKeyEvent(evt);
1514           } catch (Exception e) {
1515             e.printStackTrace();
1516           }
1517           rfb.notify();
1518         }
1519       }
1520     }
1521     // Don't ever pass keyboard events to AWT for default processing.
1522     // Otherwise, pressing Tab would switch focus to ButtonPanel etc.
1523     evt.consume();
1524   }
1525
1526   public void processLocalMouseEvent(MouseEvent evt, boolean moved) {
1527     if (viewer.rfb != null && rfb.inNormalProtocol) {
1528       if (moved) {
1529         softCursorMove(evt.getX(), evt.getY());
1530       }
1531       if (rfb.framebufferWidth != scaledWidth) {
1532         int sx = (evt.getX() * 100 + scalingFactor/2) / scalingFactor;
1533         int sy = (evt.getY() * 100 + scalingFactor/2) / scalingFactor;
1534         evt.translatePoint(sx - evt.getX(), sy - evt.getY());
1535       }
1536       synchronized(rfb) {
1537         try {
1538           rfb.writePointerEvent(evt);
1539         } catch (Exception e) {
1540           e.printStackTrace();
1541         }
1542         rfb.notify();
1543       }
1544     }
1545   }
1546
1547   //
1548   // Ignored events.
1549   //
1550
1551   public void mouseClicked(MouseEvent evt) {}
1552   public void mouseEntered(MouseEvent evt) {}
1553   public void mouseExited(MouseEvent evt) {}
1554
1555
1556   //////////////////////////////////////////////////////////////////
1557   //
1558   // Handle cursor shape updates (XCursor and RichCursor encodings).
1559   //
1560
1561   boolean showSoftCursor = false;
1562
1563   MemoryImageSource softCursorSource;
1564   Image softCursor;
1565
1566   int cursorX = 0, cursorY = 0;
1567   int cursorWidth, cursorHeight;
1568   int origCursorWidth, origCursorHeight;
1569   int hotX, hotY;
1570   int origHotX, origHotY;
1571
1572   //
1573   // Handle cursor shape update (XCursor and RichCursor encodings).
1574   //
1575
1576   synchronized void
1577     handleCursorShapeUpdate(int encodingType,
1578                             int xhot, int yhot, int width, int height)
1579     throws IOException {
1580
1581     softCursorFree();
1582
1583     if (width * height == 0)
1584       return;
1585
1586     // Ignore cursor shape data if requested by user.
1587     if (viewer.options.ignoreCursorUpdates) {
1588       int bytesPerRow = (width + 7) / 8;
1589       int bytesMaskData = bytesPerRow * height;
1590
1591       if (encodingType == rfb.EncodingXCursor) {
1592         rfb.is.skipBytes(6 + bytesMaskData * 2);
1593       } else {
1594         // rfb.EncodingRichCursor
1595         rfb.is.skipBytes(width * height + bytesMaskData);
1596       }
1597       return;
1598     }
1599
1600     // Decode cursor pixel data.
1601     softCursorSource = decodeCursorShape(encodingType, width, height);
1602
1603     // Set original (non-scaled) cursor dimensions.
1604     origCursorWidth = width;
1605     origCursorHeight = height;
1606     origHotX = xhot;
1607     origHotY = yhot;
1608
1609     // Create off-screen cursor image.
1610     createSoftCursor();
1611
1612     // Show the cursor.
1613     showSoftCursor = true;
1614     repaint(viewer.deferCursorUpdates,
1615             cursorX - hotX, cursorY - hotY, cursorWidth, cursorHeight);
1616   }
1617
1618   //
1619   // decodeCursorShape(). Decode cursor pixel data and return
1620   // corresponding MemoryImageSource instance.
1621   //
1622
1623   synchronized MemoryImageSource
1624     decodeCursorShape(int encodingType, int width, int height)
1625     throws IOException {
1626
1627     int bytesPerRow = (width + 7) / 8;
1628     int bytesMaskData = bytesPerRow * height;
1629
1630     int[] softCursorPixels = new int[width * height];
1631
1632     if (encodingType == rfb.EncodingXCursor) {
1633
1634       // Read foreground and background colors of the cursor.
1635       byte[] rgb = new byte[6];
1636       rfb.readFully(rgb);
1637       int[] colors = { (0xFF000000 | (rgb[3] & 0xFF) << 16 |
1638                         (rgb[4] & 0xFF) << 8 | (rgb[5] & 0xFF)),
1639                        (0xFF000000 | (rgb[0] & 0xFF) << 16 |
1640                         (rgb[1] & 0xFF) << 8 | (rgb[2] & 0xFF)) };
1641
1642       // Read pixel and mask data.
1643       byte[] pixBuf = new byte[bytesMaskData];
1644       rfb.readFully(pixBuf);
1645       byte[] maskBuf = new byte[bytesMaskData];
1646       rfb.readFully(maskBuf);
1647
1648       // Decode pixel data into softCursorPixels[].
1649       byte pixByte, maskByte;
1650       int x, y, n, result;
1651       int i = 0;
1652       for (y = 0; y < height; y++) {
1653         for (x = 0; x < width / 8; x++) {
1654           pixByte = pixBuf[y * bytesPerRow + x];
1655           maskByte = maskBuf[y * bytesPerRow + x];
1656           for (n = 7; n >= 0; n--) {
1657             if ((maskByte >> n & 1) != 0) {
1658               result = colors[pixByte >> n & 1];
1659             } else {
1660               result = 0;       // Transparent pixel
1661             }
1662             softCursorPixels[i++] = result;
1663           }
1664         }
1665         for (n = 7; n >= 8 - width % 8; n--) {
1666           if ((maskBuf[y * bytesPerRow + x] >> n & 1) != 0) {
1667             result = colors[pixBuf[y * bytesPerRow + x] >> n & 1];
1668           } else {
1669             result = 0;         // Transparent pixel
1670           }
1671           softCursorPixels[i++] = result;
1672         }
1673       }
1674
1675     } else {
1676       // encodingType == rfb.EncodingRichCursor
1677
1678       // Read pixel and mask data.
1679       byte[] pixBuf = new byte[width * height * bytesPixel];
1680       rfb.readFully(pixBuf);
1681       byte[] maskBuf = new byte[bytesMaskData];
1682       rfb.readFully(maskBuf);
1683
1684       // Decode pixel data into softCursorPixels[].
1685       byte pixByte, maskByte;
1686       int x, y, n, result;
1687       int i = 0;
1688       for (y = 0; y < height; y++) {
1689         for (x = 0; x < width / 8; x++) {
1690           maskByte = maskBuf[y * bytesPerRow + x];
1691           for (n = 7; n >= 0; n--) {
1692             if ((maskByte >> n & 1) != 0) {
1693               if (bytesPixel == 1) {
1694                 result = cm8.getRGB(pixBuf[i]);
1695               } else {
1696                 result = 0xFF000000 |
1697                   (pixBuf[i * 4 + 2] & 0xFF) << 16 |
1698                   (pixBuf[i * 4 + 1] & 0xFF) << 8 |
1699                   (pixBuf[i * 4] & 0xFF);
1700               }
1701             } else {
1702               result = 0;       // Transparent pixel
1703             }
1704             softCursorPixels[i++] = result;
1705           }
1706         }
1707         for (n = 7; n >= 8 - width % 8; n--) {
1708           if ((maskBuf[y * bytesPerRow + x] >> n & 1) != 0) {
1709             if (bytesPixel == 1) {
1710               result = cm8.getRGB(pixBuf[i]);
1711             } else {
1712               result = 0xFF000000 |
1713                 (pixBuf[i * 4 + 2] & 0xFF) << 16 |
1714                 (pixBuf[i * 4 + 1] & 0xFF) << 8 |
1715                 (pixBuf[i * 4] & 0xFF);
1716             }
1717           } else {
1718             result = 0;         // Transparent pixel
1719           }
1720           softCursorPixels[i++] = result;
1721         }
1722       }
1723
1724     }
1725
1726     return new MemoryImageSource(width, height, softCursorPixels, 0, width);
1727   }
1728
1729   //
1730   // createSoftCursor(). Assign softCursor new Image (scaled if necessary).
1731   // Uses softCursorSource as a source for new cursor image.
1732   //
1733
1734   synchronized void
1735     createSoftCursor() {
1736
1737     if (softCursorSource == null)
1738       return;
1739
1740     int scaleCursor = viewer.options.scaleCursor;
1741     if (scaleCursor == 0 || !inputEnabled)
1742       scaleCursor = 100;
1743
1744     // Save original cursor coordinates.
1745     int x = cursorX - hotX;
1746     int y = cursorY - hotY;
1747     int w = cursorWidth;
1748     int h = cursorHeight;
1749
1750     cursorWidth = (origCursorWidth * scaleCursor + 50) / 100;
1751     cursorHeight = (origCursorHeight * scaleCursor + 50) / 100;
1752     hotX = (origHotX * scaleCursor + 50) / 100;
1753     hotY = (origHotY * scaleCursor + 50) / 100;
1754     softCursor = Toolkit.getDefaultToolkit().createImage(softCursorSource);
1755
1756     if (scaleCursor != 100) {
1757       softCursor = softCursor.getScaledInstance(cursorWidth, cursorHeight,
1758                                                 Image.SCALE_SMOOTH);
1759     }
1760
1761     if (showSoftCursor) {
1762       // Compute screen area to update.
1763       x = Math.min(x, cursorX - hotX);
1764       y = Math.min(y, cursorY - hotY);
1765       w = Math.max(w, cursorWidth);
1766       h = Math.max(h, cursorHeight);
1767
1768       repaint(viewer.deferCursorUpdates, x, y, w, h);
1769     }
1770   }
1771
1772   //
1773   // softCursorMove(). Moves soft cursor into a particular location.
1774   //
1775
1776   synchronized void softCursorMove(int x, int y) {
1777     int oldX = cursorX;
1778     int oldY = cursorY;
1779     cursorX = x;
1780     cursorY = y;
1781     if (showSoftCursor) {
1782       repaint(viewer.deferCursorUpdates,
1783               oldX - hotX, oldY - hotY, cursorWidth, cursorHeight);
1784       repaint(viewer.deferCursorUpdates,
1785               cursorX - hotX, cursorY - hotY, cursorWidth, cursorHeight);
1786     }
1787   }
1788
1789   //
1790   // softCursorFree(). Remove soft cursor, dispose resources.
1791   //
1792
1793   synchronized void softCursorFree() {
1794     if (showSoftCursor) {
1795       showSoftCursor = false;
1796       softCursor = null;
1797       softCursorSource = null;
1798
1799       repaint(viewer.deferCursorUpdates,
1800               cursorX - hotX, cursorY - hotY, cursorWidth, cursorHeight);
1801     }
1802   }
1803 }