From 1e83d9a5994e0e68497a136b719c9c1c53103f3c Mon Sep 17 00:00:00 2001 From: dscho Date: Sun, 23 Sep 2001 02:00:31 +0000 Subject: cleaned up warnings, cursor changes --- Makefile | 4 +- README | 56 ++++++++- TODO | 20 ++-- cursor.c | 376 +++++++++++++++++++++++++++++++++++++++++++++++------------- example.c | 98 ++++++++++++---- httpd.c | 4 +- main.c | 58 ++++++++-- rfb.h | 38 ++++-- rfbserver.c | 44 +++---- sockets.c | 1 + zlib.c | 2 - 11 files changed, 545 insertions(+), 156 deletions(-) diff --git a/Makefile b/Makefile index 0154b72..d5ed14c 100644 --- a/Makefile +++ b/Makefile @@ -20,10 +20,10 @@ OSX_LIBS = -framework ApplicationServices -framework Carbon SOURCES=main.c rfbserver.c miregion.c auth.c sockets.c xalloc.c \ stats.c corre.c hextile.c rre.c translate.c cutpaste.c \ - zlib.c tight.c httpd.c + zlib.c tight.c httpd.c cursor.o OBJS=main.o rfbserver.o miregion.o auth.o sockets.o xalloc.o \ stats.o corre.o hextile.o rre.o translate.o cutpaste.o \ - zlib.o tight.o httpd.o + zlib.o tight.o httpd.o cursor.o all: example pnmshow storepasswd diff --git a/README b/README index d71d847..5fa5725 100644 --- a/README +++ b/README @@ -1,6 +1,15 @@ LibVNCServer: a library for easy implementation of a RDP/VNC server. Copyright (C) 2001 Johannes E. Schindelin +What is it? +----------- + +VNC is set of programs using the RFB (Remote Frame Buffer) protocol. They +are designed to "export" a frame buffer via net. It is already in wide use +for administration, but it is not that easy to make a server yourself. + +This has been changed by LibVNCServer. + There are two examples included: - example, a shared scribble sheet - pnmshow, a program to show PNMs (pictures) over the net. @@ -12,13 +21,56 @@ How to use ---------- To make a server, you just have to initialise a server structure using the -function rfbDefaultScreenInit. +function rfbDefaultScreenInit, like + rfbScreenInfoPtr rfbScreen = + rfbDefaultScreenInit(argc,argv,maxx,maxy,8,3,bpp); -You then can set hooks and io functions. +You then can set hooks and io functions (see below). You can use a blocking event loop, a background (pthread based) event loop, or implement your own using the processEvents function. +Also, there is functionality included to draw a cursor (see below). + +To start also an HTTP server (running on port 5800+display_number), you have +to set rfbScreen->httpdDir to a directory containing vncviewer.jar and +index.vnc (like the included "classes" directory). + +Hooks and IO functions +---------------------- + +TODO + +Cursor handling +--------------- + +The rfbCursor structure consists mainly of a mask and a source. The mask +describes, which pixels are drawn for the cursor (a cursor needn't be +rectangular). The source describes, which colour those pixels should have. + +The standard is an XCursor: a cursor with a foreground and a background +colour (stored in backRed and similar with a range from 0-0xffff). The +arrays "mask" and "source" consist of byte padded rows in MSB order (i.e. a +10x4 cursor's mask has 2x4 bytes, because 2 bytes are needed to hold 10 bits). + +It is very easy to make a cursor like this: + +char* cur=" " + " xx " + " x " + " "; +char* mask="xxxx" + "xxxx" + "xxxx" + "xxx "; +rfbCursorPtr c=rfbMakeXCursor(4,4,cur,mask); + +You can even set "mask" to NULL in this call and LibVNCServer will calculate +a mask for you. + +There is also an array named "richSource" for colourful cursors. They have +the same format as the frameBuffer. + History ------- diff --git a/TODO b/TODO index 5ffaa28..a7d0b14 100644 --- a/TODO +++ b/TODO @@ -1,17 +1,15 @@ -.cutpaste - -httpd - -.other encodings - +dont draw rich cursors as xcursors +test drawing of cursors when not using xcursor or rich cursor encoding adapt rdp2vnc (rdesktop) - udp - rfbCloseClient, rfbConnect, ConnectToTcpAddr - CORBA - translate.c: warning about non 8-bit colourmaps -cursors +done: + +.cursors +.cutpaste +.httpd +.other encodings + diff --git a/cursor.c b/cursor.c index 0ce6807..a47952a 100644 --- a/cursor.c +++ b/cursor.c @@ -24,11 +24,13 @@ #include #include "rfb.h" -#include "mipointer.h" + +/* + #include "mipointer.h" #include "sprite.h" #include "cursorstr.h" #include "servermd.h" - +*/ /* Copied from Xvnc/lib/font/util/utilbitmap.c */ static unsigned char _reverse_byte[0x100] = { @@ -67,12 +69,12 @@ static unsigned char _reverse_byte[0x100] = { }; -static int EncodeRichCursorData8 (char *buf, rfbPixelFormat *fmt, - CursorPtr pCursor); -static int EncodeRichCursorData16 (char *buf, rfbPixelFormat *fmt, - CursorPtr pCursor); -static int EncodeRichCursorData32 (char *buf, rfbPixelFormat *fmt, - CursorPtr pCursor); +static int EncodeRichCursorData8 (rfbClientPtr cl, char *buf, rfbPixelFormat *fmt, + rfbCursorPtr pCursor); +static int EncodeRichCursorData16 (rfbClientPtr cl, char *buf, rfbPixelFormat *fmt, + rfbCursorPtr pCursor); +static int EncodeRichCursorData32 (rfbClientPtr cl, char *buf, rfbPixelFormat *fmt, + rfbCursorPtr pCursor); /* @@ -80,45 +82,54 @@ static int EncodeRichCursorData32 (char *buf, rfbPixelFormat *fmt, */ Bool -rfbSendCursorShape(cl, pScreen) +rfbSendCursorShape(cl) rfbClientPtr cl; - ScreenPtr pScreen; { - CursorPtr pCursor; + rfbCursorPtr pCursor; rfbFramebufferUpdateRectHeader rect; rfbXCursorColors colors; int saved_ublen; - int bitmapRowBytes, paddedRowBytes, maskBytes, dataBytes; + int bitmapRowBytes, maskBytes, dataBytes; int i, j; CARD8 *bitmapData; CARD8 bitmapByte; + pCursor = cl->screen->getCursorPtr(cl); + if (cl->useRichCursorEncoding) { - rect.encoding = Swap32IfLE(rfbEncodingRichCursor); + if(!pCursor->richSource) + MakeRichCursorFromXCursor(cl->screen,pCursor); + rect.encoding = Swap32IfLE(rfbEncodingRichCursor); } else { - rect.encoding = Swap32IfLE(rfbEncodingXCursor); + if(!pCursor->source) + MakeXCursorFromRichCursor(cl->screen,pCursor); + rect.encoding = Swap32IfLE(rfbEncodingXCursor); } - pCursor = rfbSpriteGetCursorPtr(pScreen); - + /*{ + rfbScreenInfoPtr s=cl->screen; + SetXCutTextProcPtr sx=cl->screen->setXCutText; + GetCursorProcPtr g=cl->screen->getCursorPtr; + }*/ + /* If there is no cursor, send update with empty cursor data. */ - if ( pCursor->bits->width == 1 && - pCursor->bits->height == 1 && - pCursor->bits->mask[0] == 0 ) { + if ( pCursor->width == 1 && + pCursor->height == 1 && + pCursor->mask[0] == 0 ) { pCursor = NULL; } if (pCursor == NULL) { - if (ublen + sz_rfbFramebufferUpdateRectHeader > UPDATE_BUF_SIZE ) { + if (cl->ublen + sz_rfbFramebufferUpdateRectHeader > UPDATE_BUF_SIZE ) { if (!rfbSendUpdateBuf(cl)) return FALSE; } rect.r.x = rect.r.y = 0; rect.r.w = rect.r.h = 0; - memcpy(&updateBuf[ublen], (char *)&rect, + memcpy(&cl->updateBuf[cl->ublen], (char *)&rect, sz_rfbFramebufferUpdateRectHeader); - ublen += sz_rfbFramebufferUpdateRectHeader; + cl->ublen += sz_rfbFramebufferUpdateRectHeader; cl->rfbCursorBytesSent += sz_rfbFramebufferUpdateRectHeader; cl->rfbCursorUpdatesSent++; @@ -131,37 +142,36 @@ rfbSendCursorShape(cl, pScreen) /* Calculate data sizes. */ - bitmapRowBytes = (pCursor->bits->width + 7) / 8; - paddedRowBytes = PixmapBytePad(pCursor->bits->width, 1); - maskBytes = bitmapRowBytes * pCursor->bits->height; + bitmapRowBytes = (pCursor->width + 7) / 8; + maskBytes = bitmapRowBytes * pCursor->height; dataBytes = (cl->useRichCursorEncoding) ? - (pCursor->bits->width * pCursor->bits->height * + (pCursor->width * pCursor->height * (cl->format.bitsPerPixel / 8)) : maskBytes; /* Send buffer contents if needed. */ - if ( ublen + sz_rfbFramebufferUpdateRectHeader + + if ( cl->ublen + sz_rfbFramebufferUpdateRectHeader + sz_rfbXCursorColors + maskBytes + dataBytes > UPDATE_BUF_SIZE ) { if (!rfbSendUpdateBuf(cl)) return FALSE; } - if ( ublen + sz_rfbFramebufferUpdateRectHeader + + if ( cl->ublen + sz_rfbFramebufferUpdateRectHeader + sz_rfbXCursorColors + maskBytes + dataBytes > UPDATE_BUF_SIZE ) { return FALSE; /* FIXME. */ } - saved_ublen = ublen; + saved_ublen = cl->ublen; /* Prepare rectangle header. */ - rect.r.x = Swap16IfLE(pCursor->bits->xhot); - rect.r.y = Swap16IfLE(pCursor->bits->yhot); - rect.r.w = Swap16IfLE(pCursor->bits->width); - rect.r.h = Swap16IfLE(pCursor->bits->height); + rect.r.x = Swap16IfLE(pCursor->xhot); + rect.r.y = Swap16IfLE(pCursor->yhot); + rect.r.w = Swap16IfLE(pCursor->width); + rect.r.h = Swap16IfLE(pCursor->height); - memcpy(&updateBuf[ublen], (char *)&rect,sz_rfbFramebufferUpdateRectHeader); - ublen += sz_rfbFramebufferUpdateRectHeader; + memcpy(&cl->updateBuf[cl->ublen], (char *)&rect,sz_rfbFramebufferUpdateRectHeader); + cl->ublen += sz_rfbFramebufferUpdateRectHeader; /* Prepare actual cursor data (depends on encoding used). */ @@ -174,57 +184,68 @@ rfbSendCursorShape(cl, pScreen) colors.backGreen = (char)(pCursor->backGreen >> 8); colors.backBlue = (char)(pCursor->backBlue >> 8); - memcpy(&updateBuf[ublen], (char *)&colors, sz_rfbXCursorColors); - ublen += sz_rfbXCursorColors; + memcpy(&cl->updateBuf[cl->ublen], (char *)&colors, sz_rfbXCursorColors); + cl->ublen += sz_rfbXCursorColors; - bitmapData = (CARD8 *)pCursor->bits->source; + bitmapData = (CARD8 *)pCursor->source; - for (i = 0; i < pCursor->bits->height; i++) { + for (i = 0; i < pCursor->height; i++) { for (j = 0; j < bitmapRowBytes; j++) { - bitmapByte = bitmapData[i * paddedRowBytes + j]; - if (screenInfo.bitmapBitOrder == LSBFirst) { + bitmapByte = bitmapData[i * bitmapRowBytes + j]; + /*if (screenInfo.bitmapBitOrder == LSBFirst) { bitmapByte = _reverse_byte[bitmapByte]; - } - updateBuf[ublen++] = (char)bitmapByte; + }*/ + cl->updateBuf[cl->ublen++] = (char)bitmapByte; } } } else { /* RichCursor encoding. */ + int bpp1=cl->screen->rfbServerFormat.bitsPerPixel/8, + bpp2=cl->format.bitsPerPixel/8; + (*cl->translateFn)(cl->translateLookupTable, + &(cl->screen->rfbServerFormat), + &cl->format, pCursor->richSource, + &cl->updateBuf[cl->ublen], + pCursor->width*bpp1, pCursor->width, pCursor->height); + + cl->ublen += pCursor->width*bpp2*pCursor->height; + /* switch (cl->format.bitsPerPixel) { case 8: - ublen += EncodeRichCursorData8(&updateBuf[ublen], + cl->ublen += EncodeRichCursorData8(cl, &cl->updateBuf[cl->ublen], &cl->format, pCursor); break; case 16: - ublen += EncodeRichCursorData16(&updateBuf[ublen], + cl->ublen += EncodeRichCursorData16(cl, &cl->updateBuf[cl->ublen], &cl->format, pCursor); break; case 32: - ublen += EncodeRichCursorData32(&updateBuf[ublen], + cl->ublen += EncodeRichCursorData32(cl, &cl->updateBuf[cl->ublen], &cl->format, pCursor); break; default: return FALSE; } + */ } /* Prepare transparency mask. */ - bitmapData = (CARD8 *)pCursor->bits->mask; + bitmapData = (CARD8 *)pCursor->mask; - for (i = 0; i < pCursor->bits->height; i++) { + for (i = 0; i < pCursor->height; i++) { for (j = 0; j < bitmapRowBytes; j++) { - bitmapByte = bitmapData[i * paddedRowBytes + j]; - if (screenInfo.bitmapBitOrder == LSBFirst) { + bitmapByte = bitmapData[i * bitmapRowBytes + j]; + /*if (screenInfo.bitmapBitOrder == LSBFirst) { bitmapByte = _reverse_byte[bitmapByte]; - } - updateBuf[ublen++] = (char)bitmapByte; + }*/ + cl->updateBuf[cl->ublen++] = (char)bitmapByte; } } - /* Send everything we have prepared in the updateBuf[]. */ + /* Send everything we have prepared in the cl->updateBuf[]. */ - cl->rfbCursorBytesSent += (ublen - saved_ublen); + cl->rfbCursorBytesSent += (cl->ublen - saved_ublen); cl->rfbCursorUpdatesSent++; if (!rfbSendUpdateBuf(cl)) @@ -244,10 +265,11 @@ rfbSendCursorShape(cl, pScreen) ((CARD32)(b) * ((fmt)->blueMax + 1) >> 16) << (fmt)->blueShift) static int -EncodeRichCursorData8(buf, fmt, pCursor) +EncodeRichCursorData8(cl, buf, fmt, pCursor) + rfbClientPtr cl; char *buf; rfbPixelFormat *fmt; - CursorPtr pCursor; + rfbCursorPtr pCursor; { int widthPixels, widthBytes; int x, y, b; @@ -260,41 +282,42 @@ EncodeRichCursorData8(buf, fmt, pCursor) pix[1] = (char)RGB48_TO_PIXEL(fmt, pCursor->foreRed, pCursor->foreGreen, pCursor->foreBlue); - src = (CARD8 *)pCursor->bits->source; - widthPixels = pCursor->bits->width; - widthBytes = PixmapBytePad(widthPixels, 1); + src = (CARD8 *)pCursor->richSource; + widthPixels = pCursor->width; + widthBytes = widthPixels; - for (y = 0; y < pCursor->bits->height; y++) { + for (y = 0; y < pCursor->height; y++) { for (x = 0; x < widthPixels / 8; x++) { bitmapByte = src[y * widthBytes + x]; - if (screenInfo.bitmapBitOrder == LSBFirst) { + /*if (screenInfo.bitmapBitOrder == LSBFirst) { bitmapByte = _reverse_byte[bitmapByte]; - } + }*/ for (b = 7; b >= 0; b--) { *buf++ = pix[bitmapByte >> b & 1]; } } if (widthPixels % 8) { bitmapByte = src[y * widthBytes + x]; - if (screenInfo.bitmapBitOrder == LSBFirst) { + /*if (screenInfo.bitmapBitOrder == LSBFirst) { bitmapByte = _reverse_byte[bitmapByte]; - } + }*/ for (b = 7; b > 7 - widthPixels % 8; b--) { *buf++ = pix[bitmapByte >> b & 1]; } } } - return (widthPixels * pCursor->bits->height); + return (widthPixels * pCursor->height); } #define DEFINE_RICH_ENCODE(bpp) \ \ static int \ -EncodeRichCursorData##bpp(buf, fmt, pCursor) \ +EncodeRichCursorData##bpp(cl, buf, fmt, pCursor) \ + rfbClientPtr cl; \ char *buf; \ rfbPixelFormat *fmt; \ - CursorPtr pCursor; \ + rfbCursorPtr pCursor; \ { \ int widthPixels, widthBytes; \ int x, y, b; \ @@ -308,21 +331,21 @@ EncodeRichCursorData##bpp(buf, fmt, pCursor) \ pix[1] = (CARD##bpp)RGB48_TO_PIXEL(fmt, pCursor->foreRed, \ pCursor->foreGreen, \ pCursor->foreBlue); \ - if (!rfbServerFormat.bigEndian != !fmt->bigEndian) { \ + if (!cl->screen->rfbServerFormat.bigEndian != !fmt->bigEndian) { \ pix[0] = Swap##bpp(pix[0]); \ pix[1] = Swap##bpp(pix[1]); \ } \ \ - src = (CARD8 *)pCursor->bits->source; \ - widthPixels = pCursor->bits->width; \ - widthBytes = PixmapBytePad(widthPixels, 1); \ + src = (CARD8 *)pCursor->richSource; \ + widthPixels = pCursor->width; \ + widthBytes = (pCursor->width*bpp)/8; \ \ - for (y = 0; y < pCursor->bits->height; y++) { \ + for (y = 0; y < pCursor->height; y++) { \ for (x = 0; x < widthPixels / 8; x++) { \ bitmapByte = src[y * widthBytes + x]; \ - if (screenInfo.bitmapBitOrder == LSBFirst) { \ + /*if (screenInfo.bitmapBitOrder == LSBFirst) { \ bitmapByte = _reverse_byte[bitmapByte]; \ - } \ + }*/ \ for (b = 7; b >= 0; b--) { \ memcpy (buf, (char *)&pix[bitmapByte >> b & 1], \ sizeof(CARD##bpp)); \ @@ -331,9 +354,9 @@ EncodeRichCursorData##bpp(buf, fmt, pCursor) \ } \ if (widthPixels % 8) { \ bitmapByte = src[y * widthBytes + x]; \ - if (screenInfo.bitmapBitOrder == LSBFirst) { \ + /*if (cl->screen.bitmapBitOrder == LSBFirst) { \ bitmapByte = _reverse_byte[bitmapByte]; \ - } \ + }*/ \ for (b = 7; b > 7 - widthPixels % 8; b--) { \ memcpy (buf, (char *)&pix[bitmapByte >> b & 1], \ sizeof(CARD##bpp)); \ @@ -342,9 +365,208 @@ EncodeRichCursorData##bpp(buf, fmt, pCursor) \ } \ } \ \ - return (widthPixels * pCursor->bits->height * (bpp / 8)); \ + return (widthPixels * pCursor->height * (bpp / 8)); \ } DEFINE_RICH_ENCODE(16) DEFINE_RICH_ENCODE(32) +void rfbConvertLSBCursorBitmapOrMask(int width,int height,unsigned char* bitmap) +{ + int i,t=(width+7)/8*height; + for(i=0;iwidth=width; + cursor->height=height; + //cursor->backRed=cursor->backGreen=cursor->backBlue=0xffff; + cursor->foreRed=cursor->foreGreen=cursor->foreBlue=0xffff; + + cursor->source = (char*)calloc(w,height); + for(j=0,cp=cursorString;j>1,cp++) + if(*cp!=' ') cursor->source[j*w+i/8]|=bit; + + if(maskString) { + cursor->mask = (char*)calloc(w,height); + for(j=0,cp=maskString;j>1,cp++) + if(*cp!=' ') cursor->mask[j*w+i/8]|=bit; + } else + cursor->mask = rfbMakeMaskForXCursor(width,height,cursor->source); + + return(cursor); +} + +char* rfbMakeMaskForXCursor(int width,int height,char* source) +{ + int i,j,w=(width+7)/8; + char* mask=(char*)calloc(w,height); + unsigned char c; + + for(j=0;j=0;i--) { + c=source[j*w+i]; + if(j>0) c|=source[(j-1)*w+i]; + if(j0 && (c&0x80)) + mask[j*w+i-1]|=0x01; + if(i>1); + } + + return(mask); +} + +void rfbFreeCursor(rfbCursorPtr cursor) +{ + if(cursor) { + free(cursor->source); + free(cursor->mask); + free(cursor); + } + +} + +/* background and foregroud colour have to be set beforehand */ +void MakeXCursorFromRichCursor(rfbScreenInfoPtr rfbScreen,rfbCursorPtr cursor) +{ + rfbPixelFormat* format=&rfbScreen->rfbServerFormat; + int i,j,w=(cursor->width+7)/8,bpp=format->bitsPerPixel/8, + width=cursor->width*bpp; + CARD32 background; + char *back=(char*)&background; + unsigned char bit; + + cursor->source=(char*)calloc(w,cursor->height); + + if(format->bigEndian) + back+=4-bpp; + + background=cursor->backRed<redShift| + cursor->backGreen<greenShift|cursor->backBlue<blueShift; + + for(j=0;jheight;j++) + for(i=0,bit=0x80;iwidth;i++,bit=(bit&1)?0x80:bit>>1) + if(memcmp(cursor->richSource+j*width+i*bpp,back,bpp)) + cursor->source[j*w+i/8]|=bit; +} + +void MakeRichCursorFromXCursor(rfbScreenInfoPtr rfbScreen,rfbCursorPtr cursor) +{ + rfbPixelFormat* format=&rfbScreen->rfbServerFormat; + int i,j,w=(cursor->width+7)/8,bpp=format->bitsPerPixel/8; + CARD32 background,foreground; + char *cp,*back=(char*)&background,*fore=(char*)&foreground; + unsigned char bit; + + cp=cursor->richSource=(char*)calloc(cursor->width*bpp,cursor->height); + + if(format->bigEndian) { + back+=4-bpp; + fore+=4-bpp; + } + + background=cursor->backRed<redShift| + cursor->backGreen<greenShift|cursor->backBlue<blueShift; + foreground=cursor->foreRed<redShift| + cursor->foreGreen<greenShift|cursor->foreBlue<blueShift; + + for(j=0;jheight;j++) + for(i=0,bit=0x80;iheight;i++,bit=(bit&1)?0x80:bit>>1,cp+=bpp) + if(cursor->source[j*w+i/8]&bit) memcpy(cp,fore,bpp); + else memcpy(cp,back,bpp); +} + +void rfbUndrawCursor(rfbClientPtr cl) +{ + rfbScreenInfoPtr s=cl->screen; + rfbCursorPtr c=s->cursor; + int j,x1,x2,y1,y2,bpp=s->rfbServerFormat.bitsPerPixel/8, + rowstride=s->paddedWidthInBytes; + if(!s->cursorIsDrawn) + return; + /* restore what is under the cursor */ + x1=s->cursorX-c->xhot; + x2=x1+c->width; + if(x1<0) x1=0; + if(x2>=s->width) x2=s->width-1; + x2-=x1; + y1=s->cursorY-c->yhot; + y2=y1+c->height; + if(y1<0) y1=0; + if(y2>=s->height) y2=s->height-1; + y2-=y1; + for(j=0;jframeBuffer+(y1+j)*rowstride+x1*bpp, + s->underCursorBuffer+j*x2*bpp, + x2*bpp); +} + +void rfbDrawCursor(rfbClientPtr cl) +{ + rfbScreenInfoPtr s=cl->screen; + rfbCursorPtr c=s->cursor; + int i,j,x1,x2,y1,y2,i1,j1,bpp=s->rfbServerFormat.bitsPerPixel/8, + rowstride=s->paddedWidthInBytes, + bufSize=c->width*c->height*bpp,w=(c->width+7)/8; + if(s->cursorIsDrawn) + rfbUndrawCursor(cl); + if(s->underCursorBufferLenunderCursorBuffer!=NULL) + free(s->underCursorBuffer); + s->underCursorBuffer=malloc(bufSize); + s->underCursorBufferLen=bufSize; + } + /* save what is under the cursor */ + i1=j1=0; /* offset in cursor */ + x1=s->cursorX-c->xhot; + x2=x1+c->width; + if(x1<0) { i1=-x1; x1=0; } + if(x2>=s->width) x2=s->width-1; + x2-=x1; + y1=s->cursorY-c->yhot; + y2=y1+c->height; + if(y1<0) { j1=-y1; y1=0; } + if(y2>=s->height) y2=s->height-1; + y2-=y1; + for(j=0;junderCursorBuffer+j*x2*bpp, + s->frameBuffer+(y1+j)*rowstride+x1*bpp, + x2*bpp); + + if(!c->richSource) + MakeRichCursorFromXCursor(s,c); + + /* now the cursor has to be drawn */ + for(j=0;jmask[(j+j1)*w+(i+i1)/8]<<((i+i1)&7))&0x80) + memcpy(s->frameBuffer+(j+y1)*rowstride+(i+x1)*bpp, + c->richSource+(j+j1)*c->width*bpp+(i+i1)*bpp,bpp); +} + +void rfbPrintXCursor(rfbCursorPtr cursor) +{ + int i,i1,j,w=(cursor->width+7)/8; + unsigned char bit; + for(j=0;jheight;j++) { + for(i=0,i1=0,bit=0x80;i1width;i1++,i+=(bit&1)?1:0,bit=(bit&1)?0x80:bit>>1) + if(cursor->source[j*w+i]&bit) putchar('#'); else putchar(' '); + putchar(':'); + for(i=0,i1=0,bit=0x80;i1width;i1++,i+=(bit&1)?1:0,bit=(bit&1)?0x80:bit>>1) + if(cursor->mask[j*w+i]&bit) putchar('#'); else putchar(' '); + putchar('\n'); + } +} diff --git a/example.c b/example.c index cdbbc2e..24d1c6a 100644 --- a/example.c +++ b/example.c @@ -68,6 +68,11 @@ void drawline(unsigned char* buffer,int rowstride,int bpp,int x1,int y1,int x2,i { int i,j; i=x1-x2; j=y1-y2; + if(i==0 && j==0) { + for(i=0;iclientData; - if(buttonMask && x>=0 && y>=0 && xoldButton==buttonMask) { /* draw a line */ - drawline(cl->screen->frameBuffer,cl->screen->paddedWidthInBytes,bpp, - x,y,cd->oldx,cd->oldy); - rfbMarkRectAsModified(cl->screen,x,y,cd->oldx,cd->oldy); - } else { /* draw a point (diameter depends on button) */ - x1=x-buttonMask; if(x1<0) x1=0; - x2=x+buttonMask; if(x2>maxx) x2=maxx; - y1=y-buttonMask; if(y1<0) y1=0; - y2=y+buttonMask; if(y2>maxy) y2=maxy; - - for(i=x1*bpp;iscreen->frameBuffer[j*cl->screen->paddedWidthInBytes+i]=0xff; - rfbMarkRectAsModified(cl->screen,x1,y1,x2-1,y2-1); - } + if(x>=0 && y>=0 && xoldButton==buttonMask) { /* draw a line */ + drawline(cl->screen->frameBuffer,cl->screen->paddedWidthInBytes,bpp, + x,y,cd->oldx,cd->oldy); + rfbMarkRectAsModified(cl->screen,x,y,cd->oldx,cd->oldy); + } else { /* draw a point (diameter depends on button) */ + x1=x-buttonMask; if(x1<0) x1=0; + x2=x+buttonMask; if(x2>maxx) x2=maxx; + y1=y-buttonMask; if(y1<0) y1=0; + y2=y+buttonMask; if(y2>maxy) y2=maxy; - /* we could get a selection like that: - rfbGotXCutText(cl->screen,"Hallo",5); - */ - } else - cd->oldButton=0; + for(i=x1*bpp;iscreen->frameBuffer[j*cl->screen->paddedWidthInBytes+i]=0xff; + rfbMarkRectAsModified(cl->screen,x1,y1,x2-1,y2-1); + } - cd->oldx=x; cd->oldy=y; cd->oldButton=buttonMask; + /* we could get a selection like that: + rfbGotXCutText(cl->screen,"Hallo",5); + */ + } else + cd->oldButton=0; + + cd->oldx=x; cd->oldy=y; cd->oldButton=buttonMask; + } } /* aux function to draw a character to x, y */ @@ -196,6 +203,24 @@ void dokey(Bool down,KeySym key,rfbClientPtr cl) } } +/* +extern void rfbPrintXCursor(rfbCursorPtr cursor); +int exampleCursorWidth=9,exampleCursorHeight=7; +char exampleCursor[]= + " " + " xx xx " + " xx xx " + " xxx " + " xx xx " + " xx xx " + " "; +rfbCursorPtr exampleCurse; +rfbCursorPtr exampleGetCursor(rfbClientPtr cl) +{ + return(exampleCurse); +} +*/ + /* Initialization */ int main(int argc,char** argv) @@ -211,8 +236,31 @@ int main(int argc,char** argv) rfbScreen->httpDir = "./classes"; initBuffer(rfbScreen->frameBuffer); + drawstring(rfbScreen->frameBuffer,maxx*bpp,bpp,20,100,"Hello, World!"); - drawstring(rfbScreen->frameBuffer,maxx*bpp,bpp,20,100,"Hallo, Welt!"); + //exampleCurse = rfbMakeXCursor(exampleCursorWidth,exampleCursorHeight,exampleCursor,0); + { + int i,j,w=32,h=32; + rfbCursorPtr c = rfbScreen->cursor; + char x[32*32],mask[32*32/8]; + c=rfbScreen->cursor = rfbMakeXCursor(w,h,x,mask); + c->mask[0]=0xff; c->mask[1]=0x0; + memset(c->mask,255,h*w/8); + c->richSource = malloc(w*h*bpp); + for(j=0;jrichSource[j*w*bpp+i*bpp+0]=0; + c->richSource[j*w*bpp+i*bpp+1]=0; + c->richSource[j*w*bpp+i*bpp+2]=j*0xff/h; + c->richSource[j*w*bpp+i*bpp+3]=0; + } + c->richSource[j*w*bpp+(w-1)*bpp+0]=0xff; + c->richSource[j*w*bpp+(w-1)*bpp+1]=0xff; + c->richSource[j*w*bpp+(w-1)*bpp+2]=0xff; + c->richSource[j*w*bpp+(w-1)*bpp+3]=0xff; + } + //memset(c->richSource,0xff,w*h*bpp); + } /* this is the blocking event loop, i.e. it never returns */ /* 40000 are the microseconds, i.e. 0.04 seconds */ diff --git a/httpd.c b/httpd.c index 37ae18a..b8391fc 100644 --- a/httpd.c +++ b/httpd.c @@ -31,6 +31,8 @@ #include #include #include +#include +#include #include "rfb.h" @@ -99,7 +101,7 @@ httpInitSockets(rfbScreenInfoPtr rfbScreen) void httpCheckFds(rfbScreenInfoPtr rfbScreen) { - int nfds, n; + int nfds; fd_set fds; struct timeval tv; struct sockaddr_in addr; diff --git a/main.c b/main.c index 6d9abe2..5f07b86 100644 --- a/main.c +++ b/main.c @@ -37,6 +37,7 @@ #endif #include #include +#include #include "rfb.h" @@ -93,8 +94,16 @@ void rfbMarkRectAsModified(rfbScreenInfoPtr rfbScreen,int x1,int y1,int x2,int y RegionRec region; int i; if(x1>x2) { i=x1; x1=x2; x2=i; } + x2++; + if(x1<0) { x1=0; if(x2==x1) x2++; } + if(x2>=rfbScreen->width) { x2=rfbScreen->width-1; if(x1==x2) x1--; } + if(y1>y2) { i=y1; y1=y2; y2=i; } - box.x1=x1; box.y1=y1; box.x2=x2+1; box.y2=y2+1; + y2++; + if(y1<0) { y1=0; if(y2==y1) y2++; } + if(y2>=rfbScreen->height) { y2=rfbScreen->height-1; if(y1==y2) y1--; } + + box.x1=x1; box.y1=y1; box.x2=x2; box.y2=y2; REGION_INIT(cl->screen,®ion,&box,0); rfbMarkRegionAsModified(rfbScreen,®ion); } @@ -295,6 +304,38 @@ void defaultSetXCutText(char* text, int len, rfbClientPtr cl) { } +static rfbCursor myCursor = +{ + //width: 8, height: 7, xhot: 3, yhot: 3, + width: 8, height: 7, xhot: 0, yhot: 0, + //source: "\000\102\044\030\044\102\000", + //mask: "\347\347\176\074\176\347\347", + source: "\000\074\176\146\176\074\000", + mask: "\176\377\377\377\377\377\176", + foreRed: 0, foreGreen: 0, foreBlue: 0, + backRed: 0xffff, backGreen: 0xffff, backBlue: 0xffff, + #define D "\000\000\000\000" + #define R "\377\000\000\000" + #define G "\000\377\000\000" + #define B "\000\000\377\000" + #define S "\377\377\000\000" + #define H "\000\377\377\000" + #define C "\377\000\377\000" + richSource: 0 + /*D D D D D D D D + D D R R R R D D + D S S S S S S D + D G G D D G G D + D H H H H H H D + D D B B B B D D + D D D D D D D D*/ +}; + +rfbCursorPtr defaultGetCursorPtr(rfbClientPtr cl) +{ + return(cl->screen->cursor); +} + void doNothingWithClient(rfbClientPtr cl) { } @@ -348,15 +389,12 @@ rfbScreenInfoPtr rfbDefaultScreenInit(int argc,char** argv,int width,int height, rfbScreen->rfbServerFormat.redShift = bitsPerSample * 2; rfbScreen->rfbServerFormat.greenShift = bitsPerSample; rfbScreen->rfbServerFormat.blueShift = 0; -fprintf(stderr,"format: %d %d %d %d %d %d\n", - rfbScreen->rfbServerFormat.redMax, - rfbScreen->rfbServerFormat.greenMax, - rfbScreen->rfbServerFormat.blueMax, - rfbScreen->rfbServerFormat.redShift, - rfbScreen->rfbServerFormat.greenShift, - rfbScreen->rfbServerFormat.blueShift); - + rfbScreen->cursorIsDrawn = FALSE; + rfbScreen->dontSendFramebufferUpdate = FALSE; + rfbScreen->cursorX=rfbScreen->cursorY=rfbScreen->underCursorBufferLen=0; + rfbScreen->underCursorBuffer=NULL; + /* We want to use the X11 REGION_* macros without having an actual X11 ScreenPtr, so we do this. Pretty ugly, but at least it lets us avoid hacking up regionstr.h, or changing every call to REGION_* @@ -384,6 +422,8 @@ fprintf(stderr,"format: %d %d %d %d %d %d\n", rfbScreen->kbdReleaseAllKeys = doNothingWithClient; rfbScreen->ptrAddEvent = defaultPtrAddEvent; rfbScreen->setXCutText = defaultSetXCutText; + rfbScreen->getCursorPtr = defaultGetCursorPtr; + rfbScreen->cursor = &myCursor; rfbScreen->newClientHook = doNothingWithClient; return(rfbScreen); diff --git a/rfb.h b/rfb.h index 4a1257f..6de3431 100644 --- a/rfb.h +++ b/rfb.h @@ -23,6 +23,8 @@ * USA. */ +#include +#include #include "scrnintstr.h" /* trying to replace the above with some more minimal set of includes */ @@ -60,12 +62,14 @@ #endif struct rfbClientRec; -//typedef struct rfbClientInfo* rfbClientPtr; +struct rfbScreenInfo; +struct rfbCursor; + typedef void (*KbdAddEventProcPtr) (Bool down, KeySym keySym, struct rfbClientRec* cl); typedef void (*KbdReleaseAllKeysProcPtr) (struct rfbClientRec* cl); typedef void (*PtrAddEventProcPtr) (int buttonMask, int x, int y, struct rfbClientRec* cl); typedef void (*SetXCutTextProcPtr) (char* str,int len, struct rfbClientRec* cl); - +typedef struct rfbCursor* (*GetCursorProcPtr) (struct rfbClientRec* pScreen); typedef void (*NewClientHookPtr)(struct rfbClientRec* cl); /* @@ -125,7 +129,11 @@ typedef struct Bool cursorIsDrawn; /* TRUE if the cursor is currently drawn */ Bool dontSendFramebufferUpdate; /* TRUE while removing or drawing the cursor */ - + + /* these variables are needed to save the area under the cursor */ + int cursorX, cursorY,underCursorBufferLen; + char* underCursorBuffer; + /* wrapped screen functions */ CloseScreenProcPtr CloseScreen; @@ -167,14 +175,16 @@ typedef struct Bool rfbNeverShared; Bool rfbDontDisconnect; struct rfbClientRec* rfbClientHead; - + struct rfbCursor* cursor; + /* the following members have to be supplied by the serving process */ char* frameBuffer; KbdAddEventProcPtr kbdAddEvent; KbdReleaseAllKeysProcPtr kbdReleaseAllKeys; PtrAddEventProcPtr ptrAddEvent; SetXCutTextProcPtr setXCutText; - + GetCursorProcPtr getCursorPtr; + /* the following members are hooks, i.e. they are called if set, but not overriding original functionality */ /* newClientHook is called just after a new client is created */ @@ -513,8 +523,22 @@ extern Bool rfbSendRectEncodingTight(rfbClientPtr cl, int x,int y,int w,int h); /* cursor.c */ -extern Bool rfbSendCursorShape(rfbClientPtr cl, ScreenPtr pScreen); - +typedef struct rfbCursor { + unsigned char *source; /* points to bits */ + unsigned char *mask; /* points to bits */ + unsigned short width, height, xhot, yhot; /* metrics */ + unsigned short foreRed, foreGreen, foreBlue; /* device-independent color */ + unsigned short backRed, backGreen, backBlue; /* device-independent color */ + unsigned char *richSource; /* source bytes for a rich cursor */ +} rfbCursor, *rfbCursorPtr; + +extern Bool rfbSendCursorShape(rfbClientPtr cl/*, rfbScreenInfoPtr pScreen*/); +extern void rfbConvertLSBCursorBitmapOrMask(int width,int height,unsigned char* bitmap); +extern rfbCursorPtr rfbMakeXCursor(int width,int height,char* cursorString,char* maskString); +extern char* rfbMakeMaskForXCursor(int width,int height,char* cursorString); +extern void MakeXCursorFromRichCursor(rfbScreenInfoPtr rfbScreen,rfbCursorPtr cursor); +extern void MakeRichCursorFromXCursor(rfbScreenInfoPtr rfbScreen,rfbCursorPtr cursor); +extern void rfbFreeCursor(rfbCursorPtr cursor); /* stats.c */ diff --git a/rfbserver.c b/rfbserver.c index b90fb05..6f48cf1 100644 --- a/rfbserver.c +++ b/rfbserver.c @@ -221,6 +221,7 @@ rfbNewClient(rfbScreen,sock) cl->zsActive[i] = FALSE; cl->enableCursorShapeUpdates = FALSE; + cl->useRichCursorEncoding = FALSE; cl->enableLastRectEncoding = FALSE; rfbResetStats(cl); @@ -630,18 +631,15 @@ rfbProcessClientNormalMessage(cl) rfbLog("Enabling X-style cursor updates for client %s\n", cl->host); cl->enableCursorShapeUpdates = TRUE; - cl->useRichCursorEncoding = FALSE; cl->cursorWasChanged = TRUE; break; case rfbEncodingRichCursor: - if (!cl->enableCursorShapeUpdates) { - rfbLog("Enabling full-color cursor updates for client " - "%s\n", cl->host); - cl->enableCursorShapeUpdates = TRUE; - cl->useRichCursorEncoding = TRUE; - cl->cursorWasChanged = TRUE; - } - break; + rfbLog("Enabling full-color cursor updates for client " + "%s\n", cl->host); + cl->enableCursorShapeUpdates = TRUE; + cl->useRichCursorEncoding = TRUE; + cl->cursorWasChanged = TRUE; + break; case rfbEncodingLastRect: if (!cl->enableLastRectEncoding) { rfbLog("Enabling LastRect protocol extension for client " @@ -829,23 +827,24 @@ rfbSendFramebufferUpdate(cl, updateRegion) RegionRec updateCopyRegion; int dx, dy; Bool sendCursorShape = FALSE; + Bool cursorWasDrawn = FALSE; /* * If this client understands cursor shape updates, cursor should be * removed from the framebuffer. Otherwise, make sure it's put up. */ -#ifdef NOT_YET if (cl->enableCursorShapeUpdates) { - if (cl->screen->cursorIsDrawn) - rfbSpriteRemoveCursor(pScreen); - if (!cl->screen->cursorIsDrawn && cl->cursorWasChanged) - sendCursorShape = TRUE; + cursorWasDrawn = cl->screen->cursorIsDrawn; + if (cl->screen->cursorIsDrawn) { + fprintf(stderr,"rfbSpriteRemoveCursor(pScreen); not yet!\n"); + } + if (!cl->screen->cursorIsDrawn && cl->cursorWasChanged) + sendCursorShape = TRUE; } else { - if (!cl->screen->cursorIsDrawn) - rfbSpriteRestoreCursor(pScreen); + if (!cl->screen->cursorIsDrawn) + fprintf(stderr,"rfbSpriteRestoreCursor(pScreen); not yet!\n"); } -#endif /* * The modifiedRegion may overlap the destination copyRegion. We remove @@ -976,13 +975,11 @@ rfbSendFramebufferUpdate(cl, updateRegion) } cl->ublen = sz_rfbFramebufferUpdateMsg; -#ifdef NOT_YET if (sendCursorShape) { cl->cursorWasChanged = FALSE; - if (!rfbSendCursorShape(cl, pScreen)) + if (!rfbSendCursorShape(cl)) return FALSE; } -#endif if (REGION_NOTEMPTY(pScreen,&updateCopyRegion)) { if (!rfbSendCopyRegion(cl,&updateCopyRegion,dx,dy)) { @@ -1047,6 +1044,13 @@ rfbSendFramebufferUpdate(cl, updateRegion) if (!rfbSendUpdateBuf(cl)) return FALSE; + if(cursorWasDrawn != cl->screen->cursorIsDrawn) { + if(cursorWasDrawn) + fprintf(stderr,"rfbSpriteRestoreCursor(pScreen); not yet!!\n"); + else + fprintf(stderr,"rfbSpriteRemoveCursor(pScreen); not yet!!\n"); + } + return TRUE; } diff --git a/sockets.c b/sockets.c index c0ac1dc..0b2f8ac 100644 --- a/sockets.c +++ b/sockets.c @@ -57,6 +57,7 @@ struct timeval #include #include #include +#include #include "rfb.h" diff --git a/zlib.c b/zlib.c index 0749d43..74e12d0 100644 --- a/zlib.c +++ b/zlib.c @@ -235,8 +235,6 @@ rfbSendRectEncodingZlib(cl, x, y, w, h) rfbClientPtr cl; int x, y, w, h; { - int totalSize = 0; - int partialSize = 0; int maxLines; int linesRemaining; rfbRectangle partialRect; -- cgit v1.2.3