From 31ff3755706ab98d3a6d82f76f3ab892e6eebfbe Mon Sep 17 00:00:00 2001 From: Stephen Heumann Date: Wed, 23 Sep 2015 19:40:17 -0500 Subject: [PATCH] Post-1.0b1 work in progress from 2004. This contains partial code for displaying the cursor locally. --- ._README | Bin 1334 -> 1334 bytes README | 2 +- clipboard.cc | 117 ++ clipboard.h | 3 + copyrect.cc | 75 + copyrect.h | 2 + cursors.txt | 38 + desktopsize.cc | 84 + desktopsize.h | 1 + handleerr.cc | 87 - hextile.cc | 301 +++ hextile.h | 2 + keyboard.cc | 153 ++ keyboard.h | 2 + make | 92 +- mouse.cc | 321 ++++ mouse.h | 3 + oldDoReadTCP.cc | 160 -- out.txt | 4882 +++++++++++++++++++++++++++++++++++++++++++++++ raw.cc | 396 ++++ raw.h | 3 + test.cc | 351 ---- vncdisplay.cc | 1078 +---------- vncdisplay.h | 38 +- vncsession.cc | 10 +- vncview.cc | 9 + 26 files changed, 6481 insertions(+), 1729 deletions(-) create mode 100644 clipboard.cc create mode 100644 clipboard.h create mode 100644 copyrect.cc create mode 100644 copyrect.h create mode 100644 cursors.txt create mode 100644 desktopsize.cc create mode 100644 desktopsize.h delete mode 100644 handleerr.cc create mode 100644 hextile.cc create mode 100644 hextile.h create mode 100644 keyboard.cc create mode 100644 keyboard.h create mode 100644 mouse.cc create mode 100644 mouse.h delete mode 100644 oldDoReadTCP.cc create mode 100644 out.txt create mode 100644 raw.cc create mode 100644 raw.h delete mode 100644 test.cc diff --git a/._README b/._README index 48b93c7c06702c6d15bcfc6f0e57f88495446e77..e7e029d684788ce2dc47c852e509a45f66eff6c4 100644 GIT binary patch delta 83 zcmdnSwT)|n5l4t?L`XqOe(}UanTcVY0=*9ym>GH)7#Qpr85l|!SSG$N7H63LfI+AM l$Y(eOA{h9X85k<2KbYLeICo+J$7DICBa8<(KV}MM0s#F97)JmA delta 83 zcmdnSwT)|n5l2Blh-*Pge(}UanTcVY0v!(+m>GH)7#Qpr85l|!I48a@7OyFIz#!BB lqr diff --git a/README b/README index 24c40b3..9762944 100644 --- a/README +++ b/README @@ -1,6 +1,6 @@ VNCview GS 1.0b1 README -VNCview GS is a VNC client (viewer) for the Apple IIgs. You can use it to display and interact with the graphical desktop of another computer through your Apple IIgs. +VNCview GS is a Virtual Network Computing client (viewer) for the Apple IIgs. You can use it to display and interact with the graphical desktop of another computer through your Apple IIgs. System Requirements A (real or emulated) ROM 01 or ROM 3 Apple IIgs diff --git a/clipboard.cc b/clipboard.cc new file mode 100644 index 0000000..25b049c --- /dev/null +++ b/clipboard.cc @@ -0,0 +1,117 @@ +#pragma noroot + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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" + +/* Update the Scrap Manager clipboard with new data sent from server. + */ +void DoServerCutText (void) { + unsigned long textLen; + unsigned long i; + + if (! DoWaitingReadTCP (3)) { /* Read & ignore padding */ + DoClose(vncWindow); + return; + } + if (! DoWaitingReadTCP (4)) { + DoClose(vncWindow); + return; + } + HLock(readBufferHndl); + textLen = SwapBytes4((unsigned long) **readBufferHndl); + HUnlock(readBufferHndl); + + if (! DoWaitingReadTCP(textLen)) { + DoClose(vncWindow); + return; + }; + if (allowClipboardTransfers) { + ZeroScrap(); + HLock(readBufferHndl); + + /* Convert lf->cr; Use pointer arithmetic so we can go over 64k */ + for (i = 0; i < textLen; i++) + if (*((*(char **)readBufferHndl)+i) == '\n') + *((*(char **)readBufferHndl)+i) = '\r'; + + /* Below function call requires to be fixed */ + PutScrap(textLen, textScrap, (Pointer) *readBufferHndl); + /* Potential errors (e.g. out of memory) ignored */ + HUnlock(readBufferHndl); + } + } + +void DoSendClipboard (void) { + static struct clientCutText { + unsigned char messageType; + unsigned char padding1; + unsigned int padding2; + unsigned long length; + } clientCutTextStruct = { 6 /* Message type 6 */ }; + + Handle scrapHandle; + unsigned long i; + + /* Only proceed if we're connected to the server and not view-only */ + if (vncConnected && !viewOnlyMode) { + clientCutTextStruct.length = GetScrapSize(textScrap); + + if (clientCutTextStruct.length == 0) + return; + + clientCutTextStruct.length = SwapBytes4(clientCutTextStruct.length); + + scrapHandle = NewHandle(1, userid(), 0x0000, NULL); + GetScrap(scrapHandle, textScrap); + if (toolerror()) + goto end; /* abort if error */ + if (TCPIPWriteTCP(hostIpid, &clientCutTextStruct.messageType, + sizeof(clientCutTextStruct), FALSE, FALSE)) + goto end; /* abort if error */ + if (toolerror()) + goto end; + + clientCutTextStruct.length = SwapBytes4(clientCutTextStruct.length); + + HLock(scrapHandle); + /* Convert cr->lf; Use pointer arithmetic so we can go over 64k */ + for (i = 0; i < clientCutTextStruct.length; i++) + if (*((*(char **)scrapHandle)+i) == '\r') + *((*(char **)scrapHandle)+i) = '\n'; + + TCPIPWriteTCP(hostIpid, (Pointer) *scrapHandle, + clientCutTextStruct.length, TRUE, FALSE); + /* Can't handle errors usefully here */ + HUnlock(scrapHandle); + + end: + DisposeHandle(scrapHandle); + } + } + diff --git a/clipboard.h b/clipboard.h new file mode 100644 index 0000000..27a49aa --- /dev/null +++ b/clipboard.h @@ -0,0 +1,3 @@ +extern void DoServerCutText (void); +extern void DoSendClipboard (void); + diff --git a/copyrect.cc b/copyrect.cc new file mode 100644 index 0000000..ddbc8db --- /dev/null +++ b/copyrect.cc @@ -0,0 +1,75 @@ +#pragma noroot + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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" + +void DoCopyRect (void) { + /* For use with GetContentOrigin() */ + unsigned long contentOrigin; + Point * contentOriginPtr = (void *) &contentOrigin; + + Rect srcRect; + unsigned int *dataPtr; /* Pointer to TCP data that was read */ + + //printf("Processing CopyRect rectangle\n"); + + if (! DoReadTCP ((unsigned long) 4)) + return; /* Not ready yet; wait */ + + contentOrigin = GetContentOrigin(vncWindow); + + HLock(readBufferHndl); + dataPtr = (unsigned int *) ((char *) (*readBufferHndl)); + srcRect.h1 = SwapBytes2(dataPtr[0]) - contentOriginPtr->h; + srcRect.v1 = SwapBytes2(dataPtr[1]) - contentOriginPtr->v; + HUnlock(readBufferHndl); + + srcRect.h2 = srcRect.h1 + rectWidth; + srcRect.v2 = srcRect.v1 + rectHeight; + + /* Check that the source rect is actually visible; if not, ask the server + to send the update using some other encoding. + */ + if (!RectInRgn(&srcRect, GetVisHandle())) { + SendFBUpdateRequest(FALSE, rectX, rectY, rectWidth, rectHeight); + displayInProgress = FALSE; + return; + } + + /* We can use the window pointer as a LocInfo pointer because it starts + * with a grafPort structure, which in turn starts with a LocInfo structure. + */ + PPToPort((struct LocInfo *) vncWindow, &srcRect, + rectX - contentOriginPtr->h, rectY - contentOriginPtr->v, modeCopy); + + displayInProgress = FALSE; + + NextRect(); /* Prepare for next rect */ + } + diff --git a/copyrect.h b/copyrect.h new file mode 100644 index 0000000..bccedba --- /dev/null +++ b/copyrect.h @@ -0,0 +1,2 @@ +extern void DoCopyRect (void); + diff --git a/cursors.txt b/cursors.txt new file mode 100644 index 0000000..d194dc9 --- /dev/null +++ b/cursors.txt @@ -0,0 +1,38 @@ +vncview.cc: if (cursor) { +vncview.cc: free(cursor); +vncview.cc: if (cursor) +vncview.cc: free(cursor); +vncview.cc: InitCursor(); /* Activate pointer cursor */ +vncview.cc: InitCursor(); /* start the arrow cursor */ +mouse.cc:unsigned char * cursor = NULL; /* Cursor from server */ +mouse.cc:/* This routine also maintains the appropriate cursor when using local cursor */ +mouse.cc: if (cursor && GetCursorAdr() == cursor) +mouse.cc: if (cursor && GetCursorAdr() != cursor) +mouse.cc: SetCursor(cursor); +mouse.cc: unsigned char *cursorPixels; +mouse.cc: /* Elements of the cursor structure (which isn't a C struct) */ +mouse.cc: unsigned int *cursorHeightPtr, *cursorWidthPtr; +mouse.cc: unsigned char *cursorImage, *cursorMask; +mouse.cc: unsigned char *oldCursor = cursor; /* So we can free() it later */ +mouse.cc: cursorPixels = (unsigned char *)(*readBufferHndl); +mouse.cc: cursor = malloc(8 + 4 * lineWords * rectHeight); +mouse.cc: if (cursor == NULL) +mouse.cc: cursorHeightPtr = (unsigned int *)(void *)cursor; +mouse.cc: cursorWidthPtr = cursorHeightPtr + 1; +mouse.cc: cursorImage = cursor + 4; +mouse.cc: cursorMask = cursorImage + lineWords * rectHeight * 2; +mouse.cc: hotSpotYPtr = (unsigned int *)(cursorMask + lineWords * rectHeight * 2); +mouse.cc: *cursorHeightPtr = rectHeight; +mouse.cc: *cursorWidthPtr = lineWords; +mouse.cc: /* Make cursorImage using translation tables */ +mouse.cc: /* Make cursorMask from bitmask */ +mouse.cc: dataPtr = cursorPixels; +mouse.cc: maskLine = cursorMask + line * lineWords * 2; +mouse.cc: imageLine = cursorImage + line * lineWords * 2; +mouse.cc: maskLine = cursorMask + line * lineWords * 2; +mouse.cc: imageLine = cursorImage + line * lineWords * 2; +mouse.cc: j = cursorPixels + rectWidth * (line + 1) - dataPtr; +mouse.cc: SetCursor(cursor); +mouse.cc: for (k = cursor; k < cursorImage; k++) +mouse.cc: fprintf(foo, "%02X", *(cursorImage + j)); +mouse.cc: for (k = cursorImage + j; k < cursorImage + j + 4; k = k + 1) diff --git a/desktopsize.cc b/desktopsize.cc new file mode 100644 index 0000000..5ed8aa5 --- /dev/null +++ b/desktopsize.cc @@ -0,0 +1,84 @@ +#pragma noroot + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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" + +/* This prototype should be in but is bogusly commented out there */ +extern pascal void SetContentOrigin2(Word, Word, Word, GrafPortPtr) inline(0x570E,dispatcher); + +void DoDesktopSize (void) { + #define screenTooBigError 2010 + unsigned long contentOrigin; + Point * contentOriginPtr = (void *) &contentOrigin; + unsigned int newX, newY; + Boolean changeOrigin = FALSE; + unsigned int oldWinHeight, oldWinWidth; + + fbWidth = rectWidth; + fbHeight = rectHeight; + + if ((fbWidth > 16384) || (fbHeight > 16384)) { + AlertWindow(awResource, NULL, screenTooBigError); + DoClose(vncWindow); + } + + oldWinHeight = winHeight; + oldWinWidth = winWidth; + winHeight = 174; + winWidth = (hRez == 640) ? 613 : 302; + if (fbWidth < winWidth) + winWidth = fbWidth; + if (fbHeight < winHeight) + winHeight = fbHeight; + if (oldWinHeight != winHeight || oldWinWidth != winWidth) + SizeWindow(winWidth, winHeight, vncWindow); + + /* Scroll if area displayed is going away */ + contentOrigin = GetContentOrigin(vncWindow); + newX = contentOriginPtr->h; + newY = contentOriginPtr->v; + + if (contentOriginPtr->h + winWidth > fbWidth) { + newX = fbWidth - winWidth; + changeOrigin = TRUE; + } + if (contentOriginPtr->v + winHeight > fbHeight) { + newY = fbHeight - winHeight; + changeOrigin = TRUE; + } + SetContentOrigin2(1, newX, newY, vncWindow); + + SetDataSize(fbWidth, fbHeight, vncWindow); + DrawControls(vncWindow); + + displayInProgress = FALSE; + + NextRect(); /* Prepare for next rect */ + } + diff --git a/desktopsize.h b/desktopsize.h new file mode 100644 index 0000000..f1cd5c3 --- /dev/null +++ b/desktopsize.h @@ -0,0 +1 @@ +extern void DoDesktopSize (void); diff --git a/handleerr.cc b/handleerr.cc deleted file mode 100644 index f3f97a9..0000000 --- a/handleerr.cc +++ /dev/null @@ -1,87 +0,0 @@ -/*************************************************************** -* HandleError.cc - routines to dosplay error messages -***************************************************************/ - -#if __ORCAC__ -#pragma lint -1 -#pragma noroot -#endif - -#if DEBUG -#pragma debug 25 -#endif - -#include -#include -#include -#include - -/*************************************************************** -* GetString - Get a string from the resource fork -* Parameters: -* resourceID - resource ID of the rCString resource -* Returns: pointer to the string; NULL for an error -* Notes: The string is in a locked resource handle. The caller -* should call FreeString when the string is no longer needed. -* Failure to do so is not catastrophic; the memory will be -* deallocated when the program is shut down. -***************************************************************/ - -char *GetString (int resourceID) -{ -Handle hndl; /* resource handle */ - -hndl = LoadResource(rCString, resourceID); -if (toolerror() == 0) { - HLock(hndl); - return (char *) (*hndl); - } -return NULL; -} - -/*************************************************************** -* FreeString - Free a resource string -* Parameters: -* resourceID - resource ID of the rCString to free -***************************************************************/ - -void FreeString (int resourceID) -{ -ReleaseResource(-3, rCString, resourceID); -} - -/*************************************************************** -* FlagError - Flag an error -* Parameters: -* error - error message number -* tError - toolbox error code; 0 if none -***************************************************************/ - -void FlagError (int error, int tError) -{ -#define errorAlert 2000 /* alert resource ID */ -#define errorBase 2000 /* base resource ID for fortunes */ - -char *substArray; /* substitution "array" */ -char *errorString; /* pointer to the error string */ - - /* form the error string */ -errorString = GetString(errorBase + error); -substArray = NULL; -if (errorString != NULL) { - substArray = (char *)malloc(strlen(substArray)+9); - if (substArray != NULL) - strcpy(substArray, errorString); - FreeString(errorBase + error); - } -if (substArray != NULL) { - if (tError != 0) /* add the tool error number */ - sprintf(&substArray[strlen(substArray)], " ($%04X)", tError); - /* show the alert */ - AlertWindow(awCString+awResource, (Pointer) &substArray, errorAlert); - free(substArray); - } - -#undef errorAlert -#undef errorBase -} diff --git a/hextile.cc b/hextile.cc new file mode 100644 index 0000000..345e673 --- /dev/null +++ b/hextile.cc @@ -0,0 +1,301 @@ +#pragma noroot + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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" + +unsigned int hexXTiles, hexYTiles; /* For in-process hextile processing */ +unsigned int hexXTileNum, hexYTileNum; +unsigned int hexTileWidth, hexTileHeight; +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 + +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; + + } + +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; + } diff --git a/hextile.h b/hextile.h new file mode 100644 index 0000000..479f508 --- /dev/null +++ b/hextile.h @@ -0,0 +1,2 @@ +extern void HexDispatch (void); +extern void DoHextileRect (void); diff --git a/keyboard.cc b/keyboard.cc new file mode 100644 index 0000000..a18b672 --- /dev/null +++ b/keyboard.cc @@ -0,0 +1,153 @@ +#pragma noroot + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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" + +/* Send a KeyEvent message to the server + */ +void SendKeyEvent (BOOLEAN keyDownFlag, unsigned long key) +{ + struct KeyEvent { + unsigned char messageType; + unsigned char keyDownFlag; + unsigned int padding; + unsigned long key; + } keyEvent = { 4 /* Message Type 4 */, + 0, + 0 /* Zero the padding */ + }; + + keyEvent.keyDownFlag = !!keyDownFlag; + keyEvent.key = SwapBytes4(key); + TCPIPWriteTCP(hostIpid, &keyEvent.messageType, sizeof(keyEvent), + TRUE, FALSE); + /* No error checking here -- Can't respond to one usefully. */ +} + + +/* Process a key down event and send it on to the server. */ +void ProcessKeyEvent (void) +{ + unsigned long key = myEvent.message & 0x0000007F; + + if (viewOnlyMode) + return; + + /* Deal with extended keys that are mapped as keypad keys */ + if (myEvent.modifiers & keyPad) { + switch (key) { + case 0x7A: key = 0xFFBE; break; /* F1 */ + case 0x78: key = 0xFFBF; break; /* F2 */ + case 0x63: key = 0xFFC0; break; /* F3 */ + case 0x76: key = 0xFFC1; break; /* F4 */ + case 0x60: key = 0xFFC2; break; /* F5 */ + case 0x61: key = 0xFFC3; break; /* F6 */ + case 0x62: key = 0xFFC4; break; /* F7 */ + case 0x64: key = 0xFFC5; break; /* F8 */ + case 0x65: key = 0xFFC6; break; /* F9 */ + case 0x6D: key = 0xFFC7; break; /* F10 */ + case 0x67: key = 0xFFC8; break; /* F11 */ + case 0x6F: key = 0xFFC9; break; /* F12 */ + case 0x69: key = 0xFF15; break; /* F13 / PrintScr -> SysRq */ + case 0x6B: key = 0xFF14; break; /* F14 / ScrLock -> ScrLock */ + case 0x71: key = 0xFF13; break; /* F15 / Pause -> Pause */ + case 0x72: key = 0xFF63; break; /* Help / Insert -> Insert */ + case 0x75: key = 0xFFFF; break; /* Forward delete -> Delete */ + case 0x73: key = 0xFF50; break; /* Home */ + case 0x77: key = 0xFF57; break; /* End */ + case 0x74: key = 0xFF55; break; /* Page Up */ + case 0x79: key = 0xFF56; break; /* Page Down */ + } + } + + if (key == 0x7f) + key = 0xFF08; /* Delete -> BackSpace */ + + if (key < 0x20) { + if (myEvent.modifiers & controlKey) { + if (((myEvent.modifiers & shiftKey) || + (myEvent.modifiers & capsLock)) + && !((myEvent.modifiers & shiftKey) && + (myEvent.modifiers & capsLock))) + key += 0x40; /* Undo effect of control on upper-case char. */ + else + key += 0x60; /* Undo effect of control */ + } + else switch (key) { + case 0x1B: key = 0xFF1B; break; /* Escape */ + case 0x09: key = 0xFF09; break; /* Tab */ + case 0x0D: key = 0xFF0D; break; /* Return / Enter */ + case 0x08: key = 0xFF51; break; /* Left arrow */ + case 0x0B: key = 0xFF52; break; /* Up arrow */ + case 0x15: key = 0xFF53; break; /* Right arrow */ + case 0x0A: key = 0xFF54; break; /* Down arrow */ + case 0x18: key = 0xFF0B; break; /* Clear / NumLock -> Clear */ + } + } + + /* Test if we seem to have a valid character and return if we don't. + This should never return, unless there are bugs in this routine or + TaskMaster gives us bogus keycodes. The test would need to be updated + if we ever start generating valid keycodes outside of these ranges. + */ + if ((key & 0xFF80) != 0xFF00 && (key & 0xFF80) != 0x0000) + return; + + SendKeyEvent(TRUE, key); + SendKeyEvent(FALSE, key); +} + +/* Send modifier keys that have changed since last update */ +void SendModifiers (void) { + static unsigned int oldModifiers = 0x00FF; /* So it runs 1st time */ + unsigned int modifiers; + + modifiers = myEvent.modifiers & 0x1B00; + + /* If unchanged, do nothing. */ + if (modifiers == oldModifiers) + return; + + /* Apple key is sent as "meta" */ + if ((modifiers & appleKey) != (oldModifiers & appleKey)) + SendKeyEvent(modifiers & appleKey, 0xFFE7); + + if ((modifiers & shiftKey) != (oldModifiers & shiftKey)) + SendKeyEvent(modifiers & shiftKey, 0xFFE1); + + /* Option key is sent as "alt," as per its labelling on some keyboards */ + if ((modifiers & optionKey) != (oldModifiers & optionKey)) + SendKeyEvent(modifiers & optionKey, 0xFFE9); + + if ((modifiers & controlKey) != (oldModifiers & controlKey)) + SendKeyEvent(modifiers & controlKey, 0xFFE3); + + oldModifiers = modifiers; +} + diff --git a/keyboard.h b/keyboard.h new file mode 100644 index 0000000..4f6d8a0 --- /dev/null +++ b/keyboard.h @@ -0,0 +1,2 @@ +extern void ProcessKeyEvent (void); +extern void SendModifiers (void); diff --git a/make b/make index 8b79003..2c46778 100644 --- a/make +++ b/make @@ -1,86 +1,42 @@ unset exit set link false -set vncview false -set vncsession false -set vncdisplay false -set colortables false set rezfork false clearmem -newer vncview.a vncview.cc -if {status} != 0 - set vncview true - set link true +for {header} in vncview vncsession vncdisplay colortables menus \ + desktopsize mouse keyboard copyrect raw hextile clipboard + unset exit + newer VNCview.GS {header}.h + if {status} != 0 + set exit on + delete -P -W =.a + end +end + +for file in vncview vncsession vncdisplay colortables \ + desktopsize mouse keyboard copyrect raw hextile clipboard + unset exit + newer {file}.a {file}.cc + if {status} != 0 + set exit on + compile +O {file}.cc keep={file} + set link true end - -newer vncsession.a vncsession.cc -if {status} != 0 - set vncsession true - set link true -end - -newer vncview.a vncview.h -if {status} != 0 - set vncview true - set link true -end - -newer vncsession.a vncview.h -if {status} != 0 - set vncsession true - set link true -end - -newer vncsession.a vncsession.h -if {status} != 0 - set vncsession true - set link true -end - -newer vncview.a vncsession.h -if {status} != 0 - set vncview true - set link true -end - -newer vncdisplay.a vncdisplay.cc -if {status} != 0 - set vncdisplay true - set link true -end - -newer colortables.a colortables.cc -if {status} != 0 - set colortables true - set link true end +unset exit newer vncview.rezfork vncview.rez if {status} != 0 - set rezfork true -end - -set exit on - -if {rezfork} == true + set exit on compile vncview.rez keep=vncview.rezfork copy -C -P -R vncview.rezfork VNCview.GS end -if {vncview} == true - compile +O vncview.cc keep=vncview -end -if {vncsession} == true - compile +O vncsession.cc keep=vncsession -end -if {vncdisplay} == true - compile +O vncdisplay.cc keep=vncdisplay -end -if {colortables} == true - compile +O colortables.cc keep=colortables -end + if {link} == true - link vncview vncsession vncdisplay colortables keep=VNCview.GS + link vncview vncsession vncdisplay colortables \ + desktopsize mouse keyboard copyrect raw hextile clipboard \ + keep=VNCview.GS filetype VNCview.GS S16 $DB03 end diff --git a/mouse.cc b/mouse.cc new file mode 100644 index 0000000..949a914 --- /dev/null +++ b/mouse.cc @@ -0,0 +1,321 @@ +#pragma noroot + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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" + +unsigned char * cursor = NULL; /* Cursor from server */ + +/* Send a DoPointerEvent reflecting the status of the mouse to the server */ +/* This routine also maintains the appropriate cursor when using local cursor */ +void DoPointerEvent (void) { + static struct { + unsigned char messageType; + unsigned char buttonMask; + unsigned int xPos; + unsigned int yPos; + } pointerEventStruct = { 5 /* message type */ }; + + Point mouseCoords; + unsigned long contentOrigin; + Point * contentOriginPtr = (void *) &contentOrigin; + RegionHndl contentRgnHndl; + unsigned int oldButtonMask; + GrafPortPtr winPtr; + unsigned long key1 = 0x0000; /* Keys to release & re-press, if any */ + unsigned long key2 = 0x0000; + + if (viewOnlyMode) + return; + + mouseCoords = myEvent.where; + + SetPort(vncWindow); + + /* Check if mouse is in content region of VNC window; don't send mouse + * updates if it isn't. + */ + if (FindWindow(&winPtr, myEvent.where.h, myEvent.where.v) != wInContent || + winPtr != vncWindow) { + if (cursor && GetCursorAdr() == cursor) + InitCursor(); + return; + } + + GlobalToLocal(&mouseCoords); + + contentOrigin = GetContentOrigin(vncWindow); + mouseCoords.h += contentOriginPtr->h; + mouseCoords.v += contentOriginPtr->v; + + mouseCoords.h = SwapBytes2(mouseCoords.h); + mouseCoords.v = SwapBytes2(mouseCoords.v); + + /* Set up correct state of mouse buttons */ + oldButtonMask = pointerEventStruct.buttonMask; + pointerEventStruct.buttonMask = 0x00; + + if ((myEvent.modifiers & btn0State) == 0x00) { /* Mouse button pressed */ + if (emulate3ButtonMouse) { + if (myEvent.modifiers & optionKey) { + pointerEventStruct.buttonMask = 0x02; + key1 = 0xFFE9; + } + if (myEvent.modifiers & appleKey) { + pointerEventStruct.buttonMask |= 0x04; + key2 = 0xFFE7; + } + } + + /* If no modifiers, just send a normal left click. */ + if (pointerEventStruct.buttonMask == 0x00) + pointerEventStruct.buttonMask = 0x01; + } + if ((myEvent.modifiers & btn1State) == 0x00) /* If 2nd (right) */ + pointerEventStruct.buttonMask |= 0x04; /* button is pressed */ + + /* Don't waste bandwidth by sending update if mouse hasn't changed. + * This may occasionally result in an initial mouse update not being + * sent. If this occurs, the user can simply move the mouse slightly + * in order to send it. + */ + if ( (pointerEventStruct.xPos == mouseCoords.h) && + (pointerEventStruct.yPos == mouseCoords.v) && + (pointerEventStruct.buttonMask == oldButtonMask) ) + return; + + pointerEventStruct.xPos = mouseCoords.h; + pointerEventStruct.yPos = mouseCoords.v; + + if (key1) + SendKeyEvent(FALSE, key1); + if (key2) + SendKeyEvent(FALSE, key2); + + TCPIPWriteTCP(hostIpid, (Pointer) &pointerEventStruct.messageType, + sizeof(pointerEventStruct), TRUE, FALSE); + /* Can't do useful error checking here */ + + if (key1) + SendKeyEvent(TRUE, key1); + if (key2) + SendKeyEvent(TRUE, key2); + + //printf("Sent mouse update: x = %u, y = %u\n", mouseCoords.h, mouseCoords.v); + //printf(" xPos = %x, yPos = %x, buttons = %x\n", pointerEventStruct.xPos, pointerEventStruct.yPos, (int) pointerEventStruct.buttonMask); + + /* Note that we don't have to request a display update here. That has + * been or will be done elsewhere when we're ready for it. + */ + + if (cursor && GetCursorAdr() != cursor) + SetCursor(cursor); +} + +void DoCursor (void) { + unsigned char *cursorPixels; + unsigned char *bitmask; + unsigned char *dataPtr; + /* Elements of the cursor structure (which isn't a C struct) */ + unsigned int *cursorHeightPtr, *cursorWidthPtr; + unsigned char *cursorImage, *cursorMask; + unsigned int *hotSpotYPtr, *hotSpotXPtr; + unsigned long bitmaskByte; + unsigned long bitmaskLineBytes, lineWords; + unsigned int line, n, j; /* Loop counters */ + unsigned char *maskLine, *imageLine; + unsigned char *oldCursor = cursor; /* So we can free() it later */ + unsigned int outBytes640; + unsigned long outBytes320; + + bitmaskLineBytes = (rectWidth + 7) / 8; + + if (!DoReadTCP(rectWidth*rectHeight + bitmaskLineBytes*rectHeight)) + return; /* Try again later */ + + HLock(readBufferHndl); + + cursorPixels = (unsigned char *)(*readBufferHndl); + bitmask = (unsigned char *)(*readBufferHndl) + rectWidth*rectHeight; + + if (hRez == 640) + lineWords = (rectWidth + 7) / 8 + 1; + else /* hRez == 320 */ + lineWords = (rectWidth + 3) / 4 + 1; + + cursor = malloc(8 + 4 * lineWords * rectHeight); + /* Sub-optimal error handling */ + if (cursor == NULL) + return; + /* Don't overflow loop indices */ + if ((lineWords > UINT_MAX) || (rectHeight > UINT_MAX)) + return; + cursorHeightPtr = (unsigned int *)(void *)cursor; + cursorWidthPtr = cursorHeightPtr + 1; + cursorImage = cursor + 4; + cursorMask = cursorImage + lineWords * rectHeight * 2; + hotSpotYPtr = (unsigned int *)(cursorMask + lineWords * rectHeight * 2); + hotSpotXPtr = hotSpotYPtr + 1; + + *cursorHeightPtr = rectHeight; + *cursorWidthPtr = lineWords; + *hotSpotYPtr = rectY; + *hotSpotXPtr = rectX; + + /* Make cursorImage using translation tables */ + /* Make cursorMask from bitmask */ + + dataPtr = cursorPixels; + + if (hRez == 320) { + for (line = 0; line < rectHeight; line++) { /* for each line ... */ + maskLine = cursorMask + line * lineWords * 2; + imageLine = cursorImage + line * lineWords * 2; + + for (j = 0; j < bitmaskLineBytes; j++) { + bitmaskByte = *(bitmask + line*bitmaskLineBytes + j); + outBytes320 = + ((bitmaskByte & 0x80) ) + ((bitmaskByte & 0x80) >> 1) + + ((bitmaskByte & 0x80) >> 2) + ((bitmaskByte & 0x80) >> 3) + + ((bitmaskByte & 0x40) >> 3) + ((bitmaskByte & 0x40) >> 4) + + ((bitmaskByte & 0x40) >> 5) + ((bitmaskByte & 0x40) >> 6) + + ((bitmaskByte & 0x20) << 10) + ((bitmaskByte & 0x20) << 9) + + ((bitmaskByte & 0x20) << 8) + ((bitmaskByte & 0x20) << 7) + + ((bitmaskByte & 0x10) << 7) + ((bitmaskByte & 0x10) << 6) + + ((bitmaskByte & 0x10) << 5) + ((bitmaskByte & 0x10) << 4) + + ((bitmaskByte & 0x08) << 20) + ((bitmaskByte & 0x08) << 19) + + ((bitmaskByte & 0x08) << 18) + ((bitmaskByte & 0x08) << 17) + + ((bitmaskByte & 0x04) << 17) + ((bitmaskByte & 0x04) << 16) + + ((bitmaskByte & 0x04) << 15) + ((bitmaskByte & 0x04) << 14) + + ((bitmaskByte & 0x02) << 30) + ((bitmaskByte & 0x02) << 29) + + ((bitmaskByte & 0x02) << 28) + ((bitmaskByte & 0x02) << 27) + + ((bitmaskByte & 0x01) << 27) + ((bitmaskByte & 0x01) << 26) + + ((bitmaskByte & 0x01) << 25) + ((bitmaskByte & 0x01) << 24); + *((unsigned long *)maskLine + j) = outBytes320; + } + *((unsigned int *)maskLine + lineWords - 1) = 0; + + for (n = 0; n < rectWidth/2; n++) { + *(imageLine + n) = coltab320[*(dataPtr++)] & 0xF0; + *(imageLine + n) += coltab320[*(dataPtr++)] & 0x0F; + *(imageLine + n) ^= 0xFF; /* Reverse color */ + *(imageLine + n) &= *(maskLine + n); + } + if (rectWidth % 2) { + *(imageLine + n) = coltab320[*(dataPtr++)] & 0xF0; + *(imageLine + n) ^= 0xFF; /* Reverse color */ + *(imageLine + n) &= *(maskLine + n); + n++; + } + *(imageLine + n) = 0; + *((unsigned int *)imageLine + lineWords - 1) = 0; + } + } + else { /* hRez == 640 */ + for (line = 0; line < rectHeight; line++) { /* for each line ... */ + maskLine = cursorMask + line * lineWords * 2; + imageLine = cursorImage + line * lineWords * 2; + + for (j = 0; j < bitmaskLineBytes; j++) { + bitmaskByte = *(bitmask + line*bitmaskLineBytes + j); + outBytes640 = + ((bitmaskByte & 0x80) ) + ((bitmaskByte & 0xC0) >> 1) + + ((bitmaskByte & 0x60) >> 2) + ((bitmaskByte & 0x30) >> 3) + + ((bitmaskByte & 0x10) >> 4) + ((bitmaskByte & 0x08) << 12) + + ((bitmaskByte & 0x0C) << 11) + ((bitmaskByte & 0x06) << 10) + + ((bitmaskByte & 0x03) << 9) + ((bitmaskByte & 0x01) << 8); + *((unsigned int *)maskLine + j) = outBytes640; + } + *((unsigned int *)maskLine + lineWords - 1) = 0; + + for (n = 0; n < lineWords * 2 - 4; n++) { + *(imageLine + n) = coltab640[*(dataPtr++)] & 0xC0; + *(imageLine + n) += coltab640[*(dataPtr++)] & 0x30; + *(imageLine + n) += coltab640[*(dataPtr++)] & 0x0C; + *(imageLine + n) += coltab640[*(dataPtr++)] & 0x03; + *(imageLine + n) ^= 0xFF; /* Reverse color */ + *(imageLine + n) &= *(maskLine + n); + } + *(imageLine + n) = 0; + j = cursorPixels + rectWidth * (line + 1) - dataPtr; + if (j-- > 0) { + *(imageLine + n) += coltab640[*(dataPtr++)] & 0xC0; + if (j-- > 0) { + *(imageLine + n) += coltab640[*(dataPtr++)] & 0x30; + if (j-- > 0) { + *(imageLine + n) += coltab640[*(dataPtr++)] & 0x0C; + if (j-- > 0) { + *(imageLine + n) += coltab640[*(dataPtr++)] & 0x03; + } + } + } + } + *(imageLine + n) ^= 0xFF; /* Reverse color */ + *(imageLine + n) &= *(maskLine + n); + *(unsigned int *)(imageLine + n + 1) = 0; + } + } + + HUnlock(readBufferHndl); + + if (GetCursorAdr() == oldCursor) + SetCursor(cursor); + if (oldCursor) + free(oldCursor); + +#if 0 + /***************/ + { + unsigned char * k; + FILE *foo = fopen("out.txt", "a"); + fprintf(foo, "Width = %u, Height = %u, Hotspot X = %u, Hotspot Y = %u:\n", + rectWidth, rectHeight, rectX, rectY); + fprintf(foo, "\n"); + for (k = cursor; k < cursorImage; k++) + fprintf(foo, "%02X ", *k); + for (j = 0; j < lineWords * rectHeight * 4; j++) { + fprintf(foo, "%02X", *(cursorImage + j)); + if ((j+1) % (lineWords * 2) == 0) + fprintf(foo, "\n"); + } + for (k = cursorImage + j; k < cursorImage + j + 4; k = k + 1) + fprintf(foo, "%02X ", *k); + //for (j = 0; j < bitmaskLineBytes*rectHeight; j++) { + // fprintf(foo, "%02X", *(bitmask + j)); + // if ((j+1) % bitmaskLineBytes == 0) + // fprintf(foo, "\n"); + // } + fprintf(foo, "\n"); + fclose(foo); + } + /***************/ +#endif + + displayInProgress = FALSE; + NextRect(); /* Prepare for next rect */ + } diff --git a/mouse.h b/mouse.h new file mode 100644 index 0000000..5af4f9b --- /dev/null +++ b/mouse.h @@ -0,0 +1,3 @@ +extern unsigned char * cursor; /* Cursor from server */ +extern void DoPointerEvent (void); +extern void DoCursor (void); diff --git a/oldDoReadTCP.cc b/oldDoReadTCP.cc deleted file mode 100644 index 034253b..0000000 --- a/oldDoReadTCP.cc +++ /dev/null @@ -1,160 +0,0 @@ - -#if 0 -/* Old version of DoReadTCP with lots of obfuscated junk in it. Don't use. */ -BOOLEAN DoReadTCP (unsigned long dataLength, BOOLEAN waitForData) { - #define buffTypePointer 0x0000 - #define buffTypeHandle 0x0001 - #define buffTypeNewHandle 0x0002 - - static srBuff theSRBuff; - static rrBuff theRRBuff; - unsigned long remainingDataLength = 0; - unsigned long initialTime; - void * currentDataPtr; - static unsigned long bytesBeforeExtraBytes = 0; /* Only valid if */ - /* extraBytes > 0 */ - static unsigned long extraBytes = 0; - - restart: - - /* Check if there was extra data left over from the last read */ - if (extraBytes > 0) { - HLock(readBufferHndl); - BlockMove((char *)*readBufferHndl + bytesBeforeExtraBytes, - *readBufferHndl, extraBytes); - HUnlock(readBufferHndl); - SetHandleSize(extraBytes, readBufferHndl); - - if (extraBytes >= dataLength) { - bytesBeforeExtraBytes = dataLength; - extraBytes = extraBytes - dataLength; - return TRUE; - } - else { - remainingDataLength = dataLength - extraBytes; - theRRBuff.rrPushFlag = TRUE; - } - } - - /* Check if there is enough data to return. If the waitForData flag is */ - /* set, wait up to 15 seconds for the data to arrive */ - initialTime = TickCount(); - do { - if (TickCount() >= initialTime + 15*60) { - readError = 1; - return FALSE; - } - TCPIPPoll(); - if ((TCPIPStatusTCP(hostIpid, &theSRBuff)) && - (theSRBuff.srRcvQueued < dataLength)) { - readError = 2; - return FALSE; - } - if (toolerror()) { - readError = 3; - return FALSE; - } - if ((theSRBuff.srRcvQueued < dataLength) && (waitForData == FALSE)) { - return FALSE; - } - } while ((theSRBuff.srRcvQueued < dataLength)); - - printf("Wanted %lu bytes; %lu bytes available.\n", dataLength, theSRBuff.srRcvQueued); - printf("Out of main loop. Started %lu; now %lu.\n", initialTime, TickCount()); - - /* Try to read the data */ - if ((remainingDataLength == 0) && - (TCPIPReadTCP(hostIpid, buffTypeHandle, (Ref) readBufferHndl, - dataLength, &theRRBuff)) && (theRRBuff.rrBuffCount < dataLength)) { - readError = 4; - return FALSE; - } - if (toolerror()) { - readError = 5; - return FALSE; - } - - printf("rrBuffCount (data read) = %lu; dataLength (data requested) = %lu\n", theRRBuff.rrBuffCount, dataLength); - - /* Return successfully if the data was read */ - if (theRRBuff.rrBuffCount >= dataLength) { - if (theRRBuff.rrBuffCount > dataLength) { - extraBytes = theRRBuff.rrBuffCount - dataLength; - bytesBeforeExtraBytes = dataLength; - } - return TRUE; - } - /* An ugly workaround for an apparent Marinetti bug wherein at least the - * requested amount of data is supposedly available in its buffers, but - * for some reason Marinetti returns less data than that in TCPIPReadTCP(). - */ -#if 1 - else if ((theRRBuff.rrBuffCount > 0) && /*(extraBytes == 0) &&*/ - (theRRBuff.rrBuffCount < dataLength)) { - char foo[200]; - char **bar = (char **)&foo; - sprintf(foo, "Returned:%lu Wanted:%lu Supposedly available:%lu", (unsigned long)(theRRBuff.rrBuffCount), (unsigned long)dataLength, (unsigned long)(theSRBuff.srRcvQueued)); - //printf("Handling extra bytes\n"); - //extraBytes = theRRBuff.rrBuffCount; - //bytesBeforeExtraBytes = 0; - AlertWindow(awResource, (Pointer)&bar, 10000); - //return FALSE; - //goto restart; - return TRUE; - } -#endif - /* This may not be necessary and should not normally be used. It */ - /* continues requesting data until a sufficient amount has been */ - /* received, which may be necessary when the data stream contains push */ - /* flags. */ - else if (theRRBuff.rrPushFlag) { - //printf("Handling push flag in middle of data.\n"); - remainingDataLength = dataLength; - SetHandleSize(dataLength, readBufferHndl); - HLock(readBufferHndl); - currentDataPtr = (*readBufferHndl) + theRRBuff.rrBuffCount; - - while (theRRBuff.rrPushFlag && (remainingDataLength > 0)) { - TCPIPPoll(); - - if ((TCPIPReadTCP(hostIpid, buffTypeHandle, NULL, - remainingDataLength, &theRRBuff)) && - (theRRBuff.rrBuffCount < dataLength)) { - readError = 6; - return FALSE; - } - if (toolerror()) { - readError = 7; - return FALSE; - } - if (theRRBuff.rrBuffCount > 0) { - HandToPtr(theRRBuff.rrBuffHandle, currentDataPtr, - (theRRBuff.rrBuffCount < remainingDataLength) ? - theRRBuff.rrBuffCount : remainingDataLength); - DisposeHandle(theRRBuff.rrBuffHandle); - if (theRRBuff.rrBuffCount > remainingDataLength) { - extraBytes = theRRBuff.rrBuffCount - dataLength; - bytesBeforeExtraBytes = remainingDataLength; - theRRBuff.rrBuffCount = remainingDataLength; - } - currentDataPtr += theRRBuff.rrBuffCount; - remainingDataLength -= theRRBuff.rrBuffCount; - if (remainingDataLength == 0) { - HUnlock(readBufferHndl); - return TRUE; - } - } - else { - HUnlock(readBufferHndl); - readError = 8; - return FALSE; - } - } - } - - HUnlock(readBufferHndl); - readError = 9; - return FALSE; - #undef buffTypeNewHandle - } -#endif /* 0 */ diff --git a/out.txt b/out.txt new file mode 100644 index 0000000..6737e0e --- /dev/null +++ b/out.txt @@ -0,0 +1,4882 @@ +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 0FFFFFFFFFF00000 +00FFFFFFFFF00000 +0F0FFFFFFFF00000 +0FF0FFFFFFF00000 +0FFF0FFFFFF00000 +0FFFF0FFFFF00000 +0FFFFF0FFFF00000 +0FFFFFF0FFF00000 +0FFFFFFF0FF00000 +0FFFFFFFF0F00000 +0FFFFF0000000000 +0FF0FF0FFFF00000 +0F0F0FF0FFF00000 +00FF0FF0FFF00000 +0FFFF0FF0FF00000 +FFFFF0FF0FF00000 +FFFFFF0FF0F00000 +FFFFFF0FF0F00000 +FFFFFFF00FF00000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 20, Hotspot X = 4, Hotspot Y = 9: + +14 00 04 00 FFFFFFFFFF000000 +0F0F00FFFF000000 +00FFFFF000000000 +0FFF000000000000 +FFFFF0FFFFF00000 +FFF0FFFFFFF00000 +F0FFFFFFFF000000 +FFFFFFFF0FF00000 +FFFFFF0FFFF00000 +FFFF0FFFFFF00000 +FF0FFFFFFFF00000 +0FFFFFFFF0F00000 +FFFF000000000000 +FFF00000FFF00000 +FF000FFFFFF00000 +F0FFFFFFFFF00000 +FFFF002090900000 +0F4F420202000000 +2020202020F00000 +4F49090200000000 +0000F00000000000 +000FFF0000000000 +00FFFFF000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +00FFFFF000000000 +000FFF0000000000 +0000F00000000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 08FFFFFFFFF00000 +00FFFFFFFFF00000 +0F0FFFFFFFF00000 +0FF0FFFFFFF00000 +0FFF0FFFFFF00000 +0FFFF0FFFFF00000 +0FFFFF0FFFF00000 +0FFFFFF0FFF00000 +0FFFFFFF0FF00000 +0FFFFFFFF0F00000 +0FFFFF0000000000 +0FF0FF0FFFF00000 +0F0F0FF0FFF00000 +00FF0FF0FFF00000 +0FFFF0FF0FF00000 +FFFFF0FF0FF00000 +FFFFFF0FF0F00000 +FFFFFF0FF0F00000 +FFFFFFF00FF00000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 21, Height = 9, Hotspot X = 10, Hotspot Y = 4: + +09 00 07 00 F0FFFFFFF0FFFFFFFFFFFF000000 +FF0FFFF0FFFFFF0FFFFFFF000000 +0FFFF0FFFFFF00FFFFF000F00000 +FFFFFFFFFF000FFF000000000000 +000000000000F0F000FFFFF00000 +FFFFFF000FFF0F00FFFF0FF00000 +FFFF00FFFFFFF0FFFF0FFFF00000 +FF0FFFFFFFFFFFFF0FFFFFF00000 +FFFFF20420490B9FBFFB9FB00000 +0000FF000000000FF00000000000 +000FFF000000000FFF0000000000 +00FFFF000000000FFFF000000000 +0FFFFFFFFFFFFFFFFFFF00000000 +FFFFFFFFFFFFFFFFFFFFF0000000 +0FFFFFFFFFFFFFFFFFFF00000000 +00FFFF000000000FFFF000000000 +000FFF000000000FFF0000000000 +0000FF000000000FF00000000000 +04 00 0A 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 08FFFFFFFFF00000 +00FFFFFFFFF00000 +0F0FFFFFFFF00000 +0FF0FFFFFFF00000 +0FFF0FFFFFF00000 +0FFFF0FFFFF00000 +0FFFFF0FFFF00000 +0FFFFFF0FFF00000 +0FFFFFFF0FF00000 +0FFFFFFFF0F00000 +0FFFFF0000000000 +0FF0FF0FFFF00000 +0F0F0FF0FFF00000 +00FF0FF0FF000000 +0FFFF0FF00000000 +FFFFF0FF00000000 +FFFFFF0FF0000000 +FFFFFF0FF0000000 +FFFFFFF000000000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 20, Hotspot X = 4, Hotspot Y = 9: + +14 00 04 00 FFFFFFFFFF000000 +0F0F00FFFF000000 +00FFFFF000000000 +0FFF000000000000 +FFFFF0FFFFF00000 +FFF0FFFFFFF00000 +F0FFFFFFFF000000 +FFFF000F0F000000 +00FFFF0FFFF00000 +FFFF0FFFFFF00000 +FF0FFFFFFFF00000 +0FFFFFFFF0F00000 +FFFF000000000000 +FFF00000FFF00000 +FF000FFFFFF00000 +F0FFFFFFFFF00000 +FFFF002090900000 +0F4F420202000000 +2020202020F00000 +4F49090200000000 +0000F00000000000 +000FFF0000000000 +00FFFFF000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +00FFFFF000000000 +000FFF0000000000 +0000F00000000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 08FFFFFFFFF00000 +00FFFFFFFFF00000 +0F0FFFFFFFF00000 +0FF0FFFFFFF00000 +0FFF0FFFFFF00000 +0FFFF0FFFFF00000 +0FFFFF0FFFF00000 +0FFFFFF0FFF00000 +0FFFFFFF0FF00000 +0FFFFFFFF0F00000 +0FFFFF0000000000 +0FF0FF0FFFF00000 +0F0F0FF0FFF00000 +00FF0FF0FF000000 +0FFFF0FF00000000 +FFFFF0FF00000000 +FFFFFF0FF0000000 +FFFFFF0FF0000000 +FFFFFFF000000000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 18, Hotspot X = 4, Hotspot Y = 9: + +12 00 04 00 FFFFFFFFFF000000 +00F000FFFFF00000 +0FFFFFFFF0F00000 +FFFFFFF0FFF00000 +FFFFF0FFFFF00000 +FFF0FFFFFFF00000 +F0FFFFFFFF000000 +FFFFFFFF0FF00000 +FFFFFF0FFFF00000 +FFFF0FFFFFF00000 +FF0FFFFFFFF00000 +0FFFFFFFF0F00000 +FFFFFFF0FFF00000 +FF000F000FF00000 +FFFFFFFF90F00000 +4902020202000000 +2020202020200000 +0202090F49000000 +0FFF0FFF00000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +0FFF0FFF00000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 0FFFFFFFFFF00000 +00FFFFFFFFF00000 +0F0FFFFFFFF00000 +0FF0FFFFFFF00000 +0FFF0FFFFFF00000 +0FFFF0FFFFF00000 +0FFFFF0FFFF00000 +0FFFFFF0FFF00000 +0FFFFFFF0FF00000 +0FFFFFFFF0F00000 +0FFFFF0000000000 +0FF0FF0FFFF00000 +0F0F0FF0FFF00000 +00FF0FF0FFF00000 +0FFFF0FF0FF00000 +FFFFF0FF0FF00000 +FFFFFF0FF0F00000 +FFFFFF0FF0F00000 +FFFFFFF00FF00000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 18, Hotspot X = 4, Hotspot Y = 9: + +12 00 04 00 FFFFFFFFFF000000 +00F000FFFFF00000 +0FFFFFFFF0F00000 +FFFFFFF0FFF00000 +FFFFF0FFFFF00000 +FFF0FFFFFFF00000 +F0FFFFFFFF000000 +FFFFFFFF0FF00000 +FFFFFF0FFFF00000 +FFFF0FFFFFF00000 +FF0FFFFFFFF00000 +0FFFFFFFF0F00000 +FFFFFFF0FFF00000 +FF000F000FF00000 +FFFFFFFF90F00000 +4902020202000000 +2020202020200000 +0202090F49000000 +0FFF0FFF00000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +0FFF0FFF00000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 0FFFFFFFFFF00000 +00FFFFFFFFF00000 +0F0FFFFFFFF00000 +0FF0FFFFFFF00000 +0FFF0FFFFFF00000 +0FFFF0FFFFF00000 +0FFFFF0FFFF00000 +0FFFFFF0FFF00000 +0FFFFFFF0FF00000 +0FFFFFFFF0F00000 +0FFFFF0000000000 +0FF0FF0FFFF00000 +0F0F0FF0FFF00000 +00FF0FF0FFF00000 +0FFFF0FF0FF00000 +FFFFF0FF0FF00000 +FFFFFF0FF0F00000 +FFFFFF0FF0F00000 +FFFFFFF00FF00000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 18, Hotspot X = 4, Hotspot Y = 9: + +12 00 04 00 FFFFFFFFFF000000 +00F000FFFFF00000 +0FFFFFFFF0F00000 +FFFFFFF0FFF00000 +FFFFF0FFFFF00000 +FFF0FFFFFFF00000 +F0FFFFFFFF000000 +FFFFFFFF0FF00000 +FFFFFF0FFFF00000 +FFFF0FFFFFF00000 +FF0FFFFFFFF00000 +0FFFFFFFF0F00000 +FFFFFFF0FFF00000 +FF000F000FF00000 +FFFFFFFF90F00000 +4902020202000000 +2020202020200000 +0202090F49000000 +0FFF0FFF00000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +008FFF0036F10900 +000FFF0000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +0FFF0FFF00000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 0FFFFFFFFFF00000 +00FFFFFFFFF00000 +0F0FFFFFFFF00000 +0FF0FFFFFFF00000 +0FFF0FFFFFF00000 +0FFFF0FFFFF00000 +0FFFFF0FFFF00000 +0FFFFFF0FFF00000 +0FFFFFFF0FF00000 +0FFFFFFFF0F00000 +0FFFFF0000000000 +0FF0FF0FFFF00000 +0F0F0FF0FFF00000 +00FF0FF0FFF00000 +0FFFF0FF0FF00000 +FFFFF0FF0FF00000 +FFFFFF0FF0F00000 +FFFFFF0FF0F00000 +FFFFFFF00FF00000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 03 00 3FFFFC3F0000 +FFF33FFF0000 +CF3FFF3F0000 +3FFCFF3F0000 +F3FF3FCF0000 +FF3F3FFF0000 +3CFFFF330000 +FF000F3C0000 +FF333CFC0000 +3CF3F3FC0000 +F3FFF3CF0000 +FFF3CFFF0000 +CF3FFFC30000 +C01223330000 +333721110000 +0000FFFF0000 +F0FFFFCC0000 +FFFF3CFF0000 +FCFCFFF30000 +C00000000000 +F00000000000 +FC0000000000 +FF0000000000 +FFC000000000 +FFF000000000 +FFFC00000000 +FFFF00000000 +FFFFC0000000 +FFFFF0000000 +FFFFFC000000 +FFFC00000000 +FCFF00000000 +F0FF00000000 +C03FC0000000 +003FC0000000 +000FF0000000 +000FF0000000 +0003C0000000 +00 00 00 00 +Width = 9, Height = 20, Hotspot X = 4, Hotspot Y = 9: + +14 00 03 00 FFFFF0CC0000 +3FC0FFC00000 +0FC000FF0000 +CFFFF3FF0000 +FCFFFF3F0000 +FFCFFFF30000 +FFFCFFFF0000 +3FFFCFFF0000 +F3FF00030000 +F003FF030000 +FFF3FFFF0000 +FF04CCCC0000 +444444440000 +CCCC40000000 +000055550000 +555555550000 +555555550000 +555555550000 +554000550000 +555555550000 +00C000000000 +03F000000000 +0FFC00000000 +3FFF00000000 +FFFFC0000000 +FFFFC0000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +FFFFC0000000 +FFFFC0000000 +3FFF00000000 +0FFC00000000 +03F000000000 +00C000000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 03 00 2FFFFC3F0000 +FFF33FFF0000 +CF3FFF3F0000 +3FFCFF3F0000 +F3FF3FCF0000 +FF3F3FFF0000 +3CFFFF330000 +FF000F3C0000 +FF333CFC0000 +3CF3F3FC0000 +F3FFF3CF0000 +FFF3CFFF0000 +CF3FFFC30000 +C01223330000 +333721110000 +000155550000 +555555550000 +555555550000 +554000550000 +C00000000000 +F00000000000 +FC0000000000 +FF0000000000 +FFC000000000 +FFF000000000 +FFFC00000000 +FFFF00000000 +FFFFC0000000 +FFFFF0000000 +FFFFFC000000 +FFFC00000000 +FCFF00000000 +F0FF00000000 +C03FC0000000 +003FC0000000 +000FF0000000 +000FF0000000 +0003C0000000 +00 00 00 00 +Width = 21, Height = 9, Hotspot X = 10, Hotspot Y = 4: + +09 00 04 00 CFFFCFFFFFC00000 +CF3FCFFF3FC00000 +FC3FCFFF0FC00000 +F03FFFFF03C00000 +C000000000C00000 +303FFFFF03C00000 +CC3FCFFF0FC00000 +FF3FCFFF3FC00000 +FFFFCFFFFFC00000 +00F00003C0000000 +03F00003F0000000 +0FF00003FC000000 +3FFFFFFFFF000000 +FFFFFFFFFFC00000 +3FFFFFFFFF000000 +0FF00003FC000000 +03F00003F0000000 +00F00003C0000000 +04 00 0A 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 03 00 2FFFFC3F0000 +FFF33FFF0000 +CF3FFF3F0000 +3FFCFF3F0000 +F3FF3FCF0000 +FF3F3FFF0000 +3CFFFF330000 +FF000F3C0000 +FF333CFC0000 +3CF3C3FC0000 +F03FF3C00000 +FFF3C3FF0000 +CF0FFFC00000 +001223330000 +333721110000 +000155550000 +555555550000 +555555550000 +554000550000 +C00000000000 +F00000000000 +FC0000000000 +FF0000000000 +FFC000000000 +FFF000000000 +FFFC00000000 +FFFF00000000 +FFFFC0000000 +FFFFF0000000 +FFFFFC000000 +FFFC00000000 +FCFF00000000 +F0FF00000000 +C03FC0000000 +003FC0000000 +000FF0000000 +000FF0000000 +0003C0000000 +00 00 00 00 +Width = 21, Height = 9, Hotspot X = 10, Hotspot Y = 4: + +09 00 04 00 CFFFCFFFFFC00000 +CF3FCFFF3FC00000 +FC3FCFFF0FC00000 +F03FFFFF03C00000 +C000000000C00000 +303FFFFF03C00000 +CC3FCFFF0FC00000 +FF3FCFFF3FC00000 +FFFFCFFFFFC00000 +00F00003C0000000 +03F00003F0000000 +0FF00003FC000000 +3FFFFFFFFF000000 +FFFFFFFFFFC00000 +3FFFFFFFFF000000 +0FF00003FC000000 +03F00003F0000000 +00F00003C0000000 +04 00 0A 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 03 00 2FFFFC3F0000 +FFF33FFF0000 +CF3FFF3F0000 +3FFCFF3F0000 +F3FF3FCF0000 +FF3F3FFF0000 +3CFFFF330000 +FF000F3C0000 +FF333CFC0000 +3CF3C3FC0000 +F03FF3C00000 +FFF3C3FF0000 +CF0FFFC00000 +001223330000 +333721110000 +000155550000 +555555550000 +555555550000 +554000550000 +C00000000000 +F00000000000 +FC0000000000 +FF0000000000 +FFC000000000 +FFF000000000 +FFFC00000000 +FFFF00000000 +FFFFC0000000 +FFFFF0000000 +FFFFFC000000 +FFFC00000000 +FCFF00000000 +F0FF00000000 +C03FC0000000 +003FC0000000 +000FF0000000 +000FF0000000 +0003C0000000 +00 00 00 00 +Width = 9, Height = 18, Hotspot X = 4, Hotspot Y = 9: + +12 00 03 00 FFFFF0300000 +3FF3FFFC0000 +FFFF3FFF0000 +CFFFF3FF0000 +FCFFFF3F0000 +FFCFFFF30000 +FFFCFFFF0000 +3FFFCFFF0000 +F3FFFCFF0000 +C0C0FFFF0000 +FCCC44440000 +444444440000 +CCC000CC0000 +300303FC0000 +C00C0FC50000 +0F3300F00000 +0C0C0C030000 +030000CF0000 +3F3F00000000 +FFFFC0000000 +3FFF00000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +3FFF00000000 +FFFFC0000000 +3F3F00000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 03 00 3FFFFC3F0000 +FFF33FFF0000 +CF3FFF3F0000 +3FFCFF3F0000 +F3FF3FCF0000 +FF3F3FFF0000 +3CFFFF330000 +FF000F3C0000 +FF333CFC0000 +3CF3F3FC0000 +F3FFF3CF0000 +FFF3CFFF0000 +CF3FFFC30000 +C01223330000 +333721110000 +0003FFFF0000 +FFFFFFFF0000 +FFFFFFFF0000 +FFFFFFFF0000 +C00000000000 +F00000000000 +FC0000000000 +FF0000000000 +FFC000000000 +FFF000000000 +FFFC00000000 +FFFF00000000 +FFFFC0000000 +FFFFF0000000 +FFFFFC000000 +FFFC00000000 +FCFF00000000 +F0FF00000000 +C03FC0000000 +003FC0000000 +000FF0000000 +000FF0000000 +0003C0000000 +00 00 00 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 0000000000000000 +0000000000000000 +0F00000000000000 +0FF0000000000000 +0FFF000000000000 +0FFFF00000000000 +0FFFFF0000000000 +0FFFFFF000000000 +0FFFFFFF00000000 +0FFFFFFFF0000000 +0FFFFF0000000000 +0FF0FF0000000000 +0F000FF000000000 +00000FF000000000 +000000FF00000000 +000000FF00000000 +0000000FF0000000 +0000000FF0000000 +0000000000000000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 21, Height = 9, Hotspot X = 10, Hotspot Y = 4: + +09 00 07 00 0000FF000000000FF00000000000 +000FFF000000000FFF0000000000 +00FFF0000000000FFFF000000000 +0FFFFFFFFF000FFF000000000000 +000000000000F0F000FFF0000000 +0FFFFF000FFF0F00FFFF00000000 +00FF00000000000FFF0000000000 +000FFF000000000F0F0000000000 +0000F2000000000FB00000000000 +0000FF000000000FF00000000000 +000FFF000000000FFF0000000000 +00FFFF000000000FFFF000000000 +0FFFFFFFFFFFFFFFFFFF00000000 +FFFFFFFFFFFFFFFFFFFFF0000000 +0FFFFFFFFFFFFFFFFFFF00000000 +00FFFF000000000FFFF000000000 +000FFF000000000FFF0000000000 +0000FF000000000FF00000000000 +04 00 0A 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 0000000000000000 +0000000000000000 +0F00000000000000 +0FF0000000000000 +0FFF000000000000 +0FFFF00000000000 +0FFFFF0000000000 +0FFFFFF000000000 +0FFFFFFF00000000 +0FFFFFFFF0000000 +0FFFFF0000000000 +0FF0FF0000000000 +0F000FF000000000 +00000FF000000000 +000000FF00000000 +000000FF00000000 +0000000FF0000000 +0000000FF0000000 +0000000000000000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 20, Hotspot X = 4, Hotspot Y = 9: + +14 00 04 00 0000F00000000000 +000F000000000000 +00FFFFF000000000 +0FFF000000000000 +FFFFF0FFF0000000 +FFF0FFFFF0000000 +000FFF0000000000 +000F000000000000 +000FFF0000000000 +000F0F0000000000 +000FFF0000000000 +000FFF0000000000 +000F000000000000 +0000000000000000 +FF000FFFF0000000 +F0FFFFFFF0000000 +0FFF002000000000 +004F420000000000 +0000200000000000 +0000000000000000 +0000F00000000000 +000FFF0000000000 +00FFFFF000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +00FFFFF000000000 +000FFF0000000000 +0000F00000000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 0000000000000000 +0000000000000000 +0F00000000000000 +0FF0000000000000 +0FFF000000000000 +0FFFF00000000000 +0FFFFF0000000000 +0FFFFFF000000000 +0FFFFFFF00000000 +0FFFFFFFF0000000 +0FFFFF0000000000 +0FF0FF0000000000 +0F000FF000000000 +00000FF000000000 +000000FF00000000 +000000FF00000000 +0000000FF0000000 +0000000FF0000000 +0000000000000000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 20, Hotspot X = 4, Hotspot Y = 9: + +14 00 04 00 0000F00000000000 +000F000000000000 +00FFFFF000000000 +0FFF000000000000 +FFFFF0FFF0000000 +FFF0FFFFF0000000 +000FFF0000000000 +000F000000000000 +000FFF0000000000 +000F0F0000000000 +000FFF0000000000 +000FFF0000000000 +000F000000000000 +0000000000000000 +FF000FFFF0000000 +F0FFFFFFF0000000 +0FFF002000000000 +004F420000000000 +0000200000000000 +0000000000000000 +0000F00000000000 +000FFF0000000000 +00FFFFF000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +008F800000000000 +000FFF0000000000 +000FFF0000000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +00FFFFF000000000 +000FFF0000000000 +0000F00000000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 0000000000000000 +0000000000000000 +0F00000000000000 +0FF0000000000000 +0FFF000000000000 +0FFFF00000000000 +0FFFFF0000000000 +0FFFFFF000000000 +0FFFFFFF00000000 +0FFFFFFFF0000000 +0FFFFF0000000000 +0FF0FF0000000000 +0F000FF000000000 +00000FF000000000 +000000FF00000000 +000000FF00000000 +0000000FF0000000 +0000000FF0000000 +0000000000000000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 18, Hotspot X = 4, Hotspot Y = 9: + +12 00 04 00 0FFF0FFF00000009 +F000F000E0000000 +0FFF0FFF00000000 +000F0F00000000FF +000F0F00000000FF +000F0F00000000FF +000F0F0000000000 +000F0F00000000F0 +000F0F00000000FF +000F0F00000000F4 +000F0F0000000044 +000F0F0000000044 +000F0F00000000F0 +000F0F0000000033 +000F0F0000000033 +0FFF0FFF0000003F +F000F000E00000F0 +0FFF0FFF000000FF +0FFF0FFF00000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +0FFF0FFF00000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 0000000000000000 +F000000000000000 +FF0000000000000F +FFF0000000000080 +FFFF000000000000 +FFFFF00000000000 +0FFFFF0000000000 +FF0FFFF00000000F +FFFF0FFF00000080 +FFFFFF0FF0000000 +FFFFFFFF17000040 +0FFFFF0000000000 +00F00FF000000010 +FF000F0F00000000 +F0000FF000000000 +00000FFFF0000080 +000000FF6A000000 +000000FFFF000010 +0000000FF0000080 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 18, Hotspot X = 4, Hotspot Y = 9: + +12 00 04 00 0FFF0FFF00000033 +F000F00020000033 +0FFF0FFF000000B4 +000F0F00000000B4 +000F0F000000004B +000F0F0000000000 +000F0F0000000000 +000F0F000000004B +000F0F000000004B +000F0F00000000B4 +000F0F00000000B4 +000F0F00000000B4 +000F0F00000000B4 +000F0F00000000B4 +000F0F000000004B +0FFF0FFF0000004B +F000F0003000004B +0FFF0FFF0000004B +0FFF0FFF00000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +0FFF0FFF00000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 0000000000000011 +F000000000000011 +FF000000000000B4 +FFF00000000000B4 +FFFF00000000004B +FFFFF00000000011 +0FFFFF0000000011 +FF0FFFF00000004B +FFFF0FFF5000004B +FFFFFF0F340000B4 +FFFFFFFF530000B4 +0FFFFF00000000B4 +00F00FF0000000B4 +FF000F0F000000B4 +F0000FF04000004B +00000FFF3000004B +000000FF4300004B +000000FF4300004B +0000000F4000004B +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 18, Hotspot X = 4, Hotspot Y = 9: + +12 00 04 00 0FFF0FFF0000004B +F000F00030000044 +0FFF0FFF00000000 +000F0F0000000044 +000F0F0000000044 +000F0F0000000033 +000F0F0000000044 +000F0F0000000044 +000F0F0000000033 +000F0F0000000044 +000F0F0000000040 +000F0F0000000033 +000F0F0000000040 +000F0F0000000004 +000F0F0000000033 +0FFF0FFF00000004 +F000F00030000040 +0FFF0FFF00000033 +0FFF0FFF00000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +0FFF0FFF00000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 0000000000000040 +F000000000000004 +FF00000000000004 +FFF0000000000004 +FFFF000000000004 +FFFFF00000000004 +0FFFFF0000000040 +FF0FFFF000000040 +FFFF0FFF50000040 +FFFFFF0F34000040 +FFFFFFFF53000040 +0FFFFF0000000004 +00F00FF000000004 +FF000F0F00000004 +F0000FF040000004 +00000FFF30000004 +000000FF43000040 +000000FF43000040 +0000000F40000040 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 20, Hotspot X = 4, Hotspot Y = 9: + +14 00 04 00 0000F00000000000 +000F0F0000000000 +00F000F00000000F +0F00000F00000080 +F0000000F0000000 +FFFF0FFFF0000000 +000F0F0000000000 +000F0F000000000F +000F0F0000000080 +000F0F0000000000 +000F0F0000000040 +000F0F0000000000 +000F0F0000000010 +000F0F0000000000 +FFFF0FFFF0000000 +F0000000E0000080 +0F00000F00000000 +00F000F000000010 +000F0F0000000080 +0000F00000000000 +0000F00000000000 +000FFF0000000000 +00FFFFF000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +00FFFFF000000000 +000FFF0000000000 +0000F00000000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 0000000000000000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF0000000000F0 +FFFFF000000000F0 +0FFFFF00000000F0 +FF0FFFF0000000F0 +FFFF0FFF500000F0 +FFFFFF0F3F0000F0 +FFFFFFFF030000F0 +0FFFFF00000000F0 +00F00FF0000000F0 +FF000F0F000000F0 +F0000FF0F0000000 +00000FFF20000000 +000000FFB3000044 +000000FF430000B0 +0000000F30000044 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 20, Hotspot X = 4, Hotspot Y = 9: + +14 00 04 00 0000F0000000004B +000F0F0000000044 +00F000F000000000 +0F00000F00000044 +F0000000F0000044 +FFFF0FFFF0000033 +000F0F0000000044 +000F0F0000000044 +000F0F0000000033 +000F0F0000000044 +000F0F0000000040 +000F0F0000000033 +000F0F0000000040 +000F0F0000000004 +FFFF0FFFF0000033 +F000000020000000 +0F00000F00000000 +00F000F000000000 +000F0F0000000002 +0000F00000000000 +0000F00000000000 +000FFF0000000000 +00FFFFF000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +008F800000000000 +000FFF0000000000 +000FFF0000000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +00FFFFF000000000 +000FFF0000000000 +0000F00000000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 0000000000000000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +0FFFFF0000000000 +FF0FFFF000000000 +FFFF0FFF500000F0 +FFFFFF0F2F0000F0 +FFFFFFFF120000F0 +0FFFFF00000000F0 +00F00FF0000000F0 +FF000F0F000000F0 +F0000FF0E0000000 +00000FFF20000000 +000000FF430000F0 +000000FFFF000040 +0000000FE000000F +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 20, Hotspot X = 4, Hotspot Y = 9: + +14 00 04 00 0000F0000000004B +000F0F0000000044 +00F000F000000000 +0F00000F00000044 +F0000000E0000044 +FFFF0FFFE0000033 +000F0F0000000044 +000F0F0000000044 +000F0F0000000033 +000F0F0000000044 +000F0F0000000040 +000F0F0000000033 +000F0F0000000040 +000F0F0000000004 +FFFF0FFFE0000033 +F000000020000000 +0F00000F00000040 +00F000F000000004 +000F0F0000000040 +0000F000000000B0 +0000F00000000000 +000FFF0000000000 +00FFFFF000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +008F800000000000 +000FFF0000000000 +000FFF0000000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +00FFFFF000000000 +000FFF0000000000 +0000F00000000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 0000000000000000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +0FFFFF0000000000 +FF0FFFF000000000 +FFFF0FFF500000F0 +FFFFFF0F1F0000F0 +FFFFFFFF210000F0 +0FFFFF00000000F0 +00F00FF0000000F0 +FF000F0F000000F0 +F0000FF0D0000000 +00000FFF20000000 +000000FFB3000044 +000000FF430000B0 +0000000F30000044 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 21, Height = 9, Hotspot X = 10, Hotspot Y = 4: + +09 00 07 00 0000FF000000000FF00000000004 +000F0F000000000F0F0000000000 +00F00F000000000F00F00000000F +0F000FFFFFFFFFFF000F00000000 +F0000000000000000000E0000000 +0F000FFFFFFFFFFF000F00000000 +00F00F000000000F00F00000000F +000F0F000000000F0F0000000000 +0000FF000000000FF00000000000 +0000FF000000000FF00000000000 +000FFF000000000FFF0000000000 +00FFFF000000000FFFF000000000 +0FFFFFFFFFFFFFFFFFFF00000000 +FFFFFFFFFFFFFFFFFFFFF0000000 +0FFFFFFFFFFFFFFFFFFF00000000 +00FFFF000000000FFFF000000000 +000FFF000000000FFF0000000000 +0000FF000000000FF00000000000 +04 00 0A 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 0000000000000040 +F000000000000004 +FF00000000000004 +FFF0000000000004 +FFFF000000000004 +FFFFF00000000004 +0FFFFF0000000040 +FF0FFFF000000040 +FFFF0FFF50000040 +FFFFFF0F24000040 +FFFFFFFF62000040 +0FFFFF0000000004 +00F00FF000000004 +FF000F0F00000004 +F0000FF030000004 +00000FFF20000004 +000000FF42000040 +000000FF42000040 +0000000F30000040 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 21, Height = 9, Hotspot X = 10, Hotspot Y = 4: + +09 00 07 00 0000FF000000000FF000000000EE +000F0F000000000F0F00000000EE +00F00F000000000F00F0000000EE +0F000FFFFFFFFFFF000F000000FE +F0000000000000000000E00000EE +0F000FFFFFFFFFFF000F000000E0 +00F00F000000000F00F00000000F +000F0F000000000F0F0000000000 +0000FF000000000FF000000000F5 +0000FF000000000FF00000000000 +000FFF000000000FFF0000000000 +00FFFF000000000FFFF000000000 +0FFFFFFFFFFFFFFFFFFF00000000 +FFFFFFFFFFFFFFFFFFFFF0000000 +0FFFFFFFFFFFFFFFFFFF00000000 +00FFFF000000000FFFF000000000 +000FFF000000000FFF0000000000 +0000FF000000000FF00000000000 +04 00 0A 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 0000000000000040 +F000000000000004 +FF00000000000004 +FFF0000000000004 +FFFF000000000004 +FFFFF00000000004 +0FFFFF0000000040 +FF0FFFF000000040 +FFFF0FFF50000040 +FFFFFF0F14000040 +FFFFFFFF71000040 +0FFFFF0000000004 +00F00FF000000004 +FF000F0F00000004 +F0000FF020000004 +00000FFF10000004 +000000FF41000040 +000000FF41000040 +0000000F20000040 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 21, Height = 9, Hotspot X = 10, Hotspot Y = 4: + +09 00 07 00 0000FF000000000FF00000000044 +000F0F000000000F0F0000000044 +00F00F000000000F00F000000044 +0F000FFFFFFFFFFF000F00000044 +F000000000000000000030000044 +0F000FFFFFFFFFFF000F00000044 +00F00F000000000F00F000000044 +000F0F000000000F0F0000000044 +0000FF000000000FF00000000044 +0000FF000000000FF00000000000 +000FFF000000000FFF0000000000 +00FFFF000000000FFFF000000000 +0FFFFFFFFFFFFFFFFFFF00000000 +FFFFFFFFFFFFFFFFFFFFF0000000 +0FFFFFFFFFFFFFFFFFFF00000000 +00FFFF000000000FFFF000000000 +000FFF000000000FFF0000000000 +0000FF000000000FF00000000000 +04 00 0A 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 0000000000000020 +F00000000000003D +FF00000000000073 +FFF0000000000020 +FFFF000000000073 +FFFFF00000000020 +0FFFFF0000000030 +FF0FFFF000000020 +FFFF0FFF50000030 +FFFFFF0F20000046 +FFFFFFFF3F000030 +0FFFFF0000000030 +00F00FF000000030 +FF000F0F00000030 +F0000FF020000034 +00000FFF30000046 +000000FF2F000030 +000000FF45000030 +0000000F30000030 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 20, Hotspot X = 4, Hotspot Y = 9: + +14 00 04 00 0000F00000000020 +000F0F000000003D +00F000F000000074 +0F00000F0000003D +F000000030000073 +FFFF0FFF40000020 +000F0F0000000030 +000F0F0000000020 +000F0F0000000030 +000F0F0000000030 +000F0F0000000030 +000F0F0000000033 +000F0F0000000030 +000F0F0000000030 +FFFF0FFF30000030 +F000000020000030 +0F00000F00000046 +00F000F000000030 +000F0F0000000046 +0000F00000000030 +0000F00000000000 +000FFF0000000000 +00FFFFF000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +00FFFFF000000000 +000FFF0000000000 +0000F00000000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 0000000000000048 +F000000000000020 +FF00000000000073 +FFF0000000000020 +FFFF000000000070 +FFFFF00000000039 +0FFFFF0000000030 +FF0FFFF000000030 +FFFF0FFF30000030 +FFFFFF0F2000000D +FFFFFFFF3F000030 +0FFFFF0000000044 +00F00FF000000046 +FF000F0F00000037 +F0000FF020000030 +00000FFF20000030 +000000FF2F000030 +000000FF2F000030 +0000000F40000046 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 20, Hotspot X = 4, Hotspot Y = 9: + +14 00 04 00 0000F0000000000F +000F0F000000000F +00F000F000000000 +0F00000F00000000 +F0000000F0000000 +FFFF0FFFF00000FF +000F0F00000000FE +000F0F0000000000 +000F0F0000000000 +000F0F000000000F +000F0F0000000000 +000F0F0000000000 +000F0F0000000000 +000F0F0000000000 +FFFF0FFFF000000F +F000000020000000 +0F00000F00000044 +00F000F000000040 +000F0F0000000044 +0000F00000000004 +0000F00000000000 +000FFF0000000000 +00FFFFF000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +00FFFFF000000000 +000FFF0000000000 +0000F00000000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 0000000000000000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +0FFFFF0000000040 +FF0FFFF000000033 +FFFF0FFF00000040 +FFFFFF0F34000004 +FFFFFFFF42000033 +0FFFFF0000000004 +00F00FF000000040 +FF000F0F00000000 +F0000FF0F0000040 +00000FFF20000000 +000000FF39000000 +000000FFFF000000 +0000000FF0000002 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 21, Height = 9, Hotspot X = 10, Hotspot Y = 4: + +09 00 07 00 0000FF000000000FF00000000044 +000F0F000000000F0F00000000FF +00F00F000000000F00F0000000EE +0F000FFFFFFFFFFF000F000000E0 +F0000000000000000000D00000EE +0F000FFFFFFFFFFF000F000000EE +00F00F000000000F00F0000000FF +000F0F000000000F0F0000000000 +0000FF000000000FF00000000000 +0000FF000000000FF00000000000 +000FFF000000000FFF0000000000 +00FFFF000000000FFFF000000000 +0FFFFFFFFFFFFFFFFFFF00000000 +FFFFFFFFFFFFFFFFFFFFF0000000 +0FFFFFFFFFFFFFFFFFFF00000000 +00FFFF000000000FFFF000000000 +000FFF000000000FFF0000000000 +0000FF000000000FF00000000000 +04 00 0A 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 00000000000000EE +F0000000000000EE +FF000000000000EE +FFF00000000000EE +FFFF0000000000EE +FFFFF000000000EE +0FFFFF00000000EE +FF0FFFF0000000B4 +FFFF0FFF5000004B +FFFFFF0F3400004B +FFFFFFFF5300004B +0FFFFF000000004B +00F00FF00000004B +FF000F0F00000044 +F0000FF040000044 +00000FFF30000044 +000000FF43000044 +000000FF43000044 +0000000F40000044 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 21, Height = 9, Hotspot X = 10, Hotspot Y = 4: + +09 00 07 00 0000FF000000000FF00000000004 +000F0F000000000F0F00000000FF +00F00F000000000F00F0000000EE +0F000FFFFFFFFFFF000F000000E0 +F0000000000000000000C00000EE +0F000FFFFFFFFFFF000F000000EE +00F00F000000000F00F0000000FF +000F0F000000000F0F0000000000 +0000FF000000000FF00000000000 +0000FF000000000FF00000000000 +000FFF000000000FFF0000000000 +00FFFF000000000FFFF000000000 +0FFFFFFFFFFFFFFFFFFF00000000 +FFFFFFFFFFFFFFFFFFFFF0000000 +0FFFFFFFFFFFFFFFFFFF00000000 +00FFFF000000000FFFF000000000 +000FFF000000000FFF0000000000 +0000FF000000000FF00000000000 +04 00 0A 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 00000000000000EE +F0000000000000EE +FF000000000000EE +FFF00000000000EE +FFFF0000000000EE +FFFFF000000000EE +0FFFFF00000000EE +FF0FFFF0000000B4 +FFFF0FFF5000004B +FFFFFF0F2400004B +FFFFFFFF6200004B +0FFFFF000000004B +00F00FF00000004B +FF000F0F00000044 +F0000FF030000044 +00000FFF20000044 +000000FF42000044 +000000FF42000044 +0000000F30000044 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF04000B6F30900 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +FFF0200036F30900 +000000FFFF000000 +FFF0100056F30900 +74 2E 74 78 +Width = 21, Height = 9, Hotspot X = 10, Hotspot Y = 4: + +09 00 07 00 0000FF000000000FF00000000004 +000F0F000000000F0F00000000FF +00F00F000000000F00F0000000EE +0F000FFFFFFFFFFF000F000000E0 +F0000000000000000000F00000E7 +0F000FFFFFFFFFFF000F00000000 +00F00F000000000F00F0000000FF +000F0F000000000F0F0000000000 +0000FF000000000FF00000000000 +0000FF000000000FF00000000000 +000FFF000000000FFF0000000000 +00FFFF000000000FFFF000000000 +0FFFFFFFFFFFFFFFFFFF00000000 +FFFFFFFFFFFFFFFFFFFFF0000000 +0FFFFFFFFFFFFFFFFFFF00000000 +00FFFF000000000FFFF000000000 +000FFF000000000FFF0000000000 +0000FF000000000FF00000000000 +04 00 0A 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 00000000000000EE +F0000000000000EE +FF000000000000EE +FFF00000000000EE +FFFF0000000000EE +FFFFF000000000EE +0FFFFF00000000EE +FF0FFFF0000000B4 +FFFF0FFF5000004B +FFFFFF0F1400004B +FFFFFFFF7100004B +0FFFFF000000004B +00F00FF00000004B +FF000F0F00000044 +F0000FF020000044 +00000FFF20000000 +000000FF41000044 +000000FF41000044 +0000000F20000044 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF04000B6F30900 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +FFF0200036F30900 +000000FFFF000000 +FFF0100056F30900 +74 2E 74 78 +Width = 21, Height = 9, Hotspot X = 10, Hotspot Y = 4: + +09 00 07 00 0000FF000000000FF00000000004 +000F0F000000000F0F00000000FF +00F00F000000000F00F0000000EE +0F000FFFFFFFFFFF000F000000E0 +F0000000000000000000F00000E7 +0F000FFFFFFFFFFF000F00000000 +00F00F000000000F00F0000000FF +000F0F000000000F0F0000000000 +0000FF000000000FF00000000000 +0000FF000000000FF00000000000 +000FFF000000000FFF0000000000 +00FFFF000000000FFFF000000000 +0FFFFFFFFFFFFFFFFFFF00000000 +FFFFFFFFFFFFFFFFFFFFF0000000 +0FFFFFFFFFFFFFFFFFFF00000000 +00FFFF000000000FFFF000000000 +000FFF000000000FFF0000000000 +0000FF000000000FF00000000000 +04 00 0A 00 +Width = 18, Height = 18, Hotspot X = 9, Hotspot Y = 9: + +12 00 06 00 000000FFFFFF000000000000 +000000F0FF0F0000000000EE +000000F0FF0F000000000000 +000000F0FF0F0000000000EE +000000F0FF0F0000000000F0 +000FF0F0FF0F0FF00000004B +00F0F0F0FF0F0F0F000000FF +0F00FFF0FF0FFF00F000004B +F0000000FF0000000E00000F +F0000000FF0000002F000044 +0F00FFF0FF0FFF00F00000FF +00F0F0F0FF0F0F0F00000044 +000FF0F0FF0F0FF000000000 +000000F0FF0F000000000000 +000000F0FF0F000000000000 +000000F0FF0F000000000000 +000000F0FF0F000000000000 +000000FFFFFF000000000002 +000000FFFFFF000000000000 +000000FFFFFF000000000000 +000000FFFFFF000000002000 +00000000FFFF000000000000 +000000FFFFFF000000000000 +000FF0FF2000100000000000 +00FFF0FFFFFF0FFF30801000 +56F30900742E747874000000 +FFFFFFFFFFFFFFFFFF000000 +FFFFFFFFFFFFFFFFFF000000 +0FFFFFFFFFFFFFFFF0000000 +00FFF0FFFFFF0FFF00000000 +000FF0FFFFFF0FF000000000 +000000FFFFFF000000000000 +000000FFFFFF000000000000 +000000FFFFFF000000000000 +000000FFFFFF000000000000 +000000FFFFFF000000000000 +09 00 09 00 +Width = 21, Height = 9, Hotspot X = 10, Hotspot Y = 4: + +09 00 07 00 0000FF000000000FF000000000EE +000F0F000000000F0F00000000E1 +00F00F000000000F00F00000000E +0F000FFFFFFFFFFF000F000000EE +F0000000000000000000D00000E1 +0F000FFFFFFFFFFF000F000000EE +00F00F000000000F00F0000000FE +000F0F000000000F0F00000000EE +0000FF000000000FF000000000EF +0000FF000000000FF00000000000 +000FFF000000000FFF0000000000 +00FFFF000000000FFFF000000000 +0FFFFFFFFFFFFFFFFFFF00000000 +FFFFFFFFFFFFFFFFFFFFF0000000 +0FFFFFFFFFFFFFFFFFFF00000000 +00FFFF000000000FFFF000000000 +000FFF000000000FFF0000000000 +0000FF000000000FF00000000000 +04 00 0A 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 000000000000000F +F00000000000000F +F000000000000000 +FF00000000000000 +0FF0000000000000 +F0FF0000000000FF +0F0FF00000000044 +FF00FF0000000000 +FFFF0FF000000000 +FFFFFF0FFF00000F +FFFFFFFF00000000 +0FFFFF0000000000 +00F00FF000000000 +F0000F0F00000044 +F0000FF0F000000F +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 21, Height = 9, Hotspot X = 10, Hotspot Y = 4: + +09 00 07 00 0000FF000000000FF00000000000 +000F0F000000000F0F0000000000 +00F00F000000000F00F000000000 +0F000FFFFFFFFFFF000F000000FF +F0000000000000000000E00000FF +0F000FFFFFFFFFFF000F000000FF +00F00F000000000F00F0000000FF +000F0F000000000F0F00000000FF +0000FF000000000FF000000000FF +0000FF000000000FF00000000000 +000FFF000000000FFF0000000000 +00FFFF000000000FFFF000000000 +0FFFFFFFFFFFFFFFFFFF00000000 +FFFFFFFFFFFFFFFFFFFFF0000000 +0FFFFFFFFFFFFFFFFFFF00000000 +00FFFF000000000FFFF000000000 +000FFF000000000FFF0000000000 +0000FF000000000FF00000000000 +04 00 0A 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 0000000000000020 +F00000000000003D +F000000000000073 +FF00000000000020 +0FF0000000000073 +F0FF000000000020 +0F0FF00000000030 +FF00FF0000000020 +FFFF0FF050000030 +FFFFFF0F30000046 +FFFFFFFF30000030 +0FFFFF0000000030 +00F00FF000000030 +F0000F0F00000030 +F0000FF020000030 +00000FFF30000046 +000000FF2F000030 +000000FF45000030 +0000000F20000030 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 21, Height = 9, Hotspot X = 10, Hotspot Y = 4: + +09 00 07 00 0000FF000000000FF00000000000 +000F0F000000000F0F0000000000 +00F00F000000000F00F000000000 +0F000FFFFFFFFFFF000F000000FF +F0000000000000000000D00000FF +0F000FFFFFFFFFFF000F000000FF +00F00F000000000F00F0000000FF +000F0F000000000F0F00000000FF +0000FF000000000FF000000000FF +0000FF000000000FF00000000000 +000FFF000000000FFF0000000000 +00FFFF000000000FFFF000000000 +0FFFFFFFFFFFFFFFFFFF00000000 +FFFFFFFFFFFFFFFFFFFFF0000000 +0FFFFFFFFFFFFFFFFFFF00000000 +00FFFF000000000FFFF000000000 +000FFF000000000FFF0000000000 +0000FF000000000FF00000000000 +04 00 0A 00 +Width = 18, Height = 18, Hotspot X = 9, Hotspot Y = 9: + +12 00 06 00 000000FFFFFF000000000067 +000000F0FF0F000000000073 +000000F0FF0F000000000020 +000000F0FF0F000000000020 +000000F0FF0F000000000037 +000FF0F0FF0F0FF000000030 +00F0F0F0FF0F0F0F00000030 +0F00FFF0FF0FFF0000000030 +F0000000FF0000003F000030 +F0000000FF0000003F000030 +0F00FFF0FF0FFF0020000030 +00F0F0F0FF0F0F0F00000030 +000FF0F0FF0F0FF000000030 +000000F0FF0F000000000030 +000000F0FF0F00000000000D +000000F0FF0F000000000030 +000000F0FF0F000000000030 +000000FFFFFF000000000046 +000000FFFFFF000000000000 +000000FFFFFF000000000000 +000000FFFFFF000000000000 +000000FFFFFF000000000000 +000000FFFFFF000000000000 +000FF0FFFFFF0FF000000000 +00FFF0FFFFFF0FFF00000000 +0FFFFFFFFFFFFFFFF0000000 +FFFFFFFFFFFFFFFFFF000000 +FFFFFFFFFFFFFFFFFF000000 +0FFFFFFFFFFFFFFFF0000000 +00FFF0FFFFFF0FFF00000000 +000FF0FFFFFF0FF000000000 +000000FFFFFF000000000000 +000000FFFFFF000000000000 +000000FFFFFF000000000000 +000000FFFFFF000000000000 +000000FFFFFF000000000000 +09 00 09 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 000000000000000F +F00000000000000F +F000000000000000 +FF00000000000000 +0FF0000000000000 +F0FF0000000000FF +0F0FF00000000044 +FF00FF0000000000 +FFFF0FF000000000 +FFFFFF0FFF00000F +FFFFFFFF00000000 +0FFFFF0000000000 +00F00FF000000000 +F0000F0F00000044 +F0000FF0E000000F +00000FFFE0000000 +000000FFFE000000 +000000FFFE000000 +0000000FE0000000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +00 00 00 00 000000000000 +000000000000 +300000000000 +3C0000000000 +3F0000000000 +3FC000000000 +3FF0000000FF +3FFC000000FF +3FFF00000000 +3FFFC0000000 +3FF0000000FF +3CF000000000 +303C00000000 +003C000000FF +000F000000FF +000F00000000 +0003C0000000 +0003C000000F +000000000000 +C00000000000 +F00000000000 +FC0000000000 +FF0000000000 +FFC000000000 +FFF000000000 +FFFC00000000 +FFFF00000000 +FFFFC0000000 +FFFFF0000000 +FFFFFC000000 +FFFC00000000 +FCFF00000000 +F0FF00000000 +C03FC0000000 +003FC0000000 +000FF0000000 +000FF0000000 +0003C0000000 +00 00 00 00 +Width = 9, Height = 20, Hotspot X = 4, Hotspot Y = 9: + +14 00 03 00 00C000000000 +033000000000 +0C0C000000F0 +30030000000F +C000C0000000 +FF3FC0000000 +0330000000FF +033000000000 +033000000000 +033000000000 +03300000000F +033000000080 +033000000000 +033000000000 +FF3FC000000F +C000C0000000 +300300000000 +0C0C00000000 +0330000000FF +00C000000000 +00C000000000 +03F000000000 +0FFC00000000 +3FFF00000000 +FFFFC0000000 +FFFFC0000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +FFFFC0000000 +FFFFC0000000 +3FFF00000000 +0FFC00000000 +03F000000000 +00C000000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 03 00 00000000006F +000000000074 +300000000020 +3C0000000047 +3F000000006F +3FC000000074 +3FF00000006D +3FFC00000020 +3FFF0000006C +3FFFC0000075 +3FF000000053 +3CF00000006E +303C00000075 +003C00000072 +000F00000066 +000F00000013 +0003C0000046 +0003C0000064 +00000000006E +C00000000000 +F00000000000 +FC0000000000 +FF0000000000 +FFC000000000 +FFF000000000 +FFFC00000000 +FFFF00000000 +FFFFC0000000 +FFFFF0000000 +FFFFFC000000 +FFFC00000000 +FCFF00000000 +F0FF00000000 +C03FC0000000 +003FC0000000 +000FF0000000 +000FF0000000 +0003C0000000 +00 00 00 00 +Width = 9, Height = 20, Hotspot X = 4, Hotspot Y = 9: + +14 00 03 00 00C0000000EE +03300000001E +0C0C0000001F +3003000000EE +C000C000001E +FF3FC000001F +0330000000EE +03300000001E +03300000001F +0330000000EE +03300000001E +03300000001F +0330000000EE +03300000001E +FF3FC000001F +C000C00000EE +30030000001E +0C0C0000001F +0330000000EE +00C00000001E +00C000000000 +03F000000000 +0FFC00000000 +3FFF00000000 +FFFFC0000000 +FFFFC0000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +FFFFC0000000 +FFFFC0000000 +3FFF00000000 +0FFC00000000 +03F000000000 +00C000000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 03 00 0000000000EE +0000000000EE +3000000000EE +3C00000000EE +3F00000000EE +3FC0000000EE +3FF0000000EE +3FFC000000EE +3FFF000000FF +3FFFC0000000 +3FF0000000E7 +3CF000000000 +303C00000004 +003C00000000 +000F00000000 +000F000000EE +0003C00000E0 +0003C000000E +0000000000EE +C00000000000 +F00000000000 +FC0000000000 +FF0000000000 +FFC000000000 +FFF000000000 +FFFC00000000 +FFFF00000000 +FFFFC0000000 +FFFFF0000000 +FFFFFC000000 +FFFC00000000 +FCFF00000000 +F0FF00000000 +C03FC0000000 +003FC0000000 +000FF0000000 +000FF0000000 +0003C0000000 +00 00 00 00 +Width = 9, Height = 20, Hotspot X = 4, Hotspot Y = 9: + +14 00 03 00 00C000000000 +033000000000 +0C0C00000000 +300300000000 +C000C0000000 +FF3FC0000000 +0330000000FF +0330000000FF +033000000000 +033000000000 +0330000000FF +033000000000 +033000000000 +0330000000FF +FF3FC00000FF +C000C0000000 +300300000000 +0C0C0000000F +033000000000 +00C000000000 +00C000000000 +03F000000000 +0FFC00000000 +3FFF00000000 +FFFFC0000000 +FFFFC0000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +FFFFC0000000 +FFFFC0000000 +3FFF00000000 +0FFC00000000 +03F000000000 +00C000000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 03 00 0000000000EE +0000000000EE +3000000000EE +3C00000000EE +3F00000000EE +3FC0000000EE +3FF0000000EE +3FFC000000EE +3FFF000000FF +3FFFC0000000 +3FF0000000E7 +3CF000000000 +303C00000004 +003C00000000 +000F00000000 +000F000000EE +0003C00000E0 +0003C000000E +0000000000EE +C00000000000 +F00000000000 +FC0000000000 +FF0000000000 +FFC000000000 +FFF000000000 +FFFC00000000 +FFFF00000000 +FFFFC0000000 +FFFFF0000000 +FFFFFC000000 +FFFC00000000 +FCFF00000000 +F0FF00000000 +C03FC0000000 +003FC0000000 +000FF0000000 +000FF0000000 +0003C0000000 +00 00 00 00 +Width = 21, Height = 9, Hotspot X = 10, Hotspot Y = 4: + +09 00 04 00 00F00003C0000000 +03C00003C0000000 +0FC00003F0000000 +3FC0FFFFFC000000 +0FC0000000000000 +00CC0FFFFF000000 +00F00000FC0000FF +00F0000330000000 +00F00003C0000000 +00F00003C0000000 +03F00003F0000000 +0FF00003FC000000 +3FFFFFFFFF000000 +FFFFFFFFFFC00000 +3FFFFFFFFF000000 +0FF00003FC000000 +03F00003F0000000 +00F00003C0000000 +04 00 0A 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 03 00 0000000000FC +0000000000FF +3000000000FF +3C00000000FF +3F00000000F0 +3FC0000000F0 +3FF0000000F0 +3FFC000000F0 +3FFF000000F0 +3FFFC0000000 +3FF0000000E7 +3CF000000000 +303C00000004 +003C00000000 +000F00000000 +000F000000FC +0003C00000F0 +0003C00000C0 +000000000000 +C00000000000 +F00000000000 +FC0000000000 +FF0000000000 +FFC000000000 +FFF000000000 +FFFC00000000 +FFFF00000000 +FFFFC0000000 +FFFFF0000000 +FFFFFC000000 +FFFC00000000 +FCFF00000000 +F0FF00000000 +C03FC0000000 +003FC0000000 +000FF0000000 +000FF0000000 +0003C0000000 +00 00 00 00 +Width = 21, Height = 9, Hotspot X = 10, Hotspot Y = 4: + +09 00 04 00 00F00003C0000030 +03C00003C0000000 +0FC00003F0000000 +3FC0FFFFFC00003F +0FC0000000000000 +00CC0FFFFF0000FF +00F00000FC000030 +00F0000330000000 +00F00003C0000000 +00F00003C0000000 +03F00003F0000000 +0FF00003FC000000 +3FFFFFFFFF000000 +FFFFFFFFFFC00000 +3FFFFFFFFF000000 +0FF00003FC000000 +03F00003F0000000 +00F00003C0000000 +04 00 0A 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 03 00 00000000006A +000000000000 +300000000004 +3C0000000002 +3F00000000D0 +3FC000000000 +3FF0000000FF +3FFC000000FF +3FFF000000FF +3FFFC0000000 +3FF00000006A +3CF000000000 +303C00000004 +003C00000000 +000F00000000 +000F00000000 +0003C00000FF +0003C0000000 +00000000002E +C00000000000 +F00000000000 +FC0000000000 +FF0000000000 +FFC000000000 +FFF000000000 +FFFC00000000 +FFFF00000000 +FFFFC0000000 +FFFFF0000000 +FFFFFC000000 +FFFC00000000 +FCFF00000000 +F0FF00000000 +C03FC0000000 +003FC0000000 +000FF0000000 +000FF0000000 +0003C0000000 +00 00 00 00 +Width = 21, Height = 9, Hotspot X = 10, Hotspot Y = 4: + +09 00 04 00 00F00003C00000FF +03C00003C0000000 +0FC00003F0000000 +3FC0FFFFFC000000 +0FC0000000000000 +00CC0FFFFF000000 +00F00000FC000000 +00F0000330000000 +00F00003C0000000 +00F00003C0000000 +03F00003F0000000 +0FF00003FC000000 +3FFFFFFFFF000000 +FFFFFFFFFFC00000 +3FFFFFFFFF000000 +0FF00003FC000000 +03F00003F0000000 +00F00003C0000000 +04 00 0A 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 03 00 0000000000FF +0000000000FF +3000000000FF +3C00000000FF +3F00000000FF +3FC0000000FF +3FF000000000 +3FFC000000FF +3FFF000000FF +3FFFC0000000 +3FF00000006A +3CF000000000 +303C00000004 +003C00000000 +000F00000000 +000F000000FF +0003C00000FF +0003C00000FF +0000000000FF +C00000000000 +F00000000000 +FC0000000000 +FF0000000000 +FFC000000000 +FFF000000000 +FFFC00000000 +FFFF00000000 +FFFFC0000000 +FFFFF0000000 +FFFFFC000000 +FFFC00000000 +FCFF00000000 +F0FF00000000 +C03FC0000000 +003FC0000000 +000FF0000000 +000FF0000000 +0003C0000000 +00 00 00 00 +Width = 9, Height = 18, Hotspot X = 4, Hotspot Y = 9: + +12 00 03 00 3F3F000000FF +C0C0C00000FF +3F3F0000000F +03300000000F +0330000000F0 +03300000000F +03300000000F +0330000000F0 +0330000000F0 +033000000000 +033000000000 +033000000088 +033000000088 +033000000008 +033000000000 +3F3F00000000 +C0C0C0000000 +3F3F00000000 +3F3F00000000 +FFFFC0000000 +3FFF00000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +3FFF00000000 +FFFFC0000000 +3F3F00000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 03 00 000000000000 +000000000000 +300000000000 +3C0000000000 +3F0000000000 +3FC000000000 +3FF000000000 +3FFC00000000 +3FFF00000000 +3FFFC0000000 +3FF000000000 +3CF000000000 +303C00000000 +003C00000000 +000F00000000 +000F00000000 +0003C0000000 +0003C0000000 +000000000000 +C00000000000 +F00000000000 +FC0000000000 +FF0000000000 +FFC000000000 +FFF000000000 +FFFC00000000 +FFFF00000000 +FFFFC0000000 +FFFFF0000000 +FFFFFC000000 +FFFC00000000 +FCFF00000000 +F0FF00000000 +C03FC0000000 +003FC0000000 +000FF0000000 +000FF0000000 +0003C0000000 +00 00 00 00 +Width = 9, Height = 18, Hotspot X = 4, Hotspot Y = 9: + +12 00 03 00 3F3F000000FF +C0C0C00000FF +3F3F0000000F +03300000000F +0330000000F0 +03300000000F +03300000000F +0330000000F0 +0330000000F0 +033000000000 +0330000000FC +0330000000FC +0330000000A8 +0330000000FC +0330000000FC +3F3F000000A8 +C0C0C00000A8 +3F3F000000FC +3F3F00000000 +FFFFC0000000 +3FFF00000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +3FFF00000000 +FFFFC0000000 +3F3F00000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 03 00 0000000000FF +0000000000AA +3000000000FF +3C00000000FF +3F00000000AA +3FC0000000AA +3FF0000000AA +3FFC000000AA +3FFF000000AA +3FFFC0000000 +3FF0000000C0 +3CF0000000C0 +303C000000C0 +003C000000C0 +000F000000C0 +000F000000C0 +0003C00000C0 +0003C0000080 +000000000080 +C00000000000 +F00000000000 +FC0000000000 +FF0000000000 +FFC000000000 +FFF000000000 +FFFC00000000 +FFFF00000000 +FFFFC0000000 +FFFFF0000000 +FFFFFC000000 +FFFC00000000 +FCFF00000000 +F0FF00000000 +C03FC0000000 +003FC0000000 +000FF0000000 +000FF0000000 +0003C0000000 +00 00 00 00 +Width = 9, Height = 18, Hotspot X = 4, Hotspot Y = 9: + +12 00 03 00 3F3F000000AA +C0C0C00000AA +3F3F000000AA +0330000000AA +0330000000FF +0330000000AA +0330000000AA +0330000000AA +0330000000AA +0330000000AA +0330000000AA +0330000000AA +0330000000AA +0330000000AA +0330000000AA +3F3F000000AA +C0C0C00000AA +3F3F000000AA +3F3F00000000 +FFFFC0000000 +3FFF00000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +3FFF00000000 +FFFFC0000000 +3F3F00000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 03 00 0000000000AA +0000000000AA +3000000000AA +3C00000000AA +3F00000000AA +3FC0000000AA +3FF0000000AA +3FFC000000FF +3FFF000000AA +3FFFC00000AA +3FF0000000AA +3CF0000000AA +303C000000AA +003C000000AA +000F000000AA +000F000000AA +0003C00000AA +0003C00000AA +0000000000AA +C00000000000 +F00000000000 +FC0000000000 +FF0000000000 +FFC000000000 +FFF000000000 +FFFC00000000 +FFFF00000000 +FFFFC0000000 +FFFFF0000000 +FFFFFC000000 +FFFC00000000 +FCFF00000000 +F0FF00000000 +C03FC0000000 +003FC0000000 +000FF0000000 +000FF0000000 +0003C0000000 +00 00 00 00 +Width = 9, Height = 18, Hotspot X = 4, Hotspot Y = 9: + +12 00 03 00 3F3F000000AA +C0C0C00000AA +3F3F000000AA +0330000000AA +0330000000AA +0330000000AA +0330000000AA +0330000000FF +0330000000AA +0330000000AA +0330000000AA +0330000000AA +0330000000A8 +033000000000 +0330000000FF +3F3F000000FF +C0C0C00000A8 +3F3F000000FF +3F3F00000000 +FFFFC0000000 +3FFF00000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +3FFF00000000 +FFFFC0000000 +3F3F00000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 03 00 0000000000AA +0000000000AA +3000000000AA +3C00000000AA +3F00000000AA +3FC0000000AA +3FF0000000AA +3FFC000000FF +3FFF000000AA +3FFFC00000AA +3FF0000000AA +3CF0000000AA +303C000000A8 +003C00000000 +000F000000FF +000F000000FF +0003C00000A8 +0003C00000FF +000000000080 +C00000000000 +F00000000000 +FC0000000000 +FF0000000000 +FFC000000000 +FFF000000000 +FFFC00000000 +FFFF00000000 +FFFFC0000000 +FFFFF0000000 +FFFFFC000000 +FFFC00000000 +FCFF00000000 +F0FF00000000 +C03FC0000000 +003FC0000000 +000FF0000000 +000FF0000000 +0003C0000000 +00 00 00 00 +Width = 9, Height = 18, Hotspot X = 4, Hotspot Y = 9: + +12 00 03 00 3F3F000000AA +C0C0C00000AA +3F3F000000FF +0330000000FF +0330000000AA +0330000000AA +0330000000AA +0330000000EA +0330000000AA +0330000000AA +0330000000AA +0330000000AA +0330000000AA +0330000000AA +0330000000AA +3F3F000000EA +C0C0C00000AA +3F3F000000A8 +3F3F00000000 +FFFFC0000000 +3FFF00000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +3FFF00000000 +FFFFC0000000 +3F3F00000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 03 00 0000000000FF +0000000000FF +3000000000FF +3C00000000FF +3F00000000FF +3FC0000000FF +3FF0000000A8 +3FFC000000FF +3FFF000000FF +3FFFC00000FF +3FF0000000FF +3CF0000000FF +303C000000FF +003C000000FF +000F000000AA +000F000000FF +0003C00000FF +0003C000003F +0000000000F3 +C00000000000 +F00000000000 +FC0000000000 +FF0000000000 +FFC000000000 +FFF000000000 +FFFC00000000 +FFFF00000000 +FFFFC0000000 +FFFFF0000000 +FFFFFC000000 +FFFC00000000 +FCFF00000000 +F0FF00000000 +C03FC0000000 +003FC0000000 +000FF0000000 +000FF0000000 +0003C0000000 +00 00 00 00 +Width = 16, Height = 16, Hotspot X = 4, Hotspot Y = 5: + +10 00 05 00 00000000000000000000 +00000000000000000035 +00000000000000000069 +00000000000000000000 +00000000000000000002 +00000000000000000000 +00000000000000000000 +00000000000000000000 +0001000000000000008D +00001000000000000022 +00000000000000000015 +00000000000000000020 +00000000000000000021 +00000000000000000018 +0000000000000000001B +01000000000000000005 +0FF000FF000000000000 +000F0F00000000000000 +0000F000000000000000 +0000F000000000000000 +0000F000000000000000 +0000F000000000000000 +0000F000000000000000 +0000F000000000000000 +000FFF00000000000000 +0000F000000000000000 +0000F000000000000000 +0000F000000000000000 +0000F000000000000000 +0000F000000000000000 +000F0F00000000000000 +0FF000FF000000000000 +05 00 04 00 +Width = 24, Height = 24, Hotspot X = 4, Hotspot Y = 4: + +18 00 07 00 0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000001 +0000000000000000000000000000 +0000000000000000000000000015 +000F100000000000000000000000 +000000F100000000000000000000 +000000000F100000000000000000 +000F00000000F100000000000000 +00000F0000000000000000000000 +0000000F00E00000000000000000 +000000000F0F0000000000000000 +00000000000F0000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +000F000000000000000000000000 +000FF00000000000000000000000 +000FFF0000000000000000000000 +000FFFF000000000000000000000 +000FFFFF00000000000000000000 +000FFFFFF0000000000000000000 +000FFFFFFF000000000000000000 +000FFFFFFFF00000000000000000 +000FFFFFFFFF0000000000000000 +000FFFFFFFFFF000000000000000 +000FFFFFFFFFFF00000000000000 +000FFFFFFFF00000000000000000 +000FFFFFFFF00000000000000000 +000FF00FFFFF0000000000000000 +000F000FFFFF0000000000000000 +00000000FFFF0000000000000000 +00000000FFFF0000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +04 00 04 00 +Width = 16, Height = 16, Hotspot X = 4, Hotspot Y = 5: + +10 00 05 00 000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +05 00 04 00 +Width = 16, Height = 16, Hotspot X = 8, Hotspot Y = 8: + +10 00 05 00 000000000000000000FF +000000000FF0000000FF +0000000FF00FE00000FF +000000000FF0000000FF +000F00000000FE0000FF +0000FF00F000FF0000F8 +0F0FF0FF0FF08000003F +0F0FFFFFFF0F040000F8 +0FF00FFFFFFF3E0000FE +000FFF0FFFFF7F00001F +000000FFFFFFE100001F +00FF00000FFFFD000010 +000FFF00000FFE0000FF +0000FFF00000F00000FF +00000FFFF000F00000FF +00000FFFFF00F00000FF +0000000FF00000000000 +000FF0FFFFFF00000000 +00FFFFFFFFFFF0000000 +00FFFFFFFFFFF0F00000 +000FFFFFFFFFFFFF0000 +000FFFFFFFFFFFFF0000 +0FFFFFFFFFFFFFFF0000 +FFFFFFFFFFFFFFFF0000 +FFFFFFFFFFFFFFF00000 +0FFFFFFFFFFFFFF00000 +00FFFFFFFFFFFFF00000 +00FFFFFFFFFFFF000000 +000FFFFFFFFFFF000000 +0000FFFFFFFFF0000000 +00000FFFFFFFF0000000 +00000FFFFFFFF0000000 +08 00 08 00 +Width = 16, Height = 16, Hotspot X = 4, Hotspot Y = 5: + +10 00 05 00 000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000F0 +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +05 00 04 00 +Width = 24, Height = 24, Hotspot X = 4, Hotspot Y = 4: + +18 00 07 00 00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +000F1000000000000000000000FF +000000F1000000000000000000FF +000000000F1000000000000000FF +000F00000000F1000000000000FF +00000F00000000000000000000FF +0000000F00E000000000000000FF +000000000F0F00000000000000FF +00000000000F00000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +0000000000000000000000000000 +0000000000000000000000000000 +000F000000000000000000000000 +000FF00000000000000000000000 +000FFF0000000000000000000000 +000FFFF000000000000000000000 +000FFFFF00000000000000000000 +000FFFFFF0000000000000000000 +000FFFFFFF000000000000000000 +000FFFFFFFF00000000000000000 +000FFFFFFFFF0000000000000000 +000FFFFFFFFFF000000000000000 +000FFFFFFFFFFF00000000000000 +000FFFFFFFF00000000000000000 +000FFFFFFFF00000000000000000 +000FF00FFFFF0000000000000000 +000F000FFFFF0000000000000000 +00000000FFFF0000000000000000 +00000000FFFF0000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +04 00 04 00 +Width = 16, Height = 16, Hotspot X = 4, Hotspot Y = 5: + +10 00 05 00 000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000F0 +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +000000000000000000FF +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +05 00 04 00 +Width = 16, Height = 16, Hotspot X = 4, Hotspot Y = 5: + +10 00 05 00 00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +000000000000000000FF +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +000000000000000000FF +00000000000000000000 +00000000000000000010 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +05 00 04 00 +Width = 24, Height = 24, Hotspot X = 4, Hotspot Y = 4: + +18 00 07 00 0000000000000000000000000004 +00000000000000000000000000DD +00000000000000000000000000DD +00000000000000000000000000DD +00000000000000000000000000DD +00000000000000000000000000DD +000000000000000000000000000F +00000000000000000000000000FF +00000000000000000000000000F0 +000F1000000000000000000000FF +000000F1000000000000000000CC +000000000F1000000000000000FF +000F00000000F1000000000000C3 +00000F000000000000000000000F +0000000F00E00000000000000000 +000000000F0F00000000000000F0 +00000000000F00000000000000DD +00000000000000000000000000DC +00000000000000000000000000DD +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +0000000000000000000000000000 +0000000000000000000000000000 +000F000000000000000000000000 +000FF00000000000000000000000 +000FFF0000000000000000000000 +000FFFF000000000000000000000 +000FFFFF00000000000000000000 +000FFFFFF0000000000000000000 +000FFFFFFF000000000000000000 +000FFFFFFFF00000000000000000 +000FFFFFFFFF0000000000000000 +000FFFFFFFFFF000000000000000 +000FFFFFFFFFFF00000000000000 +000FFFFFFFF00000000000000000 +000FFFFFFFF00000000000000000 +000FF00FFFFF0000000000000000 +000F000FFFFF0000000000000000 +00000000FFFF0000000000000000 +00000000FFFF0000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +04 00 04 00 +Width = 16, Height = 16, Hotspot X = 4, Hotspot Y = 5: + +10 00 05 00 00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +05 00 04 00 +Width = 24, Height = 24, Hotspot X = 4, Hotspot Y = 4: + +18 00 07 00 0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +000F1000000000000000000000FF +000000F1000000000000000000FF +000000000F1000000000000000FF +000F00000000F1000000000000F0 +00000F00000000000000000000FF +0000000F00E000000000000000FF +000000000F0F00000000000000FF +00000000000F00000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +0000000000000000000000000000 +0000000000000000000000000000 +000F000000000000000000000000 +000FF00000000000000000000000 +000FFF0000000000000000000000 +000FFFF000000000000000000000 +000FFFFF00000000000000000000 +000FFFFFF0000000000000000000 +000FFFFFFF000000000000000000 +000FFFFFFFF00000000000000000 +000FFFFFFFFF0000000000000000 +000FFFFFFFFFF000000000000000 +000FFFFFFFFFFF00000000000000 +000FFFFFFFF00000000000000000 +000FFFFFFFF00000000000000000 +000FF00FFFFF0000000000000000 +000F000FFFFF0000000000000000 +00000000FFFF0000000000000000 +00000000FFFF0000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +04 00 04 00 +Width = 16, Height = 16, Hotspot X = 4, Hotspot Y = 5: + +10 00 05 00 00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +05 00 04 00 +Width = 24, Height = 24, Hotspot X = 4, Hotspot Y = 4: + +18 00 07 00 0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +000F1000000000000000000000FF +000000F1000000000000000000FF +000000000F1000000000000000FF +000F00000000F1000000000000F0 +00000F00000000000000000000FF +0000000F00E000000000000000FF +000000000F0F00000000000000FF +00000000000F00000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +0000000000000000000000000000 +0000000000000000000000000000 +000F000000000000000000000000 +000FF00000000000000000000000 +000FFF0000000000000000000000 +000FFFF000000000000000000000 +000FFFFF00000000000000000000 +000FFFFFF0000000000000000000 +000FFFFFFF000000000000000000 +000FFFFFFFF00000000000000000 +000FFFFFFFFF0000000000000000 +000FFFFFFFFFF000000000000000 +000FFFFFFFFFFF00000000000000 +000FFFFFFFF00000000000000000 +000FFFFFFFF00000000000000000 +000FF00FFFFF0000000000000000 +000F000FFFFF0000000000000000 +00000000FFFF0000000000000000 +00000000FFFF0000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +04 00 04 00 +Width = 16, Height = 16, Hotspot X = 4, Hotspot Y = 5: + +10 00 05 00 00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +00000000000000000000 +05 00 04 00 +Width = 24, Height = 24, Hotspot X = 4, Hotspot Y = 4: + +18 00 07 00 0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +000F1000000000000000000000FF +000000F1000000000000000000FF +000000000F1000000000000000FF +000F00000000F1000000000000F0 +00000F00000000000000000000FF +0000000F00E000000000000000FF +000000000F0F00000000000000FF +00000000000F00000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +00000000000000000000000000FF +0000000000000000000000000000 +0000000000000000000000000000 +000F000000000000000000000000 +000FF00000000000000000000000 +000FFF0000000000000000000000 +000FFFF000000000000000000000 +000FFFFF00000000000000000000 +000FFFFFF0000000000000000000 +000FFFFFFF000000000000000000 +000FFFFFFFF00000000000000000 +000FFFFFFFFF0000000000000000 +000FFFFFFFFFF000000000000000 +000FFFFFFFFFFF00000000000000 +000FFFFFFFF00000000000000000 +000FFFFFFFF00000000000000000 +000FF00FFFFF0000000000000000 +000F000FFFFF0000000000000000 +00000000FFFF0000000000000000 +00000000FFFF0000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +0000000000000000000000000000 +04 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 FFFFFFFFFF000088 +0FFFFFFFFF0000B7 +00FFFFFFFF000035 +000FFFFFFF0000F4 +0000FFFFFF0000F4 +00000FFFFF000048 +F00000FFFF000001 +00F0000FFF000000 +0000F000FF000000 +000000F00F000000 +00000000F0000000 +F00000FFFF0000EF +FF0FF00FFF000012 +00FFF0F0FF0000AD +0FFFF00F8F0000EB +FFFFF0000F0000F7 +FFFFFF0000000048 +FFFFFF0053000048 +FFFFFFF05F000022 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 18, Hotspot X = 4, Hotspot Y = 9: + +12 00 04 00 F000F000FF0000EE +0FFF0FFF2F0000EE +F000F000FF0000EE +FFF0F0FFFF0000EE +FFF0F0FFFF0000EE +FFF0F0FFFF0000EE +FFF0F0FFFF0000EE +FFF0F0FFFF0000EE +FFF0F0FFFF0000EE +FFF0F0FFFF0000EE +FFF0F0FFFF0000EE +FFF0F0FFFF0000EE +FFF0F0FFFF0000EE +FFF0F0FFFF0000EE +FFF0F0FFFF0000EE +F000F000FF0000EE +0FFF0FFF2F0000EE +F000F000FF0000EE +0FFF0FFF00000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +0FFF0FFF00000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 FFFFFFFFFF0000B7 +0FFFFFFFFF000035 +00FFFFFFFF000090 +000FFFFFFF0000F4 +0000FFFFFF0000A2 +00000FFFFF000000 +F00000FFFF000000 +00F0000FFF000000 +0000F000FF000000 +000000F00F000000 +00000000D9000064 +F00000FFFF000002 +FF0FF00FFF000085 +00FFF0F0FF000077 +0FFFF00FEF000085 +FFFFF000EF0000A8 +FFFFFF00E7000085 +FFFFFF00E50000A5 +FFFFFFF02F0000F5 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 18, Hotspot X = 4, Hotspot Y = 9: + +12 00 04 00 F000F000FF000035 +0FFF0FFF9F000001 +F000F000FF000000 +FFF0F0FFFF000099 +FFF0F0FFFF000035 +FFF0F0FFFF00001C +FFF0F0FFFF0000E4 +FFF0F0FFFF000000 +FFF0F0FFFF000000 +FFF0F0FFFF000000 +FFF0F0FFFF000000 +FFF0F0FFFF000019 +FFF0F0FFFF000035 +FFF0F0FFFF000035 +FFF0F0FFFF000085 +F000F000FF000000 +0FFF0FFF0F000000 +F000F000FF0000FF +0FFF0FFF00000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +008F800000000000 +000FFF0000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +0FFF0FFF00000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 FFFFFFFFFF000000 +0FFFFFFFFF000000 +00FFFFFFFF000000 +000FFFFFFF000000 +0000FFFFFF0000A2 +00000FFFFF000000 +F00000FFFF000000 +00F0000FFF000000 +0000F000FF000000 +000000F000000000 +0000000017000064 +F00000FFFF000002 +FF0FF00FFF000085 +00FFF0F0FF000077 +0FFFF00F1F000085 +FFFFF000DF000000 +FFFFFF00C6000000 +FFFFFF0000000000 +FFFFFFF00F000002 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 03 00 FFFFFF0000EE +FFFFFF0000EE +CFFFFF0000EE +C3FFFF0000EE +C0FFFF0000EE +C03FFF0000EE +C00FFF0000EE +C003FF0000EE +C000FF0000EE +C0003F0000EE +C00FFF0000EE +C30FFF0000EE +CFC3FF0000EE +FFC3FF0000EE +FFF0FF0000EE +FFF0FF0000EE +FFFC3F0000EE +FFFC3F0000EE +FFFFFF0000EE +C00000000000 +F00000000000 +FC0000000000 +FF0000000000 +FFC000000000 +FFF000000000 +FFFC00000000 +FFFF00000000 +FFFFC0000000 +FFFFF0000000 +FFFFFC000000 +FFFC00000000 +FCFF00000000 +F0FF00000000 +C03FC0000000 +003FC0000000 +000FF0000000 +000FF0000000 +0003C0000000 +00 00 00 00 +Width = 9, Height = 18, Hotspot X = 4, Hotspot Y = 9: + +12 00 03 00 C0C0FF0000AA +3F3F3F0000AA +C0C0FF0000AB +FCCFFF0000FF +FCCFFF0000FF +FCCFFF0000AA +FCCFFF0000AA +FCCFFF0000AA +FCCFFF0000AA +FCCFFF0000AA +FCCFFF0000AA +FCCFFF0000AA +FCCFFF0000AB +FCCFFF0000AA +FCCFFF0000AA +C0C0FF0000AA +3F3F3F0000AA +C0C0FF0000AA +3F3F00000000 +FFFFC0000000 +3FFF00000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +03F000000000 +3FFF00000000 +FFFFC0000000 +3F3F00000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 03 00 FFFFFF00006A +FFFFFF000000 +CFFFFF000004 +C3FFFF000002 +C0FFFF000000 +C03FFF000000 +C00FFF0000F0 +C003FF000000 +C000FF000000 +C0003F000000 +C00FFF000080 +C30FFF0000C0 +CFC3FF0000C0 +FFC3FF0000C0 +FFF0FF0000C0 +FFF0FF0000C0 +FFFC3F0000C0 +FFFC3F0000C0 +FFFFFF000000 +C00000000000 +F00000000000 +FC0000000000 +FF0000000000 +FFC000000000 +FFF000000000 +FFFC00000000 +FFFF00000000 +FFFFC0000000 +FFFFF0000000 +FFFFFC000000 +FFFC00000000 +FCFF00000000 +F0FF00000000 +C03FC0000000 +003FC0000000 +000FF0000000 +000FF0000000 +0003C0000000 +00 00 00 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 F000000000000088 +0F000000000000B7 +00F0000000000035 +000F0000000000F4 +0000F000000000F4 +00000F0000000048 +F00000F000000001 +00F0000F00000000 +0000F000F0000000 +000000F00F000000 +00000000F0000000 +F00000F0000000EF +FF00F00F00000012 +0000F0F0000000AD +0000000F800000EB +00000000000000F7 +0000000000000048 +0000000053000048 +0000000050000022 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 18, Hotspot X = 4, Hotspot Y = 9: + +12 00 04 00 00000000000000EE +0FFF0FFF200000EE +0000F000000000EE +0000F000000000EE +0000F000000000EE +0000F000000000EE +0000F000000000EE +0000F000000000EE +0000F000000000EE +0000F000000000EE +0000F000000000EE +0000F000000000EE +0000F000000000EE +0000F000000000EE +0000F000000000EE +0000F000000000EE +0FFF0FFF200000EE +00000000000000EE +0FFF0FFF00000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +0FFF0FFF00000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 F000000000000040 +0F00000000000044 +00F0000000000044 +000F0000000000E0 +0000F000000000EE +00000F00000000EE +F00000F0000000E0 +00F0000F000000EE +0000F000000000EE +000000F0210000E0 +0000000002000000 +F00000F0000000EE +FF00F00F000000E0 +0000F0F0000000E1 +0000000F100000DF +00000000D0000000 +000000000100000F +0000000000000000 +00000000000000F0 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 F000000000000000 +FF00000000000000 +F0F0000000000000 +F00F000000000000 +F000F00000000000 +F0000F0000000000 +F00000F000000000 +F000000F00000000 +F0000000F0000000 +F00000000F000000 +F00000FFFFF00000 +F00F00F000000000 +F0F0F00F00000000 +FF00F00F00000000 +F0000F00F0000000 +00000F00F0000000 +000000F00F000000 +000000F00F000000 +0000000FF0000000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 18, Hotspot X = 4, Hotspot Y = 9: + +12 00 04 00 0000000000000000 +FF0FFF0000000000 +0000000000000000 +0000000000000000 +00000F0000000000 +000F000000000000 +0000000000000000 +0000000000000000 +0000000000000000 +0000F00000000000 +0000000000000000 +0000000000000000 +0000000000000000 +000FF00000000000 +0000000000000000 +06FDFDFD00000000 +DFDFDFDFD0000000 +0DFD06F000000000 +0FFF0FFF00000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +0FFF0FFF00000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 F000000000000000 +FF00000000000000 +F0F0000000000000 +F00F000000000000 +F000F00000000000 +F0000F0000000000 +F00000F000000000 +F000000F00000000 +F0000000F0000000 +F00000000F000000 +F00000FFFFF00000 +F00F00F000000000 +F0F0F00F00000000 +FF00F00F00000000 +F0000F00F0000000 +00000F00F0000000 +000000F00F000000 +000000F00F000000 +0000000FF0000000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 18, Hotspot X = 4, Hotspot Y = 9: + +12 00 04 00 0000000000000000 +FF0FFF0000000000 +0000000000000000 +0000000000000000 +00000F0000000000 +000F000000000000 +0000000000000000 +0000000000000000 +0000000000000000 +0000F00000000000 +0000000000000000 +0000000000000000 +0000000000000000 +000FF00000000000 +0000000000000000 +06FDFDFD00000000 +DFDFDFDFD0000000 +0DFD06F000000000 +0FFF0FFF00000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +008FFF0000000000 +000FFF0000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +0FFF0FFF00000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 F000000000000000 +FF00000000000000 +F0F0000000000000 +F00F000000000000 +F000F00000000000 +F0000F0000000000 +F00000F000000000 +F000000F00000000 +F0000000F0000000 +F00000000F000000 +F00000FFFFF00000 +F00F00F000000000 +F0F0F00F00000000 +FF00F00F00000000 +F0000F00F0000000 +00000F00F0000000 +000000F00F000000 +000000F00F000000 +0000000FF0000000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 18, Hotspot X = 4, Hotspot Y = 9: + +12 00 04 00 0000000000000000 +FF0FFF0000000000 +0000000000000000 +0000000000000000 +00000F0000000000 +000F000000000000 +0000000000000000 +0000000000000000 +0000000000000000 +0000F00000000000 +0000000000000000 +0000000000000000 +0000000000000000 +000FF00000000000 +0000000000000000 +06FDFDFD00000000 +DFDFDFDFD0000000 +0DFD06F000000000 +0FFF0FFF00000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +008FFF0000000000 +000FFF0000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +0FFF0FFF00000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 F000000000000000 +FF00000000000000 +F0F0000000000000 +F00F000000000000 +F000F00000000000 +F0000F0000000000 +F00000F000000000 +F000000F00000000 +F0000000F0000000 +F00000000F000000 +F00000FFFFF00000 +F00F00F000000000 +F0F0F00F00000000 +FF00F00F00000000 +F0000F00F0000000 +00000F00F0000000 +000000F00F000000 +000000F00F000000 +0000000FF0000000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 20, Hotspot X = 4, Hotspot Y = 9: + +14 00 04 00 0000000000000000 +0000FF0000000000 +0000000000000000 +0000FFFF00000000 +00000F0000000000 +000F000000000000 +0000000000000000 +0000000000000000 +0000000000000000 +0000F00000000000 +0000000000000000 +0000000000000000 +0000FF0000000000 +000FFF0000000000 +00FFF00000000000 +0F00000000000000 +0000FFDF00000000 +00B0BDF000000000 +000FDF0000000000 +0000F00000000000 +0000F00000000000 +000FFF0000000000 +00FFFFF000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +00FFFFF000000000 +000FFF0000000000 +0000F00000000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 F000000000000000 +FF00000000000000 +F0F0000000000000 +F00F000000000000 +F000F00000000000 +F0000F0000000000 +F00000F000000000 +F000000F00000000 +F0000000F0000000 +F00000000F000000 +F00000FFFFF00000 +F00F00F000000000 +F0F0F00F00000000 +FF00F00F00000000 +F0000F00F0000000 +00000F00F0000000 +000000F00F000000 +000000F00F000000 +0000000FF0000000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 9, Height = 20, Hotspot X = 4, Hotspot Y = 9: + +14 00 04 00 0000000000000000 +0000FF0000000000 +0000000000000000 +0000FFFF00000000 +00000F0000000000 +000F000000000000 +0000000000000000 +0000000000000000 +0000000000000000 +0000F00000000000 +0000000000000000 +0000000000000000 +0000FF0000000000 +000FFF0000000000 +00FFF00000000000 +0F00000000000000 +0000FFDF00000000 +00B0BDF000000000 +000FDF0000000000 +0000F00000000000 +0000F00000000000 +000FFF0000000000 +00FFFFF000000000 +0FFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +000FFF0000000000 +FFFFFFFFF0000000 +FFFFFFFFF0000000 +0FFFFFFF00000000 +00FFFFF000000000 +000FFF0000000000 +0000F00000000000 +09 00 04 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 F000000000000000 +FF00000000000000 +F0F0000000000000 +F00F000000000000 +F000F00000000000 +F0000F0000000000 +F00000F000000000 +F000000F00000000 +F0000000F0000000 +F00000000F000000 +F00000FFFFF00000 +F00F00F000000000 +F0F0F00F00000000 +FF00F00F00000000 +F0000F00F0000000 +00000F00F0000000 +000000F00F000000 +000000F00F000000 +0000000FF0000000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 +Width = 21, Height = 9, Hotspot X = 10, Hotspot Y = 4: + +09 00 07 00 0000000000000000000000000000 +0000000000000000000000000000 +00000F0000000000000000000000 +0000000000FFF000FFFF00000000 +FFFFFFFFFFFF0F0FFF0000000000 +000000FFF000F0FF000000000000 +0000FF000000000000F000000000 +0000000000000000F00000000000 +00000D0000000000400000000000 +0000FF000000000FF00000000000 +000FFF000000000FFF0000000000 +00FFFF000000000FFFF000000000 +0FFFFFFFFFFFFFFFFFFF00000000 +FFFFFFFFFFFFFFFFFFFFF0000000 +0FFFFFFFFFFFFFFFFFFF00000000 +00FFFF000000000FFFF000000000 +000FFF000000000FFF0000000000 +0000FF000000000FF00000000000 +04 00 0A 00 +Width = 11, Height = 19, Hotspot X = 0, Hotspot Y = 0: + +13 00 04 00 F000000000000000 +FF00000000000000 +F0F0000000000000 +F00F000000000000 +F000F00000000000 +F0000F0000000000 +F00000F000000000 +F000000F00000000 +F0000000F0000000 +F00000000F000000 +F00000FFFFF00000 +F00F00F000000000 +F0F0F00F00000000 +FF00F00F00000000 +F0000F00F0000000 +00000F00F0000000 +000000F00F000000 +000000F00F000000 +0000000FF0000000 +F000000000000000 +FF00000000000000 +FFF0000000000000 +FFFF000000000000 +FFFFF00000000000 +FFFFFF0000000000 +FFFFFFF000000000 +FFFFFFFF00000000 +FFFFFFFFF0000000 +FFFFFFFFFF000000 +FFFFFFFFFFF00000 +FFFFFFF000000000 +FFF0FFFF00000000 +FF00FFFF00000000 +F0000FFFF0000000 +00000FFFF0000000 +000000FFFF000000 +000000FFFF000000 +0000000FF0000000 +00 00 00 00 diff --git a/raw.cc b/raw.cc new file mode 100644 index 0000000..07cd430 --- /dev/null +++ b/raw.cc @@ -0,0 +1,396 @@ +#pragma noroot + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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" + +/* Data on state of raw rectangle drawing routines */ +unsigned int lineBytes; /* Number of bytes in a line of GS pixels */ +unsigned long pixels; + +unsigned int drawingLine; /* Line to be drawn while displaying */ +static BOOLEAN extraByteAdvance; + +unsigned char *destPtr; + +/* Ends drawing of a raw rectangle when it is complete or aborted + * because the rectangle is not visible. + */ +void StopRawDrawing (void) { + HUnlock(readBufferHndl); + free(srcLocInfo.ptrToPixImage); /* Allocated as destPtr */ + + displayInProgress = FALSE; + + NextRect(); /* Prepare for next rect */ +} + +#pragma optimize 95 /* To work around an ORCA/C optimizer bug */ + +/* Draw one or more lines from a raw rectangle + */ +void RawDraw (void) { + unsigned int i; /* Loop indices */ + unsigned char *dataPtr; + unsigned char *lineDataPtr, *initialLineDataPtr; + unsigned char *finalDestPtr; + static EventRecord unusedEventRec; + + /* For use with GetContentOrigin() */ + unsigned long contentOrigin; + Point * contentOriginPtr = (void *) &contentOrigin; + + SetPort(vncWindow); /* Drawing in VNC window */ + dataPtr = (unsigned char *) *readBufferHndl; + + /* Check if what we're drawing is visible, and skip any invisible part + * by skipping some lines or completely aborting drawing the rectangle. + */ + if (checkBounds) { + Rect drawingRect; + + contentOrigin = GetContentOrigin(vncWindow); + drawingRect.h1 = rectX - contentOriginPtr->h; + drawingRect.h2 = rectX - contentOriginPtr->h + rectWidth; + drawingRect.v1 = rectY - contentOriginPtr->v + drawingLine; + drawingRect.v2 = rectY - contentOriginPtr->v + rectHeight; + + if (!RectInRgn(&drawingRect, GetVisHandle())) { + StopRawDrawing(); + return; + } + else if (rectY + drawingLine < contentOriginPtr->v) { + destPtr += (unsigned long)lineBytes * + (contentOriginPtr->v - rectY - drawingLine); + drawingLine = contentOriginPtr->v - rectY; + + if (drawingLine >= rectHeight) { /* Sanity check */ + StopRawDrawing(); + return; + } + } + else if (rectY + rectHeight - 1 > contentOriginPtr->v + winHeight) + rectHeight = contentOriginPtr->v + winHeight - rectY + 1; + + checkBounds = FALSE; + } + + lineDataPtr = dataPtr + (unsigned long) drawingLine * rectWidth; + + do { /* We short-circuit back to here if there are no events pending */ + + finalDestPtr = destPtr + lineBytes - 1; + if (hRez == 640) { + initialLineDataPtr = lineDataPtr; + while (destPtr + 7 < finalDestPtr) { /* Unrolled loop */ + *(destPtr++) = bigcoltab640a[*(unsigned int*)(void*)lineDataPtr] + + bigcoltab640b[*(unsigned int*)(void*)(lineDataPtr+2)]; + lineDataPtr += 4; + *(destPtr++) = bigcoltab640a[*(unsigned int*)(void*)lineDataPtr] + + bigcoltab640b[*(unsigned int*)(void*)(lineDataPtr+2)]; + lineDataPtr += 4; + *(destPtr++) = bigcoltab640a[*(unsigned int*)(void*)lineDataPtr] + + bigcoltab640b[*(unsigned int*)(void*)(lineDataPtr+2)]; + lineDataPtr += 4; + *(destPtr++) = bigcoltab640a[*(unsigned int*)(void*)lineDataPtr] + + bigcoltab640b[*(unsigned int*)(void*)(lineDataPtr+2)]; + lineDataPtr += 4; + *(destPtr++) = bigcoltab640a[*(unsigned int*)(void*)lineDataPtr] + + bigcoltab640b[*(unsigned int*)(void*)(lineDataPtr+2)]; + lineDataPtr += 4; + *(destPtr++) = bigcoltab640a[*(unsigned int*)(void*)lineDataPtr] + + bigcoltab640b[*(unsigned int*)(void*)(lineDataPtr+2)]; + lineDataPtr += 4; + *(destPtr++) = bigcoltab640a[*(unsigned int*)(void*)lineDataPtr] + + bigcoltab640b[*(unsigned int*)(void*)(lineDataPtr+2)]; + lineDataPtr += 4; + *(destPtr++) = bigcoltab640a[*(unsigned int*)(void*)lineDataPtr] + + bigcoltab640b[*(unsigned int*)(void*)(lineDataPtr+2)]; + lineDataPtr += 4; + } + while (destPtr < finalDestPtr) { + *(destPtr++) = bigcoltab640a[*(unsigned int*)(void*)lineDataPtr] + + bigcoltab640b[*(unsigned int*)(void*)(lineDataPtr+2)]; + lineDataPtr += 4; + } + /* Final byte to produce */ + *destPtr = pixTransTbl[*(lineDataPtr++)] & 0xC0; + for (i = lineDataPtr - initialLineDataPtr; i < rectWidth; i++) + switch (i & 0x03) { + case 0x01: /* pixels 1, 5, 9, ... */ + *destPtr += pixTransTbl[*(lineDataPtr++)] & 0x30; + break; + case 0x02: /* pixels 2, 6, 10, ... */ + *destPtr += pixTransTbl[*(lineDataPtr++)] & 0x0C; + break; + case 0x03: /* pixels 3, 7, 11, ... */ + *destPtr += pixTransTbl[*(lineDataPtr++)] & 0x03; + } + destPtr++; + } + else { /* 320 mode */ + while (destPtr + 7 < finalDestPtr) { /* Unrolled loop */ + *(destPtr++) = bigcoltab320[*(unsigned int*)(void*)lineDataPtr]; + lineDataPtr += 2; + *(destPtr++) = bigcoltab320[*(unsigned int*)(void*)lineDataPtr]; + lineDataPtr += 2; + *(destPtr++) = bigcoltab320[*(unsigned int*)(void*)lineDataPtr]; + lineDataPtr += 2; + *(destPtr++) = bigcoltab320[*(unsigned int*)(void*)lineDataPtr]; + lineDataPtr += 2; + *(destPtr++) = bigcoltab320[*(unsigned int*)(void*)lineDataPtr]; + lineDataPtr += 2; + *(destPtr++) = bigcoltab320[*(unsigned int*)(void*)lineDataPtr]; + lineDataPtr += 2; + *(destPtr++) = bigcoltab320[*(unsigned int*)(void*)lineDataPtr]; + lineDataPtr += 2; + *(destPtr++) = bigcoltab320[*(unsigned int*)(void*)lineDataPtr]; + lineDataPtr += 2; + } + while (destPtr < finalDestPtr) { + *(destPtr++) = bigcoltab320[*(unsigned int*)(void*)lineDataPtr]; + lineDataPtr += 2; + } + /* Final byte to produce */ + *destPtr = pixTransTbl[*(lineDataPtr++)] & 0xF0; + if (extraByteAdvance) + destPtr++; /* Not ending on byte boundary - update index */ + else + *(destPtr++) += pixTransTbl[*(lineDataPtr++)] & 0x0F; + } + + drawingLine++; + + if (pixels > 613 && !(drawingLine & 0x03)) { /* Draw every 4th line */ + srcRect.v2 = drawingLine; + contentOrigin = GetContentOrigin(vncWindow); + PPToPort(&srcLocInfo, &srcRect, rectX - contentOriginPtr->h, + rectY + srcRect.v1 - contentOriginPtr->v, modeCopy); + srcRect.v1 = drawingLine; + } + + /* Check whether we're done with this rectangle */ + if (drawingLine >= rectHeight) { + /* Draw final rect, if necessary */ + if (drawingLine > srcRect.v1) { + srcRect.v2 = drawingLine; + contentOrigin = GetContentOrigin(vncWindow); + PPToPort(&srcLocInfo, &srcRect, rectX - contentOriginPtr->h, + rectY + srcRect.v1 - contentOriginPtr->v, modeCopy); + } + StopRawDrawing(); + return; + } + + /* Check if there are actually any events that need to be processed. + * If not, save time by not going through the whole event loop, but + * instead processing the minimum necessary periodic tasks and then + * going straight to the next line of data. + */ + if (EventAvail(0xFFFF, &unusedEventRec)) + return; + + SystemTask(); /* Let periodic Desk Accesories do their things */ + TCPIPPoll(); /* Let Marinetti keep processing data */ + + } while (1); +} + +#pragma optimize -1 + +/* Draw one line of Raw data - used if the complete rect isn't yet available */ +void RawDrawLine (void) { + unsigned int i; + unsigned char *dataPtr; + unsigned long contentOrigin; + Point * contentOriginPtr = (void *) &contentOrigin; + + if (hRez == 640) { + if (rectWidth & 0x03) /* Width not an exact multiple of 4 */ + lineBytes = rectWidth/4 + 1; + else /* Width is a multiple of 4 */ + lineBytes = rectWidth/4; + } + else { /* 320 mode */ + if (rectWidth & 0x01) /* Width not an exact multiple of 2 */ + lineBytes = rectWidth/2 + 1; + else /* Width is a multiple of 2 */ + lineBytes = rectWidth/2; + } + + destPtr = calloc(lineBytes, 1); + if (!destPtr) { /* Couldn't allocate memory */ + DoClose(vncWindow); + return; + } + + srcLocInfo.ptrToPixImage = destPtr; + srcLocInfo.width = lineBytes; + srcLocInfo.boundsRect.v2 = 1; + /* 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; break; + case 0x01: srcLocInfo.boundsRect.h2 = rectWidth+3; break; + case 0x02: srcLocInfo.boundsRect.h2 = rectWidth+2; break; + case 0x03: srcLocInfo.boundsRect.h2 = rectWidth+1; + } + } + else { + switch (rectWidth & 0x01) { + case 0x00: srcLocInfo.boundsRect.h2 = rectWidth; break; + case 0x01: srcLocInfo.boundsRect.h2 = rectWidth+1; + } + } + + /* Don't include padding in the area we will actually copy over */ + srcRect.h2 = rectWidth; + srcRect.v1 = 0; + srcRect.v2 = 1; + + HLock(readBufferHndl); + dataPtr = (unsigned char *) *readBufferHndl; + SetPort(vncWindow); /* Drawing in VNC window */ + + if (hRez == 640) + for (i = 0; i < rectWidth; /* i is incremented in loop */) { + switch (i & 0x03) { + case 0x00: /* pixels 0, 4, 8, ... */ + *destPtr = pixTransTbl[dataPtr[i++]] & 0xC0; + break; + case 0x01: /* pixels 1, 5, 9, ... */ + *destPtr += pixTransTbl[dataPtr[i++]] & 0x30; + break; + case 0x02: /* pixels 2, 6, 10, ... */ + *destPtr += pixTransTbl[dataPtr[i++]] & 0x0C; + break; + case 0x03: /* pixels 3, 7, 11, ... */ + *(destPtr++) += pixTransTbl[dataPtr[i++]] & 0x03; + } + } + else /* 320 mode */ + for (i = 0; i < rectWidth; /* i is incremented in loop */) { + if ((i & 0x01) == 0) /* pixels 0, 2, 4, ... */ + *destPtr = pixTransTbl[dataPtr[i++]] & 0xF0; + else { /* pixels 1, 3, 5, ... */ + *(destPtr++) += pixTransTbl[dataPtr[i++]] & 0x0F; + } + } + + HUnlock(readBufferHndl); + contentOrigin = GetContentOrigin(vncWindow); + PPToPort(&srcLocInfo, &srcRect, rectX - contentOriginPtr->h, + rectY - contentOriginPtr->v, modeCopy); + free(srcLocInfo.ptrToPixImage); /* Allocated as destPtr */ + + TCPIPPoll(); + + rectHeight--; /* One less line left to draw */ + rectY++; /* Rest of rect starts one line below this */ + } + +/* Process rectangle data in raw encoding and write it to screen. + */ +void DoRawRect (void) { + unsigned long bufferLength; + + pixels = (unsigned long) rectWidth * rectHeight; + + /* Try to read data */ + if (! DoReadTCP (pixels)) { + /* Only support line-by-line drawing if the connection is quite slow; + * otherwise it's actually detrimental to overall speed. The Hextile + * setting is used as a hint at the connection speed. + */ + if (useHextile && rectHeight > 1 && DoReadTCP ((unsigned long) rectWidth)) + RawDrawLine(); /* Some data ready - draw first line */ + return; /* Not ready yet; wait */ + } + + /* Here if data is ready to be processed */ + + if (hRez == 640) { + if (rectWidth & 0x03) { /* Width not an exact multiple of 4 */ + lineBytes = rectWidth/4 + 1; + extraByteAdvance = TRUE; + } + else { /* Width is a multiple of 4 */ + lineBytes = rectWidth/4; + extraByteAdvance = FALSE; + } + } + else { /* 320 mode */ + if (rectWidth & 0x01) { /* Width not an exact multiple of 2 */ + lineBytes = rectWidth/2 + 1; + extraByteAdvance = TRUE; + } + else { /* Width is a multiple of 2 */ + lineBytes = rectWidth/2; + extraByteAdvance = FALSE; + } + } + + bufferLength = lineBytes * rectHeight; + destPtr = calloc(bufferLength, 1); + if (!destPtr) { /* Couldn't allocate memory */ + DoClose(vncWindow); + return; + } + + srcLocInfo.ptrToPixImage = destPtr; + srcLocInfo.width = lineBytes; + 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; break; + case 0x01: srcLocInfo.boundsRect.h2 = rectWidth+3; break; + case 0x02: srcLocInfo.boundsRect.h2 = rectWidth+2; break; + case 0x03: srcLocInfo.boundsRect.h2 = rectWidth+1; + } + } + else { + switch (rectWidth & 0x01) { + case 0x00: srcLocInfo.boundsRect.h2 = rectWidth; break; + case 0x01: srcLocInfo.boundsRect.h2 = rectWidth+1; + } + } + + /* Don't include padding in the area we will actually copy over */ + srcRect.h2 = rectWidth; + srcRect.v1 = 0; + + displayInProgress = TRUE; + drawingLine = 0; /* Drawing first line of rect */ + checkBounds = TRUE; /* Flag to check bounds when drawing 1st line */ + HLock(readBufferHndl); /* Lock handle just once for efficiency */ + } diff --git a/raw.h b/raw.h new file mode 100644 index 0000000..8ee2232 --- /dev/null +++ b/raw.h @@ -0,0 +1,3 @@ +extern void RawDraw (void); +extern void DoRawRect (void); + diff --git a/test.cc b/test.cc deleted file mode 100644 index 1d4cbcd..0000000 --- a/test.cc +++ /dev/null @@ -1,351 +0,0 @@ -/******************************************************************** -* vncview.cc - main program code for VNCview GS -********************************************************************/ - -#if __ORCAC__ -#pragma lint -1 -#endif - -#if DEBUG -/* #pragma debug 25 */ -#endif - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "VNCsession.h" - -#define appleMenu 1 -#define fileMenu 2 -#define editMenu 3 - -#define appleAbout 257 - -#define fileNewConnection 260 -#define fileReturnToVNCSession 261 -#define fileClose 255 -#define fileQuit 256 - -#define editUndo 250 -#define editCut 251 -#define editCopy 252 -#define editPaste 253 -#define editClear 254 -#define editSendClipboard 262 - -#define noMarinettiError 2001 -#define outOfMemoryError 2002 - -#define disconnectTCPIPAlert 2003 - -#define NCWindow 1000 /* Offset for "New Connection" */ - /* window and its controls */ -#define winNewConnection 1 -#define btnConnect 1 -#define btnCancel 2 -#define linServer 3 -#define txtServer 4 -#define txtServerInfo 5 -#define txtPassword 6 -#define linPassword 7 -#define txtDisplay 8 -#define rectDisplay 9 -#define radColor 10 -#define radGray 11 -#define rad320 12 -#define rad640 13 -#define chkLocalPtr 24 -#define txtPointer 25 -#define chkShared 16 -#define chkClipboard 17 -#define txtTransfers 23 -#define chkEmul3Btn 18 -#define chkViewOnly 19 -#define txtDeleteSends 20 -#define radDelete 21 -#define radBackspace 22 - -BOOLEAN done = FALSE; /* are we done, yet? */ -EventRecord myEvent; /* event record for menu mode */ -GrafPortPtr newConnWindow; /* pointer to new connection window */ -BOOLEAN vncConnected = FALSE; /* are we connected to a VNC host */ - -/* Connection options */ -BOOLEAN color = TRUE; -int hRez = 320; -BOOLEAN requestSharedSession = FALSE; -BOOLEAN allowClipboardTransfers = TRUE; -BOOLEAN emulate3ButtonMouse = FALSE; -BOOLEAN viewOnlyMode = FALSE; -BOOLEAN localPointer = FALSE; -unsigned long deleteKeysym = 0xff08; -char vncServer[257]; -char vncPassword[10]; - - -/*************************************************************** -* DrawContents - Draw the contents of the active port -***************************************************************/ - -#pragma databank 1 - -void DrawContents (void) { - PenNormal(); /* use a "normal" pen */ - DrawControls(GetPort()); /* draw controls in window */ - } - -#pragma databank 0 - -/*************************************************************** -* DoAbout - Draw our about box -***************************************************************/ - -void DoAbout (void) { - #define alertID 1 /* alert string resource ID */ - - AlertWindow(awCString+awResource, NULL, alertID); - - #undef alertID - } - -/*************************************************************** -* DoNewConnection - Show the New Connection window -***************************************************************/ - -void DoNewConnection (void) { - MakeThisCtlTarget(GetCtlHandleFromID(newConnWindow, linServer)); - ShowWindow(newConnWindow); - } - -/*************************************************************** -* DoClose - Close the frontmost window/connection -* Parameters: -* wPtr - window to close -***************************************************************/ - -void DoClose (GrafPortPtr wPtr) { - if (wPtr == newConnWindow) { - HideWindow(newConnWindow); - } - else if (wPtr && vncConnected) { /* Close VNC session if no other */ - /* DisconnectVNCSession(); */ /* are open on top of VNC window */ - }; - } - -/*************************************************************** -* DoLEEdit - Handle edit menu items for LineEdit controls -* Parameters: -* editAction: Action selected from edit menu -***************************************************************/ - -void DoLEEdit (int editAction) { - CtlRecHndl ctl; /* target control handle */ - unsigned long id; /* control ID */ - GrafPortPtr port; /* caller's GrafPort */ - - port = GetPort(); - SetPort(newConnWindow); - ctl = FindTargetCtl(); - id = GetCtlID(ctl); - if ((id == linServer) || (id == linPassword)) { - LEFromScrap(); - switch (editAction) { - case editCut: if (id == linServer) { - LECut((LERecHndl) GetCtlTitle(ctl)); - }; - LEToScrap(); - break; - case editCopy: if (id == linServer) { - LECopy((LERecHndl) GetCtlTitle(ctl)); - }; - LEToScrap(); - break; - case editPaste: LEPaste((LERecHndl) GetCtlTitle(ctl)); - break; - case editClear: LEDelete((LERecHndl) GetCtlTitle(ctl)); - break; - }; - }; - SetPort(port); - } - -/*************************************************************** -* HandleMenu - Initialize the menu bar. -***************************************************************/ - -void HandleMenu (void) { - int menuNum, menuItemNum; /* menu number & menu item number */ - - menuNum = myEvent.wmTaskData >> 16; - menuItemNum = myEvent.wmTaskData; - switch (menuItemNum) { /* go handle the menu */ - case appleAbout: DoAbout(); break; - - case fileNewConnection: DoNewConnection(); break; - case fileReturnToVNCSession: break; - case fileClose: DoClose(FrontWindow()); break; - case fileQuit: done = TRUE; break; - - case editCut: DoLEEdit(editCut); break; - case editCopy: DoLEEdit(editCopy); break; - case editPaste: DoLEEdit(editPaste); break; - case editClear: DoLEEdit(editClear); break; - } - HiliteMenu(FALSE, menuNum); /* unhighlight the menu */ - } - -/*************************************************************** -* HandleControl - Handle a control press in the New Conn. window -***************************************************************/ - -void HandleControl (void) { - switch (myEvent.wmTaskData4) { - case btnConnect: DoConnect(); break; - case btnCancel: DoClose(newConnWindow); break; - case radColor: color = TRUE; break; - case radGray: color = FALSE; break; - case rad320: hRez = 320; /* "320x200" */ break; - case rad640: hRez = 640; /* "640x200" */ break; - case chkShared: requestSharedSession = !requestSharedSession; - break; - case chkClipboard: allowClipboardTransfers = !allowClipboardTransfers; - break; - case chkEmul3Btn: emulate3ButtonMouse = !emulate3ButtonMouse; break; - case chkViewOnly: viewOnlyMode = !viewOnlyMode; break; - case radDelete: deleteKeysym = 0xffff; /* delete -> del */ break; - case radBackspace: deleteKeysym = 0xff08; /* delete -> bs */ break; - case txtTransfers: allowClipboardTransfers = !allowClipboardTransfers; - SetCtlValueByID(!allowClipboardTransfers, - newConnWindow, 17); break; - case chkLocalPtr: localPointer = !localPointer; break; - case txtPointer: SetCtlValueByID(!localPointer, newConnWindow, 24); - localPointer = !localPointer; break; - }; - } - -/*************************************************************** -* InitMenus - Initialize the menu bar. -***************************************************************/ - -void InitMenus (void) { - #define menuID 1 /* menu bar resource ID */ - - int height; /* height of the largest menu */ - MenuBarRecHndl menuBarHand; /* for 'handling' the menu bar */ - - /* create the menu bar */ - menuBarHand = NewMenuBar2(refIsResource, menuID, NULL); - SetSysBar(menuBarHand); - SetMenuBar(NULL); - FixAppleMenu(1); /* add desk accessories */ - height = FixMenuBar(); /* draw the completed menu bar */ - DrawMenuBar(); - - #undef menuID - } - -/*************************************************************** -* CheckMenus - Check the menus to see if they should be dimmed -***************************************************************/ - -void CheckMenus (void) { - GrafPortPtr activeWindow; /* Front visible window */ - - activeWindow = FrontWindow(); - if (activeWindow) { - if (GetSysWFlag(activeWindow)) { /* NDA window is active */ - EnableMItem(fileClose); - EnableMItem(editUndo); - EnableMItem(editCut); - EnableMItem(editCopy); - EnableMItem(editPaste); - EnableMItem(editClear); - } - else if (activeWindow == newConnWindow) { /* New Connection window */ - EnableMItem(fileClose); - DisableMItem(editUndo); - EnableMItem(editCut); - EnableMItem(editCopy); - EnableMItem(editPaste); - EnableMItem(editClear); - } - } - else { /* no editable window on top */ - DisableMItem(fileClose); - DisableMItem(editUndo); - DisableMItem(editCut); - DisableMItem(editCopy); - DisableMItem(editPaste); - DisableMItem(editClear); - }; - - if (vncConnected) { /* VNC connection present */ - EnableMItem(fileReturnToVNCSession); - EnableMItem(fileClose); - EnableMItem(editSendClipboard); - } - else { - DisableMItem(fileReturnToVNCSession); - DisableMItem(editSendClipboard); - } - } - -/*************************************************************** -* Main - Initial startup function -***************************************************************/ - -int main (void) { - int event; /* event type returned by TaskMaster */ - Ref startStopParm; /* tool start/shutdown parameter */ - - #define wrNum 1001 /* New Conn. window resource number */ - - startStopParm = /* start up the tools */ - StartUpTools(userid(), 2, 1); - if (toolerror() != 0) - SysFailMgr(toolerror(), "\pCould not start tools: "); -#if 0 - LoadOneTool(54, 0x200); /* load Marinetti 2.0+ */ - if (toolerror()) { /* Check that Marinetti is available */ - SysBeep(); - AlertWindow(awResource, NULL, noMarinettiError); - done = TRUE; - } - else - TCPIPStartUp(); -#endif - - InitMenus(); /* set up the menu bar */ - InitCursor(); /* start the arrow cursor */ - - vncConnected = FALSE; /* Initially not connected */ - - newConnWindow = NewWindow2("\p New VNC Connection ", 0, - DrawContents, NULL, 0x02, wrNum, rWindParam1); - #undef wrNum - - DoNewConnection(); /* Display new connection window */ - - /* main event loop */ - myEvent.wmTaskMask = 0x001F71FF;/* let TaskMaster do everything that's needed */ - while (!done) { - CheckMenus(); - event = TaskMaster(everyEvent, &myEvent); -printf("In event loop after TaskMaster\n"); - } - ShutDownTools(1, startStopParm); /* shut down the tools */ - } diff --git a/vncdisplay.cc b/vncdisplay.cc index 74588ef..ef40527 100644 --- a/vncdisplay.cc +++ b/vncdisplay.cc @@ -1,13 +1,10 @@ +#pragma noroot + #include #include #include #include #include -#include "vncsession.h" -#include "vncview.h" -#include "vncdisplay.h" -#include "colortables.h" -#include "menus.h" #include #include #include @@ -17,12 +14,25 @@ #include #include #include +#include + +#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" unsigned int fbHeight; unsigned int fbWidth; BOOLEAN displayInProgress; -unsigned int drawingLine; /* Line to be drawn while displaying */ unsigned int numRects; unsigned int rectX; @@ -31,55 +41,23 @@ unsigned int rectWidth; unsigned int rectHeight; unsigned long rectEncoding; -unsigned int hexXTiles, hexYTiles; /* For in-process hextile processing */ -unsigned int hexXTileNum, hexYTileNum; -unsigned int hexTileWidth, hexTileHeight; -unsigned char hexBackground, hexForeground; - -BOOLEAN extraByteAdvance; - -#define encodingRaw 0 -#define encodingCopyRect 1 -#define encodingRRE 2 -#define encodingCoRRE 4 -#define encodingHextile 5 -#define encodingZRLE 16 -#define encodingCursor 0xffffff11 -#define encodingDesktopSize 0xffffff21 - -/* 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 - -GrafPortPtr hexPort = NULL; - GrafPortPtr vncWindow; /* VNC session window dimensions */ unsigned int winHeight; unsigned int winWidth; -/* Data on state of raw rectangle drawing routines */ -BOOLEAN checkBounds = FALSE; /* Adjust drawing to stay in bounds */ -unsigned int lineBytes; /* Number of bytes in a line of GS pixels */ -unsigned long pixels; - /* On the next 2 structs, only certain values are permanently zero. * Others are changed later. */ -static struct LocInfo srcLocInfo = {0, 0, 0, {0, 0, 0, 0} }; -static Rect srcRect = {0, 0, 0, 0}; -unsigned char *destPtr; +struct LocInfo srcLocInfo = {0, 0, 0, {0, 0, 0, 0} }; + +/* Used by multiple encodings */ +Rect srcRect = {0, 0, 0, 0}; unsigned char *pixTransTbl; +BOOLEAN checkBounds = FALSE; /* Adjust drawing to stay in bounds */ + #define txtColor 10 #define txtGray 11 #define txtTransfers 23 @@ -232,26 +210,6 @@ void SendFBUpdateRequest (BOOLEAN incremental, unsigned int x, unsigned int y, /* No error checking here -- Can't respond to one usefully. */ } -/* Send a KeyEvent message to the server - */ -void SendKeyEvent (BOOLEAN keyDownFlag, unsigned long key) -{ - struct KeyEvent { - unsigned char messageType; - unsigned char keyDownFlag; - unsigned int padding; - unsigned long key; - } keyEvent = { 4 /* Message Type 4 */, - 0, - 0 /* Zero the padding */ - }; - - keyEvent.keyDownFlag = !!keyDownFlag; - keyEvent.key = SwapBytes4(key); - TCPIPWriteTCP(hostIpid, &keyEvent.messageType, sizeof(keyEvent), - TRUE, FALSE); - /* No error checking here -- Can't respond to one usefully. */ -} /* Start responding to a FramebufferUpdate from the server */ @@ -294,142 +252,6 @@ void DoSetColourMapEntries (void) { } } -/* Update the Scrap Manager clipboard with new data sent from server. - */ -void DoServerCutText (void) { - unsigned long textLen; - unsigned long i; - - if (! DoWaitingReadTCP (3)) { /* Read & ignore padding */ - DoClose(vncWindow); - return; - } - if (! DoWaitingReadTCP (4)) { - DoClose(vncWindow); - return; - } - HLock(readBufferHndl); - textLen = SwapBytes4((unsigned long) **readBufferHndl); - HUnlock(readBufferHndl); - - if (! DoWaitingReadTCP(textLen)) { - DoClose(vncWindow); - return; - }; - if (allowClipboardTransfers) { - ZeroScrap(); - HLock(readBufferHndl); - - /* Convert lf->cr; Use pointer arithmetic so we can go over 64k */ - for (i = 0; i < textLen; i++) - if (*((*(char **)readBufferHndl)+i) == '\n') - *((*(char **)readBufferHndl)+i) = '\r'; - - /* Below function call requires to be fixed */ - PutScrap(textLen, textScrap, (Pointer) *readBufferHndl); - /* Potential errors (e.g. out of memory) ignored */ - HUnlock(readBufferHndl); - } - } - -/* Send a DoPointerEvent reflecting the status of the mouse to the server */ -void DoPointerEvent (void) { - static struct { - unsigned char messageType; - unsigned char buttonMask; - unsigned int xPos; - unsigned int yPos; - } pointerEventStruct = { 5 /* message type */ }; - - Point mouseCoords; - unsigned long contentOrigin; - Point * contentOriginPtr = (void *) &contentOrigin; - RegionHndl contentRgnHndl; - unsigned int oldButtonMask; - GrafPortPtr winPtr; - unsigned long key1 = 0x0000; /* Keys to release & re-press, if any */ - unsigned long key2 = 0x0000; - - if (viewOnlyMode) - return; - - mouseCoords = myEvent.where; - - SetPort(vncWindow); - - /* Check if mouse is in content region of VNC window; don't send mouse - * updates if it isn't. - */ - if (FindWindow(&winPtr, myEvent.where.h, myEvent.where.v) != wInContent || - winPtr != vncWindow) - return; - - GlobalToLocal(&mouseCoords); - - contentOrigin = GetContentOrigin(vncWindow); - mouseCoords.h += contentOriginPtr->h; - mouseCoords.v += contentOriginPtr->v; - - mouseCoords.h = SwapBytes2(mouseCoords.h); - mouseCoords.v = SwapBytes2(mouseCoords.v); - - /* Set up correct state of mouse buttons */ - oldButtonMask = pointerEventStruct.buttonMask; - pointerEventStruct.buttonMask = 0x00; - - if ((myEvent.modifiers & btn0State) == 0x00) { /* Mouse button pressed */ - if (emulate3ButtonMouse) { - if (myEvent.modifiers & optionKey) { - pointerEventStruct.buttonMask = 0x02; - key1 = 0xFFE9; - } - if (myEvent.modifiers & appleKey) { - pointerEventStruct.buttonMask |= 0x04; - key2 = 0xFFE7; - } - } - - /* If no modifiers, just send a normal left click. */ - if (pointerEventStruct.buttonMask == 0x00) - pointerEventStruct.buttonMask = 0x01; - } - if ((myEvent.modifiers & btn1State) == 0x00) /* If 2nd (right) */ - pointerEventStruct.buttonMask |= 0x04; /* button is pressed */ - - /* Don't waste bandwidth by sending update if mouse hasn't changed. - * This may occasionally result in an initial mouse update not being - * sent. If this occurs, the user can simply move the mouse slightly - * in order to send it. - */ - if ( (pointerEventStruct.xPos == mouseCoords.h) && - (pointerEventStruct.yPos == mouseCoords.v) && - (pointerEventStruct.buttonMask == oldButtonMask) ) - return; - - pointerEventStruct.xPos = mouseCoords.h; - pointerEventStruct.yPos = mouseCoords.v; - - if (key1) - SendKeyEvent(FALSE, key1); - if (key2) - SendKeyEvent(FALSE, key2); - - TCPIPWriteTCP(hostIpid, (Pointer) &pointerEventStruct.messageType, - sizeof(pointerEventStruct), TRUE, FALSE); - /* Can't do useful error checking here */ - - if (key1) - SendKeyEvent(TRUE, key1); - if (key2) - SendKeyEvent(TRUE, key2); - - //printf("Sent mouse update: x = %u, y = %u\n", mouseCoords.h, mouseCoords.v); - //printf(" xPos = %x, yPos = %x, buttons = %x\n", pointerEventStruct.xPos, pointerEventStruct.yPos, (int) pointerEventStruct.buttonMask); - - /* Note that we don't have to request a display update here. That has - * been or will be done elsewhere when we're ready for it. - */ -} /* Here when we're done processing one rectangle and ready to start the next. * If last FramebufferUpdate had multiple rectangles, we set up for next one. @@ -464,713 +286,7 @@ void NextRect (void) { winWidth, winHeight); } } - -/* Ends drawing of a raw rectangle when it is complete or aborted - * because the rectangle is not visible. - */ -void StopRawDrawing (void) { - HUnlock(readBufferHndl); - free(srcLocInfo.ptrToPixImage); /* Allocated as destPtr */ - - displayInProgress = FALSE; - - NextRect(); /* Prepare for next rect */ -} - -#pragma optimize 95 /* To work around an ORCA/C optimizer bug */ - -/* Draw one or more lines from a raw rectangle - */ -void RawDraw (void) { - unsigned int i; /* Loop indices */ - unsigned char *dataPtr; - unsigned char *lineDataPtr, *initialLineDataPtr; - unsigned char *finalDestPtr; - static EventRecord unusedEventRec; - - /* For use with GetContentOrigin() */ - unsigned long contentOrigin; - Point * contentOriginPtr = (void *) &contentOrigin; - - SetPort(vncWindow); /* Drawing in VNC window */ - dataPtr = (unsigned char *) *readBufferHndl; - - /* Check if what we're drawing is visible, and skip any invisible part - * by skipping some lines or completely aborting drawing the rectangle. - */ - if (checkBounds) { - Rect drawingRect; - - contentOrigin = GetContentOrigin(vncWindow); - drawingRect.h1 = rectX - contentOriginPtr->h; - drawingRect.h2 = rectX - contentOriginPtr->h + rectWidth; - drawingRect.v1 = rectY - contentOriginPtr->v + drawingLine; - drawingRect.v2 = rectY - contentOriginPtr->v + rectHeight; - - if (!RectInRgn(&drawingRect, GetVisHandle())) { - StopRawDrawing(); - return; - } - else if (rectY + drawingLine < contentOriginPtr->v) { - destPtr += (unsigned long)lineBytes * - (contentOriginPtr->v - rectY - drawingLine); - drawingLine = contentOriginPtr->v - rectY; - if (drawingLine >= rectHeight) { /* Sanity check */ - StopRawDrawing(); - return; - } - } - else if (rectY + rectHeight - 1 > contentOriginPtr->v + winHeight) - rectHeight = contentOriginPtr->v + winHeight - rectY + 1; - - checkBounds = FALSE; - } - - lineDataPtr = dataPtr + (unsigned long) drawingLine * rectWidth; - - do { /* We short-circuit back to here if there are no events pending */ - - finalDestPtr = destPtr + lineBytes - 1; - if (hRez == 640) { - initialLineDataPtr = lineDataPtr; - while (destPtr + 7 < finalDestPtr) { /* Unrolled loop */ - *(destPtr++) = bigcoltab640a[*(unsigned int*)(void*)lineDataPtr] - + bigcoltab640b[*(unsigned int*)(void*)(lineDataPtr+2)]; - lineDataPtr += 4; - *(destPtr++) = bigcoltab640a[*(unsigned int*)(void*)lineDataPtr] - + bigcoltab640b[*(unsigned int*)(void*)(lineDataPtr+2)]; - lineDataPtr += 4; - *(destPtr++) = bigcoltab640a[*(unsigned int*)(void*)lineDataPtr] - + bigcoltab640b[*(unsigned int*)(void*)(lineDataPtr+2)]; - lineDataPtr += 4; - *(destPtr++) = bigcoltab640a[*(unsigned int*)(void*)lineDataPtr] - + bigcoltab640b[*(unsigned int*)(void*)(lineDataPtr+2)]; - lineDataPtr += 4; - *(destPtr++) = bigcoltab640a[*(unsigned int*)(void*)lineDataPtr] - + bigcoltab640b[*(unsigned int*)(void*)(lineDataPtr+2)]; - lineDataPtr += 4; - *(destPtr++) = bigcoltab640a[*(unsigned int*)(void*)lineDataPtr] - + bigcoltab640b[*(unsigned int*)(void*)(lineDataPtr+2)]; - lineDataPtr += 4; - *(destPtr++) = bigcoltab640a[*(unsigned int*)(void*)lineDataPtr] - + bigcoltab640b[*(unsigned int*)(void*)(lineDataPtr+2)]; - lineDataPtr += 4; - *(destPtr++) = bigcoltab640a[*(unsigned int*)(void*)lineDataPtr] - + bigcoltab640b[*(unsigned int*)(void*)(lineDataPtr+2)]; - lineDataPtr += 4; - } - while (destPtr < finalDestPtr) { - *(destPtr++) = bigcoltab640a[*(unsigned int*)(void*)lineDataPtr] - + bigcoltab640b[*(unsigned int*)(void*)(lineDataPtr+2)]; - lineDataPtr += 4; - } - /* Final byte to produce */ - *destPtr = pixTransTbl[*(lineDataPtr++)] & 0xC0; - for (i = lineDataPtr - initialLineDataPtr; i < rectWidth; i++) - switch (i & 0x03) { - case 0x01: /* pixels 1, 5, 9, ... */ - *destPtr += pixTransTbl[*(lineDataPtr++)] & 0x30; - break; - case 0x02: /* pixels 2, 6, 10, ... */ - *destPtr += pixTransTbl[*(lineDataPtr++)] & 0x0C; - break; - case 0x03: /* pixels 3, 7, 11, ... */ - *destPtr += pixTransTbl[*(lineDataPtr++)] & 0x03; - } - destPtr++; - } - else { /* 320 mode */ - while (destPtr + 7 < finalDestPtr) { /* Unrolled loop */ - *(destPtr++) = bigcoltab320[*(unsigned int*)(void*)lineDataPtr]; - lineDataPtr += 2; - *(destPtr++) = bigcoltab320[*(unsigned int*)(void*)lineDataPtr]; - lineDataPtr += 2; - *(destPtr++) = bigcoltab320[*(unsigned int*)(void*)lineDataPtr]; - lineDataPtr += 2; - *(destPtr++) = bigcoltab320[*(unsigned int*)(void*)lineDataPtr]; - lineDataPtr += 2; - *(destPtr++) = bigcoltab320[*(unsigned int*)(void*)lineDataPtr]; - lineDataPtr += 2; - *(destPtr++) = bigcoltab320[*(unsigned int*)(void*)lineDataPtr]; - lineDataPtr += 2; - *(destPtr++) = bigcoltab320[*(unsigned int*)(void*)lineDataPtr]; - lineDataPtr += 2; - *(destPtr++) = bigcoltab320[*(unsigned int*)(void*)lineDataPtr]; - lineDataPtr += 2; - } - while (destPtr < finalDestPtr) { - *(destPtr++) = bigcoltab320[*(unsigned int*)(void*)lineDataPtr]; - lineDataPtr += 2; - } - /* Final byte to produce */ - *destPtr = pixTransTbl[*(lineDataPtr++)] & 0xF0; - if (extraByteAdvance) - destPtr++; /* Not ending on byte boundary - update index */ - else - *(destPtr++) += pixTransTbl[*(lineDataPtr++)] & 0x0F; - } - - drawingLine++; - - if (pixels > 613 && !(drawingLine & 0x03)) { /* Draw every 4th line */ - srcRect.v2 = drawingLine; - contentOrigin = GetContentOrigin(vncWindow); - PPToPort(&srcLocInfo, &srcRect, rectX - contentOriginPtr->h, - rectY + srcRect.v1 - contentOriginPtr->v, modeCopy); - srcRect.v1 = drawingLine; - } - - /* Check whether we're done with this rectangle */ - if (drawingLine >= rectHeight) { - /* Draw final rect, if necessary */ - if (drawingLine > srcRect.v1) { - srcRect.v2 = drawingLine; - contentOrigin = GetContentOrigin(vncWindow); - PPToPort(&srcLocInfo, &srcRect, rectX - contentOriginPtr->h, - rectY + srcRect.v1 - contentOriginPtr->v, modeCopy); - } - StopRawDrawing(); - return; - } - - /* Check if there are actually any events that need to be processed. - * If not, save time by not going through the whole event loop, but - * instead processing the minimum necessary periodic tasks and then - * going straight to the next line of data. - */ - if (EventAvail(0xFFFF, &unusedEventRec)) - return; - - SystemTask(); /* Let periodic Desk Accesories do their things */ - TCPIPPoll(); /* Let Marinetti keep processing data */ - - } while (1); -} - -#pragma optimize -1 - -/* Draw one line of Raw data - used if the complete rect isn't yet available */ -void RawDrawLine (void) { - unsigned int i; - unsigned char *dataPtr; - unsigned long contentOrigin; - Point * contentOriginPtr = (void *) &contentOrigin; - - if (hRez == 640) { - if (rectWidth & 0x03) /* Width not an exact multiple of 4 */ - lineBytes = rectWidth/4 + 1; - else /* Width is a multiple of 4 */ - lineBytes = rectWidth/4; - } - else { /* 320 mode */ - if (rectWidth & 0x01) /* Width not an exact multiple of 2 */ - lineBytes = rectWidth/2 + 1; - else /* Width is a multiple of 2 */ - lineBytes = rectWidth/2; - } - - destPtr = calloc(lineBytes, 1); - if (!destPtr) { /* Couldn't allocate memory */ - DoClose(vncWindow); - return; - } - - srcLocInfo.ptrToPixImage = destPtr; - srcLocInfo.width = lineBytes; - srcLocInfo.boundsRect.v2 = 1; - /* 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; break; - case 0x01: srcLocInfo.boundsRect.h2 = rectWidth+3; break; - case 0x02: srcLocInfo.boundsRect.h2 = rectWidth+2; break; - case 0x03: srcLocInfo.boundsRect.h2 = rectWidth+1; - } - } - else { - switch (rectWidth & 0x01) { - case 0x00: srcLocInfo.boundsRect.h2 = rectWidth; break; - case 0x01: srcLocInfo.boundsRect.h2 = rectWidth+1; - } - } - - /* Don't include padding in the area we will actually copy over */ - srcRect.h2 = rectWidth; - srcRect.v1 = 0; - srcRect.v2 = 1; - - HLock(readBufferHndl); - dataPtr = (unsigned char *) *readBufferHndl; - SetPort(vncWindow); /* Drawing in VNC window */ - - if (hRez == 640) - for (i = 0; i < rectWidth; /* i is incremented in loop */) { - switch (i & 0x03) { - case 0x00: /* pixels 0, 4, 8, ... */ - *destPtr = pixTransTbl[dataPtr[i++]] & 0xC0; - break; - case 0x01: /* pixels 1, 5, 9, ... */ - *destPtr += pixTransTbl[dataPtr[i++]] & 0x30; - break; - case 0x02: /* pixels 2, 6, 10, ... */ - *destPtr += pixTransTbl[dataPtr[i++]] & 0x0C; - break; - case 0x03: /* pixels 3, 7, 11, ... */ - *(destPtr++) += pixTransTbl[dataPtr[i++]] & 0x03; - } - } - else /* 320 mode */ - for (i = 0; i < rectWidth; /* i is incremented in loop */) { - if ((i & 0x01) == 0) /* pixels 0, 2, 4, ... */ - *destPtr = pixTransTbl[dataPtr[i++]] & 0xF0; - else { /* pixels 1, 3, 5, ... */ - *(destPtr++) += pixTransTbl[dataPtr[i++]] & 0x0F; - } - } - - HUnlock(readBufferHndl); - contentOrigin = GetContentOrigin(vncWindow); - PPToPort(&srcLocInfo, &srcRect, rectX - contentOriginPtr->h, - rectY - contentOriginPtr->v, modeCopy); - free(srcLocInfo.ptrToPixImage); /* Allocated as destPtr */ - - TCPIPPoll(); - - rectHeight--; /* One less line left to draw */ - rectY++; /* Rest of rect starts one line below this */ - } - -/* Process rectangle data in raw encoding and write it to screen. - */ -void DoRawRect (void) { - unsigned long bufferLength; - - pixels = (unsigned long) rectWidth * rectHeight; - - /* Try to read data */ - if (! DoReadTCP (pixels)) { - /* Only support line-by-line drawing if the connection is quite slow; - * otherwise it's actually detrimental to overall speed. The Hextile - * setting is used as a hint at the connection speed. - */ - if (useHextile && rectHeight > 1 && DoReadTCP ((unsigned long) rectWidth)) - RawDrawLine(); /* Some data ready - draw first line */ - return; /* Not ready yet; wait */ - } - - /* Here if data is ready to be processed */ - - if (hRez == 640) { - if (rectWidth & 0x03) { /* Width not an exact multiple of 4 */ - lineBytes = rectWidth/4 + 1; - extraByteAdvance = TRUE; - } - else { /* Width is a multiple of 4 */ - lineBytes = rectWidth/4; - extraByteAdvance = FALSE; - } - } - else { /* 320 mode */ - if (rectWidth & 0x01) { /* Width not an exact multiple of 2 */ - lineBytes = rectWidth/2 + 1; - extraByteAdvance = TRUE; - } - else { /* Width is a multiple of 2 */ - lineBytes = rectWidth/2; - extraByteAdvance = FALSE; - } - } - - bufferLength = lineBytes * rectHeight; - destPtr = calloc(bufferLength, 1); - if (!destPtr) { /* Couldn't allocate memory */ - DoClose(vncWindow); - return; - } - - srcLocInfo.ptrToPixImage = destPtr; - srcLocInfo.width = lineBytes; - 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; break; - case 0x01: srcLocInfo.boundsRect.h2 = rectWidth+3; break; - case 0x02: srcLocInfo.boundsRect.h2 = rectWidth+2; break; - case 0x03: srcLocInfo.boundsRect.h2 = rectWidth+1; - } - } - else { - switch (rectWidth & 0x01) { - case 0x00: srcLocInfo.boundsRect.h2 = rectWidth; break; - case 0x01: srcLocInfo.boundsRect.h2 = rectWidth+1; - } - } - - /* Don't include padding in the area we will actually copy over */ - srcRect.h2 = rectWidth; - srcRect.v1 = 0; - - displayInProgress = TRUE; - drawingLine = 0; /* Drawing first line of rect */ - checkBounds = TRUE; /* Flag to check bounds when drawing 1st line */ - HLock(readBufferHndl); /* Lock handle just once for efficiency */ - } - -void DoCopyRect (void) { - /* For use with GetContentOrigin() */ - unsigned long contentOrigin; - Point * contentOriginPtr = (void *) &contentOrigin; - - Rect srcRect; - unsigned int *dataPtr; /* Pointer to TCP data that was read */ - - //printf("Processing CopyRect rectangle\n"); - - if (! DoReadTCP ((unsigned long) 4)) - return; /* Not ready yet; wait */ - - contentOrigin = GetContentOrigin(vncWindow); - - HLock(readBufferHndl); - dataPtr = (unsigned int *) ((char *) (*readBufferHndl)); - srcRect.h1 = SwapBytes2(dataPtr[0]) - contentOriginPtr->h; - srcRect.v1 = SwapBytes2(dataPtr[1]) - contentOriginPtr->v; - HUnlock(readBufferHndl); - - srcRect.h2 = srcRect.h1 + rectWidth; - srcRect.v2 = srcRect.v1 + rectHeight; - - /* Check that the source rect is actually visible; if not, ask the server - to send the update using some other encoding. - */ - if (!RectInRgn(&srcRect, GetVisHandle())) { - SendFBUpdateRequest(FALSE, rectX, rectY, rectWidth, rectHeight); - displayInProgress = FALSE; - return; - } - - /* We can use the window pointer as a LocInfo pointer because it starts - * with a grafPort structure, which in turn starts with a LocInfo structure. - */ - PPToPort((struct LocInfo *) vncWindow, &srcRect, - rectX - contentOriginPtr->h, rectY - contentOriginPtr->v, modeCopy); - - displayInProgress = FALSE; - - NextRect(); /* Prepare for next rect */ - } - -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; - - } - -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; - } - -/* This prototype should be in but is bogusly commented out there */ -extern pascal void SetContentOrigin2(Word, Word, Word, GrafPortPtr) inline(0x570E,dispatcher); - -void DoDesktopSize (void) { - #define screenTooBigError 2010 - unsigned long contentOrigin; - Point * contentOriginPtr = (void *) &contentOrigin; - unsigned int newX, newY; - Boolean changeOrigin = FALSE; - unsigned int oldWinHeight, oldWinWidth; - - fbWidth = rectWidth; - fbHeight = rectHeight; - - if ((fbWidth > 16384) || (fbHeight > 16384)) { - AlertWindow(awResource, NULL, screenTooBigError); - DoClose(vncWindow); - } - - oldWinHeight = winHeight; - oldWinWidth = winWidth; - winHeight = 174; - winWidth = (hRez == 640) ? 613 : 302; - if (fbWidth < winWidth) - winWidth = fbWidth; - if (fbHeight < winHeight) - winHeight = fbHeight; - if (oldWinHeight != winHeight || oldWinWidth != winWidth) - SizeWindow(winWidth, winHeight, vncWindow); - - /* Scroll if area displayed is going away */ - contentOrigin = GetContentOrigin(vncWindow); - newX = contentOriginPtr->h; - newY = contentOriginPtr->v; - - if (contentOriginPtr->h + winWidth > fbWidth) { - newX = fbWidth - winWidth; - changeOrigin = TRUE; - } - if (contentOriginPtr->v + winHeight > fbHeight) { - newY = fbHeight - winHeight; - changeOrigin = TRUE; - } - SetContentOrigin2(1, newX, newY, vncWindow); - - SetDataSize(fbWidth, fbHeight, vncWindow); - DrawControls(vncWindow); - - displayInProgress = FALSE; - - NextRect(); /* Prepare for next rect */ - } - void ConnectedEventLoop (void) { unsigned char messageType; #define FBUpdate 0 @@ -1206,6 +322,9 @@ void ConnectedEventLoop (void) { case encodingDesktopSize: DoDesktopSize(); return; + case encodingCursor: + DoCursor(); + return; default: DisplayConnectStatus ( "\pInvalid rectangle from server.", FALSE); DoClose(vncWindow); @@ -1231,156 +350,9 @@ void ConnectedEventLoop (void) { "\pInvalid message from server.", FALSE); DoClose(vncWindow); - //printf("Closing due to bad message from server\n"); return; } } } -void DoSendClipboard (void) { - static struct clientCutText { - unsigned char messageType; - unsigned char padding1; - unsigned int padding2; - unsigned long length; - } clientCutTextStruct = { 6 /* Message type 6 */ }; - Handle scrapHandle; - unsigned long i; - - /* Only proceed if we're connected to the server and not view-only */ - if (vncConnected && !viewOnlyMode) { - clientCutTextStruct.length = GetScrapSize(textScrap); - - if (clientCutTextStruct.length == 0) - return; - - clientCutTextStruct.length = SwapBytes4(clientCutTextStruct.length); - - scrapHandle = NewHandle(1, userid(), 0x0000, NULL); - GetScrap(scrapHandle, textScrap); - if (toolerror()) - goto end; /* abort if error */ - if (TCPIPWriteTCP(hostIpid, &clientCutTextStruct.messageType, - sizeof(clientCutTextStruct), FALSE, FALSE)) - goto end; /* abort if error */ - if (toolerror()) - goto end; - - clientCutTextStruct.length = SwapBytes4(clientCutTextStruct.length); - - HLock(scrapHandle); - /* Convert cr->lf; Use pointer arithmetic so we can go over 64k */ - for (i = 0; i < clientCutTextStruct.length; i++) - if (*((*(char **)scrapHandle)+i) == '\r') - *((*(char **)scrapHandle)+i) = '\n'; - - TCPIPWriteTCP(hostIpid, (Pointer) *scrapHandle, - clientCutTextStruct.length, TRUE, FALSE); - /* Can't handle errors usefully here */ - HUnlock(scrapHandle); - - end: - DisposeHandle(scrapHandle); - } - } - -/* Process a key down event and send it on to the server. */ -void ProcessKeyEvent (void) -{ - unsigned long key = myEvent.message & 0x0000007F; - - if (viewOnlyMode) - return; - - /* Deal with extended keys that are mapped as keypad keys */ - if (myEvent.modifiers & keyPad) { - switch (key) { - case 0x7A: key = 0xFFBE; break; /* F1 */ - case 0x78: key = 0xFFBF; break; /* F2 */ - case 0x63: key = 0xFFC0; break; /* F3 */ - case 0x76: key = 0xFFC1; break; /* F4 */ - case 0x60: key = 0xFFC2; break; /* F5 */ - case 0x61: key = 0xFFC3; break; /* F6 */ - case 0x62: key = 0xFFC4; break; /* F7 */ - case 0x64: key = 0xFFC5; break; /* F8 */ - case 0x65: key = 0xFFC6; break; /* F9 */ - case 0x6D: key = 0xFFC7; break; /* F10 */ - case 0x67: key = 0xFFC8; break; /* F11 */ - case 0x6F: key = 0xFFC9; break; /* F12 */ - case 0x69: key = 0xFF15; break; /* F13 / PrintScr -> SysRq */ - case 0x6B: key = 0xFF14; break; /* F14 / ScrLock -> ScrLock */ - case 0x71: key = 0xFF13; break; /* F15 / Pause -> Pause */ - case 0x72: key = 0xFF63; break; /* Help / Insert -> Insert */ - case 0x75: key = 0xFFFF; break; /* Forward delete -> Delete */ - case 0x73: key = 0xFF50; break; /* Home */ - case 0x77: key = 0xFF57; break; /* End */ - case 0x74: key = 0xFF55; break; /* Page Up */ - case 0x79: key = 0xFF56; break; /* Page Down */ - } - } - - if (key == 0x7f) - key = 0xFF08; /* Delete -> BackSpace */ - - if (key < 0x20) { - if (myEvent.modifiers & controlKey) { - if (((myEvent.modifiers & shiftKey) || - (myEvent.modifiers & capsLock)) - && !((myEvent.modifiers & shiftKey) && - (myEvent.modifiers & capsLock))) - key += 0x40; /* Undo effect of control on upper-case char. */ - else - key += 0x60; /* Undo effect of control */ - } - else switch (key) { - case 0x1B: key = 0xFF1B; break; /* Escape */ - case 0x09: key = 0xFF09; break; /* Tab */ - case 0x0D: key = 0xFF0D; break; /* Return / Enter */ - case 0x08: key = 0xFF51; break; /* Left arrow */ - case 0x0B: key = 0xFF52; break; /* Up arrow */ - case 0x15: key = 0xFF53; break; /* Right arrow */ - case 0x0A: key = 0xFF54; break; /* Down arrow */ - case 0x18: key = 0xFF0B; break; /* Clear / NumLock -> Clear */ - } - } - - /* Test if we seem to have a valid character and return if we don't. - This should never return, unless there are bugs in this routine or - TaskMaster gives us bogus keycodes. The test would need to be updated - if we ever start generating valid keycodes outside of these ranges. - */ - if ((key & 0xFF80) != 0xFF00 && (key & 0xFF80) != 0x0000) - return; - - SendKeyEvent(TRUE, key); - SendKeyEvent(FALSE, key); -} - -/* Send modifier keys that have changed since last update */ -void SendModifiers (void) { - static unsigned int oldModifiers = 0x00FF; /* So it runs 1st time */ - unsigned int modifiers; - - modifiers = myEvent.modifiers & 0x1B00; - - /* If unchanged, do nothing. */ - if (modifiers == oldModifiers) - return; - - /* Apple key is sent as "meta" */ - if ((modifiers & appleKey) != (oldModifiers & appleKey)) - SendKeyEvent(modifiers & appleKey, 0xFFE7); - - if ((modifiers & shiftKey) != (oldModifiers & shiftKey)) - SendKeyEvent(modifiers & shiftKey, 0xFFE1); - - /* Option key is sent as "alt," as per its labelling on some keyboards */ - if ((modifiers & optionKey) != (oldModifiers & optionKey)) - SendKeyEvent(modifiers & optionKey, 0xFFE9); - - if ((modifiers & controlKey) != (oldModifiers & controlKey)) - SendKeyEvent(modifiers & controlKey, 0xFFE3); - - oldModifiers = modifiers; -} diff --git a/vncdisplay.h b/vncdisplay.h index 2950413..5b2601f 100644 --- a/vncdisplay.h +++ b/vncdisplay.h @@ -1,8 +1,41 @@ extern unsigned int fbHeight; extern unsigned int fbWidth; +extern BOOLEAN displayInProgress; + +extern unsigned int numRects; +extern unsigned int rectX; +extern unsigned int rectY; +extern unsigned int rectWidth; +extern unsigned int rectHeight; +extern unsigned long rectEncoding; + +#define encodingRaw 0 +#define encodingCopyRect 1 +#define encodingRRE 2 +#define encodingCoRRE 4 +#define encodingHextile 5 +#define encodingZRLE 16 +#define encodingCursor 0xffffff11 +#define encodingDesktopSize 0xffffff21 + extern GrafPortPtr vncWindow; +/* VNC session window dimensions */ +extern unsigned int winHeight; +extern unsigned int winWidth; + +/* On the next 2 structs, only certain values are permanently zero. + * Others are changed later. + */ +extern struct LocInfo srcLocInfo; + +/* Used by multiple encodings */ +extern Rect srcRect; +extern unsigned char *pixTransTbl; + +extern BOOLEAN checkBounds; /* Adjust drawing to stay in bounds */ + void InitVNCWindow (void); void SendFBUpdateRequest (BOOLEAN /*incremental*/, unsigned int /*x*/, @@ -10,8 +43,3 @@ void SendFBUpdateRequest (BOOLEAN /*incremental*/, unsigned int /*x*/, void ConnectedEventLoop (void); -void DoSendClipboard (void); -void DoPointerEvent (void); - -void ProcessKeyEvent (void); -void SendModifiers (void); diff --git a/vncsession.cc b/vncsession.cc index 2b27a62..767ad10 100644 --- a/vncsession.cc +++ b/vncsession.cc @@ -635,13 +635,15 @@ BOOLEAN FinishVNCHandshaking (void) { unsigned long firstEncoding; unsigned long secondEncoding; unsigned long thirdEncoding; + unsigned long fourthEncoding; } encodings = { 2, /* Message Type - SetEncodings */ 0, /* padding */ 0, /* number of encodings - set below */ SwapBytes4(0xffffff21), /* DesktopSize pseudo-encoding */ - SwapBytes4(1), /* first encoding: CopyRect */ - SwapBytes4(5) /* second encoding: Hextile */ + SwapBytes4(0xffffff11), /* Cursor pseudo-encoding */ + SwapBytes4(1), /* CopyRect encoding */ + SwapBytes4(5) /* Hextile encoding */ /* Per the spec, raw encoding is supported even though * it is not listed here explicitly. */ @@ -691,11 +693,11 @@ BOOLEAN FinishVNCHandshaking (void) { return FALSE; if (useHextile) { - encodings.numberOfEncodings = SwapBytes2(3); + encodings.numberOfEncodings = SwapBytes2(4); encodingInfoSize = sizeof(encodings); } else { /* No Hextile */ - encodings.numberOfEncodings = SwapBytes2(2); + encodings.numberOfEncodings = SwapBytes2(3); encodingInfoSize = sizeof(encodings) - 4; } diff --git a/vncview.cc b/vncview.cc index 1a25a37..d658a39 100644 --- a/vncview.cc +++ b/vncview.cc @@ -33,6 +33,9 @@ #include "vncdisplay.h" #include "menus.h" #include "colortables.h" +#include "mouse.h" +#include "keyboard.h" +#include "clipboard.h" #define noMarinettiError 2001 #define outOfMemoryError 2002 @@ -140,6 +143,10 @@ void DoClose (GrafPortPtr wPtr) { EnableMItem(fileNewConnection); InitMenus(0); myEvent.wmTaskMask = 0x001F79FF; /* let TaskMaster handle keys again */ + if (cursor) { + InitCursor(); + free(cursor); + } }; } @@ -353,6 +360,8 @@ void Quit (void) { free(bigcoltab640a); if (bigcoltab640b) free(bigcoltab640b); + if (cursor) + free(cursor); /* Ask the user if we should disconnect only if the connection */ /* is not "permanent," i.e. started when the system boots up. */