VNCviewGS/hextile.cc

306 lines
11 KiB
C++
Raw Normal View History

#if __ORCAC__
#pragma lint -1
#pragma noroot
segment "VNCview GS";
#endif
#include <window.h>
#include <quickdraw.h>
#include <qdaux.h>
#include <desk.h>
#include <memory.h>
#include <resources.h>
#include <tcpip.h>
#include <menu.h>
#include <control.h>
#include <misctool.h>
#include <scrap.h>
#include <stdio.h>
#include <stdlib.h>
#include <event.h>
#include <limits.h>
#include "vncsession.h"
#include "vncview.h"
#include "vncdisplay.h"
#include "colortables.h"
#include "menus.h"
#include "clipboard.h"
#include "desktopsize.h"
#include "mouse.h"
#include "keyboard.h"
#include "copyrect.h"
#include "raw.h"
#include "hextile.h"
static unsigned int hexXTiles, hexYTiles; /* For in-process hextile processing */
static unsigned int hexXTileNum, hexYTileNum;
static unsigned int hexTileWidth, hexTileHeight;
static unsigned char hexBackground, hexForeground;
static BOOLEAN extraByteAdvance;
/* Used in Hextile encoding */
#define Raw 0x01
#define BackgroundSpecified 0x02
#define ForegroundSpecified 0x04
#define AnySubrects 0x08
#define SubrectsColoured 0x10
#define hexWaitingForSubencoding 1
#define hexWaitingForMoreInfo 2
#define hexWaitingForSubrect 4
#define hexWaitingForRawData 8
static void HexNextTile (void) {
hexXTileNum++;
if (hexXTileNum == hexXTiles) {
hexYTileNum++;
if (hexYTileNum == hexYTiles) { /* Done with this Hextile rect */
displayInProgress = FALSE;
NextRect();
return;
}
hexXTileNum = 0;
}
hexTileWidth = (hexXTileNum == hexXTiles - 1) ?
rectWidth - 16 * (hexXTiles - 1) : 16;
hexTileHeight = (hexYTileNum == hexYTiles - 1) ?
rectHeight - 16 * (hexYTiles - 1) : 16;
}
static void HexRawDraw (Point *contentOriginPtr, int rectWidth, int rectHeight) {
unsigned int i, j; /* Loop indices */
unsigned int n = 0;
unsigned char *dataPtr;
unsigned char pixels[128];
static Rect srcRect = {0,0,0,0};
dataPtr = (unsigned char *) *readBufferHndl;
if ((hRez==640 && (rectWidth & 0x03)) || (hRez==320 && (rectWidth & 0x01)))
extraByteAdvance = TRUE;
else
extraByteAdvance = FALSE;
for (j = 0; j < rectHeight; j++) {
for (i = 0; i < rectWidth; i++) {
if (hRez == 640) {
switch (i & 0x03) {
case 0x00: /* pixels 0, 4, 8, ... */
pixels[n] = pixTransTbl[ *(dataPtr +
(unsigned long) j*rectWidth + i)
] & 0xC0;
break;
case 0x01: /* pixels 1, 5, 9, ... */
pixels[n] += pixTransTbl[ *(dataPtr +
(unsigned long) j*rectWidth + i)
] & 0x30;
break;
case 0x02: /* pixels 2, 6, 10, ... */
pixels[n] += pixTransTbl[ *(dataPtr +
(unsigned long) j*rectWidth + i)
] & 0x0C;
break;
case 0x03: /* pixels 3, 7, 11, ... */
pixels[n] += pixTransTbl[ *(dataPtr +
(unsigned long) j*rectWidth + i)
] & 0x03;
n++;
} /* switch */
} /* if */
else { /* 320 mode */
switch(i & 0x01) {
case 0x00: /* pixels 0, 2, 4, ... */
pixels[n] = pixTransTbl[ *(dataPtr +
(unsigned long) j*rectWidth + i)
] & 0xF0;
break;
case 0x01: /* pixels 1, 3, 5, ... */
pixels[n] += pixTransTbl[ *(dataPtr +
(unsigned long) j*rectWidth + i)
] & 0x0F;
n++;
} /* switch */
} /* else */
} /* i loop */
/* When not ending a line on a byte boundary, the index isn't updated,
* so we do it here.
*/
if (extraByteAdvance)
n++;
} /* j loop */
srcLocInfo.ptrToPixImage = (void *) pixels;
srcLocInfo.boundsRect.v2 = rectHeight;
/* Since the lines are rounded up to integral numbers of bytes, this
* padding must be accounted for here.
*/
if (hRez == 640) {
switch (rectWidth & 0x03) {
case 0x00: srcLocInfo.boundsRect.h2 = rectWidth;
srcLocInfo.width = rectWidth/4; break;
case 0x01: srcLocInfo.boundsRect.h2 = rectWidth+3;
srcLocInfo.width = rectWidth/4 + 1; break;
case 0x02: srcLocInfo.boundsRect.h2 = rectWidth+2;
srcLocInfo.width = rectWidth/4 + 1; break;
case 0x03: srcLocInfo.boundsRect.h2 = rectWidth+1;
srcLocInfo.width = rectWidth/4 + 1;
}
}
else { /* hRez == 320 */
switch (rectWidth & 0x01) {
case 0x00: srcLocInfo.boundsRect.h2 = rectWidth;
srcLocInfo.width = rectWidth/2; break;
case 0x01: srcLocInfo.boundsRect.h2 = rectWidth+1;
srcLocInfo.width = rectWidth/2 + 1;
}
}
srcRect.v2 = hexTileHeight;
srcRect.h2 = hexTileWidth;
PPToPort(&srcLocInfo, &srcRect,
rectX + hexXTileNum * 16 - contentOriginPtr->h,
rectY + hexYTileNum * 16 - contentOriginPtr->v, modeCopy);
}
/* The macros below are used in HexDispatch() */
#define HexDispatch_NextTile() do { \
HexNextTile(); \
HUnlock(readBufferHndl); \
/* Set up for next time */ \
status = hexWaitingForSubencoding; \
bytesNeeded = 1; \
return; \
} while (0)
#define HexDispatch_DrawRect(color, X, Y, width, height) do { \
SetSolidPenPat((color)); \
drawingRect.h1 = rectX + hexXTileNum * 16 + (X) - contentOriginPtr->h; \
drawingRect.v1 = rectY + hexYTileNum * 16 + (Y) - contentOriginPtr->v; \
drawingRect.h2 = rectX + hexXTileNum * 16 + (X) + (width) - contentOriginPtr->h; \
drawingRect.v2 = rectY + hexYTileNum * 16 + (Y) + (height) - contentOriginPtr->v; \
PaintRect(&drawingRect); \
} while (0)
#define HexDispatch_DrawBackground() \
HexDispatch_DrawRect(hexBackground, 0, 0, hexTileWidth, hexTileHeight)
void HexDispatch (void) {
static unsigned char status = hexWaitingForSubencoding;
static unsigned long bytesNeeded = 1;
static unsigned char subencoding;
static unsigned int numSubrects;
int i;
/* For use with GetContentOrigin() */
unsigned long contentOrigin;
Point * contentOriginPtr = (void *) &contentOrigin;
int tileBytes;
unsigned int srX, srY, srWidth, srHeight;
Rect drawingRect;
static unsigned char pixels[128];
unsigned char *dataPtr;
contentOrigin = GetContentOrigin(vncWindow);
SetPort(vncWindow);
/* If we don't have the next bit of needed data yet, return. */
while (DoReadTCP(bytesNeeded)) {
HLock(readBufferHndl);
dataPtr = *(unsigned char **) readBufferHndl;
/* If we're here, readBufferHndl contains bytesNeeded bytes of data. */
switch (status) {
case hexWaitingForSubencoding:
subencoding = *dataPtr;
if (subencoding & Raw) {
bytesNeeded = hexTileWidth * hexTileHeight;
status = hexWaitingForRawData;
}
else {
bytesNeeded = 0;
if (subencoding & BackgroundSpecified)
bytesNeeded++;
if (subencoding & ForegroundSpecified)
bytesNeeded++;
if (subencoding & AnySubrects)
bytesNeeded++;
else if (bytesNeeded == 0) {
/* No more data - just draw background */
HexDispatch_DrawBackground();
HexDispatch_NextTile();
}
status = hexWaitingForMoreInfo;
}
break;
case hexWaitingForRawData:
HexRawDraw(contentOriginPtr, hexTileWidth, hexTileHeight);
HexDispatch_NextTile();
break;
case hexWaitingForMoreInfo:
if (subencoding & BackgroundSpecified) {
hexBackground = pixTransTbl[*(dataPtr++)];
}
if (subencoding & ForegroundSpecified) {
hexForeground = pixTransTbl[*(dataPtr++)];
}
if (subencoding & AnySubrects) {
numSubrects = *dataPtr;
if (numSubrects) {
status = hexWaitingForSubrect;
bytesNeeded = numSubrects * ((subencoding & SubrectsColoured) ? 3 : 2);
break;
}
else
HexDispatch_NextTile();
}
else { /* no subrects */
HexDispatch_DrawBackground();
HexDispatch_NextTile();
}
case hexWaitingForSubrect: {
HexDispatch_DrawBackground();
while (numSubrects-- > 0) {
if (subencoding & SubrectsColoured) {
hexForeground = pixTransTbl[*(dataPtr++)];
}
srX = *dataPtr >> 4;
srY = *(dataPtr++) & 0x0F;
srWidth = (*dataPtr >> 4) + 1;
srHeight = (*(dataPtr++) & 0x0F) + 1;
HexDispatch_DrawRect(hexForeground, srX, srY, srWidth, srHeight);
}
HexDispatch_NextTile();
}
}
HUnlock(readBufferHndl);
}
}
/* Called when we initially get a Hextile rect; set up to process it */
void DoHextileRect (void) {
hexXTiles = (rectWidth + 15) / 16;
hexYTiles = (rectHeight + 15) / 16;
hexXTileNum = 0;
hexYTileNum = 0;
displayInProgress = TRUE;
hexTileWidth = (hexYTileNum == hexXTiles - 1) ?
rectWidth - 16 * (hexXTiles - 1) : 16;
hexTileHeight = (hexYTileNum == hexYTiles - 1) ?
rectHeight - 16 * (hexYTiles - 1) : 16;
/* Set up for Hextile drawing */
srcRect.v1 = 0;
srcRect.h1 = 0;
}