The Ecere SDK - sdk/blob - ecere/src/gfx/drivers/XDisplayDriver.ec

   1 namespace gfx::drivers;
   2
   3 import "instance"
   4
   5 #if (defined(__unix__) || defined(__APPLE__)) && !defined(ECERE_MINIGLX)
   6
   7 default:
   8
   9 #define property _property
  10 #define new _new
  11 #define class _class
  12 #define uint _uint
  13
  14 #define Window    X11Window
  15 #define Cursor    X11Cursor
  16 #define Font      X11Font
  17 #define Display   X11Display
  18 #define Time      X11Time
  19 #define KeyCode   X11KeyCode
  20 #define Picture   X11Picture
  21
  22 #include <X11/Xlib.h>
  23 #include <X11/Xutil.h>
  24 #include <X11/extensions/shape.h>
  25 #include <X11/extensions/Xrender.h>
  26 #include <X11/extensions/XShm.h>
  27 #include <sys/ipc.h>
  28 #include <sys/shm.h>
  29
  30 #undef Window
  31 #undef Cursor
  32 #undef Font
  33 #undef Display
  34 #undef Time
  35 #undef KeyCode
  36 #undef Picture
  37
  38 #undef uint
  39 #undef new
  40 #undef property
  41 #undef class
  42
  43 private:
  44
  45 import "Display"
  46 import "XInterface"
  47
  48 /*
  49 static byte defaultRGBLookup[32768];
  50 bool rgbLookupSet = false;
  51 */
  52 class XDisplay : LFBDisplay //struct
  53 {
  54    Pixmap pixmap;
  55    Pixmap shapePixmap;
  56    GC windowGC, gc;
  57    Point offset;
  58    Box updateBox;
  59    X11Picture picture;
  60    X11Picture shapePicture;
  61    XShmSegmentInfo shminfo;
  62    XImage * image;
  63    XShmSegmentInfo shminfoShape;
  64    XImage * shapeImage;
  65 };
  66
  67 class XSurface : struct
  68 {
  69    Font font;
  70    bool opaqueText;
  71    int xOffset;
  72    bool writingText;
  73
  74    ColorAlpha foreground, background;
  75    bool opaque;
  76    bool clipped;
  77    Pixmap pixmap;
  78    X11Picture picture;
  79    X11Picture colorPicture;
  80    Pixmap colorPixmap;
  81 };
  82
  83 class XBitmap : struct
  84 {
  85    Pixmap pixmap;
  86    Pixmap mask;
  87    X11Picture picture;
  88    X11Picture maskPicture;
  89 };
  90
  91 XRenderPictFormat * GetXRenderFormat(PixelFormat pixelFormat, bool alphaBlend)
  92 {
  93    XRenderPictFormat * format = null;
  94    switch(pixelFormat)
  95    {
  96       case pixelFormatAlpha:
  97          format = XRenderFindStandardFormat(xGlobalDisplay, PictStandardA8);
  98          break;
  99       case pixelFormat888:
 100          format = XRenderFindStandardFormat(xGlobalDisplay, alphaBlend ? PictStandardARGB32 : PictStandardRGB24);
 101          // printf("R: %d G: %d B: %d\n", format->direct.red, format->direct.green, format->direct.blue);
 102          break;
 103       case pixelFormat555:
 104       {
 105          XRenderPictFormat info = { 0 };
 106
 107          info.depth = 16;
 108          info.type = PictTypeDirect;
 109          info.direct.red = 10;
 110          info.direct.green = 5;
 111          info.direct.blue = 0;
 112          info.direct.redMask   = 0x1F;
 113          info.direct.greenMask = 0x1F;
 114          info.direct.blueMask  = 0x1F;
 115
 116          format = XRenderFindFormat(xGlobalDisplay,
 117             /*PictFormatDepth|*/PictFormatType| PictFormatAlpha|PictFormatRed|PictFormatGreen|PictFormatBlue|
 118             PictFormatRedMask|PictFormatGreenMask|PictFormatBlueMask|PictFormatAlphaMask, &info, 0);
 119          break;
 120       }
 121       case pixelFormat565:
 122       {
 123          XRenderPictFormat info = { 0 };
 124
 125          info.depth = 16;
 126          info.type = PictTypeDirect;
 127          info.direct.alpha = 0;
 128          info.direct.red = 11;
 129          info.direct.green = 5;
 130          info.direct.blue = 0;
 131          info.direct.redMask   = 0x1F;
 132          info.direct.greenMask = 0x3F;
 133          info.direct.blueMask  = 0x1F;
 134          info.direct.alphaMask = 0;
 135          info.id = 0xba;
 136
 137          format = XRenderFindFormat(xGlobalDisplay,
 138             /*PictFormatDepth|*/PictFormatType|PictFormatAlpha|PictFormatRed|PictFormatGreen|PictFormatBlue|
 139             PictFormatRedMask|PictFormatGreenMask|PictFormatBlueMask|PictFormatAlphaMask, &info, 0);
 140          break;
 141       }
 142    }
 143    return format;
 144 }
 145
 146 static bool ClipBlitCoords(Surface surface, Bitmap src, int *dx, int *dy, int *sx, int *sy, int *w, int *h, bool * flip)
 147 {
 148    *flip = false;
 149
 150    if(surface.box.right < surface.box.left || surface.box.bottom < surface.box.top) return false;
 151
 152    if(*w < 0) { *w = -*w; *flip = true; }
 153
 154    //Clip against the edges of the source
 155    if(*sx<0)
 156    {
 157       *dx+=-*sx;
 158       *w-=-*sx;
 159       *sx=0;
 160    }
 161    if(*sy<0)
 162    {
 163       *dy+=0-*sy;
 164       *h-=0-*sy;
 165       *sy=0;
 166    }
 167    if(*sx+*w>src.width-1)
 168       *w-=*sx+*w-(src.width-1)-1;
 169    if(*sy+*h>src.height-1)
 170       *h-=*sy+*h-(src.height-1)-1;
 171    //Clip against the edges of the destination
 172    if(*dx<surface.box.left)
 173    {
 174       if(!*flip) *sx+=surface.box.left-*dx;
 175       *w-=surface.box.left-*dx;
 176       *dx=surface.box.left;
 177    }
 178    if(*dy<surface.box.top)
 179    {
 180       *sy+=surface.box.top-*dy;
 181       *h-=surface.box.top-*dy;
 182       *dy=surface.box.top;
 183    }
 184    if((*dx+*w)>surface.box.right)
 185    {
 186       if(*flip) *sx+=(uint)(*dx+*w)-surface.box.right-1;
 187       *w-=((uint)(*dx+*w)-surface.box.right-1);
 188    }
 189    if((*dy+*h)>surface.box.bottom)
 190       *h-=((*dy+*h)-surface.box.bottom-1);
 191    if((*w<=0)||(*h<=0))
 192       return false;
 193    return true;
 194 }
 195
 196 static bool ClipStretchCoords(Surface surface, Bitmap src, int *dx, int *dy, int *sx, int *sy, int *w, int *h, int *sw, int *sh, bool * flip)
 197 {
 198    float s2dw,s2dh,d2sw,d2sh;
 199    *flip = false;
 200
 201    if(surface.box.right < surface.box.left || surface.box.bottom < surface.box.top || !src.picture) return false;
 202
 203    if(Sgn(*w) != Sgn(*sw))
 204    {
 205       *w = Abs(*w);
 206       *sw = Abs(*sw);
 207       *flip = true;
 208    }
 209
 210    s2dw=(float)*w / *sw;
 211    s2dh=(float)*h / *sh;
 212    d2sw=(float)*sw / *w;
 213    d2sh=(float)*sh / *h;
 214
 215    //Clip against the edges of the source
 216    if(*sx < 0)
 217    {
 218       *dx += (int)((0-*sx) * s2dw);
 219       *w -= (int)((0-*sx) * s2dw);
 220       *sw -= 0-*sx;
 221       *sx=0;
 222    }
 223    if(*sy < 0)
 224    {
 225       *dy += (int)((0-*sy) * s2dh);
 226       *h -= (int)((0-*sy) * s2dh);
 227
 228       *sh -= 0-*sy;
 229       *sy=0;
 230    }
 231    if(*sx+*sw>src.width-1)
 232    {
 233       *w-=(int)((*sx+*sw-(src.width-1)-1)*s2dw);
 234       *sw-=*sx+*sw-(src.width-1)-1;
 235    }
 236    if(*sy+*sh>(src.height-1))
 237    {
 238       *h-=(int)((*sy+*sh-(src.height-1)-1)*s2dh);
 239       *sh-=*sy+*sh-(src.height-1)-1;
 240    }
 241    //Clip against the edges of the destination
 242    if(*dx < surface.box.left)
 243    {
 244       if(!*flip) *sx += (int)((surface.box.left-*dx)*d2sw);
 245       *sw-=(int)((surface.box.left-*dx)*d2sw);
 246       *w-=surface.box.left-*dx;
 247       *dx=surface.box.left;
 248    }
 249    if(*dy < surface.box.top)
 250    {
 251       *sy += (int)((surface.box.top-*dy)*d2sh);
 252       *sh -= (int)((surface.box.top-*dy)*d2sh);
 253       *h -= surface.box.top-*dy;
 254       *dy =surface.box.top;
 255    }
 256    if((*dx+*w)>surface.box.right)
 257    {
 258       if(*flip) *sx+=(int)(((*dx+*w)-surface.box.right-1)*d2sw);
 259       *sw-=(int)(((*dx + *w)-surface.box.right-1)*d2sw);
 260       *w-=((*dx+*w)-surface.box.right-1);
 261    }
 262    if((*dy+*h)>surface.box.bottom)
 263    {
 264       *sh-=(int)(((*dy+*h)-surface.box.bottom-1)*d2sh);
 265       *h-=((*dy+*h)-surface.box.bottom-1);
 266    }
 267    if((*w<=0)||(*h<=0)||(*sw<=0)||(*sh<=0))
 268       return false;
 269    return true;
 270 }
 271
 272 static void PutBitmapMask(Pixmap mask, Bitmap bitmap) {
 273    XImage image = {0};
 274    GC maskGC = XCreateGC(xGlobalDisplay, mask, 0, null);
 275    uint wordWidth = (bitmap.width+31) >> 5;
 276
 277    uint x,y;
 278    uint32 *b = new0 uint32[wordWidth * bitmap.height];
 279    uint32 f = 1;
 280
 281    XSetGraphicsExposures(xGlobalDisplay, maskGC, False);
 282
 283    image.width = bitmap.width;
 284    image.height = bitmap.height;
 285
 286    image.format = XYBitmap;
 287    #ifdef __BIG_ENDIAN__
 288    image.byte_order = MSBFirst;
 289    #else
 290    image.byte_order = LSBFirst;
 291    #endif
 292    image.bitmap_unit = 32;
 293    image.bitmap_bit_order = LSBFirst;
 294    image.bitmap_pad = 32;
 295    image.depth = 1;
 296    image.bytes_per_line = wordWidth << 2;
 297
 298    image.data = (char*)b;
 299
 300    XInitImage(&image);
 301
 302    switch(bitmap.pixelFormat) {
 303       case pixelFormat4: {
 304
 305       } break;
 306       case pixelFormat8: {
 307          byte *p = (byte*)bitmap.picture;
 308
 309          for(y = 0; y<bitmap.height; y++, p+=bitmap.stride) {
 310             for(x = 0; x<bitmap.width; x++) {
 311                if(p[x])
 312                   *b |= f; //XPutPixel(&image, x,y, 1);
 313                if (!(f<<=1))
 314                   b++, f=1;
 315             }
 316             if (f != 1)
 317                b++, f=1;
 318          }
 319       } break;
 320       case pixelFormat444:
 321       case pixelFormat555:
 322       case pixelFormat565: {
 323          uint16 *p = (uint16*)bitmap.picture;
 324 #ifdef _DEBUG
 325          PrintLn(bitmap.pixelFormat);
 326 #endif
 327          for(y = 0; y<bitmap.height; y++, p+=bitmap.stride) {
 328             for(x = 0; x<bitmap.width; x++) {
 329                if(p[x])
 330                   *b |= f; //XPutPixel(&image, x,y, 1);
 331                if (!(f<<=1))
 332                   b++, f=1;
 333             }
 334             if (f != 1)
 335                b++, f=1;
 336          }
 337       } break;
 338       case pixelFormat888: {
 339          ColorAlpha *p = (ColorAlpha*)bitmap.picture;
 340          for(y = 0; y<bitmap.height; y++, p+=bitmap.stride) {
 341             for(x = 0; x<bitmap.width; x++) {
 342                if(p[x].a)
 343                   *b |= f; //XPutPixel(&image, x,y, 1);
 344                if (!(f<<=1))
 345                   b++, f=1;
 346             }
 347             if (f != 1)
 348                b++, f=1;
 349          }
 350       } break;
 351       case pixelFormatAlpha: {
 352
 353       } break;
 354       case pixelFormatText: {
 355
 356       } break;
 357       case pixelFormatRGBA: {
 358
 359       } break;
 360    }
 361
 362    XSetForeground(xGlobalDisplay, maskGC, 1);
 363    XSetBackground(xGlobalDisplay, maskGC, 0);
 364
 365    XPutImage(xGlobalDisplay, mask, maskGC, &image,
 366       0, 0, 0, 0, //coordinates
 367       bitmap.width, bitmap.height);
 368
 369    XFreeGC(xGlobalDisplay, maskGC);
 370    delete image.data;
 371 }
 372
 373 class XDisplayDriver : DisplayDriver
 374 {
 375    class_property(name) = "X";
 376
 377    bool CreateDisplaySystem(DisplaySystem displaySystem)
 378    {
 379       //displaySystem.driverData = calloc(1, sizeof(LFBSystem));
 380       displaySystem.flags.memBackBuffer = true;
 381       displaySystem.pixelFormat = xSystemPixelFormat;
 382       return true;
 383    }
 384
 385    void DestroyDisplaySystem(DisplaySystem displaySystem)
 386    {
 387       // delete displaySystem.driverData;
 388    }
 389
 390    void DestroyDisplay(Display display)
 391    {
 392       XDisplay xDisplay = display.driverData;
 393
 394       // Free Shared Memory Pixmap
 395       if(xDisplay.shapePixmap)
 396          XFreePixmap(xGlobalDisplay, xDisplay.shapePixmap);
 397       if(xDisplay.pixmap)
 398          XFreePixmap(xGlobalDisplay, xDisplay.pixmap);
 399       if(xDisplay.image)
 400       {
 401          if(xDisplay.shminfoShape.shmid != -1)
 402          {
 403             XShmDetach(xGlobalDisplay, &xDisplay.shminfo);
 404             if(xDisplay.shminfo.shmaddr != (void *)-1)
 405                shmdt(xDisplay.shminfo.shmaddr);
 406             shmctl(xDisplay.shminfo.shmid, IPC_RMID, 0);
 407          }
 408       }
 409       if(xDisplay.shapeImage)
 410       {
 411          if(xDisplay.shminfoShape.shmid != -1)
 412          {
 413             XShmDetach(xGlobalDisplay, &xDisplay.shminfoShape);
 414             if(xDisplay.shminfoShape.shmaddr != (void *)-1)
 415                shmdt(xDisplay.shminfoShape.shmaddr);
 416             shmctl(xDisplay.shminfoShape.shmid, IPC_RMID, 0);
 417          }
 418          XDestroyImage(xDisplay.shapeImage);
 419          xDisplay.shapeImage = None;
 420       }
 421       if(xDisplay.picture)
 422          XRenderFreePicture(xGlobalDisplay, xDisplay.picture);
 423       if(xDisplay.shapePicture)
 424          XRenderFreePicture(xGlobalDisplay, xDisplay.picture);
 425       if(xDisplay.windowGC)
 426          XFreeGC(xGlobalDisplay, xDisplay.windowGC);
 427       if(xDisplay.gc)
 428          XFreeGC(xGlobalDisplay, xDisplay.gc);
 429       delete xDisplay;
 430       display.driverData = null;
 431    }
 432
 433    void SetPalette(Display display, ColorAlpha * palette, bool colorMatch)
 434    {
 435
 436
 437    }
 438
 439    bool CreateDisplay(Display display)
 440    {
 441       bool result = false;
 442       XDisplay xDisplay = display.driverData = XDisplay { };
 443
 444       if(display)
 445       {
 446          xDisplay.windowGC = XCreateGC(xGlobalDisplay, (X11Window)display.window, 0, null);
 447          XSetGraphicsExposures(xGlobalDisplay, xDisplay.windowGC, False);
 448          result = true;
 449       }
 450       return result;
 451    }
 452
 453    bool DisplaySize(Display display, int width, int height)
 454    {
 455       XDisplay xDisplay = display.driverData;
 456       bool result = false;
 457
 458       if(width > display.width || height > display.height)
 459       {
 460          display.width = width;
 461          display.height = height;
 462
 463          if(xDisplay.picture)
 464             XRenderFreePicture(xGlobalDisplay, xDisplay.picture);
 465
 466          {
 467             XRenderPictureAttributes attributes = { 0 };
 468             XRenderPictFormat * format = GetXRenderFormat(xSystemPixelFormat, display.alphaBlend);
 469             attributes.component_alpha = 1;
 470             attributes.poly_mode = PolyModeImprecise;
 471             attributes.poly_edge = PolyEdgeSmooth;
 472
 473             if(xDisplay.pixmap)
 474             {
 475                XFreePixmap(xGlobalDisplay, xDisplay.pixmap);
 476                xDisplay.pixmap = None;
 477             }
 478             if(xDisplay.shapePixmap)
 479             {
 480                XFreePixmap(xGlobalDisplay, xDisplay.shapePixmap);
 481                xDisplay.shapePixmap = None;
 482             }
 483
 484             // Free Shared Memory Pixmap
 485             if(xDisplay.image)
 486             {
 487                if(xDisplay.shminfoShape.shmid != -1)
 488                {
 489                   XShmDetach(xGlobalDisplay, &xDisplay.shminfo);
 490                   if(xDisplay.shminfo.shmaddr != (void *)-1)
 491                      shmdt(xDisplay.shminfo.shmaddr);
 492                   shmctl(xDisplay.shminfo.shmid, IPC_RMID, 0);
 493                }
 494                XDestroyImage(xDisplay.image);
 495                xDisplay.image = None;
 496             }
 497             if(xDisplay.shapeImage)
 498             {
 499                if(xDisplay.shminfoShape.shmid != -1)
 500                {
 501                   XShmDetach(xGlobalDisplay, &xDisplay.shminfoShape);
 502                   if(xDisplay.shminfoShape.shmaddr != (void *)-1)
 503                      shmdt(xDisplay.shminfoShape.shmaddr);
 504                   shmctl(xDisplay.shminfoShape.shmid, IPC_RMID, 0);
 505                }
 506                XDestroyImage(xDisplay.shapeImage);
 507                xDisplay.shapeImage = None;
 508             }
 509
 510             // Initialize Shared Memory Pixmap
 511 #ifdef __linux__
 512             if(xSharedMemory && display.useSharedMemory && format)
 513             {
 514 #ifdef _DEBUG
 515                printf("Using shared memory!\n");
 516 #endif
 517                xDisplay.image = XShmCreateImage(xGlobalDisplay, xSystemVisual /*DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay))*/,
 518                   format->depth, ZPixmap, null, &xDisplay.shminfo, width, height);
 519             }
 520             else if(display.useSharedMemory && !xSharedMemory)
 521                printf("%s", $"Error: Requested shared memory but shared memory pixmaps are not supported by X server.\n");
 522 #endif
 523             if(xDisplay.image)
 524             {
 525                memset(&xDisplay.shminfo, 0, sizeof(XShmSegmentInfo));
 526                // printf("shmget: %d\n", xDisplay.image->bytes_per_line * xDisplay.image->height);
 527                xDisplay.shminfo.shmid = shmget(IPC_PRIVATE, xDisplay.image->bytes_per_line * xDisplay.image->height, IPC_CREAT|0777);
 528                if(xDisplay.shminfo.shmid != -1)
 529                {
 530                   xDisplay.shminfo.shmaddr = shmat(xDisplay.shminfo.shmid, 0, 0);
 531                   if(xDisplay.shminfo.shmaddr != (void *)-1)
 532                   {
 533                      // printf("%d,  %d\n", xDisplay.shminfo.shmid, xDisplay.shminfo.shmaddr);
 534                      xDisplay.shminfo.readOnly = False;
 535                      if(XShmAttach(xGlobalDisplay, &xDisplay.shminfo))
 536                      {
 537                         xDisplay.pixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, xDisplay.shminfo.shmaddr, &xDisplay.shminfo, width, height, format->depth);
 538
 539                         xDisplay.bitmap.width = width;
 540                         xDisplay.bitmap.height = height;
 541                         xDisplay.bitmap.stride = xDisplay.image->bytes_per_line >> GetColorDepthShifts(display.pixelFormat);
 542                         xDisplay.bitmap.pixelFormat = display.pixelFormat;
 543                         xDisplay.bitmap.picture = (byte *)xDisplay.shminfo.shmaddr;
 544                         xDisplay.bitmap.size = width * height;
 545                         xDisplay.bitmap.sizeBytes = (uint)xDisplay.bitmap.size << GetColorDepthShifts(display.pixelFormat);
 546                      }
 547                   }
 548                }
 549                if(!xDisplay.pixmap)
 550                {
 551                   if(xDisplay.shminfo.shmid != -1)
 552                   {
 553                      XShmDetach(xGlobalDisplay, &xDisplay.shminfo);
 554                      if(xDisplay.shminfo.shmaddr != (void *)-1)
 555                         shmdt(xDisplay.shminfo.shmaddr);
 556                      shmctl(xDisplay.shminfo.shmid, IPC_RMID, 0);
 557                   }
 558                   XDestroyImage(xDisplay.image);
 559                   xDisplay.image = None;
 560                }
 561             }
 562
 563 #ifdef __linux__
 564             // Initialize Shared Memory Shape Pixmap
 565             if(xSharedMemory && display.useSharedMemory && display.alphaBlend)
 566                xDisplay.shapeImage = XShmCreateImage(xGlobalDisplay, xSystemVisual /*DefaultVisual(xGlobalDisplay, DefaultScreen(xGlobalDisplay))*/,
 567                   1, ZPixmap, null, &xDisplay.shminfoShape, width, height);
 568 #endif
 569             if(xDisplay.shapeImage)
 570             {
 571                xDisplay.shminfoShape.shmid = shmget(IPC_PRIVATE, xDisplay.shapeImage->bytes_per_line * xDisplay.shapeImage->height, IPC_CREAT|0777);
 572                if(xDisplay.shminfoShape.shmid != -1)
 573                {
 574                   xDisplay.shminfoShape.shmaddr = shmat(xDisplay.shminfoShape.shmid, 0, 0);
 575                   if(xDisplay.shminfoShape.shmaddr != (void *)-1)
 576                   {
 577                      xDisplay.shminfoShape.readOnly = False;
 578                      if(XShmAttach(xGlobalDisplay, &xDisplay.shminfoShape))
 579                      {
 580                         xDisplay.shapePixmap = XShmCreatePixmap(xGlobalDisplay, (X11Window)display.window, xDisplay.shminfoShape.shmaddr, &xDisplay.shminfoShape, width, height, 1);
 581                      }
 582                   }
 583                }
 584                if(!xDisplay.shapePixmap)
 585                {
 586                   if(xDisplay.shminfoShape.shmid != -1)
 587                   {
 588                      XShmDetach(xGlobalDisplay, &xDisplay.shminfoShape);
 589                      if(xDisplay.shminfoShape.shmaddr != (void *)-1)
 590                         shmdt(xDisplay.shminfoShape.shmaddr);
 591                      shmctl(xDisplay.shminfoShape.shmid, IPC_RMID, 0);
 592                   }
 593                   XDestroyImage(xDisplay.shapeImage);
 594                   xDisplay.shapeImage = None;
 595                }
 596             }
 597
 598             if(!xDisplay.pixmap && format)
 599                xDisplay.pixmap = XCreatePixmap(xGlobalDisplay, (X11Window)display.window, width, height, format->depth);
 600             if(display.alphaBlend && !xDisplay.shapePixmap)
 601                xDisplay.shapePixmap = XCreatePixmap(xGlobalDisplay, (X11Window)display.window, width, height, 1);
 602             if(!xDisplay.gc)
 603             {
 604                xDisplay.gc = XCreateGC(xGlobalDisplay, (Pixmap)xDisplay.pixmap, 0, null);
 605                XSetGraphicsExposures(xGlobalDisplay, xDisplay.gc, False);
 606             }
 607
 608             if(format)
 609                xDisplay.picture = XRenderCreatePicture(xGlobalDisplay, xDisplay.pixmap, format, CPComponentAlpha, &attributes);
 610
 611             if(display.alphaBlend)
 612                xDisplay.shapePicture = XRenderCreatePicture(xGlobalDisplay, xDisplay.shapePixmap, XRenderFindStandardFormat(xGlobalDisplay, PictStandardA1), 0, &attributes);
 613          }
 614       }
 615       xDisplay.updateBox.left = display.width;
 616       xDisplay.updateBox.top = display.height;
 617       xDisplay.updateBox.right = 0;
 618       xDisplay.updateBox.bottom = 0;
 619
 620       result = true;
 621       return result;
 622    }
 623
 624    void DisplayPosition(Display display, int x, int y)
 625    {
 626       XDisplay xDisplay = display.driverData;
 627       xDisplay.offset.x = x;
 628       xDisplay.offset.y = y;
 629    }
 630
 631    void RestorePalette(Display display)
 632    {
 633
 634    }
 635
 636    void FreeBitmap(DisplaySystem displaySystem, Bitmap bitmap)
 637    {
 638       XBitmap xBitmap = bitmap.driverData;
 639       if(xBitmap)
 640       {
 641          if(xBitmap.pixmap)
 642             XFreePixmap(xGlobalDisplay, xBitmap.pixmap);
 643          if(xBitmap.mask)
 644             XFreePixmap(xGlobalDisplay, xBitmap.mask);
 645          if(xBitmap.picture)
 646             XRenderFreePicture(xGlobalDisplay, xBitmap.picture);
 647          if(xBitmap.maskPicture)
 648             XRenderFreePicture(xGlobalDisplay, xBitmap.maskPicture);
 649          delete xBitmap;
 650          bitmap.driverData = null;
 651       }
 652       ((subclass(DisplayDriver))class(LFBDisplayDriver)).FreeBitmap(displaySystem, bitmap);
 653    }
 654
 655    bool MakeDDBitmap(DisplaySystem displaySystem, Bitmap bitmap, bool mipMaps)
 656    {
 657       //XDisplay xDisplay = display.driverData;
 658       XBitmap xBitmap { };
 659       XImage image = { 0 };
 660       GC gc = 0;
 661
 662       if(bitmap.pixelFormat != pixelFormatAlpha)
 663          bitmap.Convert(null, bitmap.alphaBlend ? pixelFormat888 : xSystemPixelFormat, null);
 664
 665       //bitmap.Convert(null, pixelFormatRGBA, null);
 666       //bitmap.Convert(null, pixelFormat888, null);
 667       xBitmap.pixmap =
 668          XCreatePixmap(xGlobalDisplay, confineWindow /*(X11Window)display.window*/, bitmap.width, bitmap.height,
 669             (bitmap.pixelFormat == pixelFormatAlpha) ? 8 : (bitmap.alphaBlend ? 32 : ((bitmap.pixelFormat == pixelFormat888) ? 24 : xSystemDepth)));
 670       if(bitmap.transparent)
 671          xBitmap.mask =
 672             XCreatePixmap(xGlobalDisplay, confineWindow /*(X11Window)display.window*/, bitmap.width, bitmap.height, 1);
 673
 674       {
 675          XRenderPictureAttributes attributes = { 0 };
 676          XRenderPictFormat * format = GetXRenderFormat(bitmap.pixelFormat, bitmap.alphaBlend);
 677          attributes.component_alpha = 1;
 678
 679          if(format)
 680             xBitmap.picture = XRenderCreatePicture(xGlobalDisplay, xBitmap.pixmap, format, CPComponentAlpha, &attributes);
 681          if(bitmap.transparent && bitmap.pixelFormat != pixelFormatAlpha)
 682             xBitmap.maskPicture = XRenderCreatePicture(xGlobalDisplay, xBitmap.mask, XRenderFindStandardFormat(xGlobalDisplay, PictStandardA1), CPComponentAlpha, &attributes);
 683       }
 684
 685       gc = XCreateGC(xGlobalDisplay, (Pixmap)xBitmap.pixmap, 0, null);
 686
 687       XSetGraphicsExposures(xGlobalDisplay, gc, False);
 688
 689       image.width = bitmap.width;
 690       image.height = bitmap.height;
 691
 692       if(bitmap.pixelFormat == pixelFormatAlpha)
 693       {
 694          image.depth = 8;
 695          image.bitmap_pad = 8;
 696          image.bytes_per_line = bitmap.stride;
 697          image.bits_per_pixel = 8;
 698       }
 699       else
 700       {
 701          image.depth = bitmap.alphaBlend ? 32 : ((bitmap.pixelFormat == pixelFormat888) ? 24 : xSystemDepth);
 702          image.bitmap_pad = (bitmap.pixelFormat == pixelFormat888) ? 32 : 16;
 703          image.bytes_per_line = ((bitmap.pixelFormat == pixelFormat888) ? 4 : 2) * bitmap.stride;
 704          image.bits_per_pixel = (bitmap.pixelFormat == pixelFormat888) ? 32 : 16;
 705       }
 706
 707       image.format = ZPixmap;
 708       //image.bitmap_bit_order = MSBFirst;
 709       #ifdef __BIG_ENDIAN__
 710       image.byte_order = MSBFirst;
 711       #endif
 712       image.bitmap_unit = 8;
 713       /*
 714       image.red_mask   = 0xF800;
 715       image.green_mask = 0x7E0;
 716       image.blue_mask  = 0x1F;
 717       */
 718
 719       /*
 720       image.red_mask   = 0x0000FF;
 721       image.green_mask = 0x00FF00;
 722       image.blue_mask  = 0xFF0000;
 723       */
 724       // image.red_mask  = 0xFFFF0000;
 725
 726       image.data = (char *)bitmap.picture;
 727       XInitImage(&image);
 728
 729       if(bitmap.pixelFormat != pixelFormatAlpha && bitmap.alphaBlend)
 730       {
 731          int x,y;
 732          for(y = 0; y<bitmap.height; y++)
 733          {
 734             for(x = 0; x<bitmap.width; x++)
 735             {
 736                ColorAlpha * p = ((ColorAlpha *)bitmap.picture) + y * bitmap.stride + x;
 737                int alpha = p->a;
 738                p->color.r = (byte)(p->color.r * alpha / 255);
 739                p->color.g = (byte)(p->color.g * alpha / 255);
 740                p->color.b = (byte)(p->color.b * alpha / 255);
 741             }
 742          }
 743       }
 744
 745       XPutImage(xGlobalDisplay, (Pixmap)xBitmap.pixmap, gc, &image,
 746          0, 0, 0, 0, bitmap.width,bitmap.height);
 747
 748       if(bitmap.transparent && !bitmap.alphaBlend && bitmap.pixelFormat != pixelFormatAlpha)
 749          PutBitmapMask(xBitmap.mask, bitmap);
 750
 751       XFreeGC(xGlobalDisplay, gc);
 752
 753       if(!bitmap.keepData)
 754          delete bitmap.picture;
 755
 756       bitmap.driverData = xBitmap;
 757       bitmap.driver = displaySystem.driver;
 758       return true;
 759    }
 760
 761    void ReleaseSurface(Display display, Surface surface)
 762    {
 763       XSurface xSurface = surface.driverData;
 764       XDisplay xDisplay = display ? display.driverData : null;
 765       XRectangle rectangle;
 766
 767       if(xSurface.colorPicture)
 768          XRenderFreePicture(xGlobalDisplay, xSurface.colorPicture);
 769
 770       rectangle.x = 0;
 771       rectangle.y = 0;
 772       if(display)
 773       {
 774          rectangle.width = (uint16)display.width;
 775          rectangle.height = (uint16)display.height;
 776          XRenderSetPictureClipRectangles(xGlobalDisplay, xDisplay.picture, 0, 0, &rectangle, 1);
 777       }
 778
 779       if(xSurface.colorPixmap)
 780          XFreePixmap(xGlobalDisplay, xSurface.colorPixmap);
 781
 782       delete xSurface;
 783    }
 784
 785    bool GetBitmapSurface(DisplaySystem displaySystem, Surface surface, Bitmap bitmap, int x, int y, Box clip)
 786    {
 787       bool result = false;
 788       XBitmap xBitmap = bitmap.driverData;
 789       XSurface xSurface;
 790
 791       if((surface.driverData = xSurface = XSurface { }))
 792       {
 793          surface.offset.x = x;
 794          surface.offset.y = y;
 795          surface.unclippedBox = surface.box = clip;
 796
 797          xSurface.pixmap = xBitmap.pixmap;
 798
 799          result = true;
 800       }
 801       return result;
 802    }
 803
 804    bool GetSurface(Display display, Surface surface, int x,int y, Box clip)
 805    {
 806       bool result = false;
 807       XDisplay xDisplay = display.driverData;
 808       XSurface xSurface;
 809       if((surface.driverData = xSurface = XSurface { }))
 810       {
 811          XRectangle rectangle;
 812
 813          surface.offset.x = x;
 814          surface.offset.y = y;
 815          surface.unclippedBox = surface.box = clip;
 816          xSurface.pixmap = xDisplay.pixmap;
 817          xSurface.picture = xDisplay.picture;
 818
 819          xSurface.colorPixmap = XCreatePixmap(xGlobalDisplay, (X11Window)confineWindow /*display.window*/, 1, 1, /*(xSystemDepth == 16) ? 16 : */32);
 820
 821          rectangle.x = (short)(clip.left + x);
 822          rectangle.y = (short)(clip.top + y);
 823          rectangle.width = (short)(clip.right - clip.left + 1);
 824          rectangle.height = (short)(clip.bottom - clip.top + 1);
 825
 826          XSetClipRectangles(xGlobalDisplay, xDisplay.gc, 0,0, &rectangle, 1, YXBanded);
 827          XRenderSetPictureClipRectangles(xGlobalDisplay, xDisplay.picture, 0, 0, &rectangle, 1);
 828
 829          xDisplay.updateBox.left  = Min(x + clip.left,  xDisplay.updateBox.left);
 830          xDisplay.updateBox.top   = Min(y + clip.top,   xDisplay.updateBox.top);
 831          xDisplay.updateBox.right = Max(x + clip.right, xDisplay.updateBox.right);
 832          xDisplay.updateBox.bottom  = Max(y + clip.bottom,  xDisplay.updateBox.bottom);
 833
 834          result = true;
 835       }
 836       return result;
 837    }
 838
 839    void Clip(Display display, Surface surface, Box clip)
 840    {
 841       XSurface xSurface = surface.driverData;
 842       XDisplay xDisplay = display.driverData;
 843       bool changed = false;
 844       if(clip != null)
 845       {
 846          Box box = clip;
 847
 848          box.Clip(surface.unclippedBox);
 849
 850          surface.box = box;
 851
 852          xSurface.clipped = true;
 853          changed = true;
 854       }
 855       else if(xSurface.clipped)
 856       {
 857          surface.box = surface.unclippedBox;
 858          xSurface.clipped = false;
 859          changed = true;
 860       }
 861       if(changed)
 862       {
 863          XRectangle rectangle =
 864          {
 865             (short)(surface.box.left + surface.offset.x),
 866             (short)(surface.box.top + surface.offset.y),
 867             (short)(surface.box.right - surface.box.left + 1),
 868             (short)(surface.box.bottom - surface.box.top + 1)
 869          };
 870          XSetClipRectangles(xGlobalDisplay, xDisplay.gc,
 871             0,0, &rectangle, 1, YXBanded);
 872       }
 873    }
 874
 875    bool GrabScreen(Display display, Bitmap bitmap, int x, int y, unsigned int w, unsigned int h)
 876    {
 877       bool result = false;
 878       XDisplay xDisplay = display ? display.driverData : null;
 879       XImage * xImage;
 880       PixelFormat format = pixelFormat888;
 881       Bitmap source { };
 882       int sx = x, sy = y;
 883       int dx = 0, dy = 0;
 884       int sw = w, sh = h;
 885
 886       if(sx<0)
 887       {
 888          dx+=-sx;
 889          sw-=-sx;
 890          sx=0;
 891       }
 892       if(sy<0)
 893       {
 894          dy+=0-sy;
 895          sh-=0-sy;
 896          sy=0;
 897       }
 898       if(display)
 899       {
 900          if(sx+sw>display.width-1)
 901             sw-=sx+sw-(display.width-1)-1;
 902          if(sy+sh>display.height-1)
 903             sh-=sy+sh-(display.height-1)-1;
 904       }
 905
 906       if(display)
 907          xImage = XGetImage(xGlobalDisplay, xDisplay.pixmap, sx, sy, sw, sh, MAXDWORD, ZPixmap);
 908       else
 909          xImage = XGetImage(xGlobalDisplay, DefaultRootWindow(xGlobalDisplay), sx, sy, sw, sh, MAXDWORD, ZPixmap);
 910
 911       source.pixelFormat = format;
 912       source.picture = (byte *)xImage->data;
 913       source.width = sw;
 914       source.height = sh;
 915       source.stride = xImage->bytes_per_line / 4;
 916
 917       if(!bitmap || bitmap.pixelFormat != format || bitmap.width < w || bitmap.height < h)
 918       {
 919          bitmap.Free();
 920          bitmap.Allocate(null, w,h,w, format, (format == pixelFormat8)?true:false);
 921       }
 922       if(bitmap)
 923       {
 924          Surface surface = bitmap.GetSurface(0, 0, null);
 925          surface.Blit(source, dx,dy,0,0,sw,sh);
 926          delete surface;
 927          result = true;
 928       }
 929       source.picture = null;
 930       delete source;
 931
 932       XDestroyImage(xImage);
 933       return result;
 934    }
 935
 936    void SetForeground(Display display, Surface surface, ColorAlpha color)
 937    {
 938       XSurface xSurface = surface.driverData;
 939       XDisplay xDisplay = display ? display.driverData : null;
 940       XRenderColor renderColor = { color.color.r * color.a, color.color.g * color.a, color.color.b * color.a, color.a * 255};
 941
 942       if(xSurface.colorPicture)
 943          XRenderFreePicture(xGlobalDisplay, xSurface.colorPicture);
 944       // xSurface.colorPicture = XRenderCreateSolidFill(xGlobalDisplay, &renderColor);
 945
 946       {
 947          XRenderPictureAttributes attributes = { 0 };
 948          // XRenderPictFormat * format = myXRenderFindStandardFormat(xGlobalDisplay, PictStandardARGB32  /*PictStandardRGB24 /*PictStandardARGB32*/, 1);
 949          XRenderPictFormat * format = /*(xSystemPixelFormat != pixelFormat888) ? GetXRenderFormat(xSystemPixelFormat, false) : */XRenderFindStandardFormat(xGlobalDisplay, PictStandardARGB32);
 950          #if !defined(__APPLE__) && !defined(__OLDX__)
 951          attributes.repeat = RepeatNormal;
 952          #else
 953          attributes.repeat = 1;
 954          #endif
 955          ///attributes.component_alpha = 0;
 956          if(format)
 957             xSurface.colorPicture = XRenderCreatePicture(xGlobalDisplay, xSurface.colorPixmap, format, /*CPComponentAlpha | */CPRepeat, &attributes);
 958          XRenderFillRectangle(xGlobalDisplay, PictOpSrc, xSurface.colorPicture, &renderColor, 0, 0, 1, 1);
 959       }
 960
 961       // xSurface.foreground = ARGB(A(color),B(color),G(color),R(color));
 962       xSurface.foreground = color;
 963
 964       if(xDisplay)
 965          XSetForeground(xGlobalDisplay, xDisplay.gc, (xSystemPixelFormat == pixelFormat888) ? xSurface.foreground :
 966             ((xSystemPixelFormat == pixelFormat565) ? ((Color565)xSurface.foreground) : ((Color555)xSurface.foreground)));
 967    }
 968
 969    void SetBackground(Display display, Surface surface, ColorAlpha color)
 970    {
 971       XSurface xSurface = surface.driverData;
 972       XDisplay xDisplay = display ? display.driverData : null;
 973       // xSurface.background = ARGB(A(color),B(color),G(color),R(color));
 974       xSurface.background = color;
 975
 976       if(xDisplay)
 977          XSetBackground(xGlobalDisplay, xDisplay.gc, (xSystemPixelFormat == pixelFormat888) ? xSurface.background :
 978             ((xSystemPixelFormat == pixelFormat565) ? ((Color565)xSurface.background) : ((Color555)xSurface.background)));
 979    }
 980
 981    ColorAlpha GetPixel(Display display, Surface surface, int x, int y)
 982    {
 983       return 0;
 984    }
 985
 986    void PutPixel(Display display, Surface surface,int x,int y)
 987    {
 988       XSurface xSurface = surface.driverData;
 989       XDisplay xDisplay = display.driverData;
 990
 991       if(xSurface.foreground.a < 255)
 992          DrawLine(display, surface, x,y,x,y);
 993       else
 994          XDrawPoint(xGlobalDisplay, (Pixmap)xDisplay.pixmap, xDisplay.gc,
 995             x + surface.offset.x,
 996             y + surface.offset.y);
 997    }
 998
 999    void DrawLine(Display display, Surface surface, int x1, int y1, int x2, int y2)
