arch/all-hosted/hidd/x11/bitmap_common.c

   1 /*
   2     Copyright © 1995-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include "x11_debug.h"
   7
   8 #include <X11/Xlib.h>
   9 #include <X11/Xutil.h>
  10 #include <X11/cursorfont.h>
  11 #include <X11/keysym.h>
  12
  13 #include <aros/macros.h>
  14 #include <exec/memory.h>
  15 #include <exec/lists.h>
  16 #include <graphics/rastport.h>
  17 #include <graphics/gfx.h>
  18 #include <hidd/graphics.h>
  19 #include <oop/oop.h>
  20
  21 #include <proto/oop.h>
  22 #include <proto/utility.h>
  23
  24 #include "x11.h"
  25 #include "bitmap.h"
  26 #include "x11gfx_intern.h"
  27
  28 /****************************************************************************************/
  29
  30 #define DO_ENDIAN_FIX     1 /* fix if X11 server running on remote server with different endianess */
  31
  32 /****************************************************************************************/
  33
  34 #define MNAME(x) X11BM__ ## x
  35
  36 #if DO_ENDIAN_FIX
  37
  38 #if AROS_BIG_ENDIAN
  39 #define NEEDS_ENDIAN_FIX(image) (((image)->bits_per_pixel >= 15) && ((image)->byte_order != MSBFirst))
  40 #define SWAP16(x) AROS_WORD2LE(x)
  41 #define SWAP32(x) AROS_LONG2LE(x)
  42 #define AROS_BYTEORDER MSBFirst
  43 #else
  44 #define NEEDS_ENDIAN_FIX(image) (((image)->bits_per_pixel >= 15) && ((image)->byte_order != LSBFirst))
  45 #define SWAP16(x) AROS_WORD2BE(x)
  46 #define SWAP32(x) AROS_LONG2BE(x)
  47 #define AROS_BYTEORDER LSBFirst
  48 #endif
  49
  50 #if 0 /* stegerg: to test above stuff*/
  51 #define NEEDS_ENDIAN_FIX(image) ((image)->bits_per_pixel >= 15)
  52 #define AROS_BYTEORDER MSBFirst
  53 #define SWAP16(x) AROS_WORD2BE(x)
  54 #define SWAP32(x) AROS_LONG2BE(x)
  55 #endif
  56
  57 /****************************************************************************************/
  58
  59 OOP_Object *X11BM__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
  60 {
  61     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
  62
  63     o = (OOP_Object *) OOP_DoSuperMethod(cl, o, (OOP_Msg) msg);
  64     if (o)
  65     {
  66         struct bitmap_data *data = OOP_INST_DATA(cl, o);
  67         BOOL ok = TRUE;
  68         BOOL framebuffer;
  69
  70         /* Get some info passed to us by the x11gfxhidd class */
  71         data->display = (Display *) GetTagData(aHidd_X11BitMap_SysDisplay, 0, msg->attrList);
  72         data->screen = GetTagData(aHidd_X11BitMap_SysScreen, 0, msg->attrList);
  73         data->cursor = (Cursor) GetTagData(aHidd_X11BitMap_SysCursor, 0, msg->attrList);
  74         data->colmap = (Colormap) GetTagData(aHidd_X11BitMap_ColorMap, 0, msg->attrList);
  75         framebuffer = GetTagData(aHidd_BitMap_FrameBuffer, FALSE, msg->attrList);
  76
  77         D(
  78             bug("[X11Bm] %s: display @ 0x%p, screen #%d\n", __PRETTY_FUNCTION__, data->display, data->screen);
  79             bug("[X11Bm] %s: cursor @ 0x%p, colormap @ 0x%p\n", __PRETTY_FUNCTION__, data->cursor, data->colmap);
  80         )
  81
  82         if (framebuffer)
  83         {
  84             /* Framebuffer is X11 window */
  85             data->flags |= BMDF_FRAMEBUFFER;
  86             ok = X11BM_InitFB(cl, o, msg->attrList);
  87         }
  88         else
  89         {
  90             /* Anything else is a pixmap */
  91             ok = X11BM_InitPM(cl, o, msg->attrList);
  92         }
  93
  94         if (ok)
  95         {
  96             /* Create an X11 GC. All objects need it. */
  97             XGCValues gcval;
  98
  99             gcval.plane_mask = AllPlanes;
 100             gcval.graphics_exposures = False;
 101
 102             HostLib_Lock();
 103
 104             data->gc = XCALL(XCreateGC, data->display, DRAWABLE(data),
 105                     GCPlaneMask | GCGraphicsExposures, &gcval);
 106             HostLib_Unlock();
 107
 108             if (!data->gc)
 109                 ok = FALSE;
 110 #if X11SOFTMOUSE
 111             else if (framebuffer)
 112                 X11BM_InitEmptyCursor(data);
 113 #endif
 114         }
 115
 116         if (!ok)
 117         {
 118             OOP_MethodID disp_mid = OOP_GetMethodID(IID_Root, moRoot_Dispose);
 119
 120             OOP_CoerceMethod(cl, o, (OOP_Msg) &disp_mid);
 121             o = NULL;
 122         }
 123     } /* if (object allocated by superclass) */
 124
 125     D(bug("[X11Bm] %s: returning object @ 0x%p\n", __PRETTY_FUNCTION__, o));
 126     return o;
 127 }
 128
 129 /****************************************************************************************/
 130
 131 VOID X11BM__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
 132 {
 133     struct bitmap_data *data = OOP_INST_DATA(cl, o);
 134
 135     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
 136
 137     if (data->gc)
 138     {
 139         HostLib_Lock();
 140         XCALL(XFreeGC, data->display, data->gc);
 141         HostLib_Unlock();
 142     }
 143
 144     if (data->flags & BMDF_FRAMEBUFFER)
 145         X11BM_DisposeFB(data, XSD(cl));
 146     else
 147         X11BM_DisposePM(data);
 148
 149     OOP_DoSuperMethod(cl, o, msg);
 150 }
 151
 152 /****************************************************************************************/
 153
 154 VOID X11BM__Hidd_BitMap__Clear(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_Clear *msg)
 155 {
 156     struct bitmap_data *data = OOP_INST_DATA(cl, o);
 157
 158     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
 159
 160     HostLib_Lock();
 161
 162     if (data->flags & BMDF_FRAMEBUFFER)
 163         X11BM_ClearFB(data, GC_BG(msg->gc));
 164     else
 165         X11BM_ClearPM(data, GC_BG(msg->gc));
 166
 167     HostLib_Unlock();
 168 }
 169
 170 /****************************************************************************************/
 171
 172 static void SwapImageEndianess(XImage *image)
 173 {
 174     LONG x, y, height, width, bpp;
 175     UBYTE *imdata = (UBYTE *) image->data;
 176
 177     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
 178
 179     width = image->width;
 180     height = image->height;
 181     bpp = (image->bits_per_pixel + 7) / 8;
 182
 183     for (y = 0; y < height; y++)
 184     {
 185         switch (bpp)
 186         {
 187         case 2:
 188             for (x = 0; x < width; x++, imdata += 2)
 189             {
 190                 UWORD pix = *(UWORD *) imdata;
 191
 192                 pix = SWAP16(pix);
 193
 194                 *(UWORD *) imdata = pix;
 195             }
 196             imdata += (image->bytes_per_line - width * 2);
 197             break;
 198
 199         case 3:
 200             for (x = 0; x < width; x++, imdata += 3)
 201             {
 202                 UBYTE pix1 = imdata[0];
 203                 UBYTE pix3 = imdata[2];
 204
 205                 imdata[0] = pix3;
 206                 imdata[2] = pix1;
 207             }
 208             imdata += (image->bytes_per_line - width * 3);
 209             break;
 210
 211         case 4:
 212             for (x = 0; x < width; x++, imdata += 4)
 213             {
 214                 ULONG pix = *(ULONG *) imdata;
 215
 216                 pix = SWAP32(pix);
 217
 218                 *(ULONG *) imdata = pix;
 219             }
 220             imdata += (image->bytes_per_line - width * 4);
 221             break;
 222
 223         } /* switch(bpp) */
 224
 225     } /* for (y = 0; y < height; y ++) */
 226
 227     image->byte_order = AROS_BYTEORDER;
 228 }
 229
 230 /****************************************************************************************/
 231
 232 #endif /* DO_ENDIAN_FIX */
 233
 234 /****************************************************************************************/
 235
 236 BOOL MNAME(Hidd_BitMap__SetColors)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_SetColors *msg)
 237 {
 238     struct bitmap_data *data = OOP_INST_DATA(cl, o);
 239     HIDDT_PixelFormat *pf;
 240     ULONG xc_i, col_i;
 241
 242     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
 243
 244     if (!OOP_DoSuperMethod(cl, o, &msg->mID))
 245         return FALSE;
 246
 247     pf = BM_PIXFMT(o);
 248
 249     if (vHidd_ColorModel_StaticPalette == HIDD_PF_COLMODEL(pf) || vHidd_ColorModel_TrueColor == HIDD_PF_COLMODEL(pf))
 250     {
 251         /* Superclass has taken care of this case */
 252         return TRUE;
 253     }
 254
 255     /* Ve have a vHidd_GT_Palette bitmap */
 256
 257     if (data->flags & BMDF_COLORMAP_ALLOCED)
 258     {
 259         LOCK_X11
 260
 261         for (xc_i = msg->firstColor, col_i = 0; col_i < msg->numColors; xc_i++, col_i++)
 262         {
 263             XColor xcol;
 264
 265             xcol.red = msg->colors[col_i].red;
 266             xcol.green = msg->colors[col_i].green;
 267             xcol.blue = msg->colors[col_i].blue;
 268             xcol.pad = 0;
 269             xcol.pixel = xc_i;
 270             xcol.flags = DoRed | DoGreen | DoBlue;
 271
 272             XCALL(XStoreColor, data->display, data->colmap, &xcol);
 273
 274         }
 275
 276         UNLOCK_X11
 277
 278     } /* if (data->flags & BMDF_COLORMAP_ALLOCED) */
 279
 280     return TRUE;
 281 }
 282
 283 /****************************************************************************************/
 284
 285 VOID MNAME(Hidd_BitMap__PutPixel)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutPixel *msg)
 286 {
 287     struct bitmap_data *data = OOP_INST_DATA(cl, o);
 288
 289     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
 290
 291     LOCK_X11
 292
 293     XCALL(XSetForeground, data->display, data->gc, msg->pixel);
 294     XCALL(XSetFunction, data->display, data->gc, GXcopy);
 295     XCALL(XDrawPoint, data->display, DRAWABLE(data), data->gc, msg->x, msg->y);
 296
 297     UNLOCK_X11
 298 }
 299
 300 /****************************************************************************************/
 301
 302 HIDDT_Pixel MNAME(Hidd_BitMap__GetPixel)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_GetPixel *msg)
 303 {
 304     struct bitmap_data *data = OOP_INST_DATA(cl, o);
 305     HIDDT_Pixel pixel = -1;
 306     XImage *image;
 307
 308     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
 309
 310     LOCK_X11
 311
 312     XCALL(XSync, data->display, False);
 313
 314     image = XCALL(XGetImage, data->display, DRAWABLE(data), msg->x, msg->y, 1, 1, AllPlanes, ZPixmap);
 315
 316     if (image)
 317     {
 318         pixel = XGetPixel(image, 0, 0);
 319         XDestroyImage(image);
 320     }
 321
 322     UNLOCK_X11
 323
 324     return pixel;
 325
 326 }
 327
 328 /****************************************************************************************/
 329
 330 ULONG MNAME(Hidd_BitMap__DrawPixel)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawPixel *msg)
 331 {
 332     struct bitmap_data *data = OOP_INST_DATA(cl, o);
 333     XGCValues gcval;
 334
 335     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
 336
 337     gcval.function = GC_DRMD(msg->gc);
 338     gcval.foreground = GC_FG(msg->gc);
 339     gcval.background = GC_BG(msg->gc);
 340
 341     LOCK_X11
 342     XCALL(XChangeGC, data->display, data->gc, GCFunction | GCForeground | GCBackground, &gcval);
 343     XCALL(XDrawPoint, data->display, DRAWABLE(data), data->gc, msg->x, msg->y);
 344     UNLOCK_X11
 345
 346     return 0;
 347 }
 348
 349 /****************************************************************************************/
 350
 351 VOID MNAME(Hidd_BitMap__FillRect)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawRect *msg)
 352 {
 353     struct bitmap_data *data = OOP_INST_DATA(cl, o);
 354     XGCValues gcval;
 355
 356     D(bug("[X11Bm] %s(%d,%d,%d,%d)\n", __PRETTY_FUNCTION__, msg->minX, msg->minY, msg->maxX, msg->maxY));
 357     D(bug("[X11Bm] %s: Drawmode = %d\n", __PRETTY_FUNCTION__, GC_DRMD(msg->gc)));
 358
 359     gcval.function = GC_DRMD(msg->gc);
 360     gcval.foreground = GC_FG(msg->gc);
 361     gcval.background = GC_BG(msg->gc);
 362
 363     LOCK_X11
 364     XCALL(XChangeGC, data->display, data->gc, GCFunction | GCForeground | GCBackground, &gcval);
 365
 366     XCALL(XFillRectangle, data->display, DRAWABLE(data), data->gc, msg->minX, msg->minY, msg->maxX - msg->minX + 1, msg->maxY - msg->minY + 1);
 367
 368     UNLOCK_X11
 369 }
 370
 371 /****************************************************************************************/
 372
 373 static ULONG *ximage_to_buf(OOP_Class *cl, OOP_Object *bm, HIDDT_Pixel *buf, XImage *image, ULONG width, ULONG height,
 374         ULONG depth, struct pHidd_BitMap_GetImage *msg)
 375 {
 376     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
 377
 378     switch (msg->pixFmt)
 379     {
 380     case vHidd_StdPixFmt_Native:
 381     {
 382         UBYTE *imdata = image->data;
 383         LONG y;
 384
 385         for (y = 0; y < height; y++)
 386         {
 387             memcpy(buf, imdata, msg->width * image->bits_per_pixel / 8);
 388
 389             imdata += image->bytes_per_line;
 390             buf = (HIDDT_Pixel *) ((UBYTE *) buf + msg->modulo);
 391         }
 392     }
 393         break;
 394
 395     case vHidd_StdPixFmt_Native32:
 396         switch (image->bits_per_pixel)
 397         {
 398         case 8:
 399         {
 400             UBYTE *imdata = (UBYTE *) image->data;
 401             LONG x, y;
 402
 403             for (y = 0; y < height; y++)
 404             {
 405                 HIDDT_Pixel *p = buf;
 406
 407                 for (x = 0; x < width; x++)
 408                 {
 409                     *p++ = *imdata++;
 410                 }
 411                 imdata += (image->bytes_per_line - width);
 412                 buf = (HIDDT_Pixel *) ((UBYTE *) buf + msg->modulo);
 413             }
 414             break;
 415         }
 416
 417         case 16:
 418         {
 419             UWORD *imdata = (UWORD *) image->data;
 420             LONG x, y;
 421
 422             for (y = 0; y < height; y++)
 423             {
 424                 HIDDT_Pixel *p = buf;
 425
 426                 for (x = 0; x < width; x++)
 427                 {
 428                     *p++ = *imdata++;
 429                 }
 430                 imdata += image->bytes_per_line / 2 - width;
 431                 buf = (HIDDT_Pixel *) ((UBYTE *) buf + msg->modulo);
 432             }
 433             break;
 434         }
 435
 436         case 32:
 437         {
 438             ULONG *imdata = (ULONG *) image->data;
 439             LONG x, y;
 440
 441             for (y = 0; y < height; y++)
 442             {
 443                 HIDDT_Pixel *p = buf;
 444
 445                 for (x = 0; x < width; x++)
 446                 {
 447                     *p++ = *imdata++;
 448                 }
 449                 imdata += image->bytes_per_line / 4 - width;
 450                 buf = (HIDDT_Pixel *) ((UBYTE *) buf + msg->modulo);
 451             }
 452             break;
 453         }
 454
 455         default:
 456         {
 457             LONG x, y;
 458
 459             LOCK_X11
 460             for (y = 0; y < height; y++)
 461             {
 462                 HIDDT_Pixel *p;
 463
 464                 p = buf;
 465                 for (x = 0; x < width; x++)
 466                 {
 467                     *p++ = XGetPixel(image, x, y);
 468                 }
 469                 buf = (HIDDT_Pixel *) ((UBYTE *) buf + msg->modulo);
 470             }
 471             UNLOCK_X11
 472             break;
 473         }
 474
 475         } /* switch (image->bits_per_pixel) */
 476
 477         break;
 478
 479     default:
 480     {
 481
 482         OOP_Object *srcpf, *dstpf, *gfxhidd;
 483         APTR srcPixels = image->data, dstBuf = buf;
 484
 485         //bug("DEFAULT PIXEL CONVERSION\n");
 486
 487         OOP_GetAttr(bm, aHidd_BitMap_GfxHidd, (IPTR *) &gfxhidd);
 488         dstpf = HIDD_Gfx_GetPixFmt(gfxhidd, msg->pixFmt);
 489
 490         OOP_GetAttr(bm, aHidd_BitMap_PixFmt, (IPTR *) &srcpf);
 491
 492         //bug("CALLING ConvertPixels()\n");
 493
 494         HIDD_BM_ConvertPixels(bm, &srcPixels, (HIDDT_PixelFormat *) srcpf, image->bytes_per_line, &dstBuf,
 495                 (HIDDT_PixelFormat *) dstpf, msg->modulo, width, height, NULL /* We have no CLUT */
 496                 );
 497
 498         //bug("CONVERTPIXELS DONE\n");
 499
 500         buf = (HIDDT_Pixel *) ((UBYTE *) buf + msg->modulo * height);
 501         break;
 502     }
 503
 504     } /* switch (msg->pixFmt) */
 505
 506     return buf;
 507 }
 508
 509 /****************************************************************************************/
 510
 511 #define ABS(a) ((a) < 0 ? -(a) : a)
 512
 513 /****************************************************************************************/
 514
 515 static inline UBYTE pix_to_lut(HIDDT_Pixel pixel, HIDDT_PixelLUT *plut, HIDDT_PixelFormat *pf)
 516 {
 517     HIDDT_ColComp red, green, blue;
 518     ULONG i, best_match = 0;
 519     ULONG diff, lowest_diff = 0xFFFFFFFF;
 520
 521     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
 522
 523     red = RED_COMP(pixel, pf);
 524     green = GREEN_COMP(pixel, pf);
 525     blue = BLUE_COMP(pixel, pf);
 526
 527     for (i = 0; i < plut->entries; i++)
 528     {
 529         register HIDDT_Pixel cur_lut = plut->pixels[i];
 530
 531         if (pixel == cur_lut)
 532             return i; /* Exact match found */
 533
 534         /* How well does these pixels match ? */
 535         diff = ABS(red - RED_COMP(cur_lut, pf)) + ABS(green - GREEN_COMP(cur_lut, pf))
 536                 + ABS(blue - BLUE_COMP(cur_lut, pf));
 537
 538         if (diff < lowest_diff)
 539         {
 540             best_match = i;
 541             lowest_diff = diff;
 542         }
 543
 544     }
 545
 546     return best_match;
 547 }
 548
 549 /****************************************************************************************/
 550
 551 static UBYTE *ximage_to_buf_lut(OOP_Class *cl, OOP_Object *bm, UBYTE *buf, XImage *image, ULONG width, ULONG height,
 552         ULONG depth, struct pHidd_BitMap_GetImageLUT *msg)
 553 {
 554     /* This one is trickier, as we have to reverse-lookup the lut.
 555      This costs CPU ! Maybe one could do some kind of caching here ?
 556      Ie. one stores the most often used RGB combinations
 557      in a trie and looks up this first to see if whe can find an exact match
 558      */
 559
 560     HIDDT_PixelFormat *pf = BM_PIXFMT(bm);
 561     UBYTE *pixarray = msg->pixels;
 562
 563     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
 564
 565     if (image->bits_per_pixel == 16)
 566     {
 567         UWORD *imdata = (UWORD *) image->data;
 568         LONG x, y;
 569
 570         for (y = 0; y < height; y++)
 571         {
 572             UBYTE *buf = pixarray;
 573
 574             for (x = 0; x < width; x++)
 575             {
 576                 *buf++ = pix_to_lut((HIDDT_Pixel) *imdata, msg->pixlut, pf);
 577
 578                 imdata++;
 579             }
 580             imdata += ((image->bytes_per_line / 2) - width); /*sg*/
 581
 582             pixarray += msg->modulo;
 583
 584         }
 585     }
 586     else
 587     {
 588         LONG x, y;
 589
 590         LOCK_X11
 591         for (y = 0; y < height; y++)
 592         {
 593             UBYTE *buf = pixarray;
 594             for (x = 0; x < width; x++)
 595             {
 596                 *buf++ = pix_to_lut((HIDDT_Pixel) XGetPixel(image, x, y), msg->pixlut, pf);
 597                 ;
 598             }
 599             pixarray += msg->modulo;
 600
 601         }
 602         UNLOCK_X11
 603
 604     }
 605
 606     return pixarray;
 607
 608 }
 609
 610 /****************************************************************************************/
 611
 612 #if USE_XSHM
 613
 614 /****************************************************************************************/
 615
 616 static void getimage_xshm(OOP_Class *cl, OOP_Object *o, LONG x, LONG y,
 617         ULONG width, ULONG height, APTR pixarray,
 618         APTR (*fromimage_func)(), APTR fromimage_data)
 619 {
 620     struct bitmap_data *data;
 621     XImage *image;
 622     IPTR depth;
 623     ULONG lines_to_copy;
 624     LONG ysize;
 625     LONG current_y;
 626     LONG maxlines;
 627     OOP_Object *pf;
 628     Pixmap temp_pixmap = 0;
 629
 630     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
 631
 632     ASSERT(width > 0 && height > 0);
 633
 634     data = OOP_INST_DATA(cl, o);
 635
 636     OOP_GetAttr(o, aHidd_BitMap_PixFmt, (IPTR *)&pf);
 637     OOP_GetAttr(pf, aHidd_PixFmt_Depth, &depth);
 638
 639 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
 640
 641     LOCK_X11
 642     image = create_xshm_ximage(data->display,
 643             DefaultVisual(data->display, data->screen),
 644             depth,
 645             ZPixmap,
 646             width,
 647             height,
 648             XSD(cl)->xshm_info);
 649     UNLOCK_X11
 650
 651     if (!image)
 652         return;
 653
 654     ASSERT(image->bytes_per_line > 0);
 655
 656     /* Calculate how many scanline can be stored in the buffer */
 657     maxlines = XSHM_MEMSIZE / image->bytes_per_line;
 658
 659     if (0 == maxlines)
 660     {
 661         bug("ALERT !!! NOT ENOUGH MEMORY TO READ A COMPLETE SCANLINE\n");
 662         bug("THROUGH XSHM IN X11GF X HIDD !!!\n");
 663         Alert(AT_DeadEnd);
 664     }
 665
 666     current_y = 0;
 667     ysize = image->height;
 668
 669     ObtainSemaphore(&XSD(cl)->shm_sema);
 670
 671     LOCK_X11
 672
 673     while (ysize)
 674     {
 675         /* Get some more pixels from the Ximage */
 676
 677         lines_to_copy = MIN(maxlines, ysize);
 678
 679         ysize -= lines_to_copy;
 680         image->height = lines_to_copy;
 681
 682         if (!temp_pixmap)
 683         {
 684             if (!(get_xshm_ximage(data->display, DRAWABLE(data), image,
 685                                     x, y + current_y)))
 686             {
 687                 /* XGetImage fails if done on a part of a X window which is off
 688                  screen (OTOH, it's no problem if it is hidden by another window).
 689                  If get_xshm_image() failed, we assume that this has happened and
 690                  thefore copy the area to a temp pixmap, and then get the ximage
 691                  from there. */
 692
 693                 temp_pixmap = XCALL(XCreatePixmap, data->display, DRAWABLE(data),
 694                         width, height - current_y, DefaultDepth(data->display, data->screen));
 695
 696                 if (temp_pixmap)
 697                 {
 698                     XCALL(XSetFunction, data->display, data->gc, GXcopy);
 699
 700                     XCALL(XCopyArea, data->display, DRAWABLE(data), temp_pixmap, data->gc,
 701                             x, y + current_y, width, height - current_y, 0, 0);
 702
 703                     XCALL(XSetFunction, data->display, data->gc, GC_DRMD(data->gc));
 704
 705                     x = 0; y = 0; current_y = 0;
 706                 }
 707             }
 708         }
 709
 710         if (temp_pixmap)
 711         {
 712             get_xshm_ximage(data->display, temp_pixmap, image,
 713                     x, y + current_y);
 714         }
 715
 716         current_y += lines_to_copy;
 717
 718         pixarray = fromimage_func(cl, o, pixarray, image, image->width,
 719                 lines_to_copy, depth, fromimage_data);
 720
 721     } /* while (pixels left to copy) */
 722
 723     if (temp_pixmap)
 724     {
 725         XCALL(XFreePixmap,data->display, temp_pixmap);
 726     }
 727
 728     UNLOCK_X11
 729
 730     ReleaseSemaphore(&XSD(cl)->shm_sema);
 731
 732     LOCK_X11
 733     destroy_xshm_ximage(image);
 734     UNLOCK_X11
 735
 736     return;
 737
 738 }
 739
 740 /****************************************************************************************/
 741
 742 #endif
 743
 744 /****************************************************************************************/
 745
 746 static void getimage_xlib(OOP_Class *cl, OOP_Object *o, LONG x, LONG y, ULONG width, ULONG height, APTR pixels,
 747         APTR(*fromimage_func)(), APTR fromimage_data)
 748 {
 749     struct bitmap_data *data;
 750     XImage *image;
 751     ULONG *pixarray = (ULONG *) pixels;
 752     OOP_Object *pf;
 753     IPTR depth;
 754
 755     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
 756
 757     data = OOP_INST_DATA(cl, o);
 758
 759     OOP_GetAttr(o, aHidd_BitMap_PixFmt, (IPTR *) &pf);
 760     OOP_GetAttr(pf, aHidd_PixFmt_Depth, &depth);
 761
 762     LOCK_X11
 763     image = XCALL(XGetImage, data->display, DRAWABLE(data), x, y,
 764             width, height, AllPlanes, ZPixmap);
 765     UNLOCK_X11
 766
 767     if (!image)
 768         return;
 769
 770 #if DO_ENDIAN_FIX
 771     if (NEEDS_ENDIAN_FIX(image))
 772     {
 773         SwapImageEndianess(image);
 774
 775         LOCK_X11
 776         XCALL(XInitImage, image);
 777         UNLOCK_X11
 778     }
 779 #endif
 780
 781     fromimage_func(cl, o, pixarray, image, width, height, depth, fromimage_data);
 782
 783     LOCK_X11
 784     XDestroyImage(image);
 785     UNLOCK_X11
 786
 787     return;
 788 }
 789
 790 /****************************************************************************************/
 791
 792 VOID MNAME(Hidd_BitMap__GetImage)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_GetImage *msg)
 793 {
 794     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
 795
 796     ASSERT(msg->width > 0 && msg->height > 0);
 797
 798 #if USE_XSHM
 799     if (XSD(cl)->use_xshm)
 800     {
 801         getimage_xshm(cl, o, msg->x, msg->y, msg->width, msg->height,
 802                 msg->pixels, (APTR (*)())ximage_to_buf, msg);
 803     }
 804     else
 805 #endif
 806     {
 807         getimage_xlib(cl, o, msg->x, msg->y, msg->width, msg->height, msg->pixels, (APTR(*)()) ximage_to_buf, msg);
 808     }
 809 }
 810
 811 /****************************************************************************************/
 812
 813 VOID MNAME(Hidd_BitMap__GetImageLUT)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_GetImageLUT *msg)
 814 {
 815     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
 816
 817     ASSERT(msg->width != 0 && msg->height != 0);
 818 #if USE_XSHM
 819     if (XSD(cl)->use_xshm)
 820     {
 821         getimage_xshm(cl, o, msg->x, msg->y, msg->width, msg->height,
 822                 msg->pixels, (APTR (*)())ximage_to_buf_lut, msg);
 823     }
 824     else
 825 #endif
 826     {
 827         getimage_xlib(cl, o, msg->x, msg->y, msg->width, msg->height, msg->pixels, (APTR(*)()) ximage_to_buf_lut, msg);
 828     }
 829 }
 830
 831 /****************************************************************************************/
 832
 833 #undef DEBUG
 834 #define DEBUG 0
 835 #include <aros/debug.h>
 836
 837 /****************************************************************************************/
 838
 839 static ULONG *buf_to_ximage(OOP_Class *cl, OOP_Object *bm, HIDDT_Pixel *buf, XImage *image, ULONG width, ULONG height,
 840         ULONG depth, struct pHidd_BitMap_PutImage *msg)
 841 {
 842     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
 843
 844     switch (msg->pixFmt)
 845     {
 846     case vHidd_StdPixFmt_Native:
 847     {
 848         UBYTE *imdata = image->data;
 849         LONG y;
 850
 851         for (y = 0; y < height; y++)
 852         {
 853             memcpy(imdata, buf, msg->width * image->bits_per_pixel / 8);
 854
 855             imdata += image->bytes_per_line;
 856             buf = (HIDDT_Pixel *) ((UBYTE *) buf + msg->modulo);
 857         }
 858     }
 859         break;
 860
 861     case vHidd_StdPixFmt_Native32:
 862         switch (image->bits_per_pixel)
 863         {
 864         case 8:
 865         {
 866             UBYTE *imdata = (UBYTE *) image->data;
 867             LONG x, y;
 868
 869             for (y = 0; y < height; y++)
 870             {
 871                 HIDDT_Pixel *p = buf;
 872
 873                 for (x = 0; x < width; x++)
 874                 {
 875                     *imdata++ = (UBYTE) *p++;
 876                 }
 877                 imdata += image->bytes_per_line - width;
 878                 buf = (HIDDT_Pixel *) ((UBYTE *) buf + msg->modulo);
 879             }
 880             break;
 881         }
 882
 883         case 16:
 884         {
 885             UWORD *imdata = (UWORD *) image->data;
 886             LONG x, y;
 887
 888             for (y = 0; y < height; y++)
 889             {
 890                 HIDDT_Pixel *p = buf;
 891
 892                 for (x = 0; x < width; x++)
 893                 {
 894                     *imdata++ = (UWORD) *p++;
 895                 }
 896                 imdata += image->bytes_per_line / 2 - width;
 897                 buf = (HIDDT_Pixel *) ((UBYTE *) buf + msg->modulo);
 898             }
 899             break;
 900         }
 901
 902         case 24:
 903         {
 904             HIDDT_PixelFormat *pf;
 905             UBYTE *imdata = image->data;
 906             LONG x, y;
 907
 908             pf = BM_PIXFMT(bm);
 909
 910             for (y = 0; y < height; y++)
 911             {
 912
 913                 HIDDT_Pixel *p = buf;
 914
 915                 for (x = 0; x < width; x++)
 916                 {
 917                     register HIDDT_Pixel pix;
 918
 919                     pix = *p++;
 920 #if (AROS_BIG_ENDIAN == 1)
 921                     *imdata ++ = pix >> 16;
 922                     *imdata ++ = (pix & pf->green_mask) >> 8;
 923                     *imdata ++ = (pix & pf->blue_mask);
 924 #else
 925                     *imdata++ = (pix & pf->blue_mask);
 926                     *imdata++ = (pix & pf->green_mask) >> 8;
 927                     *imdata++ = pix >> 16;
 928 #endif
 929                 }
 930                 imdata += image->bytes_per_line - width * 3;
 931                 buf = (HIDDT_Pixel *) ((UBYTE *) buf + msg->modulo);
 932             }
 933             break;
 934         }
 935
 936         case 32:
 937         {
 938             ULONG *imdata = (ULONG *) image->data;
 939             LONG x, y;
 940
 941             for (y = 0; y < height; y++)
 942             {
 943                 HIDDT_Pixel *p = buf;
 944
 945                 for (x = 0; x < width; x++)
 946                 {
 947                     *imdata++ = (ULONG) *p++;
 948                 }
 949                 imdata += image->bytes_per_line / 4 - width;
 950                 buf = (HIDDT_Pixel *) ((UBYTE *) buf + msg->modulo);
 951             }
 952             break;
 953         }
 954
 955         default:
 956         {
 957             LONG x, y;
 958
 959             LOCK_X11
 960             for (y = 0; y < height; y++)
 961             {
 962                 HIDDT_Pixel *p;
 963
 964                 p = buf;
 965                 for (x = 0; x < width; x++)
 966                 {
 967                     XPutPixel(image, x, y, *p++);
 968                 }
 969                 buf = (HIDDT_Pixel *) ((UBYTE *) buf + msg->modulo);
 970             }
 971             UNLOCK_X11
 972             break;
 973         }
 974
 975         } /* switch (image->bits_per_pixel) */
 976
 977         break;
 978
 979     default:
 980     {
 981         OOP_Object *srcpf, *dstpf, *gfxhidd;
 982         APTR srcPixels = buf, dstBuf = image->data;
 983
 984         //bug("DEFAULT PIXEL CONVERSION\n");
 985
 986         OOP_GetAttr(bm, aHidd_BitMap_GfxHidd, (IPTR *) &gfxhidd);
 987         srcpf = HIDD_Gfx_GetPixFmt(gfxhidd, msg->pixFmt);
 988
 989         OOP_GetAttr(bm, aHidd_BitMap_PixFmt, (IPTR *) &dstpf);
 990
 991         //bug("CALLING ConvertPixels()\n");
 992
 993         HIDD_BM_ConvertPixels(bm, &srcPixels, (HIDDT_PixelFormat *) srcpf, msg->modulo, &dstBuf,
 994                 (HIDDT_PixelFormat *) dstpf, image->bytes_per_line, width, height, NULL); /* We have no CLUT */
 995
 996         //bug("CONVERTPIXELS DONE\n");
 997
 998         buf = (HIDDT_Pixel *) ((UBYTE *) buf + msg->modulo * height);
 999         break;
1000     }
1001
1002     } /* switch (msg->pixFmt) */
1003
1004     return buf;
1005 }
1006
1007 /****************************************************************************************/
1008
1009 static UBYTE *buf_to_ximage_lut(OOP_Class *cl, OOP_Object *bm, UBYTE *pixarray, XImage *image, ULONG width,
1010         ULONG height, ULONG depth, struct pHidd_BitMap_PutImageLUT *msg)
1011 {
1012     HIDDT_Pixel *lut = msg->pixlut->pixels;
1013
1014     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
1015
1016     switch (image->bits_per_pixel)
1017     {
1018     case 8:
1019     {
1020         UBYTE *imdata = (UBYTE *) image->data;
1021         LONG x, y;
1022
1023         for (y = 0; y < height; y++)
1024         {
1025             UBYTE *buf = pixarray;
1026
1027             for (x = 0; x < width; x++)
1028             {
1029                 *imdata++ = (UBYTE) lut[*buf++];
1030             }
1031             pixarray += msg->modulo;
1032             imdata += (image->bytes_per_line - width); /*sg*/
1033         }
1034         break;
1035     }
1036
1037     case 16:
1038     {
1039         UWORD *imdata = (UWORD *) image->data;
1040         LONG x, y;
1041
1042         for (y = 0; y < height; y++)
1043         {
1044             UBYTE *buf = pixarray;
1045
1046             for (x = 0; x < width; x++)
1047             {
1048                 *imdata++ = (UWORD) lut[*buf++];
1049             }
1050             pixarray += msg->modulo;
1051             imdata += ((image->bytes_per_line / 2) - width); /*sg*/
1052         }
1053         break;
1054     }
1055
1056     case 32:
1057     {
1058         ULONG *imdata = (ULONG *) image->data;
1059         LONG x, y;
1060
1061         for (y = 0; y < height; y++)
1062         {
1063             UBYTE *buf = pixarray;
1064
1065             for (x = 0; x < width; x++)
1066             {
1067                 *imdata++ = (ULONG) lut[*buf++];
1068
1069             }
1070             pixarray += msg->modulo;
1071             imdata += ((image->bytes_per_line / 4) - width); /*sg*/
1072         }
1073         break;
1074     }
1075
1076     default:
1077     {
1078         LONG x, y;
1079
1080         for (y = 0; y < height; y++)
1081         {
1082             UBYTE *buf = pixarray;
1083
1084             for (x = 0; x < width; x++)
1085             {
1086                 XPutPixel(image, x, y, lut[*buf++]);
1087             }
1088
1089             pixarray += msg->modulo;
1090
1091         }
1092         break;
1093
1094     }
1095
1096     } /* switch(image->bits_per_pixel) */
1097
1098     return pixarray;
1099 }
1100
1101 /****************************************************************************************/
1102
1103 #if USE_XSHM
1104
1105 /****************************************************************************************/
1106
1107 static void putimage_xshm(OOP_Class *cl, OOP_Object *o, OOP_Object *gc,
1108         LONG x, LONG y, ULONG width, ULONG height,
1109         APTR pixarray, APTR (*toimage_func)(), APTR toimage_data)
1110 {
1111
1112     struct bitmap_data *data;
1113     XImage *image;
1114     IPTR depth;
1115     ULONG lines_to_copy;
1116     LONG ysize;
1117     LONG current_y;
1118     LONG maxlines;
1119     OOP_Object *pf;
1120
1121     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
1122
1123     data = OOP_INST_DATA(cl, o);
1124
1125     OOP_GetAttr(o, aHidd_BitMap_PixFmt, (IPTR *)&pf);
1126     OOP_GetAttr(pf, aHidd_PixFmt_Depth, &depth);
1127
1128 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
1129
1130     LOCK_X11
1131     image = create_xshm_ximage(data->display,
1132             DefaultVisual(data->display, data->screen),
1133             depth,
1134             ZPixmap,
1135             width,
1136             height,
1137             XSD(cl)->xshm_info);
1138     UNLOCK_X11
1139
1140     if (!image)
1141         return;
1142
1143     /* Calculate how many scanline can be stored in the buffer */
1144     maxlines = XSHM_MEMSIZE / image->bytes_per_line;
1145
1146     if (0 == maxlines)
1147     {
1148         bug("ALERT !!! NOT ENOUGH MEMORY TO WRITE A COMPLETE SCANLINE\n");
1149         bug("THROUGH XSHM IN X11GF X HIDD !!!\n");
1150         Alert(AT_DeadEnd);
1151     }
1152
1153     current_y = 0;
1154     ysize = image->height;
1155
1156     ObtainSemaphore(&XSD(cl)->shm_sema);
1157
1158     while (ysize)
1159     {
1160         /* Get some more pixels from the HIDD */
1161
1162         lines_to_copy = MIN(maxlines, ysize);
1163
1164         ysize -= lines_to_copy;
1165         image->height = lines_to_copy;
1166
1167         pixarray = toimage_func(cl, o, pixarray, image, image->width,
1168                 lines_to_copy, depth, toimage_data);
1169
1170         LOCK_X11
1171         XCALL(XSetFunction, data->display, data->gc, GC_DRMD(gc));
1172
1173         put_xshm_ximage(data->display,
1174                 DRAWABLE(data),
1175                 data->gc,
1176                 image,
1177                 0, 0,
1178                 x, y + current_y,
1179                 image->width, lines_to_copy,
1180                 FALSE);
1181
1182         UNLOCK_X11
1183
1184         current_y += lines_to_copy;
1185
1186     } /* while (pixels left to copy) */
1187
1188     ReleaseSemaphore(&XSD(cl)->shm_sema);
1189
1190     LOCK_X11
1191     destroy_xshm_ximage(image);
1192     UNLOCK_X11
1193
1194     return;
1195
1196 }
1197
1198 /****************************************************************************************/
1199
1200 #endif
1201
1202 /****************************************************************************************/
1203
1204 static void putimage_xlib(OOP_Class *cl, OOP_Object *o, OOP_Object *gc, LONG x, LONG y, ULONG width, ULONG height,
1205         APTR pixarray, APTR(*toimage_func)(), APTR toimage_data)
1206 {
1207
1208     struct bitmap_data *data;
1209     XImage *image;
1210     ULONG bperline;
1211     IPTR depth;
1212     OOP_Object *pf;
1213
1214     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
1215
1216     data = OOP_INST_DATA(cl, o);
1217
1218     OOP_GetAttr(o, aHidd_BitMap_PixFmt, (IPTR *) &pf);
1219     OOP_GetAttr(pf, aHidd_PixFmt_Depth, &depth);
1220
1221     LOCK_X11
1222     image = XCALL(XCreateImage, data->display,
1223             DefaultVisual(data->display, data->screen),
1224             depth,
1225             ZPixmap,
1226             0,
1227             NULL,
1228             width,
1229             height,
1230             32,
1231             0);
1232     UNLOCK_X11
1233
1234     if (!image)
1235         return;
1236
1237 #if DO_ENDIAN_FIX
1238     if (NEEDS_ENDIAN_FIX(image))
1239     {
1240         image->byte_order = AROS_BYTEORDER;
1241
1242         LOCK_X11
1243         XCALL(XInitImage, image);
1244         UNLOCK_X11
1245     }
1246 #endif
1247
1248     bperline = image->bytes_per_line;
1249     image->data = (char *) AllocVec((size_t) height * bperline, MEMF_PUBLIC);
1250
1251     if (!image->data)
1252     {
1253         LOCK_X11
1254         XCALL(XFree, image);
1255         UNLOCK_X11
1256
1257         return;
1258     }
1259
1260     toimage_func(cl, o, pixarray, image, width, height, depth, toimage_data);
1261
1262     LOCK_X11
1263     XCALL(XSetFunction, data->display, data->gc, GC_DRMD(gc));
1264     XCALL( XPutImage, data->display, DRAWABLE(data), data->gc, image, 0, 0, x, y, width, height);
1265     UNLOCK_X11
1266
1267     FreeVec(image->data);
1268
1269     LOCK_X11
1270     XCALL(XFree, image);
1271     UNLOCK_X11
1272
1273 }
1274
1275 /****************************************************************************************/
1276
1277 VOID MNAME(Hidd_BitMap__PutImage)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutImage *msg)
1278 {
1279     D(bug("[X11Bm] %s(pa=%p, x=%d, y=%d, w=%d, h=%d)\n", __PRETTY_FUNCTION__, msg->pixels, msg->x, msg->y, msg->width,
1280                     msg->height));
1281
1282 #if USE_XSHM
1283     if (XSD(cl)->use_xshm)
1284     {
1285         putimage_xshm(cl, o, msg->gc, msg->x, msg->y,
1286                 msg->width, msg->height, msg->pixels,
1287                 (APTR (*)()) buf_to_ximage, msg);
1288     }
1289     else
1290 #endif
1291     {
1292         putimage_xlib(cl, o, msg->gc, msg->x, msg->y, msg->width, msg->height, msg->pixels, (APTR(*)()) buf_to_ximage, msg);
1293     }
1294 }
1295
1296 /****************************************************************************************/
1297
1298 VOID MNAME(Hidd_BitMap__PutImageLUT)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutImageLUT *msg)
1299 {
1300     D(bug("[X11Bm] %s(pa=%p, x=%d, y=%d, w=%d, h=%d)\n", __PRETTY_FUNCTION__, msg->pixels, msg->x, msg->y, msg->width,
1301                     msg->height));
1302
1303 #if USE_XSHM
1304     if (XSD(cl)->use_xshm)
1305     {
1306         putimage_xshm(cl, o, msg->gc, msg->x, msg->y,
1307                 msg->width, msg->height, msg->pixels,
1308                 (APTR (*)())buf_to_ximage_lut, msg);
1309     }
1310     else
1311 #endif
1312     {
1313         putimage_xlib(cl, o, msg->gc, msg->x, msg->y, msg->width, msg->height, msg->pixels, (APTR(*)()) buf_to_ximage_lut, msg);
1314     }
1315 }
1316
1317 /****************************************************************************************/
1318
1319 VOID MNAME(Root__Get)(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
1320 {
1321     struct bitmap_data *data = OOP_INST_DATA(cl, o);
1322     ULONG idx;
1323
1324     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
1325
1326     if (IS_X11BM_ATTR(msg->attrID, idx))
1327     {
1328         switch (idx)
1329         {
1330         case aoHidd_X11BitMap_Drawable:
1331             *msg->storage = (IPTR) DRAWABLE(data);
1332             return;
1333
1334         case aoHidd_X11BitMap_GC:
1335             *msg->storage = (IPTR) data->gc;
1336             return;
1337         }
1338     }
1339
1340     OOP_DoSuperMethod(cl, o, &msg->mID);
1341 }
1342
1343 /****************************************************************************************/
1344
1345 BOOL X11BM__Root__Set(OOP_Class *cl, OOP_Object *o, struct pRoot_Set *msg)
1346 {
1347     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
1348
1349 #if ADJUST_XWIN_SIZE
1350     /* This provides support for framebuffer display mode switching */
1351     struct bitmap_data *data = OOP_INST_DATA(cl, o);
1352
1353     if (data->flags & BMDF_FRAMEBUFFER)
1354     {
1355         struct TagItem *tag = FindTagItem(aHidd_BitMap_ModeID, msg->attrList);
1356
1357         if (tag)
1358         {
1359             if (!X11BM_SetMode(data, tag->ti_Data, XSD(cl)))
1360             {
1361                 /* Bail out if error happened, see aoHidd_BitMap_ModeID documentation */
1362                 return FALSE;
1363             }
1364         }
1365     }
1366 #endif
1367     return OOP_DoSuperMethod(cl, o, &msg->mID);
1368 }
1369
1370 /****************************************************************************************/
1371
1372 VOID MNAME(Hidd_BitMap__DrawLine)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawLine *msg)
1373 {
1374     struct bitmap_data *data = OOP_INST_DATA(cl, o);
1375     OOP_Object *gc = msg->gc;
1376
1377     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
1378
1379     if (GC_LINEPAT(gc) != (UWORD) ~0)
1380     {
1381         OOP_DoSuperMethod(cl, o, (OOP_Msg) msg);
1382
1383         return;
1384     }
1385
1386     LOCK_X11
1387
1388     if (GC_DOCLIP(gc))
1389     {
1390         XRectangle cr;
1391
1392         cr.x = GC_CLIPX1(gc);
1393         cr.y = GC_CLIPY1(gc);
1394         cr.width = GC_CLIPX2(gc) - cr.x + 1;
1395         cr.height = GC_CLIPY2(gc) - cr.y + 1;
1396
1397         XCALL(XSetClipRectangles, data->display, data->gc, 0, 0, &cr, 1, Unsorted);
1398     }
1399
1400     XCALL(XSetForeground, data->display, data->gc, GC_FG(gc));
1401     XCALL(XSetFunction, data->display, data->gc, GC_DRMD(gc));
1402
1403     XCALL( XDrawLine, data->display, DRAWABLE(data), data->gc, msg->x1, msg->y1, msg->x2, msg->y2);
1404
1405     if (GC_DOCLIP(gc))
1406     {
1407         XCALL(XSetClipMask, data->display, data->gc, None);
1408     }
1409
1410     UNLOCK_X11
1411 }
1412
1413 /****************************************************************************************/
1414
1415 VOID MNAME(Hidd_BitMap__DrawEllipse)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawEllipse *msg)
1416 {
1417     struct bitmap_data *data = OOP_INST_DATA(cl, o);
1418     OOP_Object *gc = msg->gc;
1419
1420     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
1421
1422     LOCK_X11
1423
1424     if (GC_DOCLIP(gc))
1425     {
1426         XRectangle cr;
1427
1428         /* bug("X11::Drawllipse: clip %d %d %d %d\n"
1429          , GC_CLIPX1(gc), GC_CLIPY1(gc), GC_CLIPX2(gc), GC_CLIPY2(gc));
1430          */
1431
1432         cr.x = GC_CLIPX1(gc);
1433         cr.y = GC_CLIPY1(gc);
1434         cr.width = GC_CLIPX2(gc) - cr.x + 1;
1435         cr.height = GC_CLIPY2(gc) - cr.y + 1;
1436
1437         XCALL(XSetClipRectangles, data->display, data->gc, 0, 0, &cr, 1, Unsorted);
1438     }
1439
1440     XCALL(XSetForeground, data->display, data->gc, GC_FG(gc));
1441     XCALL(XSetFunction, data->display, data->gc, GC_DRMD(gc));
1442
1443     /* bug("X11::Drawllipse: coord %d %d %d %d\n"
1444      , msg->x, msg->y, msg->rx, msg->ry);
1445
1446      */
1447
1448     XCALL(XDrawArc, data->display, DRAWABLE(data), data->gc, msg->x - msg->rx, msg->y - msg->ry, msg->rx * 2, msg->ry * 2, 0, 360 * 64);
1449
1450     if (GC_DOCLIP(gc))
1451     {
1452         XCALL(XSetClipMask, data->display, data->gc, None);
1453     }
1454
1455     UNLOCK_X11
1456 }
1457
1458 /****************************************************************************************/
1459
1460 VOID MNAME(Hidd_BitMap__UpdateRect)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_UpdateRect *msg)
1461 {
1462     struct bitmap_data *data = OOP_INST_DATA(cl, o);
1463
1464     D(bug("[X11Bm] %s()\n", __PRETTY_FUNCTION__));
1465
1466     LOCK_X11
1467
1468     if (data->flags & BMDF_FRAMEBUFFER)
1469         X11BM_ExposeFB(data, msg->x, msg->y, msg->width, msg->height);
1470
1471     XCALL(XFlush, data->display);
1472
1473     UNLOCK_X11
1474 }