arch/all-x11/hidd/bitmap_common.c

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