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