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