1000    {
1001       XDisplay xDisplay = display ? display.driverData : null;
1002       XSurface xSurface = surface.driverData;
1003       if(!xDisplay || xSurface.foreground.a < 255)
1004       {
1005          XTrapezoid traps[3];
1006          int nTraps = 0;
1007          double offset = 0.5;
1008          double width = 0.5;
1009
1010          x1 += surface.offset.x;
1011          y1 += surface.offset.y;
1012          x2 += surface.offset.x;
1013          y2 += surface.offset.y;
1014
1015          if(y1 == y2)
1016          {
1017             x2++;
1018             x1--;
1019             {
1020                XTrapezoid trap1 =
1021                {
1022                   XDoubleToFixed(y1 - width + offset), XDoubleToFixed(y1 + width + offset),
1023                   { { XDoubleToFixed(Min(x1, x2) - 0 + offset), XDoubleToFixed(y1 - width + offset) }, { XDoubleToFixed(Min(x1, x2) + 0.0 + offset), XDoubleToFixed(y1 + width+ offset) } },
1024                   { { XDoubleToFixed(Max(x1, x2) - 0 + offset), XDoubleToFixed(y1 - width + offset) }, { XDoubleToFixed(Max(x1, x2) + 0.0 + offset), XDoubleToFixed(y1 + width+ offset) } }
1025                };
1026                traps[0] = trap1;
1027                nTraps = 1;
1028             }
1029          }
1030          else if(x1 == x2)
1031          {
1032             y2++;
1033             y1--;
1034             {
1035                XTrapezoid trap1 =
1036                {
1037                   XDoubleToFixed(Min(y1, y2) - 0.0 + offset), XDoubleToFixed(Max(y1, y2) + 0.0 + offset),
1038                   { { XDoubleToFixed(x1 - width + offset), XDoubleToFixed(Min(y1, y2) - 0.0 + offset) }, { XDoubleToFixed(x1 - width + offset), XDoubleToFixed(Max(y1, y2) + 0.0 + offset) } },
1039                   { { XDoubleToFixed(x1 + width + offset), XDoubleToFixed(Min(y1, y2) - 0.0 + offset) }, { XDoubleToFixed(x1 + width + offset), XDoubleToFixed(Max(y1, y2) + 0.0 + offset) } }
1040                };
1041                traps[0] = trap1;
1042                nTraps = 1;
1043             }
1044          }
1045          else
1046          {
1047             double dx, dy, l;
1048             Pointf A, B, C, D, E, F;
1049             if(y1 > y2)
1050             {
1051                int tmp = y2;
1052                y2 = y1;
1053                y1 = tmp;
1054                tmp = x2;
1055                x2 = x1;
1056                x1 = tmp;
1057             }
1058
1059             dx = x2 - x1;
1060             dy = y2 - y1;
1061             l = sqrt(dx * dx + dy * dy);
1062             dx /= l;
1063             dy /= l;
1064
1065             if(x2 > x1)
1066             {
1067                A = { (float)(x1 + dy * width), (float)(y1 - dx * width) };
1068                B = { (float)(x1 - dy * width), (float)(y1 + dx * width) };
1069                C = { (float)(A.x + ((B.y - A.y) * dx / dy)), B.y };
1070                E = { (float)(x2 + dy * width), (float)(y2 - dx * width) };
1071                F = { (float)(x2 - dy * width), (float)(y2 + dx * width) };
1072                D = { (float)(F.x + ((E.y - F.y) * dx / dy)), E.y };
1073
1074                {
1075                   XTrapezoid trap1 =
1076                   {
1077                      XDoubleToFixed(A.y + offset), XDoubleToFixed(B.y + offset),
1078                      { { XDoubleToFixed(A.x + offset), XDoubleToFixed(A.y + offset) }, { XDoubleToFixed(B.x + offset), XDoubleToFixed(B.y + offset) } },
1079                      { { XDoubleToFixed(A.x + offset), XDoubleToFixed(A.y + offset) }, { XDoubleToFixed(C.x + offset), XDoubleToFixed(C.y + offset) } }
1080                   };
1081                   XTrapezoid trap2 =
1082                   {
1083                      XDoubleToFixed(B.y + offset), XDoubleToFixed(D.y + offset),
1084                      { { XDoubleToFixed(B.x + offset), XDoubleToFixed(B.y + offset) }, { XDoubleToFixed(D.x + offset), XDoubleToFixed(D.y + offset) } },
1085                      { { XDoubleToFixed(C.x + offset), XDoubleToFixed(C.y + offset) }, { XDoubleToFixed(E.x + offset), XDoubleToFixed(E.y + offset) } }
1086                   };
1087                   XTrapezoid trap3 =
1088                   {
1089                      XDoubleToFixed(D.y + offset), XDoubleToFixed(F.y + offset),
1090                      { { XDoubleToFixed(D.x + offset), XDoubleToFixed(D.y + offset) }, { XDoubleToFixed(F.x + offset), XDoubleToFixed(F.y + offset) } },
1091                      { { XDoubleToFixed(E.x + offset), XDoubleToFixed(E.y + offset) }, { XDoubleToFixed(F.x + offset), XDoubleToFixed(F.y + offset) } }
1092                   };
1093                   traps[0] = trap1;
1094                   traps[1] = trap2;
1095                   traps[2] = trap3;
1096                   nTraps = 3;
1097                }
1098             }
1099             else
1100             {
1101                A = { (float)(x1 - dy * width), (float)(y1 + dx * width) };
1102                B = { (float)(x1 + dy * width), (float)(y1 - dx * width) };
1103                C = { (float)(A.x + ((B.y - A.y) * dx / dy)), B.y };
1104                E = { (float)(x2 - dy * width), (float)(y2 + dx * width) };
1105                F = { (float)(x2 + dy * width), (float)(y2 - dx * width) };
1106                D = { (float)(F.x + ((E.y - F.y) * dx / dy)), E.y };
1107
1108                {
1109                   XTrapezoid trap1 =
1110                   {
1111                      XDoubleToFixed(A.y + offset), XDoubleToFixed(B.y + offset),
1112                      { { XDoubleToFixed(A.x + offset), XDoubleToFixed(A.y + offset) }, { XDoubleToFixed(C.x + offset), XDoubleToFixed(C.y + offset) } },
1113                      { { XDoubleToFixed(A.x + offset), XDoubleToFixed(A.y + offset) }, { XDoubleToFixed(B.x + offset), XDoubleToFixed(B.y + offset) } }
1114                   };
1115                   XTrapezoid trap2 =
1116                   {
1117                      XDoubleToFixed(B.y + offset), XDoubleToFixed(D.y + offset),
1118                      { { XDoubleToFixed(C.x + offset), XDoubleToFixed(C.y + offset) }, { XDoubleToFixed(E.x + offset), XDoubleToFixed(E.y + offset) } },
1119                      { { XDoubleToFixed(B.x + offset), XDoubleToFixed(B.y + offset) }, { XDoubleToFixed(D.x + offset), XDoubleToFixed(D.y + offset) } }
1120                   };
1121                   XTrapezoid trap3 =
1122                   {
1123                      XDoubleToFixed(D.y + offset), XDoubleToFixed(F.y + offset),
1124                      { { XDoubleToFixed(E.x + offset), XDoubleToFixed(E.y + offset) }, { XDoubleToFixed(F.x + offset), XDoubleToFixed(F.y + offset) } },
1125                      { { XDoubleToFixed(D.x + offset), XDoubleToFixed(D.y + offset) }, { XDoubleToFixed(F.x + offset), XDoubleToFixed(F.y + offset) } }
1126                   };
1127                   traps[0] = trap1;
1128                   traps[1] = trap2;
1129                   traps[2] = trap3;
1130                   nTraps = 3;
1131                }
1132             }
1133             /*
1134             printf("Line: (%d, %d)-(%d, %d)\n", x1,y1, x2,y2);
1135             printf("Line: A = (%.2f, %.2f), B = (%.2f, %.2f), C = (%.2f, %.2f)\n", A.x,A.y, B.x,B.y, C.x,C.y);
1136             printf("Line: D = (%.2f, %.2f), E = (%.2f, %.2f), F = (%.2f, %.2f)\n", D.x,D.y, E.x,E.y, F.x,F.y);
1137             printf("Trap1: top = %.2f, bottom = %.2f, left = (%.2f, %.2f)-(%.2f, %.2f), right = (%.2f, %.2f)-(%.2f, %.2f)\n",
1138                traps[0].top / 65536.0, traps[0].bottom / 65536.0,
1139                traps[0].left.p1.x / 65536.0, traps[0].left.p1.y / 65536.0, traps[0].left.p2.x / 65536.0, traps[0].left.p2.y / 65536.0,
1140                traps[0].right.p1.x / 65536.0, traps[0].right.p1.y / 65536.0, traps[0].right.p2.x / 65536.0, traps[0].right.p2.y / 65536.0);
1141             printf("Trap2: top = %.2f, bottom = %.2f, left = (%.2f, %.2f)-(%.2f, %.2f), right = (%.2f, %.2f)-(%.2f, %.2f)\n",
1142                traps[1].top / 65536.0, traps[1].bottom / 65536.0,
1143                traps[1].left.p1.x / 65536.0,  traps[1].left.p1.y / 65536.0,  traps[1].left.p2.x / 65536.0,  traps[1].left.p2.y / 65536.0,
1144                traps[1].right.p1.x / 65536.0, traps[1].right.p1.y / 65536.0, traps[1].right.p2.x / 65536.0, traps[1].right.p2.y / 65536.0);
1145             printf("Trap3: top = %.2f, bottom = %.2f, left = (%.2f, %.2f)-(%.2f, %.2f), right = (%.2f, %.2f)-(%.2f, %.2f)\n",
1146                traps[2].top / 65536.0, traps[2].bottom / 65536.0,
1147                traps[2].left.p1.x / 65536.0,  traps[2].left.p1.y / 65536.0,  traps[2].left.p2.x / 65536.0,  traps[2].left.p2.y / 65536.0,
1148                traps[2].right.p1.x / 65536.0, traps[2].right.p1.y / 65536.0, traps[2].right.p2.x / 65536.0, traps[2].right.p2.y / 65536.0);
1149             printf("\n");
1150             */
1151          }
1152          XRenderCompositeTrapezoids(xGlobalDisplay, PictOpOver, xSurface.colorPicture, xSurface.picture, None, 0, 0, traps, nTraps);
1153       }
1154       else
1155          XDrawLine(xGlobalDisplay, (Pixmap)xDisplay.pixmap, xDisplay.gc,
1156             x1 + surface.offset.x,
1157             y1 + surface.offset.y,
1158             x2 + surface.offset.x,
1159             y2 + surface.offset.y);
1160    }
1161
1162    void Rectangle(Display display, Surface surface,int x1,int y1,int x2,int y2)
1163    {
1164       XDisplay xDisplay = display ? display.driverData : null;
1165       XSurface xSurface = surface.driverData;
1166
1167       if(!xDisplay || xSurface.foreground.a < 255)
1168       {
1169          DrawLine(display, surface,x1,y1,x2-1,y1);
1170          DrawLine(display, surface,x2,y1,x2,y2-1);
1171          DrawLine(display, surface,x1,y2,x2-1,y2);
1172          DrawLine(display, surface,x1,y1+1,x1,y2-1);
1173       }
1174       else
1175          XDrawRectangle(xGlobalDisplay, (Pixmap)xDisplay.pixmap, xDisplay.gc,
1176             x1 + surface.offset.x,
1177             y1 + surface.offset.y,
1178             x2 - x1, y2 - y1);
1179    }
1180
1181    void Area(Display display, Surface surface,int x1,int y1,int x2,int y2)
1182    {
1183       XDisplay xDisplay = display ? display.driverData : null;
1184       XSurface xSurface = surface.driverData;
1185       if(!xDisplay || xSurface.background.a < 255)
1186       {
1187          XRenderColor renderColor =
1188          {
1189             (uint16)(xSurface.background.color.r * xSurface.background.a),
1190             (uint16)(xSurface.background.color.g * xSurface.background.a),
1191             (uint16)(xSurface.background.color.b * xSurface.background.a),
1192             (uint16)xSurface.background.a * 255
1193          };
1194          x1 += surface.offset.x;
1195          y1 += surface.offset.y;
1196          x2 += surface.offset.x;
1197          y2 += surface.offset.y;
1198          XRenderFillRectangle(xGlobalDisplay, PictOpOver, xSurface.picture, &renderColor, x1, y1, (x2 - x1) + 1, (y2 - y1) + 1);
1199       }
1200       else
1201       {
1202          XSetForeground(xGlobalDisplay, xDisplay.gc, (xSystemPixelFormat == pixelFormat888) ? xSurface.background :
1203             ((xSystemPixelFormat == pixelFormat565) ? ((Color565)xSurface.background) : ((Color555)xSurface.background)));
1204          XFillRectangle(xGlobalDisplay, (Pixmap) xDisplay.pixmap, xDisplay.gc,
1205             x1 + surface.offset.x,
1206             y1 + surface.offset.y,
1207             x2 - x1 + 1, y2 - y1 + 1);
1208          XSetForeground(xGlobalDisplay, xDisplay.gc, (xSystemPixelFormat == pixelFormat888) ? xSurface.foreground :
1209             ((xSystemPixelFormat == pixelFormat565) ? ((Color565)xSurface.foreground) : ((Color555)xSurface.foreground)));
1210       }
1211    }
1212
1213    void Clear(Display display, Surface surface, ClearType flags)
1214    {
1215       if(flags != depthBuffer)
1216       {
1217          // XDisplay xDisplay = display.driverData;
1218          XSurface xSurface = surface.driverData;
1219          if(xSurface.background.a < 255)
1220          {
1221             int x1 = surface.box.left;
1222             int y1 = surface.box.top;
1223             int x2 = surface.box.right;
1224             int y2 = surface.box.bottom;
1225             XRenderColor renderColor =
1226             {
1227                (uint16)(xSurface.background.color.r * xSurface.background.a),
1228                (uint16)(xSurface.background.color.g * xSurface.background.a),
1229                (uint16)(xSurface.background.color.b * xSurface.background.a),
1230                (uint16)xSurface.background.a * 255
1231             };
1232             x1 += surface.offset.x;
1233             y1 += surface.offset.y;
1234             x2 += surface.offset.x;
1235             y2 += surface.offset.y;
1236             XRenderFillRectangle(xGlobalDisplay, PictOpSrc, xSurface.picture, &renderColor, x1, y1, (x2 - x1) + 1, (y2 - y1) + 1);
1237          }
1238          else
1239             Area(display, surface,surface.box.left,surface.box.top,surface.box.right,surface.box.bottom);
1240       }
1241    }
1242
1243    bool ConvertBitmap(DisplaySystem displaySystem, Bitmap src, PixelFormat format, ColorAlpha * palette)
1244    {
1245       return true;
1246    }
1247
1248    bool AllocateBitmap(DisplaySystem displaySystem, Bitmap bitmap, int width, int height, int stride, PixelFormat format, bool allocatePalette)
1249    {
1250       bool result = false;
1251       XBitmap xBitmap = bitmap.driverData = XBitmap { };
1252       if(xBitmap)
1253       {
1254          if(!stride)
1255          {
1256             switch(GetColorDepthShifts(format))
1257             {
1258                case 0: stride = (width + 3) & 0xFFFFFFFC; break;
1259                case 1: stride = (width + 1) & 0xFFFFFFFE; break;
1260                case 2: stride = width;                    break;
1261             }
1262          }
1263
1264          bitmap.stride = stride;
1265          bitmap.width = width;
1266          bitmap.height = height;
1267          bitmap.size = (uint)stride * (uint)height;
1268          bitmap.sizeBytes = bitmap.size << GetColorDepthShifts(format);
1269          bitmap.pixelFormat = format;
1270          bitmap.transparent = false;
1271          bitmap.allocatePalette = allocatePalette;
1272          if(allocatePalette)
1273          {
1274             bitmap.palette = new ColorAlpha[256];
1275             if(bitmap.palette)
1276                CopyBytesBy4(bitmap.palette, GetDefaultPalette(), 256);
1277          }
1278          else
1279             bitmap.palette = GetDefaultPalette();
1280
1281          result = true;
1282
1283          if(!result)
1284             FreeBitmap(displaySystem, bitmap);
1285       }
1286
1287       return result;
1288    }
1289
1290    void Blit(Display display, Surface surface, Bitmap src, int dx, int dy, int sx, int sy, int w, int h)
1291    {
1292       XDisplay xDisplay = display.driverData;
1293       XSurface xSurface = surface.driverData;
1294       XBitmap xBitmap = src.driverData;
1295       if(xBitmap)
1296       {
1297          bool flip;
1298          if(!ClipBlitCoords(surface, src, &dx, &dy, &sx, &sy, &w, &h, &flip))
1299             return;
1300
1301          dx += surface.offset.x;
1302          dy += surface.offset.y;
1303
1304          if(src.transparent && !src.alphaBlend && !display.alphaBlend)
1305          {
1306             XSetClipMask(xGlobalDisplay, xDisplay.gc, xBitmap.mask);
1307             XSetClipOrigin(xGlobalDisplay, xDisplay.gc, dx - sx, dy - sy);
1308          }
1309          if(xSurface.xOffset)
1310          {
1311             XTransform transform =
1312             {
1313                {
1314                   { (int)(1.0f * (1<<16)), (int)(0.0f * (1<<16)), -(xSurface.xOffset << 10) },
1315                   { (int)(0.0f), (int)(-1.0f * (1<<16)), (int)(0.0f * (1<<16)) },
1316                   { (int)(0.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(1.0f * (1<<16)) }
1317                }
1318             };
1319             // printf("XOffset: %d\n", xSurface.xOffset);
1320             XRenderSetPictureTransform(xGlobalDisplay, xBitmap.picture, &transform);
1321          }
1322
1323          if(src.alphaBlend || display.alphaBlend)
1324          {
1325             if(src.pixelFormat == pixelFormatAlpha)
1326             {
1327                XRenderComposite(xGlobalDisplay, PictOpOver, xSurface.colorPicture, xBitmap.picture, xSurface.picture, 0, 0, sx, sy, dx, dy, w + (xSurface.xOffset ? 1 : 1), h);
1328             }
1329             else if(src.alphaBlend)
1330                XRenderComposite(xGlobalDisplay, PictOpOver, xBitmap.picture, None, xSurface.picture, sx, sy, sx, sy, dx, dy, w, h);
1331             else
1332                XRenderComposite(xGlobalDisplay, PictOpOver, xBitmap.picture, xBitmap.maskPicture, xSurface.picture, sx, sy, sx, sy, dx, dy, w, h);
1333          }
1334          else
1335             XCopyArea(xGlobalDisplay, (Pixmap)xBitmap.pixmap, (Pixmap)xSurface.pixmap, xDisplay.gc,
1336                sx, sy, w, h, dx, dy);
1337
1338          if(xSurface.xOffset)
1339          {
1340             XTransform identity =
1341             {
1342                {
1343                   { (int)(1.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(0.0f * (1<<16)) },
1344                   { (int)(0.0f * (1<<16)), (int)(1.0f * (1<<16)), (int)(0.0f * (1<<16)) },
1345                   { (int)(0.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(1.0f * (1<<16)) }
1346                }
1347             };
1348             XRenderSetPictureTransform(xGlobalDisplay, xBitmap.picture, &identity);
1349          }
1350          if(src.transparent && !src.alphaBlend && !display.alphaBlend)
1351          {
1352             XSetClipOrigin(xGlobalDisplay, xDisplay.gc, 0, 0);
1353             {
1354                XRectangle rectangle;
1355
1356                rectangle.x = (short)(surface.unclippedBox.left + surface.offset.x);
1357                rectangle.y = (short)(surface.unclippedBox.top + surface.offset.y);
1358                rectangle.width = (short)(surface.unclippedBox.right - surface.unclippedBox.left + 1);
1359                rectangle.height = (short)(surface.unclippedBox.bottom - surface.unclippedBox.top + 1);
1360
1361                XSetClipRectangles(xGlobalDisplay, xDisplay.gc, 0,0, &rectangle, 1, YXBanded);
1362             }
1363          }
1364       }
1365    }
1366
1367    void Stretch(Display display, Surface surface, Bitmap src, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
1368    {
1369       XSurface xSurface = surface.driverData;
1370       XBitmap xBitmap = src.driverData;
1371       if(xBitmap)
1372       {
1373          XTransform transform =
1374          {
1375             {
1376                { (int)((float)sw / w * (1<<16)), (int)(0.0f * (1<<16)), (int)(0.0f * (1<<16)) },
1377                { (int)(0.0f * (1<<16)), (int)((float)sh / h * (1<<16)), (int)(0.0f * (1<<16)) },
1378                { (int)(0.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(1.0f * (1<<16)) }
1379             }
1380          };
1381          XTransform identity =
1382          {
1383             {
1384                { (int)(1.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(0.0f * (1<<16)) },
1385                { (int)(0.0f * (1<<16)), (int)(1.0f * (1<<16)), (int)(0.0f * (1<<16)) },
1386                { (int)(0.0f * (1<<16)), (int)(0.0f * (1<<16)), (int)(1.0f * (1<<16)) }
1387             }
1388          };
1389          dx += surface.offset.x;
1390          dy += surface.offset.y;
1391
1392          XRenderSetPictureTransform(xGlobalDisplay, xBitmap.picture, &transform);
1393
1394          if(src.pixelFormat == pixelFormatAlpha)
1395             XRenderComposite(xGlobalDisplay, PictOpOver, xSurface.colorPicture, xBitmap.picture, xSurface.picture, 0, 0, sx, sy, dx, dy, w, h);
1396          else if(src.alphaBlend)
1397             XRenderComposite(xGlobalDisplay, PictOpOver, xBitmap.picture, None, xSurface.picture, sx, sy, sx, sy, dx, dy, w, h);
1398          else
1399          {
1400             XRenderSetPictureTransform(xGlobalDisplay, xBitmap.maskPicture, &transform);
1401             XRenderComposite(xGlobalDisplay, PictOpOver, xBitmap.picture, xBitmap.maskPicture, xSurface.picture, sx, sy, sx, sy, dx, dy, w, h);
1402             XRenderSetPictureTransform(xGlobalDisplay, xBitmap.maskPicture, &identity);
1403          }
1404          XRenderSetPictureTransform(xGlobalDisplay, xBitmap.picture, &identity);
1405       }
1406    }
1407
1408    void Filter(Display display, Surface surface, Bitmap src, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
1409    {
1410       XBitmap xBitmap = src.driverData;
1411       if(xBitmap)
1412       {
1413          XRenderSetPictureFilter(xGlobalDisplay, xBitmap.picture, "bilinear", null, 0);
1414          Stretch(display, surface, src, dx, dy, sx, sy, w, h, sw, sh);
1415          XRenderSetPictureFilter(xGlobalDisplay, xBitmap.picture, "nearest", null, 0);
1416       }
1417    }
1418
1419    void BlitDI(Display display, Surface surface, Bitmap src, int dx, int dy, int sx, int sy, int w, int h)
1420    {
1421       XImage image = { 0 };
1422       XDisplay xDisplay = display ? display.driverData : null;
1423       XSurface xSurface = surface.driverData;
1424       bool flip;
1425
1426       if(!xDisplay || !src.picture || !ClipBlitCoords(surface, src, &dx, &dy, &sx, &sy, &w, &h, &flip))
1427          return;
1428
1429       if(src.pixelFormat == display.pixelFormat)
1430       {
1431          image.width = src.width;
1432          image.height = src.height;
1433          image.depth = (src.pixelFormat == pixelFormat888) ? 24 : xSystemDepth;
1434          image.bitmap_pad = (src.pixelFormat == pixelFormat888) ? 32 : 16;
1435          image.format = ZPixmap;
1436          image.bitmap_unit = 8;
1437          image.bytes_per_line = ((src.pixelFormat == pixelFormat888) ? 4 : 2) * src.stride;
1438          image.bits_per_pixel = (src.pixelFormat == pixelFormat888) ? 32 : 16;
1439
1440          image.data = (char *)src.picture;
1441          XInitImage(&image);
1442
1443          XPutImage(xGlobalDisplay, (Pixmap)xSurface.pixmap, xDisplay.gc, &image,
1444             sx, sy, dx + surface.offset.x, dy + surface.offset.y, w,h);
1445       }
1446       else
1447       {
1448          Bitmap temp { };
1449          Surface s;
1450          temp.Allocate(null, w, h, 0, xSystemPixelFormat, false);
1451          s = temp.GetSurface(0,0,null);
1452          s.Blit(src, 0,0, sx,sy, flip ? -w : w, h);
1453
1454          image.width = w;
1455          image.height = h;
1456          image.depth = (temp.pixelFormat == pixelFormat888) ? 24 : xSystemDepth;
1457          image.bitmap_pad = (temp.pixelFormat == pixelFormat888) ? 32 : 16;
1458          image.format = ZPixmap;
1459          image.bitmap_unit = 8;
1460          image.bytes_per_line = ((temp.pixelFormat == pixelFormat888) ? 4 : 2) * temp.stride;
1461          image.bits_per_pixel = (temp.pixelFormat == pixelFormat888) ? 32 : 16;
1462
1463          image.data = (char *)temp.picture;
1464
1465          XInitImage(&image);
1466          if(!src.transparent)
1467          {
1468             // printf("Stride: %d, dx: %d, dy: %d, w: %d, h: %d, %d\n", temp.stride, dx + surface.offset.x, dy + surface.offset.y, w,h, xSystemDepth);
1469             XPutImage(xGlobalDisplay, (Pixmap)xSurface.pixmap, xDisplay.gc, &image,
1470                0, 0, dx + surface.offset.x, dy + surface.offset.y, w,h);
1471          }
1472          else
1473          {
1474          #if 0
1475             GC maskGC = 0, gc = 0;
1476             Pixmap pixmap, mask;
1477
1478             pixmap = XCreatePixmap(xGlobalDisplay, (X11Window)confineWindow /*display.window*/, w, h, xSystemDepth /*24*/);
1479             mask = XCreatePixmap(xGlobalDisplay, (X11Window)confineWindow /*display.window*/, w, h, 1);
1480
1481             gc = XCreateGC(xGlobalDisplay, pixmap, 0, null);
1482             maskGC = XCreateGC(xGlobalDisplay, mask, 0, null);
1483             XSetGraphicsExposures(xGlobalDisplay, gc, False);
1484             XSetGraphicsExposures(xGlobalDisplay, maskGC, False);
1485
1486             XPutImage(xGlobalDisplay, pixmap, gc, &image, 0, 0, 0, 0, w,h);
1487             XSetForeground(xGlobalDisplay, maskGC, 0);
1488             XFillRectangle(xGlobalDisplay, mask, maskGC, 0, 0, w, h);
1489             XSetForeground(xGlobalDisplay, maskGC, 1);
1490             if(temp.pixelFormat == pixelFormat888)
1491             {
1492                int x,y;
1493                for(y = 0; y<h; y++)
1494                {
1495                   for(x = 0; x<w; x++)
1496                   {
1497                      if(((ColorAlpha *)temp.picture)[y * temp.stride + x].a)
1498                         XDrawPoint(xGlobalDisplay, mask, maskGC, x, y);
1499                   }
1500                }
1501             }
1502             else if(src.pixelFormat == pixelFormat8)
1503             {
1504                int x,y;
1505                for(y = 0; y<h; y++)
1506                {
1507                   for(x = 0; x<w; x++)
1508                   {
1509                      if(src.picture[(y + sy) * src.stride + (flip ? (w-1-(sx + x)) : (sx + x)])
1510                         XDrawPoint(xGlobalDisplay, mask, maskGC, x, y);
1511                   }
1512                }
1513             }
1514             else
1515             {
1516                int x,y;
1517                for(y = 0; y<h; y++)
1518                {
1519                   for(x = 0; x<w; x++)
1520                   {
1521                      if(((uint16 *)temp.picture)[y * temp.stride + x])
1522                         XDrawPoint(xGlobalDisplay, mask, maskGC, x, y);
1523                   }
1524                }
1525             }
1526
1527             XFreeGC(xGlobalDisplay, maskGC);
1528          #else
1529          GC gc = 0;
1530             Pixmap pixmap, mask;
1531
1532             pixmap = XCreatePixmap(xGlobalDisplay, (X11Window)confineWindow /*display.window*/, w, h, xSystemDepth /*24*/);
1533             mask = XCreatePixmap(xGlobalDisplay, (X11Window)confineWindow /*display.window*/, w, h, 1);
1534
1535             gc = XCreateGC(xGlobalDisplay, pixmap, 0, null);
1536             XSetGraphicsExposures(xGlobalDisplay, gc, False);
1537
1538             XPutImage(xGlobalDisplay, pixmap, gc, &image, 0, 0, 0, 0, w,h);
1539
1540          PutBitmapMask(mask, temp);
1541          #endif
1542
1543             XSetClipMask(xGlobalDisplay, xDisplay.gc, mask);
1544             XSetClipOrigin(xGlobalDisplay, xDisplay.gc, dx + surface.offset.x, dy + surface.offset.y);
1545             XCopyArea(xGlobalDisplay, pixmap, (Pixmap)xSurface.pixmap, xDisplay.gc, 0, 0, w, h, dx + surface.offset.x, dy + surface.offset.y);
1546             XSetClipOrigin(xGlobalDisplay, xDisplay.gc, 0, 0);
1547             {
1548                XRectangle rectangle;
1549
1550                rectangle.x = (short)(surface.unclippedBox.left + surface.offset.x);
1551                rectangle.y = (short)(surface.unclippedBox.top + surface.offset.y);
1552                rectangle.width = (short)(surface.unclippedBox.right - surface.unclippedBox.left + 1);
1553                rectangle.height = (short)(surface.unclippedBox.bottom - surface.unclippedBox.top + 1);
1554
1555                XSetClipRectangles(xGlobalDisplay, xDisplay.gc, 0,0, &rectangle, 1, YXBanded);
1556             }
1557
1558             XFreeGC(xGlobalDisplay, gc);
1559             XFreePixmap(xGlobalDisplay, pixmap);
1560             XFreePixmap(xGlobalDisplay, mask);
1561          }
1562          delete s;
1563          delete temp;
1564       }
1565    }
1566
1567    void StretchDI(Display display, Surface surface, Bitmap src, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
1568    {
1569       bool flip;
1570       if(ClipStretchCoords(surface, src, &dx, &dy, &sx, &sy, &w, &h, &sw, &sh, &flip))
1571       {
1572          XImage image = { 0 };
1573          XDisplay xDisplay = display.driverData;
1574          XSurface xSurface = surface.driverData;
1575          Bitmap temp { };
1576          Surface s;
1577          temp.Allocate(null, w, h, 0, xSystemPixelFormat, false);
1578          s = temp.GetSurface(0,0,null);
1579          s.Stretch(src, 0,0, sx,sy, w, h, sw, sh);
1580
1581          image.width = w;
1582          image.height = h;
1583          image.depth = (temp.pixelFormat == pixelFormat888) ? 24 : xSystemDepth;
1584          image.bitmap_pad = (temp.pixelFormat == pixelFormat888) ? 32 : 16;
1585          image.format = ZPixmap;
1586          image.bitmap_unit = 8;
1587          image.bytes_per_line = ((temp.pixelFormat == pixelFormat888) ? 4 : 2) * temp.stride;
1588          image.bits_per_pixel = (temp.pixelFormat == pixelFormat888) ? 32 : 16;
1589
1590          image.data = (char *)temp.picture;
1591          XInitImage(&image);
1592
1593          // printf("Blitting DI\n");
1594          XPutImage(xGlobalDisplay, (Pixmap)xSurface.pixmap, xDisplay.gc, &image,
1595             0, 0, dx + surface.offset.x, dy + surface.offset.y, w,h);
1596
1597          delete s;
1598          delete temp;
1599       }
1600    }
1601
1602    void FilterDI(Display display, Surface surface, Bitmap src, int dx, int dy, int sx, int sy, int w, int h, int sw, int sh)
1603    {
1604       bool flip;
1605       if(ClipStretchCoords(surface, src, &dx, &dy, &sx, &sy, &w, &h, &sw, &sh, &flip))
1606       {
1607          XImage image = { 0 };
1608          XDisplay xDisplay = display.driverData;
1609          XSurface xSurface = surface.driverData;
1610          Bitmap temp { };
1611          Surface s;
1612          temp.Allocate(null, w, h, 0, xSystemPixelFormat, false);
1613          s = temp.GetSurface(0,0,null);
1614          s.Filter(src, 0,0, sx,sy, w, h, sw, sh);
1615
1616          image.width = w;
1617          image.height = h;
1618          image.depth = (temp.pixelFormat == pixelFormat888) ? 24 : xSystemDepth;
1619          image.bitmap_pad = (temp.pixelFormat == pixelFormat888) ? 32 : 16;
1620          image.format = ZPixmap;
1621          image.bitmap_unit = 8;
1622          image.bytes_per_line = ((temp.pixelFormat == pixelFormat888) ? 4 : 2) * temp.stride;
1623          image.bits_per_pixel = (temp.pixelFormat == pixelFormat888) ? 32 : 16;;
1624
1625          image.data = (char *)temp.picture;
1626          XInitImage(&image);
1627
1628          // printf("Blitting DI\n");
1629          XPutImage(xGlobalDisplay, (Pixmap)xSurface.pixmap, xDisplay.gc, &image,
1630             0, 0, dx + surface.offset.x, dy + surface.offset.y, w,h);
1631
1632          delete s;
1633          delete temp;
1634       }
1635    }
1636
1637    Font LoadFont(DisplaySystem displaySystem, const char * faceName, float size, FontFlags flags)
1638    {
1639       Font font;
1640       font = ((subclass(DisplayDriver))class(LFBDisplayDriver)).LoadFont(displaySystem, faceName, size, flags);
1641       return font;
1642    }
1643
1644    void UnloadFont(DisplaySystem displaySystem, Font font)
1645    {
1646       ((subclass(DisplayDriver))class(LFBDisplayDriver)).UnloadFont(displaySystem, font);
1647    }
1648
1649    void TextFont(Display display, Surface surface, Font font)
1650    {
1651       // XSurface xSurface = surface.driverData;
1652       ((subclass(DisplayDriver))class(LFBDisplayDriver)).TextFont(display, surface, font);
1653    }
1654
1655    void TextOpacity(Display display, Surface surface, bool opaque)
1656    {
1657       XSurface xSurface = surface.driverData;
1658       xSurface.opaque = opaque;
1659    }
1660
1661    #define CHAR_WIDTH   6
1662    #define CHAR_HEIGHT  14
1663
1664    void WriteText(Display display, Surface surface, int x, int y, const char * text, int len)
1665    {
1666       XSurface xSurface = surface.driverData;
1667       //XDisplay xDisplay = display.driverData;
1668       int tw, th;
1669
1670       ((subclass(DisplayDriver))class(LFBDisplayDriver)).TextExtent(display, surface, text, len, &tw, &th);
1671       if(xSurface.opaque)
1672       {
1673 #if 0
1674          XSetForeground(xGlobalDisplay, xDisplay.gc, xSurface.background);
1675
1676          XFillRectangle(xGlobalDisplay, (Pixmap)xDisplay.pixmap, xDisplay.gc,
1677             x + surface.offset.x, y + surface.offset.y,
1678             tw /*len * CHAR_WIDTH*/, th /*CHAR_HEIGHT*/);
1679
1680          XSetForeground(xGlobalDisplay, xDisplay.gc, xSurface.foreground);
1681 #endif
1682
1683          XRenderColor renderColor =
1684          {
1685             (uint16)(xSurface.background.color.r * xSurface.background.a),
1686             (uint16)(xSurface.background.color.g * xSurface.background.a),
1687             (uint16)(xSurface.background.color.b * xSurface.background.a),
1688             (uint16)xSurface.background.a
1689          };
1690          //printf("Filling rectangle\n");
1691          XRenderFillRectangle(xGlobalDisplay, PictOpSrc /*PictOpOver*/, xSurface.picture, &renderColor,
1692             x + surface.offset.x, y + surface.offset.y, tw, th);
1693       }
1694       /*
1695       XDrawString(xGlobalDisplay, (Pixmap)xDisplay.pixmap, xDisplay.gc,
1696          x + surface.offset.x, y + surface.offset.y + 12, text, len);
1697       */
1698
1699       ((subclass(DisplayDriver))class(LFBDisplayDriver)).WriteText(display, surface, x, y, text, len);
1700    }
1701
1702    void TextExtent(Display display, Surface surface, const char * text, int len, int * width, int * height)
1703    {
1704       XSurface xSurface = surface.driverData;
1705       /*
1706       uint realLen;
1707       for(realLen = 0; realLen<len && text[realLen]; realLen++);
1708       if(width) *width = len * CHAR_WIDTH;
1709       if(height) *height = CHAR_HEIGHT;
1710       */
1711
1712       FontExtent(display.displaySystem, xSurface.font, text, len, width, height);
1713    }
1714
1715    void FontExtent(DisplaySystem displaySystem, Font font, const char * text, int len, int * width, int * height)
1716    {
1717       /*
1718       if(width) *width = len * CHAR_WIDTH;
1719       if(height) *height = CHAR_HEIGHT;
1720       */
1721       ((subclass(DisplayDriver))class(LFBDisplayDriver)).FontExtent(displaySystem, font, text, len, width, height);
1722    }
1723
1724    void DrawingChar(Display display, Surface surface, byte character)
1725    {
1726
1727    }
1728
1729    void LineStipple(Display display, Surface surface, uint stipple)
1730    {
1731       XDisplay xDisplay = display.driverData;
1732       char list[32] = { 0 };
1733       int count = 0;
1734
1735       if(stipple)
1736       {
1737          int c;
1738          int offset = 0;
1739          uint16 on = 0x8000;
1740
1741          for(c = 0; c<32; c++)
1742          {
1743             if((stipple & 0x8000) == on)
1744                list[count]++;
1745             else
1746             {
1747                if(!list[count])
1748                   offset = 1;
1749                else
1750                {
1751                   count++;
1752                   list[count]++;
1753                   on ^= 0x8000;
1754                }
1755             }
1756             stipple <<= 1;
1757          }
1758          XSetLineAttributes(xGlobalDisplay, xDisplay.gc, 0, LineOnOffDash, CapButt, JoinMiter);
1759          XSetDashes(xGlobalDisplay, xDisplay.gc, offset, list, count);
1760       }
1761       else
1762       {
1763          list[0] = 4;
1764          count = 1;
1765          XSetLineAttributes(xGlobalDisplay, xDisplay.gc, 0, LineSolid, CapButt, JoinMiter);
1766          XSetDashes(xGlobalDisplay, xDisplay.gc, 0, list, count);
1767       }
1768    }
1769
1770    bool Lock(Display display)
1771    {
1772       //XLockDisplay(xGlobalDisplay);
1773       return true;
1774    }
1775
1776    void Unlock(Display display)
1777    {
1778       //XUnlockDisplay(xGlobalDisplay);
1779    }
1780
1781    void StartUpdate(Display display)
1782    {
1783
1784    }
1785
1786    void Scroll(Display display, Box scroll, int x, int y, Extent dirty)
1787    {
1788
1789    }
1790
1791    void Update(Display display, Box updateBox)
1792    {
1793       XDisplay xDisplay = display.driverData;
1794       Box * box = (updateBox != null) ? updateBox : &xDisplay.updateBox;
1795
1796       {
1797          XRectangle rectangle;
1798          rectangle.x = 0;
1799          rectangle.y = 0;
1800          rectangle.width = (uint16)display.width;
1801          rectangle.height = (uint16)display.height;
1802          XSetClipRectangles(xGlobalDisplay, xDisplay.gc, 0,0, &rectangle, 1, YXBanded);
1803       }
1804       /*if(display.alphaBlend)
1805          XRenderComposite(xGlobalDisplay, PictOpSrc, xDisplay.picture, None, xDisplay.windowPicture, box->left, box->top, 0, 0, box->left, box->top,
1806             box->right - box->left + 1, box->bottom - box->top + 1);
1807       else*/
1808          XCopyArea(xGlobalDisplay, (Pixmap)xDisplay.pixmap, (X11Window)display.window, xDisplay.gc /*windowGC*/,
1809             box->left, box->top,
1810             box->right - box->left + 1,
1811             box->bottom - box->top + 1,
1812             box->left, box->top);
1813
1814       if(display.alphaBlend)
1815       {
1816          Box * box = &xDisplay.updateBox;
1817          XRenderComposite(xGlobalDisplay, PictOpSrc, xDisplay.picture, None, xDisplay.shapePicture, box->left, box->top, 0, 0, box->left, box->top,
1818             box->right - box->left + 1, box->bottom - box->top + 1);
1819          #if !defined(__APPLE__) && !defined(__OLDX__)
1820          XShapeCombineMask(xGlobalDisplay, (X11Window)display.window, ShapeInput, 0, 0, xDisplay.shapePixmap, ShapeSet);
1821          #else
1822          XShapeCombineMask(xGlobalDisplay, (X11Window)display.window, 2, 0, 0, xDisplay.shapePixmap, ShapeSet);
1823          #endif
1824       }
1825
1826       XFlush(xGlobalDisplay);
1827       if(updateBox == null)
1828       {
1829          xDisplay.updateBox.left = display.width;
1830          xDisplay.updateBox.top = display.height;
1831          xDisplay.updateBox.right = 0;
1832          xDisplay.updateBox.bottom = 0;
1833       }
1834    }
1835
1836    void EndUpdate(Display display)
1837    {
1838
1839    }
1840 }
1841
1842 default dllexport long IS_XGetPixmap(Bitmap bitmap)
1843 {
1844    XBitmap xBitmap = bitmap.driverData;
1845    return xBitmap.pixmap;
1846 }
1847
1848 default dllexport void IS_XGetSurfaceInfo(Surface surface, Pixmap * pixmap, GC * gc, int *x, int * y)
1849 {
1850    Display display = surface.display;
1851    XDisplay xDisplay = display.driverData;
1852
1853    *pixmap = xDisplay.pixmap;
1854    *gc = xDisplay.gc;
1855    *x = surface.offset.x;
1856    *y = surface.offset.y;
1857 }
1858
1859 #endif