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

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