?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
jscript: Removed unused do_*_tag_format arguments.
[wine/multimedia.git] / dlls / winex11.drv / xrender.c
blob11b2ccf5bf29ab9105af2f44af73cead7242d3f1
1 /*
2 * Functions to use the XRender extension
3 *
4 * Copyright 2001, 2002 Huw D M Davies for CodeWeavers
5 * Copyright 2009 Roderick Colenbrander
6 * Copyright 2011 Alexandre Julliard
7 *
8 * Some parts also:
9 * Copyright 2000 Keith Packard, member of The XFree86 Project, Inc.
10 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 */
25 #include "config.h"
26 #include "wine/port.h"
27
28 #include <assert.h>
29 #include <stdarg.h>
30 #include <string.h>
31 #include <stdlib.h>
32
33 #include "windef.h"
34 #include "winbase.h"
35 #include "x11drv.h"
36 #include "winternl.h"
37 #include "wine/library.h"
38 #include "wine/unicode.h"
39 #include "wine/debug.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(xrender);
42
43 #ifdef SONAME_LIBXRENDER
44
45 WINE_DECLARE_DEBUG_CHANNEL(winediag);
46
47 #include <X11/Xlib.h>
48 #include <X11/extensions/Xrender.h>
49
50 #ifndef RepeatNone /* added in 0.10 */
51 #define RepeatNone 0
52 #define RepeatNormal 1
53 #define RepeatPad 2
54 #define RepeatReflect 3
55 #endif
56
57 enum wxr_format
58 {
59 WXR_FORMAT_MONO,
60 WXR_FORMAT_GRAY,
61 WXR_FORMAT_X1R5G5B5,
62 WXR_FORMAT_X1B5G5R5,
63 WXR_FORMAT_R5G6B5,
64 WXR_FORMAT_B5G6R5,
65 WXR_FORMAT_R8G8B8,
66 WXR_FORMAT_B8G8R8,
67 WXR_FORMAT_A8R8G8B8,
68 WXR_FORMAT_B8G8R8A8,
69 WXR_FORMAT_X8R8G8B8,
70 WXR_FORMAT_B8G8R8X8,
71 WXR_NB_FORMATS,
72 WXR_INVALID_FORMAT = WXR_NB_FORMATS
73 };
74
75 typedef struct wine_xrender_format_template
76 {
77 unsigned int depth;
78 unsigned int alpha;
79 unsigned int alphaMask;
80 unsigned int red;
81 unsigned int redMask;
82 unsigned int green;
83 unsigned int greenMask;
84 unsigned int blue;
85 unsigned int blueMask;
86 } WineXRenderFormatTemplate;
87
88 static const WineXRenderFormatTemplate wxr_formats_template[WXR_NB_FORMATS] =
89 {
90 /* Format depth alpha mask red mask green mask blue mask*/
91 /* WXR_FORMAT_MONO */ { 1, 0, 0x01, 0, 0, 0, 0, 0, 0 },
92 /* WXR_FORMAT_GRAY */ { 8, 0, 0xff, 0, 0, 0, 0, 0, 0 },
93 /* WXR_FORMAT_X1R5G5B5 */ { 16, 0, 0, 10, 0x1f, 5, 0x1f, 0, 0x1f },
94 /* WXR_FORMAT_X1B5G5R5 */ { 16, 0, 0, 0, 0x1f, 5, 0x1f, 10, 0x1f },
95 /* WXR_FORMAT_R5G6B5 */ { 16, 0, 0, 11, 0x1f, 5, 0x3f, 0, 0x1f },
96 /* WXR_FORMAT_B5G6R5 */ { 16, 0, 0, 0, 0x1f, 5, 0x3f, 11, 0x1f },
97 /* WXR_FORMAT_R8G8B8 */ { 24, 0, 0, 16, 0xff, 8, 0xff, 0, 0xff },
98 /* WXR_FORMAT_B8G8R8 */ { 24, 0, 0, 0, 0xff, 8, 0xff, 16, 0xff },
99 /* WXR_FORMAT_A8R8G8B8 */ { 32, 24, 0xff, 16, 0xff, 8, 0xff, 0, 0xff },
100 /* WXR_FORMAT_B8G8R8A8 */ { 32, 0, 0xff, 8, 0xff, 16, 0xff, 24, 0xff },
101 /* WXR_FORMAT_X8R8G8B8 */ { 32, 0, 0, 16, 0xff, 8, 0xff, 0, 0xff },
102 /* WXR_FORMAT_B8G8R8X8 */ { 32, 0, 0, 8, 0xff, 16, 0xff, 24, 0xff },
103 };
104
105 static const ColorShifts wxr_color_shifts[WXR_NB_FORMATS] =
106 {
107 /* format phys red phys green phys blue log red log green log blue */
108 /* WXR_FORMAT_MONO */ { { 0,0,0 }, { 0,0,0 }, { 0,0,0 }, { 0,0,0 }, { 0,0,0 }, { 0,0,0 } },
109 /* WXR_FORMAT_GRAY */ { { 0,0,0 }, { 0,0,0 }, { 0,0,0 }, { 0,0,0 }, { 0,0,0 }, { 0,0,0 } },
110 /* WXR_FORMAT_X1R5G5B5 */ { {10,5,31}, { 5,5,31}, { 0,5,31}, {10,5,31}, { 5,5,31}, { 0,5,31} },
111 /* WXR_FORMAT_X1B5G5R5 */ { { 0,5,31}, { 5,5,31}, {10,5,31}, { 0,5,31}, { 5,5,31}, {10,5,31} },
112 /* WXR_FORMAT_R5G6B5 */ { {11,5,31}, { 5,6,63}, { 0,5,31}, {11,5,31}, { 5,6,63}, { 0,5,31} },
113 /* WXR_FORMAT_B5G6R5 */ { { 0,5,31}, { 5,6,63}, {11,5,31}, { 0,5,31}, { 5,6,63}, {11,5,31} },
114 /* WXR_FORMAT_R8G8B8 */ { {16,8,255}, { 8,8,255}, { 0,8,255}, {16,8,255}, { 8,8,255}, { 0,8,255} },
115 /* WXR_FORMAT_B8G8R8 */ { { 0,8,255}, { 8,8,255}, {16,8,255}, { 0,8,255}, { 8,8,255}, {16,8,255} },
116 /* WXR_FORMAT_A8R8G8B8 */ { {16,8,255}, { 8,8,255}, { 0,8,255}, {16,8,255}, { 8,8,255}, { 0,8,255} },
117 /* WXR_FORMAT_B8G8R8A8 */ { { 8,8,255}, {16,8,255}, {24,8,255}, { 8,8,255}, {16,8,255}, {24,8,255} },
118 /* WXR_FORMAT_X8R8G8B8 */ { {16,8,255}, { 8,8,255}, { 0,8,255}, {16,8,255}, { 8,8,255}, { 0,8,255} },
119 /* WXR_FORMAT_B8G8R8X8 */ { { 8,8,255}, {16,8,255}, {24,8,255}, { 8,8,255}, {16,8,255}, {24,8,255} },
120 };
121
122 static enum wxr_format default_format = WXR_INVALID_FORMAT;
123 static XRenderPictFormat *pict_formats[WXR_NB_FORMATS + 1 /* invalid format */];
124
125 typedef struct
126 {
127 LOGFONTW lf;
128 XFORM xform;
129 SIZE devsize; /* size in device coords */
130 DWORD hash;
131 } LFANDSIZE;
132
133 #define INITIAL_REALIZED_BUF_SIZE 128
134
135 typedef enum { AA_None = 0, AA_Grey, AA_RGB, AA_BGR, AA_VRGB, AA_VBGR, AA_MAXVALUE } AA_Type;
136
137 typedef struct
138 {
139 GlyphSet glyphset;
140 XRenderPictFormat *font_format;
141 int nrealized;
142 BOOL *realized;
143 XGlyphInfo *gis;
144 } gsCacheEntryFormat;
145
146 typedef struct
147 {
148 LFANDSIZE lfsz;
149 AA_Type aa_default;
150 gsCacheEntryFormat * format[AA_MAXVALUE];
151 INT count;
152 INT next;
153 } gsCacheEntry;
154
155 struct xrender_physdev
156 {
157 struct gdi_physdev dev;
158 X11DRV_PDEVICE *x11dev;
159 HRGN region;
160 enum wxr_format format;
161 int cache_index;
162 BOOL update_clip;
163 Picture pict;
164 Picture pict_src;
165 XRenderPictFormat *pict_format;
166 };
167
168 static inline struct xrender_physdev *get_xrender_dev( PHYSDEV dev )
169 {
170 return (struct xrender_physdev *)dev;
171 }
172
173 static const struct gdi_dc_funcs xrender_funcs;
174
175 static gsCacheEntry *glyphsetCache = NULL;
176 static DWORD glyphsetCacheSize = 0;
177 static INT lastfree = -1;
178 static INT mru = -1;
179
180 #define INIT_CACHE_SIZE 10
181
182 static int antialias = 1;
183
184 static void *xrender_handle;
185
186 #define MAKE_FUNCPTR(f) static typeof(f) * p##f;
187 MAKE_FUNCPTR(XRenderAddGlyphs)
188 MAKE_FUNCPTR(XRenderChangePicture)
189 MAKE_FUNCPTR(XRenderComposite)
190 MAKE_FUNCPTR(XRenderCompositeText16)
191 MAKE_FUNCPTR(XRenderCreateGlyphSet)
192 MAKE_FUNCPTR(XRenderCreatePicture)
193 MAKE_FUNCPTR(XRenderFillRectangle)
194 MAKE_FUNCPTR(XRenderFindFormat)
195 MAKE_FUNCPTR(XRenderFindVisualFormat)
196 MAKE_FUNCPTR(XRenderFreeGlyphSet)
197 MAKE_FUNCPTR(XRenderFreePicture)
198 MAKE_FUNCPTR(XRenderSetPictureClipRectangles)
199 #ifdef HAVE_XRENDERCREATELINEARGRADIENT
200 MAKE_FUNCPTR(XRenderCreateLinearGradient)
201 #endif
202 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
203 MAKE_FUNCPTR(XRenderSetPictureTransform)
204 #endif
205 MAKE_FUNCPTR(XRenderQueryExtension)
206
207 #ifdef SONAME_LIBFONTCONFIG
208 #include <fontconfig/fontconfig.h>
209 MAKE_FUNCPTR(FcConfigSubstitute)
210 MAKE_FUNCPTR(FcDefaultSubstitute)
211 MAKE_FUNCPTR(FcFontMatch)
212 MAKE_FUNCPTR(FcInit)
213 MAKE_FUNCPTR(FcPatternCreate)
214 MAKE_FUNCPTR(FcPatternDestroy)
215 MAKE_FUNCPTR(FcPatternAddInteger)
216 MAKE_FUNCPTR(FcPatternAddString)
217 MAKE_FUNCPTR(FcPatternGetBool)
218 MAKE_FUNCPTR(FcPatternGetInteger)
219 MAKE_FUNCPTR(FcPatternGetString)
220 static void *fontconfig_handle;
221 static BOOL fontconfig_installed;
222 #endif
223
224 #undef MAKE_FUNCPTR
225
226 static CRITICAL_SECTION xrender_cs;
227 static CRITICAL_SECTION_DEBUG critsect_debug =
228 {
229 0, 0, &xrender_cs,
230 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
231 0, 0, { (DWORD_PTR)(__FILE__ ": xrender_cs") }
232 };
233 static CRITICAL_SECTION xrender_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
234
235 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
236 ( ( (ULONG)_x4 << 24 ) | \
237 ( (ULONG)_x3 << 16 ) | \
238 ( (ULONG)_x2 << 8 ) | \
239 (ULONG)_x1 )
240
241 #define MS_GASP_TAG MS_MAKE_TAG('g', 'a', 's', 'p')
242
243 #define GASP_GRIDFIT 0x01
244 #define GASP_DOGRAY 0x02
245
246 #ifdef WORDS_BIGENDIAN
247 #define get_be_word(x) (x)
248 #define NATIVE_BYTE_ORDER MSBFirst
249 #else
250 #define get_be_word(x) RtlUshortByteSwap(x)
251 #define NATIVE_BYTE_ORDER LSBFirst
252 #endif
253
254 static BOOL has_alpha( enum wxr_format format )
255 {
256 return (format == WXR_FORMAT_A8R8G8B8 || format == WXR_FORMAT_B8G8R8A8);
257 }
258
259 static enum wxr_format get_format_without_alpha( enum wxr_format format )
260 {
261 switch (format)
262 {
263 case WXR_FORMAT_A8R8G8B8: return WXR_FORMAT_X8R8G8B8;
264 case WXR_FORMAT_B8G8R8A8: return WXR_FORMAT_B8G8R8X8;
265 default: return format;
266 }
267 }
268
269 static BOOL get_xrender_template(const WineXRenderFormatTemplate *fmt, XRenderPictFormat *templ, unsigned long *mask)
270 {
271 templ->id = 0;
272 templ->type = PictTypeDirect;
273 templ->depth = fmt->depth;
274 templ->direct.alpha = fmt->alpha;
275 templ->direct.alphaMask = fmt->alphaMask;
276 templ->direct.red = fmt->red;
277 templ->direct.redMask = fmt->redMask;
278 templ->direct.green = fmt->green;
279 templ->direct.greenMask = fmt->greenMask;
280 templ->direct.blue = fmt->blue;
281 templ->direct.blueMask = fmt->blueMask;
282 templ->colormap = 0;
283
284 *mask = PictFormatType | PictFormatDepth | PictFormatAlpha | PictFormatAlphaMask | PictFormatRed | PictFormatRedMask | PictFormatGreen | PictFormatGreenMask | PictFormatBlue | PictFormatBlueMask;
285
286 return TRUE;
287 }
288
289 static BOOL is_wxrformat_compatible_with_default_visual(const WineXRenderFormatTemplate *fmt)
290 {
291 if(fmt->depth != screen_depth)
292 return FALSE;
293 if( (fmt->redMask << fmt->red) != visual->red_mask)
294 return FALSE;
295 if( (fmt->greenMask << fmt->green) != visual->green_mask)
296 return FALSE;
297 if( (fmt->blueMask << fmt->blue) != visual->blue_mask)
298 return FALSE;
299
300 /* We never select a default ARGB visual */
301 if(fmt->alphaMask)
302 return FALSE;
303
304 return TRUE;
305 }
306
307 static int load_xrender_formats(void)
308 {
309 int count = 0;
310 unsigned int i;
311
312 for (i = 0; i < WXR_NB_FORMATS; i++)
313 {
314 XRenderPictFormat templ;
315
316 if(is_wxrformat_compatible_with_default_visual(&wxr_formats_template[i]))
317 {
318 wine_tsx11_lock();
319 pict_formats[i] = pXRenderFindVisualFormat(gdi_display, visual);
320 if (!pict_formats[i])
321 {
322 /* Xrender doesn't like DirectColor visuals, try to find a TrueColor one instead */
323 if (visual->class == DirectColor)
324 {
325 XVisualInfo info;
326 if (XMatchVisualInfo( gdi_display, DefaultScreen(gdi_display),
327 screen_depth, TrueColor, &info ))
328 {
329 pict_formats[i] = pXRenderFindVisualFormat(gdi_display, info.visual);
330 if (pict_formats[i]) visual = info.visual;
331 }
332 }
333 }
334 wine_tsx11_unlock();
335 if (pict_formats[i]) default_format = i;
336 }
337 else
338 {
339 unsigned long mask = 0;
340 get_xrender_template(&wxr_formats_template[i], &templ, &mask);
341
342 wine_tsx11_lock();
343 pict_formats[i] = pXRenderFindFormat(gdi_display, mask, &templ, 0);
344 wine_tsx11_unlock();
345 }
346 if (pict_formats[i])
347 {
348 count++;
349 TRACE("Loaded pict_format with id=%#lx for wxr_format=%#x\n", pict_formats[i]->id, i);
350 }
351 }
352 return count;
353 }
354
355 /***********************************************************************
356 * X11DRV_XRender_Init
357 *
358 * Let's see if our XServer has the extension available
359 *
360 */
361 const struct gdi_dc_funcs *X11DRV_XRender_Init(void)
362 {
363 int event_base, i;
364 BOOL ok;
365
366 if (!client_side_with_render) return NULL;
367 if (!(xrender_handle = wine_dlopen(SONAME_LIBXRENDER, RTLD_NOW, NULL, 0))) return NULL;
368
369 #define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(xrender_handle, #f, NULL, 0)) == NULL) return NULL
370 #define LOAD_OPTIONAL_FUNCPTR(f) p##f = wine_dlsym(xrender_handle, #f, NULL, 0)
371 LOAD_FUNCPTR(XRenderAddGlyphs);
372 LOAD_FUNCPTR(XRenderChangePicture);
373 LOAD_FUNCPTR(XRenderComposite);
374 LOAD_FUNCPTR(XRenderCompositeText16);
375 LOAD_FUNCPTR(XRenderCreateGlyphSet);
376 LOAD_FUNCPTR(XRenderCreatePicture);
377 LOAD_FUNCPTR(XRenderFillRectangle);
378 LOAD_FUNCPTR(XRenderFindFormat);
379 LOAD_FUNCPTR(XRenderFindVisualFormat);
380 LOAD_FUNCPTR(XRenderFreeGlyphSet);
381 LOAD_FUNCPTR(XRenderFreePicture);
382 LOAD_FUNCPTR(XRenderSetPictureClipRectangles);
383 LOAD_FUNCPTR(XRenderQueryExtension);
384 #ifdef HAVE_XRENDERCREATELINEARGRADIENT
385 LOAD_OPTIONAL_FUNCPTR(XRenderCreateLinearGradient);
386 #endif
387 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
388 LOAD_OPTIONAL_FUNCPTR(XRenderSetPictureTransform);
389 #endif
390 #undef LOAD_OPTIONAL_FUNCPTR
391 #undef LOAD_FUNCPTR
392
393 wine_tsx11_lock();
394 ok = pXRenderQueryExtension(gdi_display, &event_base, &xrender_error_base);
395 wine_tsx11_unlock();
396 if (!ok) return NULL;
397
398 TRACE("Xrender is up and running error_base = %d\n", xrender_error_base);
399 if(!load_xrender_formats()) /* This fails in buggy versions of libXrender.so */
400 {
401 ERR_(winediag)("Wine has detected that you probably have a buggy version "
402 "of libXrender. Because of this client side font rendering "
403 "will be disabled. Please upgrade this library.\n");
404 return NULL;
405 }
406
407 if (!visual->red_mask || !visual->green_mask || !visual->blue_mask)
408 {
409 WARN("one or more of the colour masks are 0, disabling XRENDER. Try running in 16-bit mode or higher.\n");
410 return NULL;
411 }
412
413 #ifdef SONAME_LIBFONTCONFIG
414 if ((fontconfig_handle = wine_dlopen(SONAME_LIBFONTCONFIG, RTLD_NOW, NULL, 0)))
415 {
416 #define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(fontconfig_handle, #f, NULL, 0)) == NULL){WARN("Can't find symbol %s\n", #f); goto sym_not_found;}
417 LOAD_FUNCPTR(FcConfigSubstitute);
418 LOAD_FUNCPTR(FcDefaultSubstitute);
419 LOAD_FUNCPTR(FcFontMatch);
420 LOAD_FUNCPTR(FcInit);
421 LOAD_FUNCPTR(FcPatternCreate);
422 LOAD_FUNCPTR(FcPatternDestroy);
423 LOAD_FUNCPTR(FcPatternAddInteger);
424 LOAD_FUNCPTR(FcPatternAddString);
425 LOAD_FUNCPTR(FcPatternGetBool);
426 LOAD_FUNCPTR(FcPatternGetInteger);
427 LOAD_FUNCPTR(FcPatternGetString);
428 #undef LOAD_FUNCPTR
429 fontconfig_installed = pFcInit();
430 }
431 else TRACE( "cannot find the fontconfig library " SONAME_LIBFONTCONFIG "\n" );
432
433 sym_not_found:
434 #endif
435
436 glyphsetCache = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
437 sizeof(*glyphsetCache) * INIT_CACHE_SIZE);
438
439 glyphsetCacheSize = INIT_CACHE_SIZE;
440 lastfree = 0;
441 for(i = 0; i < INIT_CACHE_SIZE; i++) {
442 glyphsetCache[i].next = i + 1;
443 glyphsetCache[i].count = -1;
444 }
445 glyphsetCache[i-1].next = -1;
446
447 if(screen_depth <= 8 || !client_side_antialias_with_render) antialias = 0;
448
449 return &xrender_funcs;
450 }
451
452 /* Helper function to convert from a color packed in a 32-bit integer to a XRenderColor */
453 static void get_xrender_color( struct xrender_physdev *physdev, COLORREF src_color, XRenderColor *dst_color )
454 {
455 if (src_color & (1 << 24)) /* PALETTEINDEX */
456 {
457 HPALETTE pal = GetCurrentObject( physdev->dev.hdc, OBJ_PAL );
458 PALETTEENTRY pal_ent;
459
460 if (!GetPaletteEntries( pal, LOWORD(src_color), 1, &pal_ent ))
461 GetPaletteEntries( pal, 0, 1, &pal_ent );
462 dst_color->red = pal_ent.peRed * 257;
463 dst_color->green = pal_ent.peGreen * 257;
464 dst_color->blue = pal_ent.peBlue * 257;
465 }
466 else
467 {
468 if (src_color >> 16 == 0x10ff) src_color = 0; /* DIBINDEX */
469
470 dst_color->red = GetRValue( src_color ) * 257;
471 dst_color->green = GetGValue( src_color ) * 257;
472 dst_color->blue = GetBValue( src_color ) * 257;
473 }
474
475 if (physdev->format == WXR_FORMAT_MONO && !dst_color->red && !dst_color->green && !dst_color->blue)
476 dst_color->alpha = 0;
477 else
478 dst_color->alpha = 0xffff;
479 }
480
481 static enum wxr_format get_xrender_format_from_bitmapinfo( const BITMAPINFO *info )
482 {
483 if (info->bmiHeader.biPlanes != 1) return WXR_INVALID_FORMAT;
484
485 switch (info->bmiHeader.biBitCount)
486 {
487 case 1:
488 return WXR_FORMAT_MONO;
489 case 4:
490 case 8:
491 break;
492 case 24:
493 if (info->bmiHeader.biCompression != BI_RGB) break;
494 return WXR_FORMAT_R8G8B8;
495 case 16:
496 case 32:
497 if (info->bmiHeader.biCompression == BI_BITFIELDS)
498 {
499 DWORD *colors = (DWORD *)((char *)info + info->bmiHeader.biSize);
500 unsigned int i;
501
502 for (i = 0; i < WXR_NB_FORMATS; i++)
503 {
504 if (info->bmiHeader.biBitCount == wxr_formats_template[i].depth &&
505 colors[0] == (wxr_formats_template[i].redMask << wxr_formats_template[i].red) &&
506 colors[1] == (wxr_formats_template[i].greenMask << wxr_formats_template[i].green) &&
507 colors[2] == (wxr_formats_template[i].blueMask << wxr_formats_template[i].blue))
508 return i;
509 }
510 break;
511 }
512 if (info->bmiHeader.biCompression != BI_RGB) break;
513 return (info->bmiHeader.biBitCount == 16) ? WXR_FORMAT_X1R5G5B5 : WXR_FORMAT_A8R8G8B8;
514 }
515 return WXR_INVALID_FORMAT;
516 }
517
518 static enum wxr_format get_bitmap_format( int bpp )
519 {
520 enum wxr_format format = WXR_INVALID_FORMAT;
521
522 if (bpp == screen_bpp)
523 {
524 switch (bpp)
525 {
526 case 16: format = WXR_FORMAT_R5G6B5; break;
527 case 24: format = WXR_FORMAT_R8G8B8; break;
528 case 32: format = WXR_FORMAT_A8R8G8B8; break;
529 }
530 }
531 return format;
532 }
533
534 /* Set the x/y scaling and x/y offsets in the transformation matrix of the source picture */
535 static void set_xrender_transformation(Picture src_pict, double xscale, double yscale, int xoffset, int yoffset)
536 {
537 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
538 XTransform xform = {{
539 { XDoubleToFixed(xscale), XDoubleToFixed(0), XDoubleToFixed(xoffset) },
540 { XDoubleToFixed(0), XDoubleToFixed(yscale), XDoubleToFixed(yoffset) },
541 { XDoubleToFixed(0), XDoubleToFixed(0), XDoubleToFixed(1) }
542 }};
543
544 pXRenderSetPictureTransform(gdi_display, src_pict, &xform);
545 #endif
546 }
547
548 /* check if we can use repeating instead of scaling for the specified source DC */
549 static BOOL use_source_repeat( struct xrender_physdev *dev )
550 {
551 return (dev->x11dev->bitmap &&
552 dev->x11dev->drawable_rect.right - dev->x11dev->drawable_rect.left == 1 &&
553 dev->x11dev->drawable_rect.bottom - dev->x11dev->drawable_rect.top == 1);
554 }
555
556 static void update_xrender_clipping( struct xrender_physdev *dev, HRGN rgn )
557 {
558 XRenderPictureAttributes pa;
559 RGNDATA *data;
560
561 if (!rgn)
562 {
563 wine_tsx11_lock();
564 pa.clip_mask = None;
565 pXRenderChangePicture( gdi_display, dev->pict, CPClipMask, &pa );
566 wine_tsx11_unlock();
567 }
568 else if ((data = X11DRV_GetRegionData( rgn, 0 )))
569 {
570 wine_tsx11_lock();
571 pXRenderSetPictureClipRectangles( gdi_display, dev->pict,
572 dev->x11dev->dc_rect.left, dev->x11dev->dc_rect.top,
573 (XRectangle *)data->Buffer, data->rdh.nCount );
574 wine_tsx11_unlock();
575 HeapFree( GetProcessHeap(), 0, data );
576 }
577 }
578
579
580 static Picture get_xrender_picture( struct xrender_physdev *dev, HRGN clip_rgn, const RECT *clip_rect )
581 {
582 if (!dev->pict && dev->pict_format)
583 {
584 XRenderPictureAttributes pa;
585
586 wine_tsx11_lock();
587 pa.subwindow_mode = IncludeInferiors;
588 dev->pict = pXRenderCreatePicture( gdi_display, dev->x11dev->drawable,
589 dev->pict_format, CPSubwindowMode, &pa );
590 wine_tsx11_unlock();
591 TRACE( "Allocing pict=%lx dc=%p drawable=%08lx\n",
592 dev->pict, dev->dev.hdc, dev->x11dev->drawable );
593 dev->update_clip = (dev->region != 0);
594 }
595
596 if (clip_rect)
597 {
598 HRGN rgn = CreateRectRgnIndirect( clip_rect );
599 if (clip_rgn) CombineRgn( rgn, rgn, clip_rgn, RGN_AND );
600 if (dev->region) CombineRgn( rgn, rgn, dev->region, RGN_AND );
601 update_xrender_clipping( dev, rgn );
602 DeleteObject( rgn );
603 }
604 else if (clip_rgn)
605 {
606 if (dev->region)
607 {
608 HRGN rgn = CreateRectRgn( 0, 0, 0, 0 );
609 CombineRgn( rgn, clip_rgn, dev->region, RGN_AND );
610 update_xrender_clipping( dev, rgn );
611 DeleteObject( rgn );
612 }
613 else update_xrender_clipping( dev, clip_rgn );
614 }
615 else if (dev->update_clip) update_xrender_clipping( dev, dev->region );
616
617 dev->update_clip = (clip_rect || clip_rgn); /* have to update again if we are using a custom region */
618 return dev->pict;
619 }
620
621 static Picture get_xrender_picture_source( struct xrender_physdev *dev, BOOL repeat )
622 {
623 if (!dev->pict_src && dev->pict_format)
624 {
625 XRenderPictureAttributes pa;
626
627 wine_tsx11_lock();
628 pa.subwindow_mode = IncludeInferiors;
629 pa.repeat = repeat ? RepeatNormal : RepeatNone;
630 dev->pict_src = pXRenderCreatePicture( gdi_display, dev->x11dev->drawable,
631 dev->pict_format, CPSubwindowMode|CPRepeat, &pa );
632 wine_tsx11_unlock();
633
634 TRACE("Allocing pict_src=%lx dc=%p drawable=%08lx repeat=%u\n",
635 dev->pict_src, dev->dev.hdc, dev->x11dev->drawable, pa.repeat);
636 }
637
638 return dev->pict_src;
639 }
640
641 static void free_xrender_picture( struct xrender_physdev *dev )
642 {
643 if (dev->pict || dev->pict_src)
644 {
645 wine_tsx11_lock();
646 XFlush( gdi_display );
647 if (dev->pict)
648 {
649 TRACE("freeing pict = %lx dc = %p\n", dev->pict, dev->dev.hdc);
650 pXRenderFreePicture(gdi_display, dev->pict);
651 dev->pict = 0;
652 }
653 if(dev->pict_src)
654 {
655 TRACE("freeing pict = %lx dc = %p\n", dev->pict_src, dev->dev.hdc);
656 pXRenderFreePicture(gdi_display, dev->pict_src);
657 dev->pict_src = 0;
658 }
659 wine_tsx11_unlock();
660 }
661 }
662
663 /* return a mask picture used to force alpha to 0 */
664 static Picture get_no_alpha_mask(void)
665 {
666 static Pixmap pixmap;
667 static Picture pict;
668
669 wine_tsx11_lock();
670 if (!pict)
671 {
672 XRenderPictureAttributes pa;
673 XRenderColor col;
674
675 pixmap = XCreatePixmap( gdi_display, root_window, 1, 1, 32 );
676 pa.repeat = RepeatNormal;
677 pa.component_alpha = True;
678 pict = pXRenderCreatePicture( gdi_display, pixmap, pict_formats[WXR_FORMAT_A8R8G8B8],
679 CPRepeat|CPComponentAlpha, &pa );
680 col.red = col.green = col.blue = 0xffff;
681 col.alpha = 0;
682 pXRenderFillRectangle( gdi_display, PictOpSrc, pict, &col, 0, 0, 1, 1 );
683 }
684 wine_tsx11_unlock();
685 return pict;
686 }
687
688 static BOOL fontcmp(LFANDSIZE *p1, LFANDSIZE *p2)
689 {
690 if(p1->hash != p2->hash) return TRUE;
691 if(memcmp(&p1->devsize, &p2->devsize, sizeof(p1->devsize))) return TRUE;
692 if(memcmp(&p1->xform, &p2->xform, sizeof(p1->xform))) return TRUE;
693 if(memcmp(&p1->lf, &p2->lf, offsetof(LOGFONTW, lfFaceName))) return TRUE;
694 return strcmpiW(p1->lf.lfFaceName, p2->lf.lfFaceName);
695 }
696
697 #if 0
698 static void walk_cache(void)
699 {
700 int i;
701
702 EnterCriticalSection(&xrender_cs);
703 for(i=mru; i >= 0; i = glyphsetCache[i].next)
704 TRACE("item %d\n", i);
705 LeaveCriticalSection(&xrender_cs);
706 }
707 #endif
708
709 static int LookupEntry(LFANDSIZE *plfsz)
710 {
711 int i, prev_i = -1;
712
713 for(i = mru; i >= 0; i = glyphsetCache[i].next) {
714 TRACE("%d\n", i);
715 if(glyphsetCache[i].count == -1) break; /* reached free list so stop */
716
717 if(!fontcmp(&glyphsetCache[i].lfsz, plfsz)) {
718 glyphsetCache[i].count++;
719 if(prev_i >= 0) {
720 glyphsetCache[prev_i].next = glyphsetCache[i].next;
721 glyphsetCache[i].next = mru;
722 mru = i;
723 }
724 TRACE("found font in cache %d\n", i);
725 return i;
726 }
727 prev_i = i;
728 }
729 TRACE("font not in cache\n");
730 return -1;
731 }
732
733 static void FreeEntry(int entry)
734 {
735 int format;
736
737 for(format = 0; format < AA_MAXVALUE; format++) {
738 gsCacheEntryFormat * formatEntry;
739
740 if( !glyphsetCache[entry].format[format] )
741 continue;
742
743 formatEntry = glyphsetCache[entry].format[format];
744
745 if(formatEntry->glyphset) {
746 wine_tsx11_lock();
747 pXRenderFreeGlyphSet(gdi_display, formatEntry->glyphset);
748 wine_tsx11_unlock();
749 formatEntry->glyphset = 0;
750 }
751 if(formatEntry->nrealized) {
752 HeapFree(GetProcessHeap(), 0, formatEntry->realized);
753 formatEntry->realized = NULL;
754 HeapFree(GetProcessHeap(), 0, formatEntry->gis);
755 formatEntry->gis = NULL;
756 formatEntry->nrealized = 0;
757 }
758
759 HeapFree(GetProcessHeap(), 0, formatEntry);
760 glyphsetCache[entry].format[format] = NULL;
761 }
762 }
763
764 static int AllocEntry(void)
765 {
766 int best = -1, prev_best = -1, i, prev_i = -1;
767
768 if(lastfree >= 0) {
769 assert(glyphsetCache[lastfree].count == -1);
770 glyphsetCache[lastfree].count = 1;
771 best = lastfree;
772 lastfree = glyphsetCache[lastfree].next;
773 assert(best != mru);
774 glyphsetCache[best].next = mru;
775 mru = best;
776
777 TRACE("empty space at %d, next lastfree = %d\n", mru, lastfree);
778 return mru;
779 }
780
781 for(i = mru; i >= 0; i = glyphsetCache[i].next) {
782 if(glyphsetCache[i].count == 0) {
783 best = i;
784 prev_best = prev_i;
785 }
786 prev_i = i;
787 }
788
789 if(best >= 0) {
790 TRACE("freeing unused glyphset at cache %d\n", best);
791 FreeEntry(best);
792 glyphsetCache[best].count = 1;
793 if(prev_best >= 0) {
794 glyphsetCache[prev_best].next = glyphsetCache[best].next;
795 glyphsetCache[best].next = mru;
796 mru = best;
797 } else {
798 assert(mru == best);
799 }
800 return mru;
801 }
802
803 TRACE("Growing cache\n");
804
805 if (glyphsetCache)
806 glyphsetCache = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
807 glyphsetCache,
808 (glyphsetCacheSize + INIT_CACHE_SIZE)
809 * sizeof(*glyphsetCache));
810 else
811 glyphsetCache = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
812 (glyphsetCacheSize + INIT_CACHE_SIZE)
813 * sizeof(*glyphsetCache));
814
815 for(best = i = glyphsetCacheSize; i < glyphsetCacheSize + INIT_CACHE_SIZE;
816 i++) {
817 glyphsetCache[i].next = i + 1;
818 glyphsetCache[i].count = -1;
819 }
820 glyphsetCache[i-1].next = -1;
821 glyphsetCacheSize += INIT_CACHE_SIZE;
822
823 lastfree = glyphsetCache[best].next;
824 glyphsetCache[best].count = 1;
825 glyphsetCache[best].next = mru;
826 mru = best;
827 TRACE("new free cache slot at %d\n", mru);
828 return mru;
829 }
830
831 static BOOL get_gasp_flags(HDC hdc, WORD *flags)
832 {
833 DWORD size;
834 WORD *gasp, *buffer;
835 WORD num_recs;
836 DWORD ppem;
837 TEXTMETRICW tm;
838
839 *flags = 0;
840
841 size = GetFontData(hdc, MS_GASP_TAG, 0, NULL, 0);
842 if(size == GDI_ERROR)
843 return FALSE;
844
845 gasp = buffer = HeapAlloc(GetProcessHeap(), 0, size);
846 GetFontData(hdc, MS_GASP_TAG, 0, gasp, size);
847
848 GetTextMetricsW(hdc, &tm);
849 ppem = abs(X11DRV_YWStoDS(hdc, tm.tmAscent + tm.tmDescent - tm.tmInternalLeading));
850
851 gasp++;
852 num_recs = get_be_word(*gasp);
853 gasp++;
854 while(num_recs--)
855 {
856 *flags = get_be_word(*(gasp + 1));
857 if(ppem <= get_be_word(*gasp))
858 break;
859 gasp += 2;
860 }
861 TRACE("got flags %04x for ppem %d\n", *flags, ppem);
862
863 HeapFree(GetProcessHeap(), 0, buffer);
864 return TRUE;
865 }
866
867 static AA_Type get_antialias_type( HDC hdc, BOOL subpixel, BOOL hinter )
868 {
869 AA_Type ret;
870 WORD flags;
871 UINT font_smoothing_type, font_smoothing_orientation;
872
873 if (subpixel &&
874 SystemParametersInfoW( SPI_GETFONTSMOOTHINGTYPE, 0, &font_smoothing_type, 0) &&
875 font_smoothing_type == FE_FONTSMOOTHINGCLEARTYPE)
876 {
877 if ( SystemParametersInfoW( SPI_GETFONTSMOOTHINGORIENTATION, 0,
878 &font_smoothing_orientation, 0) &&
879 font_smoothing_orientation == FE_FONTSMOOTHINGORIENTATIONBGR)
880 {
881 ret = AA_BGR;
882 }
883 else
884 ret = AA_RGB;
885 /*FIXME
886 If the monitor is in portrait mode, ClearType is disabled in the MS Windows (MSDN).
887 But, Wine's subpixel rendering can support the portrait mode.
888 */
889 }
890 else if (!hinter || !get_gasp_flags(hdc, &flags) || flags & GASP_DOGRAY)
891 ret = AA_Grey;
892 else
893 ret = AA_None;
894
895 return ret;
896 }
897
898 static int GetCacheEntry( HDC hdc, LFANDSIZE *plfsz )
899 {
900 int ret;
901 int format;
902 gsCacheEntry *entry;
903 static int hinter = -1;
904 static int subpixel = -1;
905 BOOL font_smoothing;
906
907 if((ret = LookupEntry(plfsz)) != -1) return ret;
908
909 ret = AllocEntry();
910 entry = glyphsetCache + ret;
911 entry->lfsz = *plfsz;
912 for( format = 0; format < AA_MAXVALUE; format++ ) {
913 assert( !entry->format[format] );
914 }
915
916 if(antialias && plfsz->lf.lfQuality != NONANTIALIASED_QUALITY)
917 {
918 if(hinter == -1 || subpixel == -1)
919 {
920 RASTERIZER_STATUS status;
921 GetRasterizerCaps(&status, sizeof(status));
922 hinter = status.wFlags & WINE_TT_HINTER_ENABLED;
923 subpixel = status.wFlags & WINE_TT_SUBPIXEL_RENDERING_ENABLED;
924 }
925
926 switch (plfsz->lf.lfQuality)
927 {
928 case ANTIALIASED_QUALITY:
929 entry->aa_default = get_antialias_type( hdc, FALSE, hinter );
930 return ret; /* ignore further configuration */
931 case CLEARTYPE_QUALITY:
932 case CLEARTYPE_NATURAL_QUALITY:
933 entry->aa_default = get_antialias_type( hdc, subpixel, hinter );
934 break;
935 case DEFAULT_QUALITY:
936 case DRAFT_QUALITY:
937 case PROOF_QUALITY:
938 default:
939 if ( SystemParametersInfoW( SPI_GETFONTSMOOTHING, 0, &font_smoothing, 0) &&
940 font_smoothing)
941 {
942 entry->aa_default = get_antialias_type( hdc, subpixel, hinter );
943 }
944 else
945 entry->aa_default = AA_None;
946 break;
947 }
948
949 font_smoothing = TRUE; /* default to enabled */
950 #ifdef SONAME_LIBFONTCONFIG
951 if (fontconfig_installed)
952 {
953 FcPattern *match, *pattern;
954 FcResult result;
955 char family[LF_FACESIZE * 4];
956
957 #if defined(__i386__) && defined(__GNUC__)
958 /* fontconfig generates floating point exceptions, mask them */
959 WORD cw, default_cw = 0x37f;
960 __asm__ __volatile__("fnstcw %0; fldcw %1" : "=m" (cw) : "m" (default_cw));
961 #endif
962
963 WideCharToMultiByte( CP_UTF8, 0, plfsz->lf.lfFaceName, -1, family, sizeof(family), NULL, NULL );
964 pattern = pFcPatternCreate();
965 pFcPatternAddString( pattern, FC_FAMILY, (FcChar8 *)family );
966 if (plfsz->lf.lfWeight != FW_DONTCARE)
967 {
968 int weight;
969 switch (plfsz->lf.lfWeight)
970 {
971 case FW_THIN: weight = FC_WEIGHT_THIN; break;
972 case FW_EXTRALIGHT: weight = FC_WEIGHT_EXTRALIGHT; break;
973 case FW_LIGHT: weight = FC_WEIGHT_LIGHT; break;
974 case FW_NORMAL: weight = FC_WEIGHT_NORMAL; break;
975 case FW_MEDIUM: weight = FC_WEIGHT_MEDIUM; break;
976 case FW_SEMIBOLD: weight = FC_WEIGHT_SEMIBOLD; break;
977 case FW_BOLD: weight = FC_WEIGHT_BOLD; break;
978 case FW_EXTRABOLD: weight = FC_WEIGHT_EXTRABOLD; break;
979 case FW_HEAVY: weight = FC_WEIGHT_HEAVY; break;
980 default: weight = (plfsz->lf.lfWeight - 80) / 4; break;
981 }
982 pFcPatternAddInteger( pattern, FC_WEIGHT, weight );
983 }
984 pFcPatternAddInteger( pattern, FC_SLANT, plfsz->lf.lfItalic ? FC_SLANT_ITALIC : FC_SLANT_ROMAN );
985 pFcConfigSubstitute( NULL, pattern, FcMatchPattern );
986 pFcDefaultSubstitute( pattern );
987 if ((match = pFcFontMatch( NULL, pattern, &result )))
988 {
989 int rgba;
990 FcBool antialias;
991
992 if (pFcPatternGetBool( match, FC_ANTIALIAS, 0, &antialias ) != FcResultMatch)
993 antialias = TRUE;
994 if (pFcPatternGetInteger( match, FC_RGBA, 0, &rgba ) == FcResultMatch)
995 {
996 FcChar8 *file;
997 if (pFcPatternGetString( match, FC_FILE, 0, &file ) != FcResultMatch) file = NULL;
998
999 TRACE( "fontconfig returned rgba %u antialias %u for font %s file %s\n",
1000 rgba, antialias, debugstr_w(plfsz->lf.lfFaceName), debugstr_a((char *)file) );
1001
1002 switch (rgba)
1003 {
1004 case FC_RGBA_RGB: entry->aa_default = AA_RGB; break;
1005 case FC_RGBA_BGR: entry->aa_default = AA_BGR; break;
1006 case FC_RGBA_VRGB: entry->aa_default = AA_VRGB; break;
1007 case FC_RGBA_VBGR: entry->aa_default = AA_VBGR; break;
1008 case FC_RGBA_NONE: entry->aa_default = AA_Grey; break;
1009 }
1010 }
1011 if (!antialias) font_smoothing = FALSE;
1012 pFcPatternDestroy( match );
1013 }
1014 pFcPatternDestroy( pattern );
1015
1016 #if defined(__i386__) && defined(__GNUC__)
1017 __asm__ __volatile__("fnclex; fldcw %0" : : "m" (cw));
1018 #endif
1019 }
1020 #endif /* SONAME_LIBFONTCONFIG */
1021
1022 /* now check Xft resources */
1023 {
1024 char *value;
1025 BOOL antialias = TRUE;
1026
1027 wine_tsx11_lock();
1028 if ((value = XGetDefault( gdi_display, "Xft", "antialias" )))
1029 {
1030 if (tolower(value[0]) == 'f' || tolower(value[0]) == 'n' ||
1031 value[0] == '0' || !strcasecmp( value, "off" ))
1032 antialias = FALSE;
1033 }
1034 if ((value = XGetDefault( gdi_display, "Xft", "rgba" )))
1035 {
1036 TRACE( "Xft resource returned rgba '%s' antialias %u\n", value, antialias );
1037 if (!strcmp( value, "rgb" )) entry->aa_default = AA_RGB;
1038 else if (!strcmp( value, "bgr" )) entry->aa_default = AA_BGR;
1039 else if (!strcmp( value, "vrgb" )) entry->aa_default = AA_VRGB;
1040 else if (!strcmp( value, "vbgr" )) entry->aa_default = AA_VBGR;
1041 else if (!strcmp( value, "none" )) entry->aa_default = AA_Grey;
1042 }
1043 wine_tsx11_unlock();
1044 if (!antialias) font_smoothing = FALSE;
1045 }
1046
1047 if (!font_smoothing) entry->aa_default = AA_None;
1048 }
1049 else
1050 entry->aa_default = AA_None;
1051
1052 return ret;
1053 }
1054
1055 static void dec_ref_cache(int index)
1056 {
1057 assert(index >= 0);
1058 TRACE("dec'ing entry %d to %d\n", index, glyphsetCache[index].count - 1);
1059 assert(glyphsetCache[index].count > 0);
1060 glyphsetCache[index].count--;
1061 }
1062
1063 static void lfsz_calc_hash(LFANDSIZE *plfsz)
1064 {
1065 DWORD hash = 0, *ptr, two_chars;
1066 WORD *pwc;
1067 int i;
1068
1069 hash ^= plfsz->devsize.cx;
1070 hash ^= plfsz->devsize.cy;
1071 for(i = 0, ptr = (DWORD*)&plfsz->xform; i < sizeof(XFORM)/sizeof(DWORD); i++, ptr++)
1072 hash ^= *ptr;
1073 for(i = 0, ptr = (DWORD*)&plfsz->lf; i < 7; i++, ptr++)
1074 hash ^= *ptr;
1075 for(i = 0, ptr = (DWORD*)plfsz->lf.lfFaceName; i < LF_FACESIZE/2; i++, ptr++) {
1076 two_chars = *ptr;
1077 pwc = (WCHAR *)&two_chars;
1078 if(!*pwc) break;
1079 *pwc = toupperW(*pwc);
1080 pwc++;
1081 *pwc = toupperW(*pwc);
1082 hash ^= two_chars;
1083 if(!*pwc) break;
1084 }
1085 plfsz->hash = hash;
1086 return;
1087 }
1088
1089 /***********************************************************************
1090 * X11DRV_XRender_Finalize
1091 */
1092 void X11DRV_XRender_Finalize(void)
1093 {
1094 int i;
1095
1096 EnterCriticalSection(&xrender_cs);
1097 for(i = mru; i >= 0; i = glyphsetCache[i].next)
1098 FreeEntry(i);
1099 LeaveCriticalSection(&xrender_cs);
1100 DeleteCriticalSection(&xrender_cs);
1101 }
1102
1103 /**********************************************************************
1104 * xrenderdrv_SelectFont
1105 */
1106 static HFONT xrenderdrv_SelectFont( PHYSDEV dev, HFONT hfont )
1107 {
1108 LFANDSIZE lfsz;
1109 struct xrender_physdev *physdev = get_xrender_dev( dev );
1110 PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSelectFont );
1111 HFONT ret = next->funcs->pSelectFont( next, hfont );
1112
1113 if (!ret) return 0;
1114
1115 GetObjectW( hfont, sizeof(lfsz.lf), &lfsz.lf );
1116
1117 TRACE("h=%d w=%d weight=%d it=%d charset=%d name=%s\n",
1118 lfsz.lf.lfHeight, lfsz.lf.lfWidth, lfsz.lf.lfWeight,
1119 lfsz.lf.lfItalic, lfsz.lf.lfCharSet, debugstr_w(lfsz.lf.lfFaceName));
1120 lfsz.lf.lfWidth = abs( lfsz.lf.lfWidth );
1121 lfsz.devsize.cx = X11DRV_XWStoDS( dev->hdc, lfsz.lf.lfWidth );
1122 lfsz.devsize.cy = X11DRV_YWStoDS( dev->hdc, lfsz.lf.lfHeight );
1123
1124 GetTransform( dev->hdc, 0x204, &lfsz.xform );
1125 TRACE("font transform %f %f %f %f\n", lfsz.xform.eM11, lfsz.xform.eM12,
1126 lfsz.xform.eM21, lfsz.xform.eM22);
1127
1128 if (GetGraphicsMode( dev->hdc ) == GM_COMPATIBLE && lfsz.xform.eM11 * lfsz.xform.eM22 < 0)
1129 lfsz.lf.lfOrientation = -lfsz.lf.lfOrientation;
1130
1131 /* Not used fields, would break hashing */
1132 lfsz.xform.eDx = lfsz.xform.eDy = 0;
1133
1134 lfsz_calc_hash(&lfsz);
1135
1136 EnterCriticalSection(&xrender_cs);
1137 if (physdev->cache_index != -1)
1138 dec_ref_cache( physdev->cache_index );
1139 physdev->cache_index = GetCacheEntry( dev->hdc, &lfsz );
1140 LeaveCriticalSection(&xrender_cs);
1141 return ret;
1142 }
1143
1144 static BOOL create_xrender_dc( PHYSDEV *pdev, enum wxr_format format )
1145 {
1146 X11DRV_PDEVICE *x11dev = get_x11drv_dev( *pdev );
1147 struct xrender_physdev *physdev = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*physdev) );
1148
1149 if (!physdev) return FALSE;
1150 physdev->x11dev = x11dev;
1151 physdev->cache_index = -1;
1152 physdev->format = format;
1153 physdev->pict_format = pict_formats[format];
1154 push_dc_driver( pdev, &physdev->dev, &xrender_funcs );
1155 return TRUE;
1156 }
1157
1158 /* store the color mask data in the bitmap info structure */
1159 static void set_color_info( XRenderPictFormat *format, BITMAPINFO *info )
1160 {
1161 DWORD *colors = (DWORD *)((char *)info + info->bmiHeader.biSize);
1162
1163 info->bmiHeader.biPlanes = 1;
1164 info->bmiHeader.biBitCount = pixmap_formats[format->depth]->bits_per_pixel;
1165 info->bmiHeader.biCompression = BI_RGB;
1166 info->bmiHeader.biClrUsed = 0;
1167
1168 switch (info->bmiHeader.biBitCount)
1169 {
1170 case 16:
1171 colors[0] = format->direct.redMask << format->direct.red;
1172 colors[1] = format->direct.greenMask << format->direct.green;
1173 colors[2] = format->direct.blueMask << format->direct.blue;
1174 info->bmiHeader.biCompression = BI_BITFIELDS;
1175 break;
1176 case 32:
1177 colors[0] = format->direct.redMask << format->direct.red;
1178 colors[1] = format->direct.greenMask << format->direct.green;
1179 colors[2] = format->direct.blueMask << format->direct.blue;
1180 if (colors[0] != 0xff0000 || colors[1] != 0x00ff00 || colors[2] != 0x0000ff)
1181 info->bmiHeader.biCompression = BI_BITFIELDS;
1182 break;
1183 }
1184 }
1185
1186
1187 /**********************************************************************
1188 * xrenderdrv_CreateDC
1189 */
1190 static BOOL xrenderdrv_CreateDC( PHYSDEV *pdev, LPCWSTR driver, LPCWSTR device,
1191 LPCWSTR output, const DEVMODEW* initData )
1192 {
1193 return create_xrender_dc( pdev, default_format );
1194 }
1195
1196 /**********************************************************************
1197 * xrenderdrv_CreateCompatibleDC
1198 */
1199 static BOOL xrenderdrv_CreateCompatibleDC( PHYSDEV orig, PHYSDEV *pdev )
1200 {
1201 if (orig) /* chain to x11drv first */
1202 {
1203 orig = GET_NEXT_PHYSDEV( orig, pCreateCompatibleDC );
1204 if (!orig->funcs->pCreateCompatibleDC( orig, pdev )) return FALSE;
1205 }
1206 /* otherwise we have been called by x11drv */
1207
1208 return create_xrender_dc( pdev, WXR_FORMAT_MONO );
1209 }
1210
1211 /**********************************************************************
1212 * xrenderdrv_DeleteDC
1213 */
1214 static BOOL xrenderdrv_DeleteDC( PHYSDEV dev )
1215 {
1216 struct xrender_physdev *physdev = get_xrender_dev( dev );
1217
1218 free_xrender_picture( physdev );
1219
1220 EnterCriticalSection( &xrender_cs );
1221 if (physdev->cache_index != -1) dec_ref_cache( physdev->cache_index );
1222 LeaveCriticalSection( &xrender_cs );
1223
1224 HeapFree( GetProcessHeap(), 0, physdev );
1225 return TRUE;
1226 }
1227
1228 /**********************************************************************
1229 * xrenderdrv_ExtEscape
1230 */
1231 static INT xrenderdrv_ExtEscape( PHYSDEV dev, INT escape, INT in_count, LPCVOID in_data,
1232 INT out_count, LPVOID out_data )
1233 {
1234 struct xrender_physdev *physdev = get_xrender_dev( dev );
1235
1236 dev = GET_NEXT_PHYSDEV( dev, pExtEscape );
1237
1238 if (escape == X11DRV_ESCAPE && in_data && in_count >= sizeof(enum x11drv_escape_codes))
1239 {
1240 if (*(const enum x11drv_escape_codes *)in_data == X11DRV_SET_DRAWABLE)
1241 {
1242 BOOL ret = dev->funcs->pExtEscape( dev, escape, in_count, in_data, out_count, out_data );
1243 if (ret) free_xrender_picture( physdev ); /* pict format doesn't change, only drawable */
1244 return ret;
1245 }
1246 }
1247 return dev->funcs->pExtEscape( dev, escape, in_count, in_data, out_count, out_data );
1248 }
1249
1250 /****************************************************************************
1251 * xrenderdrv_CopyBitmap
1252 */
1253 static BOOL xrenderdrv_CopyBitmap( HBITMAP src, HBITMAP dst )
1254 {
1255 return X11DRV_CopyBitmap( src, dst );
1256 }
1257
1258 /****************************************************************************
1259 * xrenderdrv_CreateBitmap
1260 */
1261 static BOOL xrenderdrv_CreateBitmap( PHYSDEV dev, HBITMAP hbitmap )
1262 {
1263 enum wxr_format format = WXR_INVALID_FORMAT;
1264 X_PHYSBITMAP *phys_bitmap;
1265 BITMAP bitmap;
1266
1267 if (!GetObjectW( hbitmap, sizeof(bitmap), &bitmap )) return FALSE;
1268
1269 if (bitmap.bmBitsPixel == 1)
1270 {
1271 if (!(phys_bitmap = X11DRV_create_phys_bitmap( hbitmap, &bitmap, 1 ))) return FALSE;
1272 phys_bitmap->format = WXR_FORMAT_MONO;
1273 phys_bitmap->trueColor = FALSE;
1274 }
1275 else
1276 {
1277 format = get_bitmap_format( bitmap.bmBitsPixel );
1278
1279 if (pict_formats[format])
1280 {
1281 if (!(phys_bitmap = X11DRV_create_phys_bitmap( hbitmap, &bitmap, pict_formats[format]->depth )))
1282 return FALSE;
1283 phys_bitmap->format = format;
1284 phys_bitmap->trueColor = TRUE;
1285 phys_bitmap->color_shifts = wxr_color_shifts[format];
1286 }
1287 else
1288 {
1289 if (!(phys_bitmap = X11DRV_create_phys_bitmap( hbitmap, &bitmap, screen_depth )))
1290 return FALSE;
1291 phys_bitmap->format = WXR_INVALID_FORMAT;
1292 phys_bitmap->trueColor = (visual->class == TrueColor || visual->class == DirectColor);
1293 phys_bitmap->color_shifts = X11DRV_PALETTE_default_shifts;
1294 }
1295 }
1296 return TRUE;
1297 }
1298
1299 /****************************************************************************
1300 * xrenderdrv_DeleteBitmap
1301 */
1302 static BOOL xrenderdrv_DeleteBitmap( HBITMAP hbitmap )
1303 {
1304 return X11DRV_DeleteBitmap( hbitmap );
1305 }
1306
1307 /***********************************************************************
1308 * xrenderdrv_SelectBitmap
1309 */
1310 static HBITMAP xrenderdrv_SelectBitmap( PHYSDEV dev, HBITMAP hbitmap )
1311 {
1312 HBITMAP ret;
1313 struct xrender_physdev *physdev = get_xrender_dev( dev );
1314
1315 dev = GET_NEXT_PHYSDEV( dev, pSelectBitmap );
1316 ret = dev->funcs->pSelectBitmap( dev, hbitmap );
1317 if (ret)
1318 {
1319 free_xrender_picture( physdev );
1320 if (hbitmap == BITMAP_stock_phys_bitmap.hbitmap) physdev->format = WXR_FORMAT_MONO;
1321 else physdev->format = X11DRV_get_phys_bitmap(hbitmap)->format;
1322 physdev->pict_format = pict_formats[physdev->format];
1323 }
1324 return ret;
1325 }
1326
1327 /***********************************************************************
1328 * xrenderdrv_GetImage
1329 */
1330 static DWORD xrenderdrv_GetImage( PHYSDEV dev, HBITMAP hbitmap, BITMAPINFO *info,
1331 struct gdi_image_bits *bits, struct bitblt_coords *src )
1332 {
1333 if (hbitmap) return X11DRV_GetImage( dev, hbitmap, info, bits, src );
1334 dev = GET_NEXT_PHYSDEV( dev, pGetImage );
1335 return dev->funcs->pGetImage( dev, hbitmap, info, bits, src );
1336 }
1337
1338 /***********************************************************************
1339 * xrenderdrv_SetDeviceClipping
1340 */
1341 static void xrenderdrv_SetDeviceClipping( PHYSDEV dev, HRGN rgn )
1342 {
1343 struct xrender_physdev *physdev = get_xrender_dev( dev );
1344
1345 physdev->region = rgn;
1346 physdev->update_clip = TRUE;
1347
1348 dev = GET_NEXT_PHYSDEV( dev, pSetDeviceClipping );
1349 dev->funcs->pSetDeviceClipping( dev, rgn );
1350 }
1351
1352
1353 /************************************************************************
1354 * UploadGlyph
1355 *
1356 * Helper to ExtTextOut. Must be called inside xrender_cs
1357 */
1358 static void UploadGlyph(struct xrender_physdev *physDev, int glyph, AA_Type format)
1359 {
1360 unsigned int buflen;
1361 char *buf;
1362 Glyph gid;
1363 GLYPHMETRICS gm;
1364 XGlyphInfo gi;
1365 gsCacheEntry *entry = glyphsetCache + physDev->cache_index;
1366 gsCacheEntryFormat *formatEntry;
1367 UINT ggo_format = GGO_GLYPH_INDEX;
1368 enum wxr_format wxr_format;
1369 static const char zero[4];
1370 static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
1371
1372 switch(format) {
1373 case AA_Grey:
1374 ggo_format |= WINE_GGO_GRAY16_BITMAP;
1375 break;
1376 case AA_RGB:
1377 ggo_format |= WINE_GGO_HRGB_BITMAP;
1378 break;
1379 case AA_BGR:
1380 ggo_format |= WINE_GGO_HBGR_BITMAP;
1381 break;
1382 case AA_VRGB:
1383 ggo_format |= WINE_GGO_VRGB_BITMAP;
1384 break;
1385 case AA_VBGR:
1386 ggo_format |= WINE_GGO_VBGR_BITMAP;
1387 break;
1388
1389 default:
1390 ERR("aa = %d - not implemented\n", format);
1391 case AA_None:
1392 ggo_format |= GGO_BITMAP;
1393 break;
1394 }
1395
1396 buflen = GetGlyphOutlineW(physDev->dev.hdc, glyph, ggo_format, &gm, 0, NULL, &identity);
1397 if(buflen == GDI_ERROR) {
1398 if(format != AA_None) {
1399 format = AA_None;
1400 entry->aa_default = AA_None;
1401 ggo_format = GGO_GLYPH_INDEX | GGO_BITMAP;
1402 buflen = GetGlyphOutlineW(physDev->dev.hdc, glyph, ggo_format, &gm, 0, NULL, &identity);
1403 }
1404 if(buflen == GDI_ERROR) {
1405 WARN("GetGlyphOutlineW failed using default glyph\n");
1406 buflen = GetGlyphOutlineW(physDev->dev.hdc, 0, ggo_format, &gm, 0, NULL, &identity);
1407 if(buflen == GDI_ERROR) {
1408 WARN("GetGlyphOutlineW failed for default glyph trying for space\n");
1409 buflen = GetGlyphOutlineW(physDev->dev.hdc, 0x20, ggo_format, &gm, 0, NULL, &identity);
1410 if(buflen == GDI_ERROR) {
1411 ERR("GetGlyphOutlineW for all attempts unable to upload a glyph\n");
1412 return;
1413 }
1414 }
1415 }
1416 TRACE("Turning off antialiasing for this monochrome font\n");
1417 }
1418
1419 /* If there is nothing for the current type, we create the entry. */
1420 if( !entry->format[format] ) {
1421 entry->format[format] = HeapAlloc(GetProcessHeap(),
1422 HEAP_ZERO_MEMORY,
1423 sizeof(gsCacheEntryFormat));
1424 }
1425 formatEntry = entry->format[format];
1426
1427 if(formatEntry->nrealized <= glyph) {
1428 formatEntry->nrealized = (glyph / 128 + 1) * 128;
1429
1430 if (formatEntry->realized)
1431 formatEntry->realized = HeapReAlloc(GetProcessHeap(),
1432 HEAP_ZERO_MEMORY,
1433 formatEntry->realized,
1434 formatEntry->nrealized * sizeof(BOOL));
1435 else
1436 formatEntry->realized = HeapAlloc(GetProcessHeap(),
1437 HEAP_ZERO_MEMORY,
1438 formatEntry->nrealized * sizeof(BOOL));
1439
1440 if (formatEntry->gis)
1441 formatEntry->gis = HeapReAlloc(GetProcessHeap(),
1442 HEAP_ZERO_MEMORY,
1443 formatEntry->gis,
1444 formatEntry->nrealized * sizeof(formatEntry->gis[0]));
1445 else
1446 formatEntry->gis = HeapAlloc(GetProcessHeap(),
1447 HEAP_ZERO_MEMORY,
1448 formatEntry->nrealized * sizeof(formatEntry->gis[0]));
1449 }
1450
1451
1452 if(formatEntry->glyphset == 0) {
1453 switch(format) {
1454 case AA_Grey:
1455 wxr_format = WXR_FORMAT_GRAY;
1456 break;
1457
1458 case AA_RGB:
1459 case AA_BGR:
1460 case AA_VRGB:
1461 case AA_VBGR:
1462 wxr_format = WXR_FORMAT_A8R8G8B8;
1463 break;
1464
1465 default:
1466 ERR("aa = %d - not implemented\n", format);
1467 case AA_None:
1468 wxr_format = WXR_FORMAT_MONO;
1469 break;
1470 }
1471
1472 wine_tsx11_lock();
1473 formatEntry->font_format = pict_formats[wxr_format];
1474 formatEntry->glyphset = pXRenderCreateGlyphSet(gdi_display, formatEntry->font_format);
1475 wine_tsx11_unlock();
1476 }
1477
1478
1479 buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buflen);
1480 GetGlyphOutlineW(physDev->dev.hdc, glyph, ggo_format, &gm, buflen, buf, &identity);
1481 formatEntry->realized[glyph] = TRUE;
1482
1483 TRACE("buflen = %d. Got metrics: %dx%d adv=%d,%d origin=%d,%d\n",
1484 buflen,
1485 gm.gmBlackBoxX, gm.gmBlackBoxY, gm.gmCellIncX, gm.gmCellIncY,
1486 gm.gmptGlyphOrigin.x, gm.gmptGlyphOrigin.y);
1487
1488 gi.width = gm.gmBlackBoxX;
1489 gi.height = gm.gmBlackBoxY;
1490 gi.x = -gm.gmptGlyphOrigin.x;
1491 gi.y = gm.gmptGlyphOrigin.y;
1492 gi.xOff = gm.gmCellIncX;
1493 gi.yOff = gm.gmCellIncY;
1494
1495 if(TRACE_ON(xrender)) {
1496 int pitch, i, j;
1497 char output[300];
1498 unsigned char *line;
1499
1500 if(format == AA_None) {
1501 pitch = ((gi.width + 31) / 32) * 4;
1502 for(i = 0; i < gi.height; i++) {
1503 line = (unsigned char*) buf + i * pitch;
1504 output[0] = '\0';
1505 for(j = 0; j < pitch * 8; j++) {
1506 strcat(output, (line[j / 8] & (1 << (7 - (j % 8)))) ? "#" : " ");
1507 }
1508 TRACE("%s\n", output);
1509 }
1510 } else {
1511 static const char blks[] = " .:;!o*#";
1512 char str[2];
1513
1514 str[1] = '\0';
1515 pitch = ((gi.width + 3) / 4) * 4;
1516 for(i = 0; i < gi.height; i++) {
1517 line = (unsigned char*) buf + i * pitch;
1518 output[0] = '\0';
1519 for(j = 0; j < pitch; j++) {
1520 str[0] = blks[line[j] >> 5];
1521 strcat(output, str);
1522 }
1523 TRACE("%s\n", output);
1524 }
1525 }
1526 }
1527
1528
1529 if(formatEntry->glyphset) {
1530 if(format == AA_None && BitmapBitOrder(gdi_display) != MSBFirst) {
1531 unsigned char *byte = (unsigned char*) buf, c;
1532 int i = buflen;
1533
1534 while(i--) {
1535 c = *byte;
1536
1537 /* magic to flip bit order */
1538 c = ((c << 1) & 0xaa) | ((c >> 1) & 0x55);
1539 c = ((c << 2) & 0xcc) | ((c >> 2) & 0x33);
1540 c = ((c << 4) & 0xf0) | ((c >> 4) & 0x0f);
1541
1542 *byte++ = c;
1543 }
1544 }
1545 else if ( format != AA_Grey &&
1546 ImageByteOrder (gdi_display) != NATIVE_BYTE_ORDER)
1547 {
1548 unsigned int i, *data = (unsigned int *)buf;
1549 for (i = buflen / sizeof(int); i; i--, data++) *data = RtlUlongByteSwap(*data);
1550 }
1551 gid = glyph;
1552
1553 /*
1554 XRenderCompositeText seems to ignore 0x0 glyphs when
1555 AA_None, which means we lose the advance width of glyphs
1556 like the space. We'll pretend that such glyphs are 1x1
1557 bitmaps.
1558 */
1559
1560 if(buflen == 0)
1561 gi.width = gi.height = 1;
1562
1563 wine_tsx11_lock();
1564 pXRenderAddGlyphs(gdi_display, formatEntry->glyphset, &gid, &gi, 1,
1565 buflen ? buf : zero, buflen ? buflen : sizeof(zero));
1566 wine_tsx11_unlock();
1567 HeapFree(GetProcessHeap(), 0, buf);
1568 }
1569
1570 formatEntry->gis[glyph] = gi;
1571 }
1572
1573 /*************************************************************
1574 * get_tile_pict
1575 *
1576 * Returns an appropriate Picture for tiling the text colour.
1577 * Call and use result within the xrender_cs
1578 */
1579 static Picture get_tile_pict( enum wxr_format wxr_format, const XRenderColor *color)
1580 {
1581 static struct
1582 {
1583 Pixmap xpm;
1584 Picture pict;
1585 XRenderColor current_color;
1586 } tiles[WXR_NB_FORMATS], *tile;
1587
1588 tile = &tiles[wxr_format];
1589
1590 if(!tile->xpm)
1591 {
1592 XRenderPictureAttributes pa;
1593 XRenderPictFormat *pict_format = pict_formats[wxr_format];
1594
1595 wine_tsx11_lock();
1596 tile->xpm = XCreatePixmap(gdi_display, root_window, 1, 1, pict_format->depth);
1597
1598 pa.repeat = RepeatNormal;
1599 tile->pict = pXRenderCreatePicture(gdi_display, tile->xpm, pict_format, CPRepeat, &pa);
1600 wine_tsx11_unlock();
1601
1602 /* init current_color to something different from text_pixel */
1603 tile->current_color = *color;
1604 tile->current_color.red ^= 0xffff;
1605
1606 if (wxr_format == WXR_FORMAT_MONO)
1607 {
1608 /* for a 1bpp bitmap we always need a 1 in the tile */
1609 XRenderColor col;
1610 col.red = col.green = col.blue = 0;
1611 col.alpha = 0xffff;
1612 wine_tsx11_lock();
1613 pXRenderFillRectangle(gdi_display, PictOpSrc, tile->pict, &col, 0, 0, 1, 1);
1614 wine_tsx11_unlock();
1615 }
1616 }
1617
1618 if (memcmp( color, &tile->current_color, sizeof(*color) ) && wxr_format != WXR_FORMAT_MONO)
1619 {
1620 wine_tsx11_lock();
1621 pXRenderFillRectangle(gdi_display, PictOpSrc, tile->pict, color, 0, 0, 1, 1);
1622 wine_tsx11_unlock();
1623 tile->current_color = *color;
1624 }
1625 return tile->pict;
1626 }
1627
1628 /*************************************************************
1629 * get_mask_pict
1630 *
1631 * Returns an appropriate Picture for masking with the specified alpha.
1632 * Call and use result within the xrender_cs
1633 */
1634 static Picture get_mask_pict( int alpha )
1635 {
1636 static Pixmap pixmap;
1637 static Picture pict;
1638 static int current_alpha;
1639
1640 if (alpha == 0xffff) return 0; /* don't need a mask for alpha==1.0 */
1641
1642 if (!pixmap)
1643 {
1644 XRenderPictureAttributes pa;
1645
1646 wine_tsx11_lock();
1647 pixmap = XCreatePixmap( gdi_display, root_window, 1, 1, 32 );
1648 pa.repeat = RepeatNormal;
1649 pict = pXRenderCreatePicture( gdi_display, pixmap,
1650 pict_formats[WXR_FORMAT_A8R8G8B8], CPRepeat, &pa );
1651 wine_tsx11_unlock();
1652 current_alpha = -1;
1653 }
1654
1655 if (alpha != current_alpha)
1656 {
1657 XRenderColor col;
1658 col.red = col.green = col.blue = 0;
1659 col.alpha = current_alpha = alpha;
1660 wine_tsx11_lock();
1661 pXRenderFillRectangle( gdi_display, PictOpSrc, pict, &col, 0, 0, 1, 1 );
1662 wine_tsx11_unlock();
1663 }
1664 return pict;
1665 }
1666
1667 /***********************************************************************
1668 * xrenderdrv_ExtTextOut
1669 */
1670 static BOOL xrenderdrv_ExtTextOut( PHYSDEV dev, INT x, INT y, UINT flags,
1671 const RECT *lprect, LPCWSTR wstr, UINT count, const INT *lpDx )
1672 {
1673 struct xrender_physdev *physdev = get_xrender_dev( dev );
1674 gsCacheEntry *entry;
1675 gsCacheEntryFormat *formatEntry;
1676 AA_Type aa_type = AA_None;
1677 unsigned int idx;
1678 Picture pict, tile_pict = 0;
1679 XGlyphElt16 *elts;
1680 POINT offset, desired, current;
1681 int render_op = PictOpOver;
1682 XRenderColor col;
1683 RECT rect, bounds;
1684
1685 get_xrender_color( physdev, GetTextColor( physdev->dev.hdc ), &col );
1686 pict = get_xrender_picture( physdev, 0, (flags & ETO_CLIPPED) ? lprect : NULL );
1687
1688 if(flags & ETO_OPAQUE)
1689 {
1690 XRenderColor bg;
1691
1692 if (physdev->format == WXR_FORMAT_MONO)
1693 /* use the inverse of the text color */
1694 bg.red = bg.green = bg.blue = bg.alpha = ~col.alpha;
1695 else
1696 get_xrender_color( physdev, GetBkColor( physdev->dev.hdc ), &bg );
1697
1698 wine_tsx11_lock();
1699 set_xrender_transformation( pict, 1, 1, 0, 0 );
1700 pXRenderFillRectangle( gdi_display, PictOpSrc, pict, &bg,
1701 physdev->x11dev->dc_rect.left + lprect->left,
1702 physdev->x11dev->dc_rect.top + lprect->top,
1703 lprect->right - lprect->left,
1704 lprect->bottom - lprect->top );
1705 wine_tsx11_unlock();
1706 add_device_bounds( physdev->x11dev, lprect );
1707 }
1708
1709 if(count == 0) return TRUE;
1710
1711 EnterCriticalSection(&xrender_cs);
1712
1713 entry = glyphsetCache + physdev->cache_index;
1714 aa_type = entry->aa_default;
1715 formatEntry = entry->format[aa_type];
1716
1717 for(idx = 0; idx < count; idx++) {
1718 if( !formatEntry ) {
1719 UploadGlyph(physdev, wstr[idx], aa_type);
1720 /* re-evaluate antialias since aa_default may have changed */
1721 aa_type = entry->aa_default;
1722 formatEntry = entry->format[aa_type];
1723 } else if( wstr[idx] >= formatEntry->nrealized || formatEntry->realized[wstr[idx]] == FALSE) {
1724 UploadGlyph(physdev, wstr[idx], aa_type);
1725 }
1726 }
1727 if (!formatEntry)
1728 {
1729 WARN("could not upload requested glyphs\n");
1730 LeaveCriticalSection(&xrender_cs);
1731 return FALSE;
1732 }
1733
1734 TRACE("Writing %s at %d,%d\n", debugstr_wn(wstr,count),
1735 physdev->x11dev->dc_rect.left + x, physdev->x11dev->dc_rect.top + y);
1736
1737 elts = HeapAlloc(GetProcessHeap(), 0, sizeof(XGlyphElt16) * count);
1738
1739 /* There's a bug in XRenderCompositeText that ignores the xDst and yDst parameters.
1740 So we pass zeros to the function and move to our starting position using the first
1741 element of the elts array. */
1742
1743 desired.x = physdev->x11dev->dc_rect.left + x;
1744 desired.y = physdev->x11dev->dc_rect.top + y;
1745 offset.x = offset.y = 0;
1746 current.x = current.y = 0;
1747
1748 tile_pict = get_tile_pict(physdev->format, &col);
1749
1750 /* FIXME the mapping of Text/BkColor onto 1 or 0 needs investigation.
1751 */
1752 if (physdev->format == WXR_FORMAT_MONO && col.red == 0 && col.green == 0 && col.blue == 0)
1753 render_op = PictOpOutReverse; /* This gives us 'black' text */
1754
1755 reset_bounds( &bounds );
1756 for(idx = 0; idx < count; idx++)
1757 {
1758 elts[idx].glyphset = formatEntry->glyphset;
1759 elts[idx].chars = wstr + idx;
1760 elts[idx].nchars = 1;
1761 elts[idx].xOff = desired.x - current.x;
1762 elts[idx].yOff = desired.y - current.y;
1763
1764 current.x += (elts[idx].xOff + formatEntry->gis[wstr[idx]].xOff);
1765 current.y += (elts[idx].yOff + formatEntry->gis[wstr[idx]].yOff);
1766
1767 rect.left = desired.x - physdev->x11dev->dc_rect.left - formatEntry->gis[wstr[idx]].x;
1768 rect.top = desired.y - physdev->x11dev->dc_rect.top - formatEntry->gis[wstr[idx]].y;
1769 rect.right = rect.left + formatEntry->gis[wstr[idx]].width;
1770 rect.bottom = rect.top + formatEntry->gis[wstr[idx]].height;
1771 add_bounds_rect( &bounds, &rect );
1772
1773 if(!lpDx)
1774 {
1775 desired.x += formatEntry->gis[wstr[idx]].xOff;
1776 desired.y += formatEntry->gis[wstr[idx]].yOff;
1777 }
1778 else
1779 {
1780 if(flags & ETO_PDY)
1781 {
1782 offset.x += lpDx[idx * 2];
1783 offset.y += lpDx[idx * 2 + 1];
1784 }
1785 else
1786 offset.x += lpDx[idx];
1787 desired.x = physdev->x11dev->dc_rect.left + x + offset.x;
1788 desired.y = physdev->x11dev->dc_rect.top + y + offset.y;
1789 }
1790 }
1791
1792 wine_tsx11_lock();
1793 /* Make sure we don't have any transforms set from a previous call */
1794 set_xrender_transformation(pict, 1, 1, 0, 0);
1795 pXRenderCompositeText16(gdi_display, render_op,
1796 tile_pict,
1797 pict,
1798 formatEntry->font_format,
1799 0, 0, 0, 0, elts, count);
1800 wine_tsx11_unlock();
1801 HeapFree(GetProcessHeap(), 0, elts);
1802
1803 LeaveCriticalSection(&xrender_cs);
1804 add_device_bounds( physdev->x11dev, &bounds );
1805 return TRUE;
1806 }
1807
1808 /* multiply the alpha channel of a picture */
1809 static void multiply_alpha( Picture pict, XRenderPictFormat *format, int alpha,
1810 int x, int y, int width, int height )
1811 {
1812 XRenderPictureAttributes pa;
1813 Pixmap src_pixmap, mask_pixmap;
1814 Picture src_pict, mask_pict;
1815 XRenderColor color;
1816
1817 wine_tsx11_lock();
1818 src_pixmap = XCreatePixmap( gdi_display, root_window, 1, 1, format->depth );
1819 mask_pixmap = XCreatePixmap( gdi_display, root_window, 1, 1, format->depth );
1820 pa.repeat = RepeatNormal;
1821 src_pict = pXRenderCreatePicture( gdi_display, src_pixmap, format, CPRepeat, &pa );
1822 pa.component_alpha = True;
1823 mask_pict = pXRenderCreatePicture( gdi_display, mask_pixmap, format, CPRepeat|CPComponentAlpha, &pa );
1824 color.red = color.green = color.blue = color.alpha = 0xffff;
1825 pXRenderFillRectangle( gdi_display, PictOpSrc, src_pict, &color, 0, 0, 1, 1 );
1826 color.alpha = alpha;
1827 pXRenderFillRectangle( gdi_display, PictOpSrc, mask_pict, &color, 0, 0, 1, 1 );
1828 pXRenderComposite( gdi_display, PictOpInReverse, src_pict, mask_pict, pict,
1829 0, 0, 0, 0, x, y, width, height );
1830 pXRenderFreePicture( gdi_display, src_pict );
1831 pXRenderFreePicture( gdi_display, mask_pict );
1832 XFreePixmap( gdi_display, src_pixmap );
1833 XFreePixmap( gdi_display, mask_pixmap );
1834 wine_tsx11_unlock();
1835 }
1836
1837 /* Helper function for (stretched) blitting using xrender */
1838 static void xrender_blit( int op, Picture src_pict, Picture mask_pict, Picture dst_pict,
1839 int x_src, int y_src, int width_src, int height_src,
1840 int x_dst, int y_dst, int width_dst, int height_dst,
1841 double xscale, double yscale )
1842 {
1843 int x_offset, y_offset;
1844
1845 if (width_src < 0)
1846 {
1847 x_src += width_src + 1;
1848 width_src = -width_src;
1849 }
1850 if (height_src < 0)
1851 {
1852 y_src += height_src + 1;
1853 height_src = -height_src;
1854 }
1855 if (width_dst < 0)
1856 {
1857 x_dst += width_dst + 1;
1858 width_dst = -width_dst;
1859 }
1860 if (height_dst < 0)
1861 {
1862 y_dst += height_dst + 1;
1863 height_dst = -height_dst;
1864 }
1865
1866 /* When we need to scale we perform scaling and source_x / source_y translation using a transformation matrix.
1867 * This is needed because XRender is inaccurate in combination with scaled source coordinates passed to XRenderComposite.
1868 * In all other cases we do use XRenderComposite for translation as it is faster than using a transformation matrix. */
1869 wine_tsx11_lock();
1870 if(xscale != 1.0 || yscale != 1.0)
1871 {
1872 /* In case of mirroring we need a source x- and y-offset because without the pixels will be
1873 * in the wrong quadrant of the x-y plane.
1874 */
1875 x_offset = (xscale < 0) ? -width_dst : 0;
1876 y_offset = (yscale < 0) ? -height_dst : 0;
1877 set_xrender_transformation(src_pict, xscale, yscale, x_src, y_src);
1878 }
1879 else
1880 {
1881 x_offset = x_src;
1882 y_offset = y_src;
1883 set_xrender_transformation(src_pict, 1, 1, 0, 0);
1884 }
1885 pXRenderComposite( gdi_display, op, src_pict, mask_pict, dst_pict,
1886 x_offset, y_offset, 0, 0, x_dst, y_dst, width_dst, height_dst );
1887 wine_tsx11_unlock();
1888 }
1889
1890 /* Helper function for (stretched) mono->color blitting using xrender */
1891 static void xrender_mono_blit( Picture src_pict, Picture dst_pict,
1892 enum wxr_format dst_format, XRenderColor *fg, XRenderColor *bg,
1893 int x_src, int y_src, int width_src, int height_src,
1894 int x_dst, int y_dst, int width_dst, int height_dst,
1895 double xscale, double yscale )
1896 {
1897 Picture tile_pict;
1898 int x_offset, y_offset;
1899 XRenderColor color;
1900
1901 if (width_src < 0)
1902 {
1903 x_src += width_src + 1;
1904 width_src = -width_src;
1905 }
1906 if (height_src < 0)
1907 {
1908 y_src += height_src + 1;
1909 height_src = -height_src;
1910 }
1911 if (width_dst < 0)
1912 {
1913 x_dst += width_dst + 1;
1914 width_dst = -width_dst;
1915 }
1916 if (height_dst < 0)
1917 {
1918 y_dst += height_dst + 1;
1919 height_dst = -height_dst;
1920 }
1921
1922 /* When doing a mono->color blit, the source data is used as mask, and the source picture
1923 * contains a 1x1 picture for tiling. The source data effectively acts as an alpha channel to
1924 * the tile data.
1925 */
1926 EnterCriticalSection( &xrender_cs );
1927 color = *bg;
1928 color.alpha = 0xffff; /* tile pict needs 100% alpha */
1929 tile_pict = get_tile_pict( dst_format, &color );
1930
1931 wine_tsx11_lock();
1932 pXRenderFillRectangle( gdi_display, PictOpSrc, dst_pict, fg, x_dst, y_dst, width_dst, height_dst );
1933
1934 if (xscale != 1.0 || yscale != 1.0)
1935 {
1936 /* In case of mirroring we need a source x- and y-offset because without the pixels will be
1937 * in the wrong quadrant of the x-y plane.
1938 */
1939 x_offset = (xscale < 0) ? -width_dst : 0;
1940 y_offset = (yscale < 0) ? -height_dst : 0;
1941 set_xrender_transformation(src_pict, xscale, yscale, x_src, y_src);
1942 }
1943 else
1944 {
1945 x_offset = x_src;
1946 y_offset = y_src;
1947 set_xrender_transformation(src_pict, 1, 1, 0, 0);
1948 }
1949 pXRenderComposite(gdi_display, PictOpOver, tile_pict, src_pict, dst_pict,
1950 0, 0, x_offset, y_offset, x_dst, y_dst, width_dst, height_dst );
1951 wine_tsx11_unlock();
1952 LeaveCriticalSection( &xrender_cs );
1953
1954 /* force the alpha channel for background pixels, it has been set to 100% by the tile */
1955 if (bg->alpha != 0xffff && (dst_format == WXR_FORMAT_A8R8G8B8 || dst_format == WXR_FORMAT_B8G8R8A8))
1956 multiply_alpha( dst_pict, pict_formats[dst_format], bg->alpha,
1957 x_dst, y_dst, width_dst, height_dst );
1958 }
1959
1960 /* create a pixmap and render picture for an image */
1961 static DWORD create_image_pixmap( BITMAPINFO *info, const struct gdi_image_bits *bits,
1962 struct bitblt_coords *src, enum wxr_format format,
1963 Pixmap *pixmap, Picture *pict, BOOL *use_repeat )
1964 {
1965 DWORD ret;
1966 int width = src->visrect.right - src->visrect.left;
1967 int height = src->visrect.bottom - src->visrect.top;
1968 int depth = pict_formats[format]->depth;
1969 struct gdi_image_bits dst_bits;
1970 XRenderPictureAttributes pa;
1971 XImage *image;
1972
1973 wine_tsx11_lock();
1974 image = XCreateImage( gdi_display, visual, depth, ZPixmap, 0, NULL,
1975 info->bmiHeader.biWidth, height, 32, 0 );
1976 wine_tsx11_unlock();
1977 if (!image) return ERROR_OUTOFMEMORY;
1978
1979 ret = copy_image_bits( info, (format == WXR_FORMAT_R8G8B8), image, bits, &dst_bits, src, NULL, ~0u );
1980 if (ret) return ret;
1981
1982 image->data = dst_bits.ptr;
1983
1984 *use_repeat = (width == 1 && height == 1);
1985 pa.repeat = *use_repeat ? RepeatNormal : RepeatNone;
1986
1987 wine_tsx11_lock();
1988 *pixmap = XCreatePixmap( gdi_display, root_window, width, height, depth );
1989 XPutImage( gdi_display, *pixmap, get_bitmap_gc( depth ), image,
1990 src->visrect.left, 0, 0, 0, width, height );
1991 *pict = pXRenderCreatePicture( gdi_display, *pixmap, pict_formats[format], CPRepeat, &pa );
1992 wine_tsx11_unlock();
1993
1994 /* make coordinates relative to the pixmap */
1995 src->x -= src->visrect.left;
1996 src->y -= src->visrect.top;
1997 OffsetRect( &src->visrect, -src->visrect.left, -src->visrect.top );
1998
1999 image->data = NULL;
2000 wine_tsx11_lock();
2001 XDestroyImage( image );
2002 wine_tsx11_unlock();
2003 if (dst_bits.free) dst_bits.free( &dst_bits );
2004 return ret;
2005 }
2006
2007 static void xrender_stretch_blit( struct xrender_physdev *physdev_src, struct xrender_physdev *physdev_dst,
2008 Drawable drawable, const struct bitblt_coords *src,
2009 const struct bitblt_coords *dst )
2010 {
2011 int x_dst, y_dst;
2012 Picture src_pict = 0, dst_pict, mask_pict = 0;
2013 BOOL use_repeat;
2014 double xscale, yscale;
2015
2016 use_repeat = use_source_repeat( physdev_src );
2017 if (!use_repeat)
2018 {
2019 xscale = src->width / (double)dst->width;
2020 yscale = src->height / (double)dst->height;
2021 }
2022 else xscale = yscale = 1; /* no scaling needed with a repeating source */
2023
2024 if (drawable) /* using an intermediate pixmap */
2025 {
2026 XRenderPictureAttributes pa;
2027
2028 x_dst = dst->x;
2029 y_dst = dst->y;
2030 pa.repeat = RepeatNone;
2031 wine_tsx11_lock();
2032 dst_pict = pXRenderCreatePicture( gdi_display, drawable, physdev_dst->pict_format, CPRepeat, &pa );
2033 wine_tsx11_unlock();
2034 }
2035 else
2036 {
2037 x_dst = physdev_dst->x11dev->dc_rect.left + dst->x;
2038 y_dst = physdev_dst->x11dev->dc_rect.top + dst->y;
2039 dst_pict = get_xrender_picture( physdev_dst, 0, &dst->visrect );
2040 }
2041
2042 src_pict = get_xrender_picture_source( physdev_src, use_repeat );
2043
2044 /* mono -> color */
2045 if (physdev_src->format == WXR_FORMAT_MONO && physdev_dst->format != WXR_FORMAT_MONO)
2046 {
2047 XRenderColor fg, bg;
2048
2049 get_xrender_color( physdev_dst, GetTextColor( physdev_dst->dev.hdc ), &fg );
2050 get_xrender_color( physdev_dst, GetBkColor( physdev_dst->dev.hdc ), &bg );
2051 fg.alpha = bg.alpha = 0;
2052
2053 xrender_mono_blit( src_pict, dst_pict, physdev_dst->format, &fg, &bg,
2054 physdev_src->x11dev->dc_rect.left + src->x,
2055 physdev_src->x11dev->dc_rect.top + src->y,
2056 src->width, src->height, x_dst, y_dst, dst->width, dst->height, xscale, yscale );
2057 }
2058 else /* color -> color (can be at different depths) or mono -> mono */
2059 {
2060 if (physdev_dst->pict_format->depth == 32 && physdev_src->pict_format->depth < 32)
2061 mask_pict = get_no_alpha_mask();
2062
2063 xrender_blit( PictOpSrc, src_pict, mask_pict, dst_pict,
2064 physdev_src->x11dev->dc_rect.left + src->x,
2065 physdev_src->x11dev->dc_rect.top + src->y,
2066 src->width, src->height, x_dst, y_dst, dst->width, dst->height, xscale, yscale );
2067 }
2068
2069 if (drawable)
2070 {
2071 wine_tsx11_lock();
2072 pXRenderFreePicture( gdi_display, dst_pict );
2073 wine_tsx11_unlock();
2074 }
2075 }
2076
2077
2078 static void xrender_put_image( Pixmap src_pixmap, Picture src_pict, Picture mask_pict, HRGN clip,
2079 XRenderPictFormat *dst_format, struct xrender_physdev *physdev,
2080 Drawable drawable, struct bitblt_coords *src,
2081 struct bitblt_coords *dst, BOOL use_repeat )
2082 {
2083 int x_dst, y_dst;
2084 Picture dst_pict;
2085 XRenderPictureAttributes pa;
2086 double xscale, yscale;
2087
2088 if (drawable) /* using an intermediate pixmap */
2089 {
2090 RGNDATA *clip_data = NULL;
2091
2092 if (clip) clip_data = X11DRV_GetRegionData( clip, 0 );
2093 x_dst = dst->x;
2094 y_dst = dst->y;
2095 pa.repeat = RepeatNone;
2096 wine_tsx11_lock();
2097 dst_pict = pXRenderCreatePicture( gdi_display, drawable, dst_format, CPRepeat, &pa );
2098 if (clip_data)
2099 pXRenderSetPictureClipRectangles( gdi_display, dst_pict, 0, 0,
2100 (XRectangle *)clip_data->Buffer, clip_data->rdh.nCount );
2101 wine_tsx11_unlock();
2102 HeapFree( GetProcessHeap(), 0, clip_data );
2103 }
2104 else
2105 {
2106 x_dst = physdev->x11dev->dc_rect.left + dst->x;
2107 y_dst = physdev->x11dev->dc_rect.top + dst->y;
2108 dst_pict = get_xrender_picture( physdev, clip, &dst->visrect );
2109 }
2110
2111 if (!use_repeat)
2112 {
2113 xscale = src->width / (double)dst->width;
2114 yscale = src->height / (double)dst->height;
2115 }
2116 else xscale = yscale = 1; /* no scaling needed with a repeating source */
2117
2118 xrender_blit( PictOpSrc, src_pict, mask_pict, dst_pict, src->x, src->y, src->width, src->height,
2119 x_dst, y_dst, dst->width, dst->height, xscale, yscale );
2120
2121 if (drawable)
2122 {
2123 wine_tsx11_lock();
2124 pXRenderFreePicture( gdi_display, dst_pict );
2125 wine_tsx11_unlock();
2126 }
2127 }
2128
2129
2130 /***********************************************************************
2131 * xrenderdrv_StretchBlt
2132 */
2133 static BOOL xrenderdrv_StretchBlt( PHYSDEV dst_dev, struct bitblt_coords *dst,
2134 PHYSDEV src_dev, struct bitblt_coords *src, DWORD rop )
2135 {
2136 struct xrender_physdev *physdev_dst = get_xrender_dev( dst_dev );
2137 struct xrender_physdev *physdev_src = get_xrender_dev( src_dev );
2138 BOOL stretch = (src->width != dst->width) || (src->height != dst->height);
2139
2140 if (src_dev->funcs != dst_dev->funcs)
2141 {
2142 dst_dev = GET_NEXT_PHYSDEV( dst_dev, pStretchBlt );
2143 return dst_dev->funcs->pStretchBlt( dst_dev, dst, src_dev, src, rop );
2144 }
2145
2146 /* XRender is of no use for color -> mono */
2147 if (physdev_dst->format == WXR_FORMAT_MONO && physdev_src->format != WXR_FORMAT_MONO)
2148 goto x11drv_fallback;
2149
2150 /* if not stretching, we only need to handle format conversion */
2151 if (!stretch && physdev_dst->format == physdev_src->format) goto x11drv_fallback;
2152
2153 if (rop != SRCCOPY)
2154 {
2155 GC tmpGC;
2156 Pixmap tmp_pixmap;
2157 struct bitblt_coords tmp;
2158
2159 /* make coordinates relative to tmp pixmap */
2160 tmp = *dst;
2161 tmp.x -= tmp.visrect.left;
2162 tmp.y -= tmp.visrect.top;
2163 OffsetRect( &tmp.visrect, -tmp.visrect.left, -tmp.visrect.top );
2164
2165 wine_tsx11_lock();
2166 tmpGC = XCreateGC( gdi_display, physdev_dst->x11dev->drawable, 0, NULL );
2167 XSetSubwindowMode( gdi_display, tmpGC, IncludeInferiors );
2168 XSetGraphicsExposures( gdi_display, tmpGC, False );
2169 tmp_pixmap = XCreatePixmap( gdi_display, root_window, tmp.visrect.right - tmp.visrect.left,
2170 tmp.visrect.bottom - tmp.visrect.top, physdev_dst->pict_format->depth );
2171 wine_tsx11_unlock();
2172
2173 xrender_stretch_blit( physdev_src, physdev_dst, tmp_pixmap, src, &tmp );
2174 execute_rop( physdev_dst->x11dev, tmp_pixmap, tmpGC, &dst->visrect, rop );
2175
2176 wine_tsx11_lock();
2177 XFreePixmap( gdi_display, tmp_pixmap );
2178 XFreeGC( gdi_display, tmpGC );
2179 wine_tsx11_unlock();
2180 }
2181 else xrender_stretch_blit( physdev_src, physdev_dst, 0, src, dst );
2182
2183 add_device_bounds( physdev_dst->x11dev, &dst->visrect );
2184 return TRUE;
2185
2186 x11drv_fallback:
2187 return X11DRV_StretchBlt( &physdev_dst->x11dev->dev, dst, &physdev_src->x11dev->dev, src, rop );
2188 }
2189
2190
2191 /***********************************************************************
2192 * xrenderdrv_PutImage
2193 */
2194 static DWORD xrenderdrv_PutImage( PHYSDEV dev, HBITMAP hbitmap, HRGN clip, BITMAPINFO *info,
2195 const struct gdi_image_bits *bits, struct bitblt_coords *src,
2196 struct bitblt_coords *dst, DWORD rop )
2197 {
2198 struct xrender_physdev *physdev;
2199 X_PHYSBITMAP *bitmap;
2200 DWORD ret;
2201 Pixmap tmp_pixmap;
2202 GC gc;
2203 enum wxr_format src_format, dst_format;
2204 XRenderPictFormat *pict_format;
2205 Pixmap src_pixmap;
2206 Picture src_pict, mask_pict = 0;
2207 BOOL use_repeat;
2208
2209 if (hbitmap)
2210 {
2211 if (!(bitmap = X11DRV_get_phys_bitmap( hbitmap ))) return ERROR_INVALID_HANDLE;
2212 physdev = NULL;
2213 dst_format = bitmap->format;
2214 }
2215 else
2216 {
2217 physdev = get_xrender_dev( dev );
2218 bitmap = NULL;
2219 dst_format = physdev->format;
2220 }
2221
2222 src_format = get_xrender_format_from_bitmapinfo( info );
2223 if (!(pict_format = pict_formats[src_format])) goto update_format;
2224
2225 /* make sure we can create an image with the same bpp */
2226 if (info->bmiHeader.biBitCount != pixmap_formats[pict_format->depth]->bits_per_pixel)
2227 goto update_format;
2228
2229 /* mono <-> color conversions not supported */
2230 if ((src_format != dst_format) && (src_format == WXR_FORMAT_MONO || dst_format == WXR_FORMAT_MONO))
2231 goto x11drv_fallback;
2232
2233 if (!bits) return ERROR_SUCCESS; /* just querying the format */
2234
2235 if (!has_alpha( src_format ) && has_alpha( dst_format )) mask_pict = get_no_alpha_mask();
2236
2237 ret = create_image_pixmap( info, bits, src, src_format, &src_pixmap, &src_pict, &use_repeat );
2238 if (!ret)
2239 {
2240 struct bitblt_coords tmp;
2241
2242 if (bitmap)
2243 {
2244 HRGN rgn = CreateRectRgnIndirect( &dst->visrect );
2245 if (clip) CombineRgn( rgn, rgn, clip, RGN_AND );
2246
2247 xrender_put_image( src_pixmap, src_pict, mask_pict, rgn,
2248 pict_formats[dst_format], NULL, bitmap->pixmap, src, dst, use_repeat );
2249 DeleteObject( rgn );
2250 }
2251 else
2252 {
2253 if (rop != SRCCOPY)
2254 {
2255 BOOL restore_region = add_extra_clipping_region( physdev->x11dev, clip );
2256
2257 /* make coordinates relative to tmp pixmap */
2258 tmp = *dst;
2259 tmp.x -= tmp.visrect.left;
2260 tmp.y -= tmp.visrect.top;
2261 OffsetRect( &tmp.visrect, -tmp.visrect.left, -tmp.visrect.top );
2262
2263 wine_tsx11_lock();
2264 gc = XCreateGC( gdi_display, physdev->x11dev->drawable, 0, NULL );
2265 XSetSubwindowMode( gdi_display, gc, IncludeInferiors );
2266 XSetGraphicsExposures( gdi_display, gc, False );
2267 tmp_pixmap = XCreatePixmap( gdi_display, root_window,
2268 tmp.visrect.right - tmp.visrect.left,
2269 tmp.visrect.bottom - tmp.visrect.top,
2270 physdev->pict_format->depth );
2271 wine_tsx11_unlock();
2272
2273 xrender_put_image( src_pixmap, src_pict, mask_pict, NULL, physdev->pict_format,
2274 NULL, tmp_pixmap, src, &tmp, use_repeat );
2275 execute_rop( physdev->x11dev, tmp_pixmap, gc, &dst->visrect, rop );
2276
2277 wine_tsx11_lock();
2278 XFreePixmap( gdi_display, tmp_pixmap );
2279 XFreeGC( gdi_display, gc );
2280 wine_tsx11_unlock();
2281
2282 if (restore_region) restore_clipping_region( physdev->x11dev );
2283 }
2284 else xrender_put_image( src_pixmap, src_pict, mask_pict, clip,
2285 physdev->pict_format, physdev, 0, src, dst, use_repeat );
2286
2287 add_device_bounds( physdev->x11dev, &dst->visrect );
2288 }
2289
2290 wine_tsx11_lock();
2291 pXRenderFreePicture( gdi_display, src_pict );
2292 XFreePixmap( gdi_display, src_pixmap );
2293 wine_tsx11_unlock();
2294 }
2295 return ret;
2296
2297 update_format:
2298 if (info->bmiHeader.biHeight > 0) info->bmiHeader.biHeight = -info->bmiHeader.biHeight;
2299 set_color_info( pict_formats[dst_format], info );
2300 return ERROR_BAD_FORMAT;
2301
2302 x11drv_fallback:
2303 if (hbitmap) return X11DRV_PutImage( dev, hbitmap, clip, info, bits, src, dst, rop );
2304 dev = GET_NEXT_PHYSDEV( dev, pPutImage );
2305 return dev->funcs->pPutImage( dev, hbitmap, clip, info, bits, src, dst, rop );
2306 }
2307
2308
2309 /***********************************************************************
2310 * xrenderdrv_BlendImage
2311 */
2312 static DWORD xrenderdrv_BlendImage( PHYSDEV dev, BITMAPINFO *info, const struct gdi_image_bits *bits,
2313 struct bitblt_coords *src, struct bitblt_coords *dst,
2314 BLENDFUNCTION func )
2315 {
2316 struct xrender_physdev *physdev = get_xrender_dev( dev );
2317 DWORD ret;
2318 enum wxr_format format;
2319 XRenderPictFormat *pict_format;
2320 Picture dst_pict, src_pict, mask_pict;
2321 Pixmap src_pixmap;
2322 BOOL use_repeat;
2323
2324 format = get_xrender_format_from_bitmapinfo( info );
2325 if (!(func.AlphaFormat & AC_SRC_ALPHA))
2326 format = get_format_without_alpha( format );
2327 else if (format != WXR_FORMAT_A8R8G8B8)
2328 return ERROR_INVALID_PARAMETER;
2329
2330 if (!(pict_format = pict_formats[format])) goto update_format;
2331
2332 /* make sure we can create an image with the same bpp */
2333 if (info->bmiHeader.biBitCount != pixmap_formats[pict_format->depth]->bits_per_pixel)
2334 goto update_format;
2335
2336 if (format == WXR_FORMAT_MONO && physdev->format != WXR_FORMAT_MONO)
2337 goto update_format;
2338
2339 if (!bits) return ERROR_SUCCESS; /* just querying the format */
2340
2341 ret = create_image_pixmap( info, bits, src, format, &src_pixmap, &src_pict, &use_repeat );
2342 if (!ret)
2343 {
2344 double xscale, yscale;
2345
2346 if (!use_repeat)
2347 {
2348 xscale = src->width / (double)dst->width;
2349 yscale = src->height / (double)dst->height;
2350 }
2351 else xscale = yscale = 1; /* no scaling needed with a repeating source */
2352
2353 dst_pict = get_xrender_picture( physdev, 0, &dst->visrect );
2354
2355 EnterCriticalSection( &xrender_cs );
2356 mask_pict = get_mask_pict( func.SourceConstantAlpha * 257 );
2357
2358 xrender_blit( PictOpOver, src_pict, mask_pict, dst_pict,
2359 src->x, src->y, src->width, src->height,
2360 physdev->x11dev->dc_rect.left + dst->x,
2361 physdev->x11dev->dc_rect.top + dst->y,
2362 dst->width, dst->height, xscale, yscale );
2363
2364 wine_tsx11_lock();
2365 pXRenderFreePicture( gdi_display, src_pict );
2366 XFreePixmap( gdi_display, src_pixmap );
2367 wine_tsx11_unlock();
2368
2369 LeaveCriticalSection( &xrender_cs );
2370 add_device_bounds( physdev->x11dev, &dst->visrect );
2371 }
2372 return ret;
2373
2374 update_format:
2375 if (info->bmiHeader.biHeight > 0) info->bmiHeader.biHeight = -info->bmiHeader.biHeight;
2376 set_color_info( physdev->pict_format, info );
2377 return ERROR_BAD_FORMAT;
2378 }
2379
2380
2381 /***********************************************************************
2382 * xrenderdrv_AlphaBlend
2383 */
2384 static BOOL xrenderdrv_AlphaBlend( PHYSDEV dst_dev, struct bitblt_coords *dst,
2385 PHYSDEV src_dev, struct bitblt_coords *src, BLENDFUNCTION blendfn )
2386 {
2387 struct xrender_physdev *physdev_dst = get_xrender_dev( dst_dev );
2388 struct xrender_physdev *physdev_src = get_xrender_dev( src_dev );
2389 Picture dst_pict, src_pict = 0, mask_pict = 0, tmp_pict = 0;
2390 XRenderPictureAttributes pa;
2391 Pixmap tmp_pixmap = 0;
2392 double xscale, yscale;
2393 BOOL use_repeat;
2394
2395 if (src_dev->funcs != dst_dev->funcs)
2396 {
2397 dst_dev = GET_NEXT_PHYSDEV( dst_dev, pAlphaBlend );
2398 return dst_dev->funcs->pAlphaBlend( dst_dev, dst, src_dev, src, blendfn );
2399 }
2400
2401 if ((blendfn.AlphaFormat & AC_SRC_ALPHA) && physdev_src->format != WXR_FORMAT_A8R8G8B8)
2402 {
2403 SetLastError( ERROR_INVALID_PARAMETER );
2404 return FALSE;
2405 }
2406
2407 dst_pict = get_xrender_picture( physdev_dst, 0, &dst->visrect );
2408
2409 use_repeat = use_source_repeat( physdev_src );
2410 if (!use_repeat)
2411 {
2412 xscale = src->width / (double)dst->width;
2413 yscale = src->height / (double)dst->height;
2414 }
2415 else xscale = yscale = 1; /* no scaling needed with a repeating source */
2416
2417 src_pict = get_xrender_picture_source( physdev_src, use_repeat );
2418
2419 if (physdev_src->format == WXR_FORMAT_MONO && physdev_dst->format != WXR_FORMAT_MONO)
2420 {
2421 /* mono -> color blending needs an intermediate color pixmap */
2422 XRenderColor fg, bg;
2423 int width = src->visrect.right - src->visrect.left;
2424 int height = src->visrect.bottom - src->visrect.top;
2425
2426 /* blending doesn't use the destination DC colors */
2427 fg.red = fg.green = fg.blue = 0;
2428 bg.red = bg.green = bg.blue = 0xffff;
2429 fg.alpha = bg.alpha = 0xffff;
2430
2431 wine_tsx11_lock();
2432 tmp_pixmap = XCreatePixmap( gdi_display, root_window, width, height,
2433 physdev_dst->pict_format->depth );
2434 pa.repeat = use_repeat ? RepeatNormal : RepeatNone;
2435 tmp_pict = pXRenderCreatePicture( gdi_display, tmp_pixmap, physdev_dst->pict_format,
2436 CPRepeat, &pa );
2437 wine_tsx11_unlock();
2438
2439 xrender_mono_blit( src_pict, tmp_pict, physdev_dst->format, &fg, &bg,
2440 src->visrect.left, src->visrect.top, width, height, 0, 0, width, height, 1, 1 );
2441 }
2442 else if (!(blendfn.AlphaFormat & AC_SRC_ALPHA) && physdev_src->pict_format)
2443 {
2444 /* we need a source picture with no alpha */
2445 enum wxr_format format = get_format_without_alpha( physdev_src->format );
2446 if (format != physdev_src->format)
2447 {
2448 wine_tsx11_lock();
2449 pa.subwindow_mode = IncludeInferiors;
2450 pa.repeat = use_repeat ? RepeatNormal : RepeatNone;
2451 tmp_pict = pXRenderCreatePicture( gdi_display, physdev_src->x11dev->drawable,
2452 pict_formats[format], CPSubwindowMode|CPRepeat, &pa );
2453 wine_tsx11_unlock();
2454 }
2455 }
2456
2457 if (tmp_pict) src_pict = tmp_pict;
2458
2459 EnterCriticalSection( &xrender_cs );
2460 mask_pict = get_mask_pict( blendfn.SourceConstantAlpha * 257 );
2461
2462 xrender_blit( PictOpOver, src_pict, mask_pict, dst_pict,
2463 physdev_src->x11dev->dc_rect.left + src->x,
2464 physdev_src->x11dev->dc_rect.top + src->y,
2465 src->width, src->height,
2466 physdev_dst->x11dev->dc_rect.left + dst->x,
2467 physdev_dst->x11dev->dc_rect.top + dst->y,
2468 dst->width, dst->height, xscale, yscale );
2469
2470 wine_tsx11_lock();
2471 if (tmp_pict) pXRenderFreePicture( gdi_display, tmp_pict );
2472 if (tmp_pixmap) XFreePixmap( gdi_display, tmp_pixmap );
2473 wine_tsx11_unlock();
2474
2475 LeaveCriticalSection( &xrender_cs );
2476 add_device_bounds( physdev_dst->x11dev, &dst->visrect );
2477 return TRUE;
2478 }
2479
2480 /***********************************************************************
2481 * xrenderdrv_GradientFill
2482 */
2483 static BOOL xrenderdrv_GradientFill( PHYSDEV dev, TRIVERTEX *vert_array, ULONG nvert,
2484 void * grad_array, ULONG ngrad, ULONG mode )
2485 {
2486 #ifdef HAVE_XRENDERCREATELINEARGRADIENT
2487 static const XFixed stops[2] = { 0, 1 << 16 };
2488 struct xrender_physdev *physdev = get_xrender_dev( dev );
2489 XLinearGradient gradient;
2490 XRenderColor colors[2];
2491 Picture src_pict, dst_pict;
2492 unsigned int i;
2493 const GRADIENT_RECT *rect = grad_array;
2494 RECT rc;
2495 POINT pt[2];
2496
2497 if (!pXRenderCreateLinearGradient) goto fallback;
2498
2499 /* <= 16-bpp uses dithering */
2500 if (!physdev->pict_format || physdev->pict_format->depth <= 16) goto fallback;
2501
2502 switch (mode)
2503 {
2504 case GRADIENT_FILL_RECT_H:
2505 case GRADIENT_FILL_RECT_V:
2506 for (i = 0; i < ngrad; i++, rect++)
2507 {
2508 const TRIVERTEX *v1 = vert_array + rect->UpperLeft;
2509 const TRIVERTEX *v2 = vert_array + rect->LowerRight;
2510
2511 colors[0].red = v1->Red * 257 / 256;
2512 colors[0].green = v1->Green * 257 / 256;
2513 colors[0].blue = v1->Blue * 257 / 256;
2514 colors[1].red = v2->Red * 257 / 256;
2515 colors[1].green = v2->Green * 257 / 256;
2516 colors[1].blue = v2->Blue * 257 / 256;
2517 /* always ignore alpha since otherwise xrender will want to pre-multiply the colors */
2518 colors[0].alpha = colors[1].alpha = 65535;
2519
2520 pt[0].x = v1->x;
2521 pt[0].y = v1->y;
2522 pt[1].x = v2->x;
2523 pt[1].y = v2->y;
2524 LPtoDP( dev->hdc, pt, 2 );
2525 if (mode == GRADIENT_FILL_RECT_H)
2526 {
2527 gradient.p1.y = gradient.p2.y = 0;
2528 if (pt[1].x > pt[0].x)
2529 {
2530 gradient.p1.x = 0;
2531 gradient.p2.x = (pt[1].x - pt[0].x) << 16;
2532 }
2533 else
2534 {
2535 gradient.p1.x = (pt[0].x - pt[1].x) << 16;
2536 gradient.p2.x = 0;
2537 }
2538 }
2539 else
2540 {
2541 gradient.p1.x = gradient.p2.x = 0;
2542 if (pt[1].y > pt[0].y)
2543 {
2544 gradient.p1.y = 0;
2545 gradient.p2.y = (pt[1].y - pt[0].y) << 16;
2546 }
2547 else
2548 {
2549 gradient.p1.y = (pt[0].y - pt[1].y) << 16;
2550 gradient.p2.y = 0;
2551 }
2552 }
2553
2554 rc.left = min( pt[0].x, pt[1].x );
2555 rc.top = min( pt[0].y, pt[1].y );
2556 rc.right = max( pt[0].x, pt[1].x );
2557 rc.bottom = max( pt[0].y, pt[1].y );
2558
2559 TRACE( "%u gradient %s colors %04x,%04x,%04x,%04x -> %04x,%04x,%04x,%04x\n",
2560 mode, wine_dbgstr_rect( &rc ),
2561 colors[0].red, colors[0].green, colors[0].blue, colors[0].alpha,
2562 colors[1].red, colors[1].green, colors[1].blue, colors[1].alpha );
2563
2564 dst_pict = get_xrender_picture( physdev, 0, NULL );
2565
2566 wine_tsx11_lock();
2567 src_pict = pXRenderCreateLinearGradient( gdi_display, &gradient, stops, colors, 2 );
2568 xrender_blit( PictOpSrc, src_pict, 0, dst_pict,
2569 0, 0, rc.right - rc.left, rc.bottom - rc.top,
2570 physdev->x11dev->dc_rect.left + rc.left,
2571 physdev->x11dev->dc_rect.top + rc.top,
2572 rc.right - rc.left, rc.bottom - rc.top, 1, 1 );
2573 pXRenderFreePicture( gdi_display, src_pict );
2574 wine_tsx11_unlock();
2575 add_device_bounds( physdev->x11dev, &rc );
2576 }
2577 return TRUE;
2578 }
2579
2580 fallback:
2581 #endif
2582 dev = GET_NEXT_PHYSDEV( dev, pGradientFill );
2583 return dev->funcs->pGradientFill( dev, vert_array, nvert, grad_array, ngrad, mode );
2584 }
2585
2586 /***********************************************************************
2587 * xrenderdrv_SelectBrush
2588 */
2589 static HBRUSH xrenderdrv_SelectBrush( PHYSDEV dev, HBRUSH hbrush, const struct brush_pattern *pattern )
2590 {
2591 struct xrender_physdev *physdev = get_xrender_dev( dev );
2592 X_PHYSBITMAP *physbitmap;
2593 BOOL delete_bitmap = FALSE;
2594 BITMAP bm;
2595 HBITMAP bitmap;
2596 Pixmap pixmap;
2597 XRenderPictFormat *pict_format;
2598 Picture src_pict, dst_pict;
2599 XRenderPictureAttributes pa;
2600
2601 if (!pattern) goto x11drv_fallback;
2602 if (physdev->format == WXR_FORMAT_MONO) goto x11drv_fallback;
2603
2604 bitmap = pattern->bitmap;
2605 if (!bitmap || !(physbitmap = X11DRV_get_phys_bitmap( bitmap )))
2606 {
2607 if (!(bitmap = create_brush_bitmap( physdev->x11dev, pattern ))) return 0;
2608 physbitmap = X11DRV_get_phys_bitmap( bitmap );
2609 delete_bitmap = TRUE;
2610 }
2611
2612 if (physbitmap->format == WXR_FORMAT_MONO) goto x11drv_fallback;
2613 if (!(pict_format = pict_formats[physbitmap->format])) goto x11drv_fallback;
2614
2615 GetObjectW( bitmap, sizeof(bm), &bm );
2616
2617 wine_tsx11_lock();
2618 pixmap = XCreatePixmap( gdi_display, root_window, bm.bmWidth, bm.bmHeight,
2619 physdev->pict_format->depth );
2620
2621 pa.repeat = RepeatNone;
2622 src_pict = pXRenderCreatePicture(gdi_display, physbitmap->pixmap, pict_format, CPRepeat, &pa);
2623 dst_pict = pXRenderCreatePicture(gdi_display, pixmap, physdev->pict_format, CPRepeat, &pa);
2624
2625 xrender_blit( PictOpSrc, src_pict, 0, dst_pict, 0, 0, bm.bmWidth, bm.bmHeight,
2626 0, 0, bm.bmWidth, bm.bmHeight, 1.0, 1.0 );
2627 pXRenderFreePicture( gdi_display, src_pict );
2628 pXRenderFreePicture( gdi_display, dst_pict );
2629
2630 if (physdev->x11dev->brush.pixmap) XFreePixmap( gdi_display, physdev->x11dev->brush.pixmap );
2631 physdev->x11dev->brush.pixmap = pixmap;
2632 physdev->x11dev->brush.fillStyle = FillTiled;
2633 physdev->x11dev->brush.pixel = 0; /* ignored */
2634 physdev->x11dev->brush.style = BS_PATTERN;
2635 wine_tsx11_unlock();
2636
2637 if (delete_bitmap) DeleteObject( bitmap );
2638 return hbrush;
2639
2640 x11drv_fallback:
2641 if (delete_bitmap) DeleteObject( bitmap );
2642 dev = GET_NEXT_PHYSDEV( dev, pSelectBrush );
2643 return dev->funcs->pSelectBrush( dev, hbrush, pattern );
2644 }
2645
2646
2647 static const struct gdi_dc_funcs xrender_funcs =
2648 {
2649 NULL, /* pAbortDoc */
2650 NULL, /* pAbortPath */
2651 xrenderdrv_AlphaBlend, /* pAlphaBlend */
2652 NULL, /* pAngleArc */
2653 NULL, /* pArc */
2654 NULL, /* pArcTo */
2655 NULL, /* pBeginPath */
2656 xrenderdrv_BlendImage, /* pBlendImage */
2657 NULL, /* pChoosePixelFormat */
2658 NULL, /* pChord */
2659 NULL, /* pCloseFigure */
2660 xrenderdrv_CopyBitmap, /* pCopyBitmap */
2661 xrenderdrv_CreateBitmap, /* pCreateBitmap */
2662 xrenderdrv_CreateCompatibleDC, /* pCreateCompatibleDC */
2663 xrenderdrv_CreateDC, /* pCreateDC */
2664 xrenderdrv_DeleteBitmap, /* pDeleteBitmap */
2665 xrenderdrv_DeleteDC, /* pDeleteDC */
2666 NULL, /* pDeleteObject */
2667 NULL, /* pDescribePixelFormat */
2668 NULL, /* pDeviceCapabilities */
2669 NULL, /* pEllipse */
2670 NULL, /* pEndDoc */
2671 NULL, /* pEndPage */
2672 NULL, /* pEndPath */
2673 NULL, /* pEnumFonts */
2674 NULL, /* pEnumICMProfiles */
2675 NULL, /* pExcludeClipRect */
2676 NULL, /* pExtDeviceMode */
2677 xrenderdrv_ExtEscape, /* pExtEscape */
2678 NULL, /* pExtFloodFill */
2679 NULL, /* pExtSelectClipRgn */
2680 xrenderdrv_ExtTextOut, /* pExtTextOut */
2681 NULL, /* pFillPath */
2682 NULL, /* pFillRgn */
2683 NULL, /* pFlattenPath */
2684 NULL, /* pFontIsLinked */
2685 NULL, /* pFrameRgn */
2686 NULL, /* pGdiComment */
2687 NULL, /* pGdiRealizationInfo */
2688 NULL, /* pGetBoundsRect */
2689 NULL, /* pGetCharABCWidths */
2690 NULL, /* pGetCharABCWidthsI */
2691 NULL, /* pGetCharWidth */
2692 NULL, /* pGetDeviceCaps */
2693 NULL, /* pGetDeviceGammaRamp */
2694 NULL, /* pGetFontData */
2695 NULL, /* pGetFontUnicodeRanges */
2696 NULL, /* pGetGlyphIndices */
2697 NULL, /* pGetGlyphOutline */
2698 NULL, /* pGetICMProfile */
2699 xrenderdrv_GetImage, /* pGetImage */
2700 NULL, /* pGetKerningPairs */
2701 NULL, /* pGetNearestColor */
2702 NULL, /* pGetOutlineTextMetrics */
2703 NULL, /* pGetPixel */
2704 NULL, /* pGetPixelFormat */
2705 NULL, /* pGetSystemPaletteEntries */
2706 NULL, /* pGetTextCharsetInfo */
2707 NULL, /* pGetTextExtentExPoint */
2708 NULL, /* pGetTextExtentExPointI */
2709 NULL, /* pGetTextFace */
2710 NULL, /* pGetTextMetrics */
2711 xrenderdrv_GradientFill, /* pGradientFill */
2712 NULL, /* pIntersectClipRect */
2713 NULL, /* pInvertRgn */
2714 NULL, /* pLineTo */
2715 NULL, /* pModifyWorldTransform */
2716 NULL, /* pMoveTo */
2717 NULL, /* pOffsetClipRgn */
2718 NULL, /* pOffsetViewportOrg */
2719 NULL, /* pOffsetWindowOrg */
2720 NULL, /* pPaintRgn */
2721 NULL, /* pPatBlt */
2722 NULL, /* pPie */
2723 NULL, /* pPolyBezier */
2724 NULL, /* pPolyBezierTo */
2725 NULL, /* pPolyDraw */
2726 NULL, /* pPolyPolygon */
2727 NULL, /* pPolyPolyline */
2728 NULL, /* pPolygon */
2729 NULL, /* pPolyline */
2730 NULL, /* pPolylineTo */
2731 xrenderdrv_PutImage, /* pPutImage */
2732 NULL, /* pRealizeDefaultPalette */
2733 NULL, /* pRealizePalette */
2734 NULL, /* pRectangle */
2735 NULL, /* pResetDC */
2736 NULL, /* pRestoreDC */
2737 NULL, /* pRoundRect */
2738 NULL, /* pSaveDC */
2739 NULL, /* pScaleViewportExt */
2740 NULL, /* pScaleWindowExt */
2741 xrenderdrv_SelectBitmap, /* pSelectBitmap */
2742 xrenderdrv_SelectBrush, /* pSelectBrush */
2743 NULL, /* pSelectClipPath */
2744 xrenderdrv_SelectFont, /* pSelectFont */
2745 NULL, /* pSelectPalette */
2746 NULL, /* pSelectPen */
2747 NULL, /* pSetArcDirection */
2748 NULL, /* pSetBkColor */
2749 NULL, /* pSetBkMode */
2750 NULL, /* pSetDCBrushColor */
2751 NULL, /* pSetDCPenColor */
2752 NULL, /* pSetDIBitsToDevice */
2753 xrenderdrv_SetDeviceClipping, /* pSetDeviceClipping */
2754 NULL, /* pSetDeviceGammaRamp */
2755 NULL, /* pSetLayout */
2756 NULL, /* pSetMapMode */
2757 NULL, /* pSetMapperFlags */
2758 NULL, /* pSetPixel */
2759 NULL, /* pSetPixelFormat */
2760 NULL, /* pSetPolyFillMode */
2761 NULL, /* pSetROP2 */
2762 NULL, /* pSetRelAbs */
2763 NULL, /* pSetStretchBltMode */
2764 NULL, /* pSetTextAlign */
2765 NULL, /* pSetTextCharacterExtra */
2766 NULL, /* pSetTextColor */
2767 NULL, /* pSetTextJustification */
2768 NULL, /* pSetViewportExt */
2769 NULL, /* pSetViewportOrg */
2770 NULL, /* pSetWindowExt */
2771 NULL, /* pSetWindowOrg */
2772 NULL, /* pSetWorldTransform */
2773 NULL, /* pStartDoc */
2774 NULL, /* pStartPage */
2775 xrenderdrv_StretchBlt, /* pStretchBlt */
2776 NULL, /* pStretchDIBits */
2777 NULL, /* pStrokeAndFillPath */
2778 NULL, /* pStrokePath */
2779 NULL, /* pSwapBuffers */
2780 NULL, /* pUnrealizePalette */
2781 NULL, /* pWidenPath */
2782 /* OpenGL not supported */
2783 };
2784
2785 #else /* SONAME_LIBXRENDER */
2786
2787 const struct gdi_dc_funcs *X11DRV_XRender_Init(void)
2788 {
2789 TRACE("XRender support not compiled in.\n");
2790 return NULL;
2791 }
2792
2793 void X11DRV_XRender_Finalize(void)
2794 {
2795 }
2796
2797 #endif /* SONAME_LIBXRENDER */
Maarten's multimedia branch