home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 8 Other / 08-Other.zip / pmvnc100.zip / rect4.c < prev    next >
C/C++ Source or Header  |  1999-08-03  |  30KB  |  847 lines
  1. /*
  2.  * rect4.c - PM VNC Viewer, Pixel Handling for bgr233 8bit static color
  3.  *           but colormap < 256, in this case maps bgr233 colors into
  4.  *           default 16 colors or gray scale.
  5.  */
  6.  
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9.  
  10. #define INCL_PM
  11. #include <os2.h>
  12.  
  13. #include "pmvncdef.h"
  14.  
  15. /*
  16.  * rbuff is used to parse CoRRE, it requires buffer of
  17.  * 255 * 255 * 32 bits (nearly 64KB * 4).
  18.  */
  19.  
  20. #define RBUFSIZ     (1024 * 256)
  21.  
  22. static  PUCHAR  rbuff = NULL ;          /* as recv buffer   */
  23.  
  24. /*
  25.  * buffer for bitmap scan conversion
  26.  */
  27.  
  28. #define MAXSCAN     (4096 * 8)
  29.  
  30. static  PUCHAR  ibuff = NULL ;          /* as scan buffer   */
  31.  
  32. /*
  33.  * minimum I/O unit min(MAXSCAN, RBUFSIZ)
  34.  */
  35.  
  36. #define MINBUF  MAXSCAN
  37.  
  38. /*
  39.  * Remote Frame Buffer
  40.  */
  41.  
  42. static  int     cxBitmap = 0 ;
  43. static  int     cyBitmap = 0 ;
  44.  
  45. static  HDC     hdcBitmap = NULLHANDLE ;
  46. static  HPS     hpsBitmap = NULLHANDLE ;
  47. static  HBITMAP hbmBitmap = NULLHANDLE ;
  48.  
  49. static  PBITMAPINFO2    pbmiBitmap = NULL ;
  50.  
  51. /*
  52.  * ColorMap for Bitmap
  53.  */
  54.  
  55. static  ULONG   mapBmp[] = {
  56. /*  0 CLR_BLACK     */  0x00000000,
  57. /*  1 CLR_BLUE      */  0x000000ff,
  58. /*  2 CLR_RED       */  0x00ff0000,
  59. /*  3 CLR_PINK      */  0x00ff00ff,
  60. /*  4 CLR_GREEN     */  0x0000ff00,
  61. /*  5 CLR_CYAN      */  0x0000ffff,
  62. /*  6 CLR_YELLOW    */  0x00ffff00,
  63. /*  7 CLR_WHITE     */  0x00ffffff,
  64. /*  8 CLR_DARKGRAY  */  0x00808080,
  65. /*  9 CLR_DARKBLUE  */  0x00000080,
  66. /* 10 CLR_DARKRED   */  0x00800000,
  67. /* 11 CLR_DARKPINK  */  0x00800080,
  68. /* 12 CLR_DARKGREEN */  0x00008000,
  69. /* 13 CLR_DARKCYAN  */  0x00008080,
  70. /* 14 CLR_BROWN     */  0x00808000,
  71. /* 15 CLR_PALEGRAY  */  0x00cccccc
  72. } ;
  73.  
  74. static  PUCHAR  mapRaw ;    /* convert raw bgr233 data  */
  75. static  PLONG   mapCol ;    /* convert bgr233 color     */
  76.  
  77. /*
  78.  * rectDone - finialize rectangle operation
  79.  */
  80.  
  81. static  void    rectDone(void)
  82. {
  83.     if (hbmBitmap != NULLHANDLE) {
  84.         GpiDeleteBitmap(hbmBitmap) ;
  85.     hbmBitmap = NULLHANDLE ;
  86.     }
  87.     if (hpsBitmap != NULLHANDLE) {
  88.         GpiDestroyPS(hpsBitmap) ;
  89.     hpsBitmap = NULLHANDLE ;
  90.     }
  91.     if (hdcBitmap != NULLHANDLE) {
  92.         DevCloseDC(hdcBitmap) ;
  93.     hdcBitmap = NULLHANDLE ;
  94.     }
  95.     if (rbuff != NULL) {
  96.         free(rbuff) ;
  97.     rbuff = NULL ;
  98.     }
  99.     if (ibuff != NULL) {
  100.         free(ibuff) ;
  101.     ibuff = NULL ;
  102.     }
  103.     if (pbmiBitmap != NULL) {
  104.         free(pbmiBitmap) ;
  105.     pbmiBitmap = NULL ;
  106.     }
  107. }
  108.  
  109. /*
  110.  * rectInit - create bitmap for Remote Frame Buffer
  111.  */
  112.  
  113. static  BOOL    rectInit(int cx, int cy)
  114. {
  115.     SIZEL   siz ;
  116.     POINTL  pt  ;
  117.     BITMAPINFOHEADER2   bmi ;
  118.     int     i   ;
  119.     PUCHAR  pc  ;
  120.     PULONG  pl  ;
  121.     
  122.     /*
  123.      * prepare buffer for drawing
  124.      */
  125.      
  126.     rbuff = malloc(RBUFSIZ) ;
  127.     ibuff = malloc(MAXSCAN) ;
  128.     pbmiBitmap = malloc(16 + sizeof(RGB2) * 16) ;
  129.     
  130.     if (rbuff == NULL || ibuff == NULL || pbmiBitmap == NULL) {
  131.         rectDone() ;
  132.     return FALSE ;
  133.     }
  134.     
  135.     /*
  136.      * create bitmap for Remote Frame Buffer
  137.      */
  138.      
  139.     siz.cx = siz.cy = 0 ;
  140.     hdcBitmap = DevOpenDC(habNetwork, OD_MEMORY, "*", 0, NULL, NULLHANDLE) ;
  141.     hpsBitmap = GpiCreatePS(habNetwork, hdcBitmap, &siz,
  142.                     PU_PELS | GPIF_DEFAULT | GPIT_MICRO | GPIA_ASSOC) ;
  143.  
  144.     if (hdcBitmap == NULLHANDLE || hpsBitmap == NULLHANDLE) {
  145.         TRACE("rectInit - failed to create HDC/HPS\n") ;
  146.         rectDone() ;
  147.     return FALSE ;
  148.     }
  149.  
  150.     memset(&bmi, 0, sizeof(bmi)) ;
  151.     bmi.cbFix = sizeof(bmi) ;
  152.     bmi.cx = cxBitmap = cx ;
  153.     bmi.cy = cyBitmap = cy ;
  154.     bmi.cPlanes       = 1  ;
  155.     bmi.cBitCount     = 8  ;
  156.     bmi.ulCompression = 0  ;
  157.     bmi.cclrUsed      = 0  ;
  158.     bmi.cclrImportant = 0  ;   
  159.  
  160.     hbmBitmap = GpiCreateBitmap(hpsBitmap, &bmi, 0, NULL, NULL) ;
  161.  
  162.     if (hbmBitmap == NULLHANDLE) {
  163.         TRACE("rectInit - failed to create bitmap\n") ;
  164.     rectDone() ;
  165.     return FALSE ;
  166.     }
  167.     
  168.     GpiSetBitmap(hpsBitmap, hbmBitmap) ;
  169.  
  170.     /*
  171.      * put initial message on it
  172.      */
  173.  
  174.     pt.x = 32 ;
  175.     pt.y = cyBitmap - 64 ;
  176.     GpiErase(hpsBitmap) ;
  177.     GpiCharStringAt(hpsBitmap, &pt, strlen(VncGreeting), VncGreeting) ;
  178.     
  179.     if (GpiCreateLogColorTable(hpsBitmap, 0, LCOLF_CONSECRGB, 0, 16, mapBmp) != TRUE) {
  180.         TRACE("rectInit - failed to set color mode INDEX\n") ;
  181.     rectDone() ;
  182.         return FALSE ;
  183.     }
  184.  
  185.     /*
  186.      * prepare bitmap info. header for later operation
  187.      */
  188.  
  189.     memset(pbmiBitmap, 0, (16 + sizeof(RGB2) * 16)) ;
  190.     pbmiBitmap->cbFix     = 16 ;
  191.     pbmiBitmap->cPlanes   =  1 ;
  192.     pbmiBitmap->cBitCount =  8 ;
  193.     pc = (PUCHAR) pbmiBitmap ;
  194.     pl = (PULONG) (pc + 16)  ;
  195.     
  196.     for (i = 0 ; i < 16 ; i++) {
  197.         *pl++ = mapBmp[i] ;
  198.     }
  199.  
  200.     return TRUE ;
  201. }
  202.  
  203. /*
  204.  * rectDraw - draw bitmap to targte PS
  205.  */
  206.  
  207. static  BOOL    rectDraw(HPS hps, PPOINTL apt)
  208. {
  209.     if (hpsBitmap == NULLHANDLE) {
  210.         return FALSE ;
  211.     }
  212.     GpiBitBlt(hps, hpsBitmap, 4, apt, ROP_SRCCOPY, BBO_IGNORE) ;
  213.     return TRUE ;
  214. }
  215.  
  216. /*
  217.  * rectRaw - raw rectangle encoding
  218.  *      read RawRect data from Server and convert to PM Bitmap
  219.  */
  220.  
  221. static  void    rawConv(rfbRectangle *r, int lines, PUCHAR buff)
  222. {
  223.     PUCHAR  sp, dp ;
  224.     int     i, j   ;
  225.     int     bytesPerLine ;
  226.     POINTL  apt[4] ;
  227.     
  228.     /*
  229.      * convert to PM bitmap, reverse vertical order and align to ULONG
  230.      */
  231.      
  232.     bytesPerLine = (r->w + 3) & ~0x03 ;
  233.     
  234.     for (i = 0, sp = buff ; i < lines ; i++) {
  235.     dp = &ibuff[bytesPerLine * (lines - i - 1)] ;
  236.     for (j = 0 ; j < r->w ; j++) {
  237.         *dp++ = mapRaw[*sp++] ;
  238.         }
  239.     }
  240.  
  241.     pbmiBitmap->cx = r->w  ;
  242.     pbmiBitmap->cy = lines ;
  243.     
  244.     apt[0].x = r->x ;
  245.     apt[0].y = (cyBitmap - r->y - lines) ;
  246.     apt[1].x = apt[0].x + r->w  - 1 ;
  247.     apt[1].y = apt[0].y + lines - 1 ;
  248.     apt[2].x = 0 ;
  249.     apt[2].y = 0 ;
  250.     apt[3].x = r->w  ;
  251.     apt[3].y = lines ;
  252.  
  253.     GpiDrawBits(hpsBitmap, ibuff, pbmiBitmap, 4, apt, ROP_SRCCOPY, 0) ;
  254. }
  255.  
  256. static  BOOL    rectRaw(rfbRectangle *r)
  257. {
  258.     int     bytesPerLine, linesToRead ;
  259.     
  260.     bytesPerLine  = r->w ;          /* for bgr233 specific  */
  261.     linesToRead   = MINBUF / ((r->w + 3) & ~0x03) ;
  262.     
  263.     if (linesToRead == 0) {
  264.         netFail("rectRaw - scanline too large, recompile!!") ;
  265.     return FALSE ;
  266.     }
  267.  
  268.     while (r->h > 0) {
  269.         if (linesToRead > r->h) {
  270.             linesToRead = r->h ;
  271.         }
  272.         if (netRecv(rbuff, bytesPerLine * linesToRead) != TRUE) {
  273.         netFail("failed to recv Raw Scanline") ;
  274.         return FALSE ;
  275.     }
  276.         rawConv(r, linesToRead, rbuff) ;
  277.     r->h -= linesToRead ;
  278.     r->y += linesToRead ;
  279.     }
  280.     return TRUE ;
  281. }
  282.  
  283. /*
  284.  * rectCopy - copy rect encoding
  285.  */
  286.  
  287. static  BOOL    rectCopy(rfbRectangle *r)
  288. {
  289.     rfbCopyRect cr  ;
  290.     POINTL  apt[3]  ;
  291.     
  292.     if (netRecv((PUCHAR) &cr, sz_rfbCopyRect) != TRUE) {
  293.         netFail("failed to recv CopyRect") ;
  294.     return FALSE ;
  295.     }
  296.  
  297.     cr.srcX = swap16(cr.srcX) ;
  298.     cr.srcY = swap16(cr.srcY) ;
  299.     
  300.     apt[0].x = r->x                      ;
  301.     apt[0].y = cyBitmap - r->y - r->h    ;
  302.     apt[1].x = r->x + r->w               ;
  303.     apt[1].y = cyBitmap - r->y           ;
  304.     apt[2].x = cr.srcX                   ;
  305.     apt[2].y = cyBitmap - cr.srcY - r->h ;
  306.     
  307.     GpiBitBlt(hpsBitmap, hpsBitmap, 3, apt, ROP_SRCCOPY, 0) ;
  308.  
  309.     return TRUE ;
  310. }
  311.  
  312. /*
  313.  * Fill Rectangle with Solid Color
  314.  */
  315.  
  316. #define     fillRect(mx, my, mw, mh, color)         \
  317. {                                                   \
  318.     POLYGON pg ;                                    \
  319.     POINTL  apt[8] ;                                \
  320.     int     n, i ;                                  \
  321.     GpiSetColor(hpsBitmap, mapCol[color]) ;         \
  322.     if ((mw) == 1 && (mh) == 1) {                   \
  323.         apt[0].x = (mx)                   ;         \
  324.         apt[0].y = cyBitmap - (my) - (mh) ;         \
  325.         GpiSetPel(hpsBitmap, &apt[0])     ;         \
  326.     } else if ((mw) <  4) {                         \
  327.         for (i = 0, n = 0 ; i < (mw) ; i++) {       \
  328.         apt[n].x = (mx) + i               ;     \
  329.         apt[n].y = cyBitmap - (my) - (mh) ;     \
  330.         n += 1                            ;     \
  331.         apt[n].x = (mx) + i               ;     \
  332.         apt[n].y = cyBitmap - (my) - 1    ;     \
  333.             n += 1                            ;     \
  334.     }                                           \
  335.     GpiPolyLineDisjoint(hpsBitmap, n, apt) ;    \
  336.     } else {                                        \
  337.         pg.ulPoints = 4  ;                              \
  338.     pg.aPointl = apt ;                              \
  339.         apt[2].x = apt[3].x = (mx)                   ;  \
  340.     apt[0].x = apt[1].x = (mx) + (mw) - 1        ;  \
  341.     apt[0].y = apt[3].y = cyBitmap - (my) - (mh) ;  \
  342.     apt[1].y = apt[2].y = cyBitmap - (my) - 1    ;  \
  343.         GpiMove(hpsBitmap, &apt[3])          ;          \
  344.         GpiPolygons(hpsBitmap, 1, &pg, 0, 0) ;          \
  345.     }                                                   \
  346. }
  347.  
  348. /*
  349.  * rectRRE - RRE encoding
  350.  */
  351.  
  352. static  BOOL    rectRRE(rfbRectangle *r)
  353. {
  354.     rfbRREHeader    hdr ;
  355.     rfbRectangle    subrect ;
  356.     CARD8   color    ;
  357.     int     i        ;
  358.  
  359.     if (netRecv((PUCHAR) &hdr, sz_rfbRREHeader) != TRUE) {
  360.         netFail("failed to recv RREHeader") ;
  361.     return FALSE ;
  362.     }
  363.     hdr.nSubrects = swap32(hdr.nSubrects) ;
  364.  
  365.     if (netRecv((PUCHAR) &color, sizeof(CARD8)) != TRUE) {
  366.         netFail("failed to recv BG color") ;
  367.     return FALSE ;
  368.     }
  369.  
  370.     fillRect(r->x, r->y, r->w, r->h, color) ;
  371.  
  372.     for (i = 0 ; i < hdr.nSubrects ; i++) {
  373.         if (netRecv((PUCHAR) &color, sizeof(CARD8)) != TRUE) {
  374.         netFail("failed to recv sub color") ;
  375.         return FALSE ;
  376.     }
  377.     if (netRecv((PUCHAR) &subrect, sz_rfbRectangle) != TRUE) {
  378.         netFail("failed to recv subrect") ;
  379.         return FALSE ;
  380.     }
  381.  
  382.     subrect.x = r->x + swap16(subrect.x) ;
  383.     subrect.y = r->y + swap16(subrect.y) ;
  384.     subrect.w = swap16(subrect.w) ;
  385.     subrect.h = swap16(subrect.h) ;
  386.  
  387.         fillRect(subrect.x, subrect.y, subrect.w, subrect.h, color) ;
  388.     }
  389.     return TRUE ;
  390. }
  391.  
  392. /*
  393.  * rectCoRRE - CoRRE encoding
  394.  */
  395.  
  396. static  BOOL    rectCoRRE(rfbRectangle *r)
  397. {
  398.     rfbRREHeader    hdr ;
  399.     rfbRectangle    subrect ;
  400.     PUCHAR  sp       ;
  401.     CARD8   color    ;
  402.     int     i        ;
  403.  
  404.     if (netRecv((PUCHAR) &hdr, sz_rfbRREHeader) != TRUE) {
  405.         netFail("failed to recv RREHeader") ;
  406.     return FALSE ;
  407.     }
  408.     hdr.nSubrects = swap32(hdr.nSubrects) ;
  409.  
  410.     if (netRecv((PUCHAR) &color, sizeof(CARD8)) != TRUE) {
  411.         netFail("failed to recv BG color") ;
  412.     return FALSE ;
  413.     }
  414.  
  415.     fillRect(r->x, r->y, r->w, r->h, color) ;
  416.  
  417.     if (netRecv(rbuff, hdr.nSubrects * 5) != TRUE) {
  418.         netFail("failed to recv subrects") ;
  419.     return FALSE ;
  420.     }
  421.  
  422.     for (i = 0, sp = rbuff ; i < hdr.nSubrects ; i++, sp += 5) {
  423.         color = *(CARD8 *) sp ;
  424.     subrect.x = r->x + sp[1] ;
  425.     subrect.y = r->y + sp[2] ;
  426.     subrect.w = sp[3] ;
  427.     subrect.h = sp[4] ;
  428.  
  429.         fillRect(subrect.x, subrect.y, subrect.w, subrect.h, color) ;
  430.     }
  431.     return TRUE ;
  432. }
  433.  
  434. /*
  435.  * rectTile - Hextile encoding
  436.  */
  437.  
  438. static  CARD8   tileFg = 0xff ;
  439. static  CARD8   tileBg = 0x00 ;
  440.  
  441. static  PUCHAR  tileScan[16] ;
  442. static  POINTL  tileBlit[4]  ;
  443.  
  444. static  void    hextileInit(int x, int y, int w, int h, CARD8 bg)
  445. {
  446.     int     i, bytesPerLine ;
  447.     
  448.     /*
  449.      * fill tile with background color
  450.      */
  451.      
  452.     bytesPerLine = (w + 3) & ~0x03 ;
  453.     memset(ibuff, bg, (bytesPerLine * h)) ;
  454.  
  455.     for (i = 0 ; i < h  ; i++) {
  456.         tileScan[i] = &ibuff[bytesPerLine * (h - i - 1)] ;
  457.     }
  458.  
  459.     /*
  460.      * prepare for final bitblt
  461.      */
  462.      
  463.     pbmiBitmap->cx = w ;
  464.     pbmiBitmap->cy = h ;
  465.  
  466.     tileBlit[0].x = x ;
  467.     tileBlit[0].y = (cyBitmap - y - h) ;
  468.     tileBlit[1].x = tileBlit[0].x + w  - 1 ;
  469.     tileBlit[1].y = tileBlit[0].y + h - 1 ;
  470.     tileBlit[2].x = 0 ;
  471.     tileBlit[2].y = 0 ;
  472.     tileBlit[3].x = w ;
  473.     tileBlit[3].y = h ;
  474. }
  475.  
  476. #define hextileDraw()   \
  477.     GpiDrawBits(hpsBitmap, ibuff, pbmiBitmap, 4, tileBlit, ROP_SRCCOPY, 0)
  478.  
  479. #define hextileFill(x, y, w, h, color)      \
  480. {                                           \
  481.     int     i ;                             \
  482.     PUCHAR  p ;                             \
  483.     if ((w) == 1) {                         \
  484.         for (i = 0 ; i < (h) ; i++) {       \
  485.             p = tileScan[(y) + i] + (x) ;   \
  486.         *p = (color) ;                  \
  487.         }                                   \
  488.     } else {                                \
  489.         for (i = 0 ; i < (h) ; i++) {       \
  490.             p = tileScan[(y) + i] + (x) ;   \
  491.             memset(p, (color), (w)) ;       \
  492.         }                                   \
  493.     }                                       \
  494. }
  495.  
  496. static  BOOL    rectTile(rfbRectangle *r)
  497. {
  498.     CARD8   subencoding, nSubrects ;
  499.     int     x, y, w, h ;
  500.     int     i, j, bytesPerLine ;
  501.     int     sn, sx, sy, sw, sh ;
  502.     PUCHAR  sp, dp ;
  503.     POINTL  apt[4] ;
  504.     
  505.     for (y = r->y ; y < (r->y + r->h) ; y += 16) {
  506.         for (x = r->x ; x < (r->x + r->w) ; x += 16) {
  507.             w = h = 16 ;
  508.         if ((r->x + r->w - x) < 16) {
  509.             w = r->x + r->w - x ;
  510.         }
  511.         if ((r->y + r->h - y) < 16) {
  512.             h = r->y + r->h - y ;
  513.         }
  514.         if (netRecv((PUCHAR) &subencoding, 1) != TRUE) {
  515.             netFail("failed to recv sub encoding") ;
  516.         return FALSE ;
  517.         }
  518.         if (subencoding & rfbHextileRaw) {
  519.  
  520.             bytesPerLine = (w + 3) & ~0x03 ;
  521.  
  522.         if (netRecv(rbuff, w * h) != TRUE) {
  523.             netFail("failed on hextile raw") ;
  524.             return FALSE ;
  525.         }
  526.         for (i = 0, sp = rbuff ; i < h ; i++) {
  527.                     dp = &ibuff[bytesPerLine * (h - i - 1)] ;
  528.             for (j = 0 ; j < w ; j++) {
  529.                 *dp++ = mapRaw[*sp++] ;
  530.             }
  531.         }
  532.         
  533.         pbmiBitmap->cx = w ;
  534.         pbmiBitmap->cy = h ;
  535.         
  536.                 apt[0].x = x ;
  537.                 apt[0].y = (cyBitmap - y - h) ;
  538.                 apt[1].x = apt[0].x + w  - 1 ;
  539.                 apt[1].y = apt[0].y + h - 1 ;
  540.                 apt[2].x = 0 ;
  541.                 apt[2].y = 0 ;
  542.                 apt[3].x = w ;
  543.                 apt[3].y = h ;
  544.  
  545.                 GpiDrawBits(hpsBitmap, ibuff, 
  546.                             pbmiBitmap, 4, apt, ROP_SRCCOPY, 0) ;
  547.         continue ;
  548.         }
  549.         if (subencoding & rfbHextileBackgroundSpecified) {
  550.             if (netRecv((PUCHAR) &tileBg, sizeof(CARD8)) != TRUE) {
  551.             netFail("failed to recv BG color") ;
  552.             return FALSE ;
  553.         }
  554.         }
  555.         if (subencoding & rfbHextileForegroundSpecified) {
  556.             if (netRecv((PUCHAR) &tileFg, sizeof(CARD8)) != TRUE) {
  557.             netFail("failed to recv FG color") ;
  558.             return FALSE ;
  559.         }
  560.         }
  561.         if ((subencoding & rfbHextileAnySubrects) == 0) {
  562.                 hextileInit(x, y, w, h, mapRaw[tileBg]) ;
  563.         hextileDraw() ;
  564.             } else if (subencoding & rfbHextileSubrectsColoured) {
  565.                 hextileInit(x, y, w, h, mapRaw[tileBg]) ;
  566.                 if (netRecv((PUCHAR) &nSubrects, 1) != TRUE) {
  567.                     netFail("failed to recv hextile nSubrects") ;
  568.                     return FALSE ;
  569.                 }
  570.                 if (netRecv((PUCHAR) rbuff, nSubrects * 3) != TRUE) {
  571.                     netFail("failed to recv hextile Subrects") ;
  572.                     return FALSE ;
  573.                 }
  574.  
  575.                 for (sn = 0, sp = rbuff ; sn < nSubrects ; sn++, sp += 3) {
  576.                     sx = rfbHextileExtractX(sp[1]) ;
  577.                     sy = rfbHextileExtractY(sp[1]) ;
  578.                     sw = rfbHextileExtractW(sp[2]) ;
  579.                     sh = rfbHextileExtractH(sp[2]) ;
  580.             hextileFill(sx, sy, sw, sh, mapRaw[sp[0]]) ;
  581.         }
  582.         hextileDraw() ;
  583.         } else {
  584.                 hextileInit(x, y, w, h, mapRaw[tileBg]) ;
  585.                 if (netRecv((PUCHAR) &nSubrects, 1) != TRUE) {
  586.                     netFail("failed to recv hextile nSubrects") ;
  587.                     return FALSE ;
  588.                 }
  589.                 if (netRecv((PUCHAR) rbuff, nSubrects * 2) != TRUE) {
  590.                     netFail("failed to recv hextile Subrects") ;
  591.                     return FALSE ;
  592.                 }
  593.  
  594.                 for (sn = 0, sp = rbuff ; sn < nSubrects ; sn++, sp += 2) {
  595.                     sx = rfbHextileExtractX(sp[0]) ;
  596.                     sy = rfbHextileExtractY(sp[0]) ;
  597.                     sw = rfbHextileExtractW(sp[1]) ;
  598.                     sh = rfbHextileExtractH(sp[1]) ;
  599.             hextileFill(sx, sy, sw, sh, mapRaw[tileFg]) ;
  600.         }
  601.         hextileDraw() ;
  602.         }
  603.         }
  604.     }
  605.     return TRUE ;
  606. }
  607.  
  608. /*
  609.  * VncPix4Tiny - Drawing Context for bgr233 mapped to default 16 colors
  610.  */
  611.  
  612. static  UCHAR   tinyRaw[] = {
  613.      0, 10, 10, 10, 10, 10,  2,  2, 12, 11, 10, 10, 10, 10,  2,  2, 
  614.     12, 12, 14, 11, 10, 10,  2,  2, 12, 12, 12, 14, 14, 14,  2,  2, 
  615.     12, 12, 12, 14, 14, 14,  3,  3,  8,  8,  8,  8,  8, 15, 15, 15, 
  616.     15, 15, 15, 15, 15, 15, 15, 15,  4,  4,  4,  4,  4,  5,  6,  6, 
  617.      9,  9, 11, 11, 10, 10,  2,  2,  9,  9, 11, 11, 10, 10,  2,  2, 
  618.     13, 13, 11, 11, 11,  2,  2,  2, 13, 13, 13, 14, 14, 14,  2,  3, 
  619.     12, 12, 13,  8,  8,  8,  3,  3,  8,  8,  8,  8,  3, 15, 15, 15, 
  620.     15, 15, 15, 15, 15, 15, 15, 15,  4,  4,  4,  4,  5,  5,  6,  6, 
  621.      9,  9,  9, 11, 11, 11,  2,  2,  9,  9,  9, 11, 11, 11,  2,  2, 
  622.      1,  1,  1, 11, 11, 11,  3,  3, 13, 13, 13,  8,  8,  8,  3,  3, 
  623.     13, 13, 13,  8,  8,  3,  3,  3,  8,  8,  8,  8,  3, 15, 15, 15, 
  624.     15, 15, 15, 15, 15, 15, 15,  4,  4,  4,  4,  5,  5,  5,  6,  6, 
  625.      1,  1,  1,  1,  1,  8,  3,  3,  1,  1,  1,  1,  1,  8,  3,  3, 
  626.      1,  1,  1,  1,  8,  8,  3,  3,  1,  1,  1,  8,  8,  3,  3,  3, 
  627.     13, 13,  8,  8,  3,  3,  3, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
  628.     15, 15, 15, 15, 15, 15,  5,  5,  5,  5,  5,  5,  5,  6,  6,  7
  629. } ;
  630.  
  631. static  LONG    tinyCol[] = {
  632.     CLR_BLACK,      CLR_DARKRED,    CLR_DARKRED,    CLR_DARKRED, 
  633.     CLR_DARKRED,    CLR_DARKRED,    CLR_RED,        CLR_RED, 
  634.     CLR_DARKGREEN,  CLR_DARKPINK,   CLR_DARKRED,    CLR_DARKRED, 
  635.     CLR_DARKRED,    CLR_DARKRED,    CLR_RED,        CLR_RED, 
  636.     CLR_DARKGREEN,  CLR_DARKGREEN,  CLR_BROWN,      CLR_DARKPINK, 
  637.     CLR_DARKRED,    CLR_DARKRED,    CLR_RED,        CLR_RED, 
  638.     CLR_DARKGREEN,  CLR_DARKGREEN,  CLR_DARKGREEN,  CLR_BROWN, 
  639.     CLR_BROWN,      CLR_BROWN,      CLR_RED,        CLR_RED, 
  640.     CLR_DARKGREEN,  CLR_DARKGREEN,  CLR_DARKGREEN,  CLR_BROWN, 
  641.     CLR_BROWN,      CLR_BROWN,      CLR_PINK,       CLR_PINK, 
  642.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  643.     CLR_DARKGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  644.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  645.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  646.     CLR_GREEN,      CLR_GREEN,      CLR_GREEN,      CLR_GREEN, 
  647.     CLR_GREEN,      CLR_CYAN,       CLR_YELLOW,     CLR_YELLOW, 
  648.     CLR_DARKBLUE,   CLR_DARKBLUE,   CLR_DARKPINK,   CLR_DARKPINK, 
  649.     CLR_DARKRED,    CLR_DARKRED,    CLR_RED,        CLR_RED, 
  650.     CLR_DARKBLUE,   CLR_DARKBLUE,   CLR_DARKPINK,   CLR_DARKPINK, 
  651.     CLR_DARKRED,    CLR_DARKRED,    CLR_RED,        CLR_RED, 
  652.     CLR_DARKCYAN,   CLR_DARKCYAN,   CLR_DARKPINK,   CLR_DARKPINK, 
  653.     CLR_DARKPINK,   CLR_RED,        CLR_RED,        CLR_RED, 
  654.     CLR_DARKCYAN,   CLR_DARKCYAN,   CLR_DARKCYAN,   CLR_BROWN, 
  655.     CLR_BROWN,      CLR_BROWN,      CLR_RED,        CLR_PINK, 
  656.     CLR_DARKGREEN,  CLR_DARKGREEN,  CLR_DARKCYAN,   CLR_DARKGRAY, 
  657.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_PINK,       CLR_PINK, 
  658.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  659.     CLR_PINK,       CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  660.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  661.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  662.     CLR_GREEN,      CLR_GREEN,      CLR_GREEN,      CLR_GREEN, 
  663.     CLR_CYAN,       CLR_CYAN,       CLR_YELLOW,     CLR_YELLOW, 
  664.     CLR_DARKBLUE,   CLR_DARKBLUE,   CLR_DARKBLUE,   CLR_DARKPINK, 
  665.     CLR_DARKPINK,   CLR_DARKPINK,   CLR_RED,        CLR_RED, 
  666.     CLR_DARKBLUE,   CLR_DARKBLUE,   CLR_DARKBLUE,   CLR_DARKPINK, 
  667.     CLR_DARKPINK,   CLR_DARKPINK,   CLR_RED,        CLR_RED, 
  668.     CLR_BLUE,       CLR_BLUE,       CLR_BLUE,       CLR_DARKPINK, 
  669.     CLR_DARKPINK,   CLR_DARKPINK,   CLR_PINK,       CLR_PINK, 
  670.     CLR_DARKCYAN,   CLR_DARKCYAN,   CLR_DARKCYAN,   CLR_DARKGRAY, 
  671.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_PINK,       CLR_PINK, 
  672.     CLR_DARKCYAN,   CLR_DARKCYAN,   CLR_DARKCYAN,   CLR_DARKGRAY, 
  673.     CLR_DARKGRAY,   CLR_PINK,       CLR_PINK,       CLR_PINK, 
  674.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  675.     CLR_PINK,       CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  676.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  677.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_GREEN, 
  678.     CLR_GREEN,      CLR_GREEN,      CLR_GREEN,      CLR_CYAN, 
  679.     CLR_CYAN,       CLR_CYAN,       CLR_YELLOW,     CLR_YELLOW, 
  680.     CLR_BLUE,       CLR_BLUE,       CLR_BLUE,       CLR_BLUE, 
  681.     CLR_BLUE,       CLR_DARKGRAY,   CLR_PINK,       CLR_PINK, 
  682.     CLR_BLUE,       CLR_BLUE,       CLR_BLUE,       CLR_BLUE, 
  683.     CLR_BLUE,       CLR_DARKGRAY,   CLR_PINK,       CLR_PINK, 
  684.     CLR_BLUE,       CLR_BLUE,       CLR_BLUE,       CLR_BLUE, 
  685.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_PINK,       CLR_PINK, 
  686.     CLR_BLUE,       CLR_BLUE,       CLR_BLUE,       CLR_DARKGRAY, 
  687.     CLR_DARKGRAY,   CLR_PINK,       CLR_PINK,       CLR_PINK, 
  688.     CLR_DARKCYAN,   CLR_DARKCYAN,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  689.     CLR_PINK,       CLR_PINK,       CLR_PINK,       CLR_PALEGRAY, 
  690.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  691.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  692.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  693.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_CYAN,       CLR_CYAN, 
  694.     CLR_CYAN,       CLR_CYAN,       CLR_CYAN,       CLR_CYAN, 
  695.     CLR_CYAN,       CLR_YELLOW,     CLR_YELLOW,     CLR_WHITE
  696. } ;
  697.  
  698. static  BOOL    rectInitTiny(int cx, int cy)
  699. {
  700.     mapRaw = tinyRaw ;
  701.     mapCol = tinyCol ;
  702.  
  703.     return rectInit(cx, cy) ;
  704. }
  705.  
  706. VNCREC      VncCtx4Tiny = {
  707.     /* bitsPerPixel */  8,          /* Current pixel format will fit    */
  708.     /* depth        */  8,          /* to PM's RGB structure with no    */
  709.     /* bigEndian    */  0,          /* conversions.                     */
  710.     /* trueColour   */  1,          /* It reduces client side load.     */
  711.     /* redMax       */  0x0007,     /* But for reduce network traffic,  */
  712.     /* greenMax     */  0x0007,     /* 8 bits BGR233 will be nice.      */
  713.     /* blureMax     */  0x0003,
  714.     /* redShift     */  0,
  715.     /* greenShift   */  3,
  716.     /* blueShift    */  6,
  717.     /* pad1, pad2   */  0, 0,
  718.     /* rectDone     */  rectDone,
  719.     /* rectInit     */  rectInitTiny,
  720.     /* rectDraw     */  rectDraw,
  721.     /* rectRaw      */  rectRaw,
  722.     /* rectCopy     */  rectCopy,
  723.     /* rectRRE      */  rectRRE,
  724.     /* rectCoRRE    */  rectCoRRE,
  725.     /* rectTile     */  rectTile
  726. } ;
  727.  
  728. /*
  729.  * VncPix8Gray - Drawing Context for bgr233 mapped to 4 level gray scale
  730.  */
  731.  
  732. static  UCHAR   grayRaw[] = {
  733.      0,  0,  0,  0,  0,  8,  8,  8,  0,  0,  0,  0,  0,  8,  8,  8, 
  734.      0,  0,  0,  0,  0,  8,  8,  8,  0,  0,  8,  8,  8,  8,  8,  8, 
  735.      8,  8,  8,  8,  8,  8,  8, 15,  8,  8,  8,  8,  8, 15, 15, 15, 
  736.     15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,  7,  7,  7, 
  737.      0,  0,  0,  0,  0,  8,  8,  8,  0,  0,  0,  0,  0,  8,  8,  8, 
  738.      0,  0,  0,  0,  0,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8, 
  739.      8,  8,  8,  8,  8,  8,  8, 15,  8,  8,  8,  8,  8, 15, 15, 15, 
  740.     15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,  7,  7,  7, 
  741.      0,  0,  0,  0,  0,  8,  8,  8,  0,  0,  0,  0,  0,  8,  8,  8, 
  742.      0,  0,  0,  0,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8, 
  743.      8,  8,  8,  8,  8,  8,  8, 15,  8,  8,  8,  8, 15, 15, 15, 15, 
  744.     15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,  7,  7,  7,  7, 
  745.      0,  0,  0,  8,  8,  8,  8,  8,  0,  0,  0,  8,  8,  8,  8,  8, 
  746.      8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8, 
  747.      8,  8,  8,  8,  8,  8, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
  748.     15, 15, 15, 15, 15, 15, 15, 15,  7,  7,  7,  7,  7,  7,  7,  7
  749. } ;
  750.  
  751. static  LONG    grayCol[] = {
  752.     CLR_BLACK,      CLR_BLACK,      CLR_BLACK,      CLR_BLACK, 
  753.     CLR_BLACK,      CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  754.     CLR_BLACK,      CLR_BLACK,      CLR_BLACK,      CLR_BLACK, 
  755.     CLR_BLACK,      CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  756.     CLR_BLACK,      CLR_BLACK,      CLR_BLACK,      CLR_BLACK, 
  757.     CLR_BLACK,      CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  758.     CLR_BLACK,      CLR_BLACK,      CLR_DARKGRAY,   CLR_DARKGRAY, 
  759.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  760.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  761.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_PALEGRAY, 
  762.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  763.     CLR_DARKGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  764.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  765.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  766.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  767.     CLR_PALEGRAY,   CLR_WHITE,      CLR_WHITE,      CLR_WHITE, 
  768.     CLR_BLACK,      CLR_BLACK,      CLR_BLACK,      CLR_BLACK, 
  769.     CLR_BLACK,      CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  770.     CLR_BLACK,      CLR_BLACK,      CLR_BLACK,      CLR_BLACK, 
  771.     CLR_BLACK,      CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  772.     CLR_BLACK,      CLR_BLACK,      CLR_BLACK,      CLR_BLACK, 
  773.     CLR_BLACK,      CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  774.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  775.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  776.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  777.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_PALEGRAY, 
  778.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  779.     CLR_DARKGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  780.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  781.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  782.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  783.     CLR_PALEGRAY,   CLR_WHITE,      CLR_WHITE,      CLR_WHITE, 
  784.     CLR_BLACK,      CLR_BLACK,      CLR_BLACK,      CLR_BLACK, 
  785.     CLR_BLACK,      CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  786.     CLR_BLACK,      CLR_BLACK,      CLR_BLACK,      CLR_BLACK, 
  787.     CLR_BLACK,      CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  788.     CLR_BLACK,      CLR_BLACK,      CLR_BLACK,      CLR_BLACK, 
  789.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  790.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  791.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  792.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  793.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_PALEGRAY, 
  794.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  795.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  796.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  797.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  798.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  799.     CLR_WHITE,      CLR_WHITE,      CLR_WHITE,      CLR_WHITE, 
  800.     CLR_BLACK,      CLR_BLACK,      CLR_BLACK,      CLR_DARKGRAY, 
  801.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  802.     CLR_BLACK,      CLR_BLACK,      CLR_BLACK,      CLR_DARKGRAY, 
  803.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  804.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  805.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  806.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  807.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  808.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_DARKGRAY, 
  809.     CLR_DARKGRAY,   CLR_DARKGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  810.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  811.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  812.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  813.     CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY,   CLR_PALEGRAY, 
  814.     CLR_WHITE,      CLR_WHITE,      CLR_WHITE,      CLR_WHITE, 
  815.     CLR_WHITE,      CLR_WHITE,      CLR_WHITE,      CLR_WHITE
  816. } ;
  817.  
  818. static  BOOL    rectInitGray(int cx, int cy)
  819. {
  820.     mapRaw = grayRaw ;
  821.     mapCol = grayCol ;
  822.  
  823.     return rectInit(cx, cy) ;
  824. }
  825.  
  826. VNCREC      VncCtx4Gray = {
  827.     /* bitsPerPixel */  8,          /* Current pixel format will fit    */
  828.     /* depth        */  8,          /* to PM's RGB structure with no    */
  829.     /* bigEndian    */  0,          /* conversions.                     */
  830.     /* trueColour   */  1,          /* It reduces client side load.     */
  831.     /* redMax       */  0x0007,     /* But for reduce network traffic,  */
  832.     /* greenMax     */  0x0007,     /* 8 bits BGR233 will be nice.      */
  833.     /* blureMax     */  0x0003,
  834.     /* redShift     */  0,
  835.     /* greenShift   */  3,
  836.     /* blueShift    */  6,
  837.     /* pad1, pad2   */  0, 0,
  838.     /* rectDone     */  rectDone,
  839.     /* rectInit     */  rectInitGray,
  840.     /* rectDraw     */  rectDraw,
  841.     /* rectRaw      */  rectRaw,
  842.     /* rectCopy     */  rectCopy,
  843.     /* rectRRE      */  rectRRE,
  844.     /* rectCoRRE    */  rectCoRRE,
  845.     /* rectTile     */  rectTile
  846. } ;
  847.