git.oblomov.eu Git - wine/blob - dlls/winex11.drv/xrender.c

   1 /*
   2  * Functions to use the XRender extension
   3  *
   4  * Copyright 2001, 2002 Huw D M Davies for CodeWeavers
   5  *
   6  * Some parts also:
   7  * Copyright 2000 Keith Packard, member of The XFree86 Project, Inc.
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 #include <assert.h>
  27 #include <stdarg.h>
  28 #include <string.h>
  29 #include <stdlib.h>
  30
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "x11drv.h"
  34 #include "winternl.h"
  35 #include "wine/library.h"
  36 #include "wine/unicode.h"
  37 #include "wine/debug.h"
  38
  39 int using_client_side_fonts = FALSE;
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(xrender);
  42
  43 #ifdef SONAME_LIBXRENDER
  44
  45 static BOOL X11DRV_XRender_Installed = FALSE;
  46
  47 #include <X11/Xlib.h>
  48 #include <X11/extensions/Xrender.h>
  49
  50
  51 enum drawable_depth_type {mono_drawable, color_drawable};
  52 static XRenderPictFormat *pict_formats[2];
  53
  54 typedef struct
  55 {
  56     LOGFONTW lf;
  57     SIZE     devsize;  /* size in device coords */
  58     DWORD    hash;
  59 } LFANDSIZE;
  60
  61 #define INITIAL_REALIZED_BUF_SIZE 128
  62
  63 typedef enum { AA_None = 0, AA_Grey, AA_RGB, AA_BGR, AA_VRGB, AA_VBGR, AA_MAXVALUE } AA_Type;
  64
  65 typedef struct
  66 {
  67     GlyphSet glyphset;
  68     XRenderPictFormat *font_format;
  69     int nrealized;
  70     BOOL *realized;
  71     void **bitmaps;
  72     XGlyphInfo *gis;
  73 } gsCacheEntryFormat;
  74
  75 typedef struct
  76 {
  77     LFANDSIZE lfsz;
  78     AA_Type aa_default;
  79     gsCacheEntryFormat * format[AA_MAXVALUE];
  80     INT count;
  81     INT next;
  82 } gsCacheEntry;
  83
  84 struct tagXRENDERINFO
  85 {
  86     int                cache_index;
  87     Picture            pict;
  88 };
  89
  90
  91 static gsCacheEntry *glyphsetCache = NULL;
  92 static DWORD glyphsetCacheSize = 0;
  93 static INT lastfree = -1;
  94 static INT mru = -1;
  95
  96 #define INIT_CACHE_SIZE 10
  97
  98 static int antialias = 1;
  99
 100 static void *xrender_handle;
 101
 102 #define MAKE_FUNCPTR(f) static typeof(f) * p##f;
 103 MAKE_FUNCPTR(XRenderAddGlyphs)
 104 MAKE_FUNCPTR(XRenderComposite)
 105 MAKE_FUNCPTR(XRenderCompositeString8)
 106 MAKE_FUNCPTR(XRenderCompositeString16)
 107 MAKE_FUNCPTR(XRenderCompositeString32)
 108 MAKE_FUNCPTR(XRenderCompositeText16)
 109 MAKE_FUNCPTR(XRenderCreateGlyphSet)
 110 MAKE_FUNCPTR(XRenderCreatePicture)
 111 MAKE_FUNCPTR(XRenderFillRectangle)
 112 MAKE_FUNCPTR(XRenderFindFormat)
 113 MAKE_FUNCPTR(XRenderFindVisualFormat)
 114 MAKE_FUNCPTR(XRenderFreeGlyphSet)
 115 MAKE_FUNCPTR(XRenderFreePicture)
 116 MAKE_FUNCPTR(XRenderSetPictureClipRectangles)
 117 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
 118 MAKE_FUNCPTR(XRenderSetPictureTransform)
 119 #endif
 120 MAKE_FUNCPTR(XRenderQueryExtension)
 121 #undef MAKE_FUNCPTR
 122
 123 static CRITICAL_SECTION xrender_cs;
 124 static CRITICAL_SECTION_DEBUG critsect_debug =
 125 {
 126     0, 0, &xrender_cs,
 127     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
 128       0, 0, { (DWORD_PTR)(__FILE__ ": xrender_cs") }
 129 };
 130 static CRITICAL_SECTION xrender_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
 131
 132 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
 133           ( ( (ULONG)_x4 << 24 ) |     \
 134             ( (ULONG)_x3 << 16 ) |     \
 135             ( (ULONG)_x2 <<  8 ) |     \
 136               (ULONG)_x1         )
 137
 138 #define MS_GASP_TAG MS_MAKE_TAG('g', 'a', 's', 'p')
 139
 140 #define GASP_GRIDFIT 0x01
 141 #define GASP_DOGRAY  0x02
 142
 143 #ifdef WORDS_BIGENDIAN
 144 #define get_be_word(x) (x)
 145 #define NATIVE_BYTE_ORDER MSBFirst
 146 #else
 147 #define get_be_word(x) RtlUshortByteSwap(x)
 148 #define NATIVE_BYTE_ORDER LSBFirst
 149 #endif
 150
 151 /***********************************************************************
 152  *   X11DRV_XRender_Init
 153  *
 154  * Let's see if our XServer has the extension available
 155  *
 156  */
 157 void X11DRV_XRender_Init(void)
 158 {
 159     int event_base, i;
 160     XRenderPictFormat pf;
 161
 162     if (client_side_with_render &&
 163         wine_dlopen(SONAME_LIBX11, RTLD_NOW|RTLD_GLOBAL, NULL, 0) &&
 164         wine_dlopen(SONAME_LIBXEXT, RTLD_NOW|RTLD_GLOBAL, NULL, 0) &&
 165         (xrender_handle = wine_dlopen(SONAME_LIBXRENDER, RTLD_NOW, NULL, 0)))
 166     {
 167
 168 #define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(xrender_handle, #f, NULL, 0)) == NULL) goto sym_not_found;
 169 LOAD_FUNCPTR(XRenderAddGlyphs)
 170 LOAD_FUNCPTR(XRenderComposite)
 171 LOAD_FUNCPTR(XRenderCompositeString8)
 172 LOAD_FUNCPTR(XRenderCompositeString16)
 173 LOAD_FUNCPTR(XRenderCompositeString32)
 174 LOAD_FUNCPTR(XRenderCompositeText16)
 175 LOAD_FUNCPTR(XRenderCreateGlyphSet)
 176 LOAD_FUNCPTR(XRenderCreatePicture)
 177 LOAD_FUNCPTR(XRenderFillRectangle)
 178 LOAD_FUNCPTR(XRenderFindFormat)
 179 LOAD_FUNCPTR(XRenderFindVisualFormat)
 180 LOAD_FUNCPTR(XRenderFreeGlyphSet)
 181 LOAD_FUNCPTR(XRenderFreePicture)
 182 LOAD_FUNCPTR(XRenderSetPictureClipRectangles)
 183 LOAD_FUNCPTR(XRenderQueryExtension)
 184 #undef LOAD_FUNCPTR
 185 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
 186 #define LOAD_OPTIONAL_FUNCPTR(f) p##f = wine_dlsym(xrender_handle, #f, NULL, 0);
 187 LOAD_OPTIONAL_FUNCPTR(XRenderSetPictureTransform)
 188 #undef LOAD_OPTIONAL_FUNCPTR
 189 #endif
 190
 191
 192         wine_tsx11_lock();
 193         if(pXRenderQueryExtension(gdi_display, &event_base, &xrender_error_base)) {
 194             X11DRV_XRender_Installed = TRUE;
 195             TRACE("Xrender is up and running error_base = %d\n", xrender_error_base);
 196             pict_formats[color_drawable] = pXRenderFindVisualFormat(gdi_display, visual);
 197             if(!pict_formats[color_drawable])
 198             {
 199                 /* Xrender doesn't like DirectColor visuals, try to find a TrueColor one instead */
 200                 if (visual->class == DirectColor)
 201                 {
 202                     XVisualInfo info;
 203                     if (XMatchVisualInfo( gdi_display, DefaultScreen(gdi_display),
 204                                           screen_depth, TrueColor, &info ))
 205                     {
 206                         pict_formats[color_drawable] = pXRenderFindVisualFormat(gdi_display, info.visual);
 207                         if (pict_formats[color_drawable]) visual = info.visual;
 208                     }
 209                 }
 210             }
 211             if(!pict_formats[color_drawable]) /* This fails in buggy versions of libXrender.so */
 212             {
 213                 wine_tsx11_unlock();
 214                 WINE_MESSAGE(
 215                     "Wine has detected that you probably have a buggy version\n"
 216                     "of libXrender.so .  Because of this client side font rendering\n"
 217                     "will be disabled.  Please upgrade this library.\n");
 218                 X11DRV_XRender_Installed = FALSE;
 219                 return;
 220             }
 221             pf.type = PictTypeDirect;
 222             pf.depth = 1;
 223             pf.direct.alpha = 0;
 224             pf.direct.alphaMask = 1;
 225             pict_formats[mono_drawable] = pXRenderFindFormat(gdi_display, PictFormatType |
 226                                                              PictFormatDepth | PictFormatAlpha |
 227                                                              PictFormatAlphaMask, &pf, 0);
 228             if(!pict_formats[mono_drawable]) {
 229                 ERR("mono_format == NULL?\n");
 230                 X11DRV_XRender_Installed = FALSE;
 231             }
 232             if (!visual->red_mask || !visual->green_mask || !visual->blue_mask) {
 233                 WARN("one or more of the colour masks are 0, disabling XRENDER. Try running in 16-bit mode or higher.\n");
 234                 X11DRV_XRender_Installed = FALSE;
 235             }
 236         }
 237         wine_tsx11_unlock();
 238     }
 239
 240 sym_not_found:
 241     if(X11DRV_XRender_Installed || client_side_with_core)
 242     {
 243         glyphsetCache = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 244                                   sizeof(*glyphsetCache) * INIT_CACHE_SIZE);
 245
 246         glyphsetCacheSize = INIT_CACHE_SIZE;
 247         lastfree = 0;
 248         for(i = 0; i < INIT_CACHE_SIZE; i++) {
 249           glyphsetCache[i].next = i + 1;
 250           glyphsetCache[i].count = -1;
 251         }
 252         glyphsetCache[i-1].next = -1;
 253         using_client_side_fonts = 1;
 254
 255         if(!X11DRV_XRender_Installed) {
 256             TRACE("Xrender is not available on your XServer, client side rendering with the core protocol instead.\n");
 257             if(screen_depth <= 8 || !client_side_antialias_with_core)
 258                 antialias = 0;
 259         } else {
 260             if(screen_depth <= 8 || !client_side_antialias_with_render)
 261                 antialias = 0;
 262         }
 263     }
 264     else TRACE("Using X11 core fonts\n");
 265 }
 266
 267 static BOOL fontcmp(LFANDSIZE *p1, LFANDSIZE *p2)
 268 {
 269   if(p1->hash != p2->hash) return TRUE;
 270   if(memcmp(&p1->devsize, &p2->devsize, sizeof(p1->devsize))) return TRUE;
 271   if(memcmp(&p1->lf, &p2->lf, offsetof(LOGFONTW, lfFaceName))) return TRUE;
 272   return strcmpW(p1->lf.lfFaceName, p2->lf.lfFaceName);
 273 }
 274
 275 #if 0
 276 static void walk_cache(void)
 277 {
 278   int i;
 279
 280   EnterCriticalSection(&xrender_cs);
 281   for(i=mru; i >= 0; i = glyphsetCache[i].next)
 282     TRACE("item %d\n", i);
 283   LeaveCriticalSection(&xrender_cs);
 284 }
 285 #endif
 286
 287 static int LookupEntry(LFANDSIZE *plfsz)
 288 {
 289   int i, prev_i = -1;
 290
 291   for(i = mru; i >= 0; i = glyphsetCache[i].next) {
 292     TRACE("%d\n", i);
 293     if(glyphsetCache[i].count == -1) { /* reached free list so stop */
 294       i = -1;
 295       break;
 296     }
 297
 298     if(!fontcmp(&glyphsetCache[i].lfsz, plfsz)) {
 299       glyphsetCache[i].count++;
 300       if(prev_i >= 0) {
 301         glyphsetCache[prev_i].next = glyphsetCache[i].next;
 302         glyphsetCache[i].next = mru;
 303         mru = i;
 304       }
 305       TRACE("found font in cache %d\n", i);
 306       return i;
 307     }
 308     prev_i = i;
 309   }
 310   TRACE("font not in cache\n");
 311   return -1;
 312 }
 313
 314 static void FreeEntry(int entry)
 315 {
 316     int i, format;
 317
 318     for(format = 0; format < AA_MAXVALUE; format++) {
 319         gsCacheEntryFormat * formatEntry;
 320
 321         if( !glyphsetCache[entry].format[format] )
 322             continue;
 323
 324         formatEntry = glyphsetCache[entry].format[format];
 325
 326         if(formatEntry->glyphset) {
 327             wine_tsx11_lock();
 328             pXRenderFreeGlyphSet(gdi_display, formatEntry->glyphset);
 329             wine_tsx11_unlock();
 330             formatEntry->glyphset = 0;
 331         }
 332         if(formatEntry->nrealized) {
 333             HeapFree(GetProcessHeap(), 0, formatEntry->realized);
 334             formatEntry->realized = NULL;
 335             if(formatEntry->bitmaps) {
 336                 for(i = 0; i < formatEntry->nrealized; i++)
 337                     HeapFree(GetProcessHeap(), 0, formatEntry->bitmaps[i]);
 338                 HeapFree(GetProcessHeap(), 0, formatEntry->bitmaps);
 339                 formatEntry->bitmaps = NULL;
 340             }
 341             HeapFree(GetProcessHeap(), 0, formatEntry->gis);
 342             formatEntry->gis = NULL;
 343             formatEntry->nrealized = 0;
 344         }
 345
 346         HeapFree(GetProcessHeap(), 0, formatEntry);
 347         glyphsetCache[entry].format[format] = NULL;
 348     }
 349 }
 350
 351 static int AllocEntry(void)
 352 {
 353   int best = -1, prev_best = -1, i, prev_i = -1;
 354
 355   if(lastfree >= 0) {
 356     assert(glyphsetCache[lastfree].count == -1);
 357     glyphsetCache[lastfree].count = 1;
 358     best = lastfree;
 359     lastfree = glyphsetCache[lastfree].next;
 360     assert(best != mru);
 361     glyphsetCache[best].next = mru;
 362     mru = best;
 363
 364     TRACE("empty space at %d, next lastfree = %d\n", mru, lastfree);
 365     return mru;
 366   }
 367
 368   for(i = mru; i >= 0; i = glyphsetCache[i].next) {
 369     if(glyphsetCache[i].count == 0) {
 370       best = i;
 371       prev_best = prev_i;
 372     }
 373     prev_i = i;
 374   }
 375
 376   if(best >= 0) {
 377     TRACE("freeing unused glyphset at cache %d\n", best);
 378     FreeEntry(best);
 379     glyphsetCache[best].count = 1;
 380     if(prev_best >= 0) {
 381       glyphsetCache[prev_best].next = glyphsetCache[best].next;
 382       glyphsetCache[best].next = mru;
 383       mru = best;
 384     } else {
 385       assert(mru == best);
 386     }
 387     return mru;
 388   }
 389
 390   TRACE("Growing cache\n");
 391
 392   if (glyphsetCache)
 393     glyphsetCache = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 394                               glyphsetCache,
 395                               (glyphsetCacheSize + INIT_CACHE_SIZE)
 396                               * sizeof(*glyphsetCache));
 397   else
 398     glyphsetCache = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 399                               (glyphsetCacheSize + INIT_CACHE_SIZE)
 400                               * sizeof(*glyphsetCache));
 401
 402   for(best = i = glyphsetCacheSize; i < glyphsetCacheSize + INIT_CACHE_SIZE;
 403       i++) {
 404     glyphsetCache[i].next = i + 1;
 405     glyphsetCache[i].count = -1;
 406   }
 407   glyphsetCache[i-1].next = -1;
 408   glyphsetCacheSize += INIT_CACHE_SIZE;
 409
 410   lastfree = glyphsetCache[best].next;
 411   glyphsetCache[best].count = 1;
 412   glyphsetCache[best].next = mru;
 413   mru = best;
 414   TRACE("new free cache slot at %d\n", mru);
 415   return mru;
 416 }
 417
 418 static BOOL get_gasp_flags(X11DRV_PDEVICE *physDev, WORD *flags)
 419 {
 420     DWORD size;
 421     WORD *gasp, *buffer;
 422     WORD num_recs;
 423     DWORD ppem;
 424     TEXTMETRICW tm;
 425
 426     *flags = 0;
 427
 428     size = GetFontData(physDev->hdc, MS_GASP_TAG,  0, NULL, 0);
 429     if(size == GDI_ERROR)
 430         return FALSE;
 431
 432     gasp = buffer = HeapAlloc(GetProcessHeap(), 0, size);
 433     GetFontData(physDev->hdc, MS_GASP_TAG,  0, gasp, size);
 434
 435     GetTextMetricsW(physDev->hdc, &tm);
 436     ppem = abs(X11DRV_YWStoDS(physDev, tm.tmAscent + tm.tmDescent - tm.tmInternalLeading));
 437
 438     gasp++;
 439     num_recs = get_be_word(*gasp);
 440     gasp++;
 441     while(num_recs--)
 442     {
 443         *flags = get_be_word(*(gasp + 1));
 444         if(ppem <= get_be_word(*gasp))
 445             break;
 446         gasp += 2;
 447     }
 448     TRACE("got flags %04x for ppem %d\n", *flags, ppem);
 449
 450     HeapFree(GetProcessHeap(), 0, buffer);
 451     return TRUE;
 452 }
 453
 454 static AA_Type get_antialias_type( X11DRV_PDEVICE *physDev, BOOL subpixel, BOOL hinter)
 455 {
 456     AA_Type ret;
 457     WORD flags;
 458     UINT font_smoothing_type, font_smoothing_orientation;
 459
 460     if (X11DRV_XRender_Installed && subpixel &&
 461         SystemParametersInfoW( SPI_GETFONTSMOOTHINGTYPE, 0, &font_smoothing_type, 0) &&
 462         font_smoothing_type == FE_FONTSMOOTHINGCLEARTYPE)
 463     {
 464         if ( SystemParametersInfoW( SPI_GETFONTSMOOTHINGORIENTATION, 0,
 465                                     &font_smoothing_orientation, 0) &&
 466              font_smoothing_orientation == FE_FONTSMOOTHINGORIENTATIONBGR)
 467         {
 468             ret = AA_BGR;
 469         }
 470         else
 471             ret = AA_RGB;
 472         /*FIXME
 473           If the monitor is in portrait mode, ClearType is disabled in the MS Windows (MSDN).
 474           But, Wine's subpixel rendering can support the portrait mode.
 475          */
 476     }
 477     else if (!hinter || !get_gasp_flags(physDev, &flags) || flags & GASP_DOGRAY)
 478         ret = AA_Grey;
 479     else
 480         ret = AA_None;
 481
 482     return ret;
 483 }
 484
 485 static int GetCacheEntry(X11DRV_PDEVICE *physDev, LFANDSIZE *plfsz)
 486 {
 487     int ret;
 488     int format;
 489     gsCacheEntry *entry;
 490     static int hinter = -1;
 491     static int subpixel = -1;
 492     BOOL font_smoothing;
 493
 494     if((ret = LookupEntry(plfsz)) != -1) return ret;
 495
 496     ret = AllocEntry();
 497     entry = glyphsetCache + ret;
 498     entry->lfsz = *plfsz;
 499     for( format = 0; format < AA_MAXVALUE; format++ ) {
 500         assert( !entry->format[format] );
 501     }
 502
 503     if(antialias && plfsz->lf.lfQuality != NONANTIALIASED_QUALITY)
 504     {
 505         if(hinter == -1 || subpixel == -1)
 506         {
 507             RASTERIZER_STATUS status;
 508             GetRasterizerCaps(&status, sizeof(status));
 509             hinter = status.wFlags & WINE_TT_HINTER_ENABLED;
 510             subpixel = status.wFlags & WINE_TT_SUBPIXEL_RENDERING_ENABLED;
 511         }
 512
 513         switch (plfsz->lf.lfQuality)
 514         {
 515             case ANTIALIASED_QUALITY:
 516                 entry->aa_default = get_antialias_type( physDev, FALSE, hinter );
 517                 break;
 518             case CLEARTYPE_QUALITY:
 519             case CLEARTYPE_NATURAL_QUALITY:
 520                 entry->aa_default = get_antialias_type( physDev, subpixel, hinter );
 521                 break;
 522             case DEFAULT_QUALITY:
 523             case DRAFT_QUALITY:
 524             case PROOF_QUALITY:
 525             default:
 526                 if ( SystemParametersInfoW( SPI_GETFONTSMOOTHING, 0, &font_smoothing, 0) &&
 527                      font_smoothing)
 528                 {
 529                     entry->aa_default = get_antialias_type( physDev, subpixel, hinter );
 530                 }
 531                 else
 532                     entry->aa_default = AA_None;
 533                 break;
 534         }
 535     }
 536     else
 537         entry->aa_default = AA_None;
 538
 539     return ret;
 540 }
 541
 542 static void dec_ref_cache(int index)
 543 {
 544     assert(index >= 0);
 545     TRACE("dec'ing entry %d to %d\n", index, glyphsetCache[index].count - 1);
 546     assert(glyphsetCache[index].count > 0);
 547     glyphsetCache[index].count--;
 548 }
 549
 550 static void lfsz_calc_hash(LFANDSIZE *plfsz)
 551 {
 552   DWORD hash = 0, *ptr;
 553   int i;
 554
 555   hash ^= plfsz->devsize.cx;
 556   hash ^= plfsz->devsize.cy;
 557   for(i = 0, ptr = (DWORD*)&plfsz->lf; i < 7; i++, ptr++)
 558     hash ^= *ptr;
 559   for(i = 0, ptr = (DWORD*)plfsz->lf.lfFaceName; i < LF_FACESIZE/2; i++, ptr++) {
 560     WCHAR *pwc = (WCHAR *)ptr;
 561     if(!*pwc) break;
 562     hash ^= *ptr;
 563     pwc++;
 564     if(!*pwc) break;
 565   }
 566   plfsz->hash = hash;
 567   return;
 568 }
 569
 570 /***********************************************************************
 571  *   X11DRV_XRender_Finalize
 572  */
 573 void X11DRV_XRender_Finalize(void)
 574 {
 575     int i;
 576
 577     EnterCriticalSection(&xrender_cs);
 578     for(i = mru; i >= 0; i = glyphsetCache[i].next)
 579         FreeEntry(i);
 580     LeaveCriticalSection(&xrender_cs);
 581 }
 582
 583
 584 /***********************************************************************
 585  *   X11DRV_XRender_SelectFont
 586  */
 587 BOOL X11DRV_XRender_SelectFont(X11DRV_PDEVICE *physDev, HFONT hfont)
 588 {
 589     LFANDSIZE lfsz;
 590
 591     GetObjectW(hfont, sizeof(lfsz.lf), &lfsz.lf);
 592     TRACE("h=%d w=%d weight=%d it=%d charset=%d name=%s\n",
 593           lfsz.lf.lfHeight, lfsz.lf.lfWidth, lfsz.lf.lfWeight,
 594           lfsz.lf.lfItalic, lfsz.lf.lfCharSet, debugstr_w(lfsz.lf.lfFaceName));
 595     lfsz.devsize.cx = X11DRV_XWStoDS( physDev, lfsz.lf.lfWidth );
 596     lfsz.devsize.cy = X11DRV_YWStoDS( physDev, lfsz.lf.lfHeight );
 597     lfsz_calc_hash(&lfsz);
 598
 599     EnterCriticalSection(&xrender_cs);
 600     if(!physDev->xrender) {
 601         physDev->xrender = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 602                                      sizeof(*physDev->xrender));
 603         physDev->xrender->cache_index = -1;
 604     }
 605     else if(physDev->xrender->cache_index != -1)
 606         dec_ref_cache(physDev->xrender->cache_index);
 607     physDev->xrender->cache_index = GetCacheEntry(physDev, &lfsz);
 608     LeaveCriticalSection(&xrender_cs);
 609     return 0;
 610 }
 611
 612 /***********************************************************************
 613  *   X11DRV_XRender_DeleteDC
 614  */
 615 void X11DRV_XRender_DeleteDC(X11DRV_PDEVICE *physDev)
 616 {
 617     X11DRV_XRender_UpdateDrawable(physDev);
 618
 619     EnterCriticalSection(&xrender_cs);
 620     if(physDev->xrender->cache_index != -1)
 621         dec_ref_cache(physDev->xrender->cache_index);
 622     LeaveCriticalSection(&xrender_cs);
 623
 624     HeapFree(GetProcessHeap(), 0, physDev->xrender);
 625     physDev->xrender = NULL;
 626     return;
 627 }
 628
 629 /***********************************************************************
 630  *   X11DRV_XRender_UpdateDrawable
 631  *
 632  * This gets called from X11DRV_SetDrawable and X11DRV_SelectBitmap.
 633  * It deletes the pict and tile when the drawable changes.
 634  */
 635 void X11DRV_XRender_UpdateDrawable(X11DRV_PDEVICE *physDev)
 636 {
 637     wine_tsx11_lock();
 638
 639     if(physDev->xrender->pict)
 640     {
 641         TRACE("freeing pict = %lx dc = %p\n", physDev->xrender->pict, physDev->hdc);
 642         XFlush(gdi_display);
 643         pXRenderFreePicture(gdi_display, physDev->xrender->pict);
 644         physDev->xrender->pict = 0;
 645     }
 646     wine_tsx11_unlock();
 647
 648     return;
 649 }
 650
 651 /************************************************************************
 652  *   UploadGlyph
 653  *
 654  * Helper to ExtTextOut.  Must be called inside xrender_cs
 655  */
 656 static BOOL UploadGlyph(X11DRV_PDEVICE *physDev, int glyph, AA_Type format)
 657 {
 658     unsigned int buflen;
 659     char *buf;
 660     Glyph gid;
 661     GLYPHMETRICS gm;
 662     XGlyphInfo gi;
 663     gsCacheEntry *entry = glyphsetCache + physDev->xrender->cache_index;
 664     gsCacheEntryFormat *formatEntry;
 665     UINT ggo_format = GGO_GLYPH_INDEX;
 666     XRenderPictFormat pf;
 667     unsigned long pf_mask;
 668     static const char zero[4];
 669     static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
 670
 671     switch(format) {
 672     case AA_Grey:
 673         ggo_format |= WINE_GGO_GRAY16_BITMAP;
 674         break;
 675     case AA_RGB:
 676         ggo_format |= WINE_GGO_HRGB_BITMAP;
 677         break;
 678     case AA_BGR:
 679         ggo_format |= WINE_GGO_HBGR_BITMAP;
 680         break;
 681     case AA_VRGB:
 682         ggo_format |= WINE_GGO_VRGB_BITMAP;
 683         break;
 684     case AA_VBGR:
 685         ggo_format |= WINE_GGO_VBGR_BITMAP;
 686         break;
 687
 688     default:
 689         ERR("aa = %d - not implemented\n", format);
 690     case AA_None:
 691         ggo_format |= GGO_BITMAP;
 692         break;
 693     }
 694
 695     buflen = GetGlyphOutlineW(physDev->hdc, glyph, ggo_format, &gm, 0, NULL, &identity);
 696     if(buflen == GDI_ERROR) {
 697         if(format != AA_None) {
 698             format = AA_None;
 699             entry->aa_default = AA_None;
 700             ggo_format = GGO_GLYPH_INDEX | GGO_BITMAP;
 701             buflen = GetGlyphOutlineW(physDev->hdc, glyph, ggo_format, &gm, 0, NULL, &identity);
 702         }
 703         if(buflen == GDI_ERROR) {
 704             WARN("GetGlyphOutlineW failed\n");
 705             return FALSE;
 706         }
 707         TRACE("Turning off antialiasing for this monochrome font\n");
 708     }
 709
 710     /* If there is nothing for the current type, we create the entry. */
 711     if( !entry->format[format] ) {
 712         entry->format[format] = HeapAlloc(GetProcessHeap(),
 713                                           HEAP_ZERO_MEMORY,
 714                                           sizeof(gsCacheEntryFormat));
 715     }
 716     formatEntry = entry->format[format];
 717
 718     if(formatEntry->nrealized <= glyph) {
 719         formatEntry->nrealized = (glyph / 128 + 1) * 128;
 720
 721         if (formatEntry->realized)
 722             formatEntry->realized = HeapReAlloc(GetProcessHeap(),
 723                                       HEAP_ZERO_MEMORY,
 724                                       formatEntry->realized,
 725                                       formatEntry->nrealized * sizeof(BOOL));
 726         else
 727             formatEntry->realized = HeapAlloc(GetProcessHeap(),
 728                                       HEAP_ZERO_MEMORY,
 729                                       formatEntry->nrealized * sizeof(BOOL));
 730
 731         if(!X11DRV_XRender_Installed) {
 732           if (formatEntry->bitmaps)
 733             formatEntry->bitmaps = HeapReAlloc(GetProcessHeap(),
 734                                       HEAP_ZERO_MEMORY,
 735                                       formatEntry->bitmaps,
 736                                       formatEntry->nrealized * sizeof(formatEntry->bitmaps[0]));
 737           else
 738             formatEntry->bitmaps = HeapAlloc(GetProcessHeap(),
 739                                       HEAP_ZERO_MEMORY,
 740                                       formatEntry->nrealized * sizeof(formatEntry->bitmaps[0]));
 741         }
 742         if (formatEntry->gis)
 743             formatEntry->gis = HeapReAlloc(GetProcessHeap(),
 744                                    HEAP_ZERO_MEMORY,
 745                                    formatEntry->gis,
 746                                    formatEntry->nrealized * sizeof(formatEntry->gis[0]));
 747         else
 748             formatEntry->gis = HeapAlloc(GetProcessHeap(),
 749                                    HEAP_ZERO_MEMORY,
 750                                    formatEntry->nrealized * sizeof(formatEntry->gis[0]));
 751     }
 752
 753
 754     if(formatEntry->glyphset == 0 && X11DRV_XRender_Installed) {
 755         switch(format) {
 756         case AA_Grey:
 757             pf_mask = PictFormatType | PictFormatDepth | PictFormatAlpha | PictFormatAlphaMask,
 758             pf.type = PictTypeDirect;
 759             pf.depth = 8;
 760             pf.direct.alpha = 0;
 761             pf.direct.alphaMask = 0xff;
 762             break;
 763
 764         case AA_RGB:
 765         case AA_BGR:
 766         case AA_VRGB:
 767         case AA_VBGR:
 768             pf_mask = PictFormatType | PictFormatDepth | PictFormatRed | PictFormatRedMask |
 769                       PictFormatGreen | PictFormatGreenMask | PictFormatBlue |
 770                       PictFormatBlueMask | PictFormatAlpha | PictFormatAlphaMask;
 771             pf.type             = PictTypeDirect;
 772             pf.depth            = 32;
 773             pf.direct.red       = 16;
 774             pf.direct.redMask   = 0xff;
 775             pf.direct.green     = 8;
 776             pf.direct.greenMask = 0xff;
 777             pf.direct.blue      = 0;
 778             pf.direct.blueMask  = 0xff;
 779             pf.direct.alpha     = 24;
 780             pf.direct.alphaMask = 0xff;
 781             break;
 782
 783         default:
 784             ERR("aa = %d - not implemented\n", format);
 785         case AA_None:
 786             pf_mask = PictFormatType | PictFormatDepth | PictFormatAlpha | PictFormatAlphaMask,
 787             pf.type = PictTypeDirect;
 788             pf.depth = 1;
 789             pf.direct.alpha = 0;
 790             pf.direct.alphaMask = 1;
 791             break;
 792         }
 793
 794         wine_tsx11_lock();
 795         formatEntry->font_format = pXRenderFindFormat(gdi_display, pf_mask, &pf, 0);
 796         formatEntry->glyphset = pXRenderCreateGlyphSet(gdi_display, formatEntry->font_format);
 797         wine_tsx11_unlock();
 798     }
 799
 800
 801     buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buflen);
 802     GetGlyphOutlineW(physDev->hdc, glyph, ggo_format, &gm, buflen, buf, &identity);
 803     formatEntry->realized[glyph] = TRUE;
 804
 805     TRACE("buflen = %d. Got metrics: %dx%d adv=%d,%d origin=%d,%d\n",
 806           buflen,
 807           gm.gmBlackBoxX, gm.gmBlackBoxY, gm.gmCellIncX, gm.gmCellIncY,
 808           gm.gmptGlyphOrigin.x, gm.gmptGlyphOrigin.y);
 809
 810     gi.width = gm.gmBlackBoxX;
 811     gi.height = gm.gmBlackBoxY;
 812     gi.x = -gm.gmptGlyphOrigin.x;
 813     gi.y = gm.gmptGlyphOrigin.y;
 814     gi.xOff = gm.gmCellIncX;
 815     gi.yOff = gm.gmCellIncY;
 816
 817     if(TRACE_ON(xrender)) {
 818         int pitch, i, j;
 819         char output[300];
 820         unsigned char *line;
 821
 822         if(format == AA_None) {
 823             pitch = ((gi.width + 31) / 32) * 4;
 824             for(i = 0; i < gi.height; i++) {
 825                 line = (unsigned char*) buf + i * pitch;
 826                 output[0] = '\0';
 827                 for(j = 0; j < pitch * 8; j++) {
 828                     strcat(output, (line[j / 8] & (1 << (7 - (j % 8)))) ? "#" : " ");
 829                 }
 830                 TRACE("%s\n", output);
 831             }
 832         } else {
 833             static const char blks[] = " .:;!o*#";
 834             char str[2];
 835
 836             str[1] = '\0';
 837             pitch = ((gi.width + 3) / 4) * 4;
 838             for(i = 0; i < gi.height; i++) {
 839                 line = (unsigned char*) buf + i * pitch;
 840                 output[0] = '\0';
 841                 for(j = 0; j < pitch; j++) {
 842                     str[0] = blks[line[j] >> 5];
 843                     strcat(output, str);
 844                 }
 845                 TRACE("%s\n", output);
 846             }
 847         }
 848     }
 849
 850
 851     if(formatEntry->glyphset) {
 852         if(format == AA_None && BitmapBitOrder(gdi_display) != MSBFirst) {
 853             unsigned char *byte = (unsigned char*) buf, c;
 854             int i = buflen;
 855
 856             while(i--) {
 857                 c = *byte;
 858
 859                 /* magic to flip bit order */
 860                 c = ((c << 1) & 0xaa) | ((c >> 1) & 0x55);
 861                 c = ((c << 2) & 0xcc) | ((c >> 2) & 0x33);
 862                 c = ((c << 4) & 0xf0) | ((c >> 4) & 0x0f);
 863
 864                 *byte++ = c;
 865             }
 866         }
 867         else if ( format != AA_Grey &&
 868                   ImageByteOrder (gdi_display) != NATIVE_BYTE_ORDER)
 869         {
 870             unsigned int i, *data = (unsigned int *)buf;
 871             for (i = buflen / sizeof(int); i; i--, data++) *data = RtlUlongByteSwap(*data);
 872         }
 873         gid = glyph;
 874
 875         /*
 876           XRenderCompositeText seems to ignore 0x0 glyphs when
 877           AA_None, which means we lose the advance width of glyphs
 878           like the space.  We'll pretend that such glyphs are 1x1
 879           bitmaps.
 880         */
 881
 882         if(buflen == 0)
 883             gi.width = gi.height = 1;
 884
 885         wine_tsx11_lock();
 886         pXRenderAddGlyphs(gdi_display, formatEntry->glyphset, &gid, &gi, 1,
 887                           buflen ? buf : zero, buflen ? buflen : sizeof(zero));
 888         wine_tsx11_unlock();
 889         HeapFree(GetProcessHeap(), 0, buf);
 890     } else {
 891         formatEntry->bitmaps[glyph] = buf;
 892     }
 893
 894     formatEntry->gis[glyph] = gi;
 895
 896     return TRUE;
 897 }
 898
 899 static void SharpGlyphMono(X11DRV_PDEVICE *physDev, INT x, INT y,
 900                             void *bitmap, XGlyphInfo *gi)
 901 {
 902     unsigned char   *srcLine = bitmap, *src;
 903     unsigned char   bits, bitsMask;
 904     int             width = gi->width;
 905     int             stride = ((width + 31) & ~31) >> 3;
 906     int             height = gi->height;
 907     int             w;
 908     int             xspan, lenspan;
 909
 910     TRACE("%d, %d\n", x, y);
 911     x -= gi->x;
 912     y -= gi->y;
 913     while (height--)
 914     {
 915         src = srcLine;
 916         srcLine += stride;
 917         w = width;
 918
 919         bitsMask = 0x80;    /* FreeType is always MSB first */
 920         bits = *src++;
 921
 922         xspan = x;
 923         while (w)
 924         {
 925             if (bits & bitsMask)
 926             {
 927                 lenspan = 0;
 928                 do
 929                 {
 930                     lenspan++;
 931                     if (lenspan == w)
 932                         break;
 933                     bitsMask = bitsMask >> 1;
 934                     if (!bitsMask)
 935                     {
 936                         bits = *src++;
 937                         bitsMask = 0x80;
 938                     }
 939                 } while (bits & bitsMask);
 940                 XFillRectangle (gdi_display, physDev->drawable,
 941                                 physDev->gc, xspan, y, lenspan, 1);
 942                 xspan += lenspan;
 943                 w -= lenspan;
 944             }
 945             else
 946             {
 947                 do
 948                 {
 949                     w--;
 950                     xspan++;
 951                     if (!w)
 952                         break;
 953                     bitsMask = bitsMask >> 1;
 954                     if (!bitsMask)
 955                     {
 956                         bits = *src++;
 957                         bitsMask = 0x80;
 958                     }
 959                 } while (!(bits & bitsMask));
 960             }
 961         }
 962         y++;
 963     }
 964 }
 965
 966 static void SharpGlyphGray(X11DRV_PDEVICE *physDev, INT x, INT y,
 967                             void *bitmap, XGlyphInfo *gi)
 968 {
 969     unsigned char   *srcLine = bitmap, *src, bits;
 970     int             width = gi->width;
 971     int             stride = ((width + 3) & ~3);
 972     int             height = gi->height;
 973     int             w;
 974     int             xspan, lenspan;
 975
 976     x -= gi->x;
 977     y -= gi->y;
 978     while (height--)
 979     {
 980         src = srcLine;
 981         srcLine += stride;
 982         w = width;
 983
 984         bits = *src++;
 985         xspan = x;
 986         while (w)
 987         {
 988             if (bits >= 0x80)
 989             {
 990                 lenspan = 0;
 991                 do
 992                 {
 993                     lenspan++;
 994                     if (lenspan == w)
 995                         break;
 996                     bits = *src++;
 997                 } while (bits >= 0x80);
 998                 XFillRectangle (gdi_display, physDev->drawable,
 999                                 physDev->gc, xspan, y, lenspan, 1);
1000                 xspan += lenspan;
1001                 w -= lenspan;
1002             }
1003             else
1004             {
1005                 do
1006                 {
1007                     w--;
1008                     xspan++;
1009                     if (!w)
1010                         break;
1011                     bits = *src++;
1012                 } while (bits < 0x80);
1013             }
1014         }
1015         y++;
1016     }
1017 }
1018
1019
1020 static void ExamineBitfield (DWORD mask, int *shift, int *len)
1021 {
1022     int s, l;
1023
1024     s = 0;
1025     while ((mask & 1) == 0)
1026     {
1027         mask >>= 1;
1028         s++;
1029     }
1030     l = 0;
1031     while ((mask & 1) == 1)
1032     {
1033         mask >>= 1;
1034         l++;
1035     }
1036     *shift = s;
1037     *len = l;
1038 }
1039
1040 static DWORD GetField (DWORD pixel, int shift, int len)
1041 {
1042     pixel = pixel & (((1 << (len)) - 1) << shift);
1043     pixel = pixel << (32 - (shift + len)) >> 24;
1044     while (len < 8)
1045     {
1046         pixel |= (pixel >> len);
1047         len <<= 1;
1048     }
1049     return pixel;
1050 }
1051
1052
1053 static DWORD PutField (DWORD pixel, int shift, int len)
1054 {
1055     shift = shift - (8 - len);
1056     if (len <= 8)
1057         pixel &= (((1 << len) - 1) << (8 - len));
1058     if (shift < 0)
1059         pixel >>= -shift;
1060     else
1061         pixel <<= shift;
1062     return pixel;
1063 }
1064
1065 static void SmoothGlyphGray(XImage *image, int x, int y, void *bitmap, XGlyphInfo *gi,
1066                             int color)
1067 {
1068     int             r_shift, r_len;
1069     int             g_shift, g_len;
1070     int             b_shift, b_len;
1071     BYTE            *maskLine, *mask, m;
1072     int             maskStride;
1073     DWORD           pixel;
1074     int             width, height;
1075     int             w, tx;
1076     BYTE            src_r, src_g, src_b;
1077
1078     x -= gi->x;
1079     y -= gi->y;
1080     width = gi->width;
1081     height = gi->height;
1082
1083     maskLine = bitmap;
1084     maskStride = (width + 3) & ~3;
1085
1086     ExamineBitfield (image->red_mask, &r_shift, &r_len);
1087     ExamineBitfield (image->green_mask, &g_shift, &g_len);
1088     ExamineBitfield (image->blue_mask, &b_shift, &b_len);
1089
1090     src_r = GetField(color, r_shift, r_len);
1091     src_g = GetField(color, g_shift, g_len);
1092     src_b = GetField(color, b_shift, b_len);
1093
1094     for(; height--; y++)
1095     {
1096         mask = maskLine;
1097         maskLine += maskStride;
1098         w = width;
1099         tx = x;
1100
1101         if(y < 0) continue;
1102         if(y >= image->height) break;
1103
1104         for(; w--; tx++)
1105         {
1106             if(tx >= image->width) break;
1107
1108             m = *mask++;
1109             if(tx < 0) continue;
1110
1111             if (m == 0xff)
1112                 XPutPixel (image, tx, y, color);
1113             else if (m)
1114             {
1115                 BYTE r, g, b;
1116
1117                 pixel = XGetPixel (image, tx, y);
1118
1119                 r = GetField(pixel, r_shift, r_len);
1120                 r = ((BYTE)~m * (WORD)r + (BYTE)m * (WORD)src_r) >> 8;
1121                 g = GetField(pixel, g_shift, g_len);
1122                 g = ((BYTE)~m * (WORD)g + (BYTE)m * (WORD)src_g) >> 8;
1123                 b = GetField(pixel, b_shift, b_len);
1124                 b = ((BYTE)~m * (WORD)b + (BYTE)m * (WORD)src_b) >> 8;
1125
1126                 pixel = (PutField (r, r_shift, r_len) |
1127                          PutField (g, g_shift, g_len) |
1128                          PutField (b, b_shift, b_len));
1129                 XPutPixel (image, tx, y, pixel);
1130             }
1131         }
1132     }
1133 }
1134
1135 /*************************************************************
1136  *                 get_tile_pict
1137  *
1138  * Returns an appropriate Picture for tiling the text colour.
1139  * Call and use result within the xrender_cs
1140  */
1141 static Picture get_tile_pict(enum drawable_depth_type type, int text_pixel)
1142 {
1143     static struct
1144     {
1145         Pixmap xpm;
1146         Picture pict;
1147         int current_color;
1148     } tiles[2], *tile;
1149     XRenderColor col;
1150
1151     tile = &tiles[type];
1152
1153     if(!tile->xpm)
1154     {
1155         XRenderPictureAttributes pa;
1156
1157         wine_tsx11_lock();
1158         tile->xpm = XCreatePixmap(gdi_display, root_window, 1, 1, pict_formats[type]->depth);
1159
1160         pa.repeat = True;
1161         tile->pict = pXRenderCreatePicture(gdi_display, tile->xpm, pict_formats[type], CPRepeat, &pa);
1162         wine_tsx11_unlock();
1163
1164         /* init current_color to something different from text_pixel */
1165         tile->current_color = ~text_pixel;
1166
1167         if(type == mono_drawable)
1168         {
1169             /* for a 1bpp bitmap we always need a 1 in the tile */
1170             col.red = col.green = col.blue = 0;
1171             col.alpha = 0xffff;
1172             wine_tsx11_lock();
1173             pXRenderFillRectangle(gdi_display, PictOpSrc, tile->pict, &col, 0, 0, 1, 1);
1174             wine_tsx11_unlock();
1175         }
1176     }
1177
1178     if(text_pixel != tile->current_color && type == color_drawable)
1179     {
1180         /* Map 0 -- 0xff onto 0 -- 0xffff */
1181         int r_shift, r_len;
1182         int g_shift, g_len;
1183         int b_shift, b_len;
1184
1185         ExamineBitfield (visual->red_mask, &r_shift, &r_len );
1186         ExamineBitfield (visual->green_mask, &g_shift, &g_len);
1187         ExamineBitfield (visual->blue_mask, &b_shift, &b_len);
1188
1189         col.red = GetField(text_pixel, r_shift, r_len);
1190         col.red |= col.red << 8;
1191         col.green = GetField(text_pixel, g_shift, g_len);
1192         col.green |= col.green << 8;
1193         col.blue = GetField(text_pixel, b_shift, b_len);
1194         col.blue |= col.blue << 8;
1195         col.alpha = 0xffff;
1196
1197         wine_tsx11_lock();
1198         pXRenderFillRectangle(gdi_display, PictOpSrc, tile->pict, &col, 0, 0, 1, 1);
1199         wine_tsx11_unlock();
1200         tile->current_color = text_pixel;
1201     }
1202     return tile->pict;
1203 }
1204
1205 static int XRenderErrorHandler(Display *dpy, XErrorEvent *event, void *arg)
1206 {
1207     return 1;
1208 }
1209
1210 /***********************************************************************
1211  *   X11DRV_XRender_ExtTextOut
1212  */
1213 BOOL X11DRV_XRender_ExtTextOut( X11DRV_PDEVICE *physDev, INT x, INT y, UINT flags,
1214                                 const RECT *lprect, LPCWSTR wstr, UINT count,
1215                                 const INT *lpDx )
1216 {
1217     RGNDATA *data;
1218     XGCValues xgcval;
1219     gsCacheEntry *entry;
1220     gsCacheEntryFormat *formatEntry;
1221     BOOL retv = FALSE;
1222     HDC hdc = physDev->hdc;
1223     int textPixel, backgroundPixel;
1224     HRGN saved_region = 0;
1225     BOOL disable_antialias = FALSE;
1226     AA_Type aa_type = AA_None;
1227     DIBSECTION bmp;
1228     unsigned int idx;
1229     double cosEsc, sinEsc;
1230     LOGFONTW lf;
1231     enum drawable_depth_type depth_type = (physDev->depth == 1) ? mono_drawable : color_drawable;
1232     Picture tile_pict = 0;
1233
1234     /* Do we need to disable antialiasing because of palette mode? */
1235     if( !physDev->bitmap || GetObjectW( physDev->bitmap->hbitmap, sizeof(bmp), &bmp ) != sizeof(bmp) ) {
1236         TRACE("bitmap is not a DIB\n");
1237     }
1238     else if (bmp.dsBmih.biBitCount <= 8) {
1239         TRACE("Disabling antialiasing\n");
1240         disable_antialias = TRUE;
1241     }
1242
1243     xgcval.function = GXcopy;
1244     xgcval.background = physDev->backgroundPixel;
1245     xgcval.fill_style = FillSolid;
1246     wine_tsx11_lock();
1247     XChangeGC( gdi_display, physDev->gc, GCFunction | GCBackground | GCFillStyle, &xgcval );
1248     wine_tsx11_unlock();
1249
1250     X11DRV_LockDIBSection( physDev, DIB_Status_GdiMod );
1251
1252     if(physDev->depth == 1) {
1253         if((physDev->textPixel & 0xffffff) == 0) {
1254             textPixel = 0;
1255             backgroundPixel = 1;
1256         } else {
1257             textPixel = 1;
1258             backgroundPixel = 0;
1259         }
1260     } else {
1261         textPixel = physDev->textPixel;
1262         backgroundPixel = physDev->backgroundPixel;
1263     }
1264
1265     if(flags & ETO_OPAQUE)
1266     {
1267         wine_tsx11_lock();
1268         XSetForeground( gdi_display, physDev->gc, backgroundPixel );
1269         XFillRectangle( gdi_display, physDev->drawable, physDev->gc,
1270                         physDev->dc_rect.left + lprect->left, physDev->dc_rect.top + lprect->top,
1271                         lprect->right - lprect->left, lprect->bottom - lprect->top );
1272         wine_tsx11_unlock();
1273     }
1274
1275     if(count == 0)
1276     {
1277         retv = TRUE;
1278         goto done_unlock;
1279     }
1280
1281
1282     GetObjectW(GetCurrentObject(physDev->hdc, OBJ_FONT), sizeof(lf), &lf);
1283     if(lf.lfEscapement != 0) {
1284         cosEsc = cos(lf.lfEscapement * M_PI / 1800);
1285         sinEsc = sin(lf.lfEscapement * M_PI / 1800);
1286     } else {
1287         cosEsc = 1;
1288         sinEsc = 0;
1289     }
1290
1291     if (flags & ETO_CLIPPED)
1292     {
1293         HRGN clip_region;
1294
1295         clip_region = CreateRectRgnIndirect( lprect );
1296         /* make a copy of the current device region */
1297         saved_region = CreateRectRgn( 0, 0, 0, 0 );
1298         CombineRgn( saved_region, physDev->region, 0, RGN_COPY );
1299         X11DRV_SetDeviceClipping( physDev, saved_region, clip_region );
1300         DeleteObject( clip_region );
1301     }
1302
1303     if(X11DRV_XRender_Installed) {
1304         if(!physDev->xrender->pict) {
1305             XRenderPictureAttributes pa;
1306             pa.subwindow_mode = IncludeInferiors;
1307
1308             wine_tsx11_lock();
1309             physDev->xrender->pict = pXRenderCreatePicture(gdi_display,
1310                                                            physDev->drawable,
1311                                                            pict_formats[depth_type],
1312                                                            CPSubwindowMode, &pa);
1313             wine_tsx11_unlock();
1314
1315             TRACE("allocing pict = %lx dc = %p drawable = %08lx\n",
1316                   physDev->xrender->pict, hdc, physDev->drawable);
1317         } else {
1318             TRACE("using existing pict = %lx dc = %p drawable = %08lx\n",
1319                   physDev->xrender->pict, hdc, physDev->drawable);
1320         }
1321
1322         if ((data = X11DRV_GetRegionData( physDev->region, 0 )))
1323         {
1324             wine_tsx11_lock();
1325             pXRenderSetPictureClipRectangles( gdi_display, physDev->xrender->pict,
1326                                               physDev->dc_rect.left, physDev->dc_rect.top,
1327                                               (XRectangle *)data->Buffer, data->rdh.nCount );
1328             wine_tsx11_unlock();
1329             HeapFree( GetProcessHeap(), 0, data );
1330         }
1331     }
1332
1333     EnterCriticalSection(&xrender_cs);
1334
1335     entry = glyphsetCache + physDev->xrender->cache_index;
1336     if( disable_antialias == FALSE )
1337         aa_type = entry->aa_default;
1338     formatEntry = entry->format[aa_type];
1339
1340     for(idx = 0; idx < count; idx++) {
1341         if( !formatEntry ) {
1342             UploadGlyph(physDev, wstr[idx], aa_type);
1343             /* re-evaluate antialias since aa_default may have changed */
1344             if( disable_antialias == FALSE )
1345                 aa_type = entry->aa_default;
1346             formatEntry = entry->format[aa_type];
1347         } else if( wstr[idx] >= formatEntry->nrealized || formatEntry->realized[wstr[idx]] == FALSE) {
1348             UploadGlyph(physDev, wstr[idx], aa_type);
1349         }
1350     }
1351     if (!formatEntry)
1352     {
1353         WARN("could not upload requested glyphs\n");
1354         LeaveCriticalSection(&xrender_cs);
1355         goto done_unlock;
1356     }
1357
1358     TRACE("Writing %s at %d,%d\n", debugstr_wn(wstr,count),
1359           physDev->dc_rect.left + x, physDev->dc_rect.top + y);
1360
1361     if(X11DRV_XRender_Installed)
1362     {
1363         XGlyphElt16 *elts = HeapAlloc(GetProcessHeap(), 0, sizeof(XGlyphElt16) * count);
1364         INT offset = 0;
1365         POINT desired, current;
1366         int render_op = PictOpOver;
1367
1368         /* There's a bug in XRenderCompositeText that ignores the xDst and yDst parameters.
1369            So we pass zeros to the function and move to our starting position using the first
1370            element of the elts array. */
1371
1372         desired.x = physDev->dc_rect.left + x;
1373         desired.y = physDev->dc_rect.top + y;
1374         current.x = current.y = 0;
1375
1376         tile_pict = get_tile_pict(depth_type, physDev->textPixel);
1377
1378         /* FIXME the mapping of Text/BkColor onto 1 or 0 needs investigation.
1379          */
1380         if((depth_type == mono_drawable) && (textPixel == 0))
1381             render_op = PictOpOutReverse; /* This gives us 'black' text */
1382
1383         for(idx = 0; idx < count; idx++)
1384         {
1385             elts[idx].glyphset = formatEntry->glyphset;
1386             elts[idx].chars = wstr + idx;
1387             elts[idx].nchars = 1;
1388             elts[idx].xOff = desired.x - current.x;
1389             elts[idx].yOff = desired.y - current.y;
1390
1391             current.x += (elts[idx].xOff + formatEntry->gis[wstr[idx]].xOff);
1392             current.y += (elts[idx].yOff + formatEntry->gis[wstr[idx]].yOff);
1393
1394             if(!lpDx)
1395             {
1396                 desired.x += formatEntry->gis[wstr[idx]].xOff;
1397                 desired.y += formatEntry->gis[wstr[idx]].yOff;
1398             }
1399             else
1400             {
1401                 offset += lpDx[idx];
1402                 desired.x = physDev->dc_rect.left + x + offset * cosEsc;
1403                 desired.y = physDev->dc_rect.top  + y - offset * sinEsc;
1404             }
1405         }
1406         wine_tsx11_lock();
1407         pXRenderCompositeText16(gdi_display, render_op,
1408                                 tile_pict,
1409                                 physDev->xrender->pict,
1410                                 formatEntry->font_format,
1411                                 0, 0, 0, 0, elts, count);
1412         wine_tsx11_unlock();
1413         HeapFree(GetProcessHeap(), 0, elts);
1414     } else {
1415         INT offset = 0, xoff = 0, yoff = 0;
1416         wine_tsx11_lock();
1417         XSetForeground( gdi_display, physDev->gc, textPixel );
1418
1419         if(aa_type == AA_None || physDev->depth == 1)
1420         {
1421             void (* sharp_glyph_fn)(X11DRV_PDEVICE *, INT, INT, void *, XGlyphInfo *);
1422
1423             if(aa_type == AA_None)
1424                 sharp_glyph_fn = SharpGlyphMono;
1425             else
1426                 sharp_glyph_fn = SharpGlyphGray;
1427
1428             for(idx = 0; idx < count; idx++) {
1429                 sharp_glyph_fn(physDev, physDev->dc_rect.left + x + xoff,
1430                                physDev->dc_rect.top + y + yoff,
1431                                formatEntry->bitmaps[wstr[idx]],
1432                                &formatEntry->gis[wstr[idx]]);
1433                 if(lpDx) {
1434                     offset += lpDx[idx];
1435                     xoff = offset * cosEsc;
1436                     yoff = offset * -sinEsc;
1437                 } else {
1438                     xoff += formatEntry->gis[wstr[idx]].xOff;
1439                     yoff += formatEntry->gis[wstr[idx]].yOff;
1440                 }
1441             }
1442         } else {
1443             XImage *image;
1444             int image_x, image_y, image_off_x, image_off_y, image_w, image_h;
1445             RECT extents = {0, 0, 0, 0};
1446             POINT cur = {0, 0};
1447             int w = physDev->drawable_rect.right - physDev->drawable_rect.left;
1448             int h = physDev->drawable_rect.bottom - physDev->drawable_rect.top;
1449
1450             TRACE("drawable %dx%d\n", w, h);
1451
1452             for(idx = 0; idx < count; idx++) {
1453                 if(extents.left > cur.x - formatEntry->gis[wstr[idx]].x)
1454                     extents.left = cur.x - formatEntry->gis[wstr[idx]].x;
1455                 if(extents.top > cur.y - formatEntry->gis[wstr[idx]].y)
1456                     extents.top = cur.y - formatEntry->gis[wstr[idx]].y;
1457                 if(extents.right < cur.x - formatEntry->gis[wstr[idx]].x + formatEntry->gis[wstr[idx]].width)
1458                     extents.right = cur.x - formatEntry->gis[wstr[idx]].x + formatEntry->gis[wstr[idx]].width;
1459                 if(extents.bottom < cur.y - formatEntry->gis[wstr[idx]].y + formatEntry->gis[wstr[idx]].height)
1460                     extents.bottom = cur.y - formatEntry->gis[wstr[idx]].y + formatEntry->gis[wstr[idx]].height;
1461                 if(lpDx) {
1462                     offset += lpDx[idx];
1463                     cur.x = offset * cosEsc;
1464                     cur.y = offset * -sinEsc;
1465                 } else {
1466                     cur.x += formatEntry->gis[wstr[idx]].xOff;
1467                     cur.y += formatEntry->gis[wstr[idx]].yOff;
1468                 }
1469             }
1470             TRACE("glyph extents %d,%d - %d,%d drawable x,y %d,%d\n", extents.left, extents.top,
1471                   extents.right, extents.bottom, physDev->dc_rect.left + x, physDev->dc_rect.top + y);
1472
1473             if(physDev->dc_rect.left + x + extents.left >= 0) {
1474                 image_x = physDev->dc_rect.left + x + extents.left;
1475                 image_off_x = 0;
1476             } else {
1477                 image_x = 0;
1478                 image_off_x = physDev->dc_rect.left + x + extents.left;
1479             }
1480             if(physDev->dc_rect.top + y + extents.top >= 0) {
1481                 image_y = physDev->dc_rect.top + y + extents.top;
1482                 image_off_y = 0;
1483             } else {
1484                 image_y = 0;
1485                 image_off_y = physDev->dc_rect.top + y + extents.top;
1486             }
1487             if(physDev->dc_rect.left + x + extents.right < w)
1488                 image_w = physDev->dc_rect.left + x + extents.right - image_x;
1489             else
1490                 image_w = w - image_x;
1491             if(physDev->dc_rect.top + y + extents.bottom < h)
1492                 image_h = physDev->dc_rect.top + y + extents.bottom - image_y;
1493             else
1494                 image_h = h - image_y;
1495
1496             if(image_w <= 0 || image_h <= 0) goto no_image;
1497
1498             X11DRV_expect_error(gdi_display, XRenderErrorHandler, NULL);
1499             image = XGetImage(gdi_display, physDev->drawable,
1500                               image_x, image_y, image_w, image_h,
1501                               AllPlanes, ZPixmap);
1502             X11DRV_check_error();
1503
1504             TRACE("XGetImage(%p, %x, %d, %d, %d, %d, %lx, %x) depth = %d rets %p\n",
1505                   gdi_display, (int)physDev->drawable, image_x, image_y,
1506                   image_w, image_h, AllPlanes, ZPixmap,
1507                   physDev->depth, image);
1508             if(!image) {
1509                 Pixmap xpm = XCreatePixmap(gdi_display, root_window, image_w, image_h,
1510                                            physDev->depth);
1511                 GC gc;
1512                 XGCValues gcv;
1513
1514                 gcv.graphics_exposures = False;
1515                 gc = XCreateGC(gdi_display, xpm, GCGraphicsExposures, &gcv);
1516                 XCopyArea(gdi_display, physDev->drawable, xpm, gc, image_x, image_y,
1517                           image_w, image_h, 0, 0);
1518                 XFreeGC(gdi_display, gc);
1519                 X11DRV_expect_error(gdi_display, XRenderErrorHandler, NULL);
1520                 image = XGetImage(gdi_display, xpm, 0, 0, image_w, image_h, AllPlanes,
1521                                   ZPixmap);
1522                 X11DRV_check_error();
1523                 XFreePixmap(gdi_display, xpm);
1524             }
1525             if(!image) goto no_image;
1526
1527             image->red_mask = visual->red_mask;
1528             image->green_mask = visual->green_mask;
1529             image->blue_mask = visual->blue_mask;
1530
1531             offset = xoff = yoff = 0;
1532             for(idx = 0; idx < count; idx++) {
1533                 SmoothGlyphGray(image, xoff + image_off_x - extents.left,
1534                                 yoff + image_off_y - extents.top,
1535                                 formatEntry->bitmaps[wstr[idx]],
1536                                 &formatEntry->gis[wstr[idx]],
1537                                 physDev->textPixel);
1538                 if(lpDx) {
1539                     offset += lpDx[idx];
1540                     xoff = offset * cosEsc;
1541                     yoff = offset * -sinEsc;
1542                 } else {
1543                     xoff += formatEntry->gis[wstr[idx]].xOff;
1544                     yoff += formatEntry->gis[wstr[idx]].yOff;
1545                 }
1546             }
1547             XPutImage(gdi_display, physDev->drawable, physDev->gc, image, 0, 0,
1548                       image_x, image_y, image_w, image_h);
1549             XDestroyImage(image);
1550         }
1551     no_image:
1552         wine_tsx11_unlock();
1553     }
1554     LeaveCriticalSection(&xrender_cs);
1555
1556     if (flags & ETO_CLIPPED)
1557     {
1558         /* restore the device region */
1559         X11DRV_SetDeviceClipping( physDev, saved_region, 0 );
1560         DeleteObject( saved_region );
1561     }
1562
1563     retv = TRUE;
1564
1565 done_unlock:
1566     X11DRV_UnlockDIBSection( physDev, TRUE );
1567     return retv;
1568 }
1569
1570 /******************************************************************************
1571  * AlphaBlend         (x11drv.@)
1572  */
1573 BOOL CDECL X11DRV_AlphaBlend(X11DRV_PDEVICE *devDst, INT xDst, INT yDst, INT widthDst, INT heightDst,
1574                              X11DRV_PDEVICE *devSrc, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc,
1575                              BLENDFUNCTION blendfn)
1576 {
1577     XRenderPictureAttributes pa;
1578     XRenderPictFormat *src_format;
1579     XRenderPictFormat argb32_templ = {
1580         0,                          /* id */
1581         PictTypeDirect,             /* type */
1582         32,                         /* depth */
1583         {                           /* direct */
1584             16,                     /* direct.red */
1585             0xff,                   /* direct.redMask */
1586             8,                      /* direct.green */
1587             0xff,                   /* direct.greenMask */
1588             0,                      /* direct.blue */
1589             0xff,                   /* direct.blueMask */
1590             24,                     /* direct.alpha */
1591             0xff,                   /* direct.alphaMask */
1592         },
1593         0,                          /* colormap */
1594     };
1595     unsigned long argb32_templ_mask =
1596         PictFormatType |
1597         PictFormatDepth |
1598         PictFormatRed |
1599         PictFormatRedMask |
1600         PictFormatGreen |
1601         PictFormatGreenMask |
1602         PictFormatBlue |
1603         PictFormatBlueMask |
1604         PictFormatAlpha |
1605         PictFormatAlphaMask;
1606
1607     Picture dst_pict, src_pict;
1608     Pixmap xpm;
1609     DIBSECTION dib;
1610     XImage *image;
1611     GC gc;
1612     XGCValues gcv;
1613     DWORD *dstbits, *data;
1614     int y, y2;
1615     POINT pts[2];
1616     BOOL top_down = FALSE;
1617     RGNDATA *rgndata;
1618     enum drawable_depth_type dst_depth_type = (devDst->depth == 1) ? mono_drawable : color_drawable;
1619
1620     if(!X11DRV_XRender_Installed) {
1621         FIXME("Unable to AlphaBlend without Xrender\n");
1622         return FALSE;
1623     }
1624     pts[0].x = xDst;
1625     pts[0].y = yDst;
1626     pts[1].x = xDst + widthDst;
1627     pts[1].y = yDst + heightDst;
1628     LPtoDP(devDst->hdc, pts, 2);
1629     xDst      = pts[0].x;
1630     yDst      = pts[0].y;
1631     widthDst  = pts[1].x - pts[0].x;
1632     heightDst = pts[1].y - pts[0].y;
1633
1634     pts[0].x = xSrc;
1635     pts[0].y = ySrc;
1636     pts[1].x = xSrc + widthSrc;
1637     pts[1].y = ySrc + heightSrc;
1638     LPtoDP(devSrc->hdc, pts, 2);
1639     xSrc      = pts[0].x;
1640     ySrc      = pts[0].y;
1641     widthSrc  = pts[1].x - pts[0].x;
1642     heightSrc = pts[1].y - pts[0].y;
1643     if (!widthDst || !heightDst || !widthSrc || !heightSrc) return TRUE;
1644
1645 #ifndef HAVE_XRENDERSETPICTURETRANSFORM
1646     if(widthDst != widthSrc || heightDst != heightSrc)
1647 #else
1648     if(!pXRenderSetPictureTransform)
1649 #endif
1650     {
1651         FIXME("Unable to Stretch, XRenderSetPictureTransform is currently required\n");
1652         return FALSE;
1653     }
1654
1655     if (!devSrc->bitmap || GetObjectW( devSrc->bitmap->hbitmap, sizeof(dib), &dib ) != sizeof(dib))
1656     {
1657         static BOOL out = FALSE;
1658         if (!out)
1659         {
1660             FIXME("not a dibsection\n");
1661             out = TRUE;
1662         }
1663         return FALSE;
1664     }
1665
1666     if (xSrc < 0 || ySrc < 0 || widthSrc < 0 || heightSrc < 0 || xSrc + widthSrc > dib.dsBmih.biWidth
1667         || ySrc + heightSrc > abs(dib.dsBmih.biHeight))
1668     {
1669         WARN("Invalid src coords: (%d,%d), size %dx%d\n", xSrc, ySrc, widthSrc, heightSrc);
1670         SetLastError(ERROR_INVALID_PARAMETER);
1671         return FALSE;
1672     }
1673
1674     if ((blendfn.AlphaFormat & AC_SRC_ALPHA) && blendfn.SourceConstantAlpha != 0xff)
1675         FIXME("Ignoring SourceConstantAlpha %d for AC_SRC_ALPHA\n", blendfn.SourceConstantAlpha);
1676
1677     if(dib.dsBm.bmBitsPixel != 32) {
1678         FIXME("not a 32 bpp dibsection\n");
1679         return FALSE;
1680     }
1681     dstbits = data = HeapAlloc(GetProcessHeap(), 0, heightSrc * widthSrc * 4);
1682
1683     if(dib.dsBmih.biHeight < 0) { /* top-down dib */
1684         top_down = TRUE;
1685         dstbits += widthSrc * (heightSrc - 1);
1686         y2 = ySrc;
1687         y = y2 + heightSrc - 1;
1688     }
1689     else
1690     {
1691         y = dib.dsBmih.biHeight - ySrc - 1;
1692         y2 = y - heightSrc + 1;
1693     }
1694
1695     if (blendfn.AlphaFormat & AC_SRC_ALPHA)
1696     {
1697         for(; y >= y2; y--)
1698         {
1699             memcpy(dstbits, (char *)dib.dsBm.bmBits + y * dib.dsBm.bmWidthBytes + xSrc * 4,
1700                    widthSrc * 4);
1701             dstbits += (top_down ? -1 : 1) * widthSrc;
1702         }
1703     }
1704     else
1705     {
1706         DWORD source_alpha = (DWORD)blendfn.SourceConstantAlpha << 24;
1707         int x;
1708
1709         for(; y >= y2; y--)
1710         {
1711             DWORD *srcbits = (DWORD *)((char *)dib.dsBm.bmBits + y * dib.dsBm.bmWidthBytes) + xSrc;
1712             for (x = 0; x < widthSrc; x++)
1713             {
1714                 DWORD argb = *srcbits++;
1715                 argb = (argb & 0xffffff) | source_alpha;
1716                 *dstbits++ = argb;
1717             }
1718             if (top_down)  /* we traversed the row forward so we should go back by two rows */
1719                 dstbits -= 2 * widthSrc;
1720         }
1721
1722     }
1723
1724     rgndata = X11DRV_GetRegionData( devDst->region, 0 );
1725
1726     wine_tsx11_lock();
1727     image = XCreateImage(gdi_display, visual, 32, ZPixmap, 0,
1728                          (char*) data, widthSrc, heightSrc, 32, widthSrc * 4);
1729
1730     /*
1731       Avoid using XRenderFindStandardFormat as older libraries don't have it
1732       src_format = pXRenderFindStandardFormat(gdi_display, PictStandardARGB32);
1733     */
1734     src_format = pXRenderFindFormat(gdi_display, argb32_templ_mask, &argb32_templ, 0);
1735
1736     TRACE("src_format %p\n", src_format);
1737
1738     pa.subwindow_mode = IncludeInferiors;
1739
1740     /* FIXME use devDst->xrender->pict ? */
1741     dst_pict = pXRenderCreatePicture(gdi_display,
1742                                      devDst->drawable,
1743                                      pict_formats[dst_depth_type],
1744                                      CPSubwindowMode, &pa);
1745     TRACE("dst_pict %08lx\n", dst_pict);
1746     TRACE("src_drawable = %08lx\n", devSrc->drawable);
1747     xpm = XCreatePixmap(gdi_display,
1748                         root_window,
1749                         widthSrc, heightSrc, 32);
1750     gcv.graphics_exposures = False;
1751     gc = XCreateGC(gdi_display, xpm, GCGraphicsExposures, &gcv);
1752     TRACE("xpm = %08lx\n", xpm);
1753     XPutImage(gdi_display, xpm, gc, image, 0, 0, 0, 0, widthSrc, heightSrc);
1754
1755     src_pict = pXRenderCreatePicture(gdi_display,
1756                                      xpm, src_format,
1757                                      CPSubwindowMode, &pa);
1758     TRACE("src_pict %08lx\n", src_pict);
1759
1760     if (rgndata)
1761     {
1762         pXRenderSetPictureClipRectangles( gdi_display, dst_pict,
1763                                           devDst->dc_rect.left, devDst->dc_rect.top,
1764                                           (XRectangle *)rgndata->Buffer,
1765                                           rgndata->rdh.nCount );
1766         HeapFree( GetProcessHeap(), 0, rgndata );
1767     }
1768
1769 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
1770     if(widthDst != widthSrc || heightDst != heightSrc) {
1771         double xscale = widthSrc/(double)widthDst;
1772         double yscale = heightSrc/(double)heightDst;
1773         XTransform xform = {{
1774             { XDoubleToFixed(xscale), XDoubleToFixed(0), XDoubleToFixed(0) },
1775             { XDoubleToFixed(0), XDoubleToFixed(yscale), XDoubleToFixed(0) },
1776             { XDoubleToFixed(0), XDoubleToFixed(0), XDoubleToFixed(1) }
1777         }};
1778         pXRenderSetPictureTransform(gdi_display, src_pict, &xform);
1779     }
1780 #endif
1781     pXRenderComposite(gdi_display, PictOpOver, src_pict, 0, dst_pict,
1782                       0, 0, 0, 0,
1783                       xDst + devDst->dc_rect.left, yDst + devDst->dc_rect.top, widthDst, heightDst);
1784
1785
1786     pXRenderFreePicture(gdi_display, src_pict);
1787     XFreePixmap(gdi_display, xpm);
1788     XFreeGC(gdi_display, gc);
1789     pXRenderFreePicture(gdi_display, dst_pict);
1790     image->data = NULL;
1791     XDestroyImage(image);
1792
1793     wine_tsx11_unlock();
1794     HeapFree(GetProcessHeap(), 0, data);
1795     return TRUE;
1796 }
1797
1798 #else /* SONAME_LIBXRENDER */
1799
1800 void X11DRV_XRender_Init(void)
1801 {
1802     TRACE("XRender support not compiled in.\n");
1803     return;
1804 }
1805
1806 void X11DRV_XRender_Finalize(void)
1807 {
1808 }
1809
1810 BOOL X11DRV_XRender_SelectFont(X11DRV_PDEVICE *physDev, HFONT hfont)
1811 {
1812   assert(0);
1813   return FALSE;
1814 }
1815
1816 void X11DRV_XRender_DeleteDC(X11DRV_PDEVICE *physDev)
1817 {
1818   assert(0);
1819   return;
1820 }
1821
1822 BOOL X11DRV_XRender_ExtTextOut( X11DRV_PDEVICE *physDev, INT x, INT y, UINT flags,
1823                                 const RECT *lprect, LPCWSTR wstr, UINT count,
1824                                 const INT *lpDx )
1825 {
1826   assert(0);
1827   return FALSE;
1828 }
1829
1830 void X11DRV_XRender_UpdateDrawable(X11DRV_PDEVICE *physDev)
1831 {
1832   assert(0);
1833   return;
1834 }
1835
1836 /******************************************************************************
1837  * AlphaBlend         (x11drv.@)
1838  */
1839 BOOL X11DRV_AlphaBlend(X11DRV_PDEVICE *devDst, INT xDst, INT yDst, INT widthDst, INT heightDst,
1840                        X11DRV_PDEVICE *devSrc, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc,
1841                        BLENDFUNCTION blendfn)
1842 {
1843   FIXME("not supported - XRENDER headers were missing at compile time\n");
1844   return FALSE;
1845 }
1846
1847 #endif /* SONAME_LIBXRENDER */