?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
configure: Changes from running autconf after previous patch.
[wine/hacks.git] / dlls / winex11.drv / xrender.c
blob4f900b2f7bf722f0ae16f595e6ad75be6dbdd571
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 *
7 * Some parts also:
8 * Copyright 2000 Keith Packard, member of The XFree86 Project, Inc.
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include <assert.h>
28 #include <stdarg.h>
29 #include <string.h>
30 #include <stdlib.h>
31
32 #include "windef.h"
33 #include "winbase.h"
34 #include "x11drv.h"
35 #include "winternl.h"
36 #include "wine/library.h"
37 #include "wine/unicode.h"
38 #include "wine/debug.h"
39
40 int using_client_side_fonts = FALSE;
41
42 WINE_DEFAULT_DEBUG_CHANNEL(xrender);
43
44 #ifdef SONAME_LIBXRENDER
45
46 static BOOL X11DRV_XRender_Installed = FALSE;
47
48 #include <X11/Xlib.h>
49 #include <X11/extensions/Xrender.h>
50
51 #ifndef RepeatNone /* added in 0.10 */
52 #define RepeatNone 0
53 #define RepeatNormal 1
54 #define RepeatPad 2
55 #define RepeatReflect 3
56 #endif
57
58 typedef enum wine_xrformat
59 {
60 WXR_FORMAT_MONO,
61 WXR_FORMAT_GRAY,
62 WXR_FORMAT_X1R5G5B5,
63 WXR_FORMAT_X1B5G5R5,
64 WXR_FORMAT_R5G6B5,
65 WXR_FORMAT_B5G6R5,
66 WXR_FORMAT_R8G8B8,
67 WXR_FORMAT_B8G8R8,
68 WXR_FORMAT_A8R8G8B8,
69 WXR_FORMAT_B8G8R8A8,
70 WXR_FORMAT_X8R8G8B8,
71 WXR_FORMAT_B8G8R8X8,
72 WXR_NB_FORMATS
73 } WXRFormat;
74
75 typedef struct wine_xrender_format_template
76 {
77 WXRFormat wxr_format;
78 unsigned int depth;
79 unsigned int alpha;
80 unsigned int alphaMask;
81 unsigned int red;
82 unsigned int redMask;
83 unsigned int green;
84 unsigned int greenMask;
85 unsigned int blue;
86 unsigned int blueMask;
87 } WineXRenderFormatTemplate;
88
89 static const WineXRenderFormatTemplate wxr_formats_template[WXR_NB_FORMATS] =
90 {
91 /* Format depth alpha mask red mask green mask blue mask*/
92 {WXR_FORMAT_MONO, 1, 0, 0x01, 0, 0, 0, 0, 0, 0 },
93 {WXR_FORMAT_GRAY, 8, 0, 0xff, 0, 0, 0, 0, 0, 0 },
94 {WXR_FORMAT_X1R5G5B5, 16, 0, 0, 10, 0x1f, 5, 0x1f, 0, 0x1f },
95 {WXR_FORMAT_X1B5G5R5, 16, 0, 0, 0, 0x1f, 5, 0x1f, 10, 0x1f },
96 {WXR_FORMAT_R5G6B5, 16, 0, 0, 11, 0x1f, 5, 0x3f, 0, 0x1f },
97 {WXR_FORMAT_B5G6R5, 16, 0, 0, 0, 0x1f, 5, 0x3f, 11, 0x1f },
98 {WXR_FORMAT_R8G8B8, 24, 0, 0, 16, 0xff, 8, 0xff, 0, 0xff },
99 {WXR_FORMAT_B8G8R8, 24, 0, 0, 0, 0xff, 8, 0xff, 16, 0xff },
100 {WXR_FORMAT_A8R8G8B8, 32, 24, 0xff, 16, 0xff, 8, 0xff, 0, 0xff },
101 {WXR_FORMAT_B8G8R8A8, 32, 0, 0xff, 8, 0xff, 16, 0xff, 24, 0xff },
102 {WXR_FORMAT_X8R8G8B8, 32, 0, 0, 16, 0xff, 8, 0xff, 0, 0xff },
103 {WXR_FORMAT_B8G8R8X8, 32, 0, 0, 8, 0xff, 16, 0xff, 24, 0xff },
104 };
105
106 typedef struct wine_xrender_format
107 {
108 WXRFormat format;
109 XRenderPictFormat *pict_format;
110 } WineXRenderFormat;
111
112 static WineXRenderFormat wxr_formats[WXR_NB_FORMATS];
113 static int WineXRenderFormatsListSize = 0;
114 static WineXRenderFormat *default_format = NULL;
115
116 typedef struct
117 {
118 LOGFONTW lf;
119 XFORM xform;
120 SIZE devsize; /* size in device coords */
121 DWORD hash;
122 } LFANDSIZE;
123
124 #define INITIAL_REALIZED_BUF_SIZE 128
125
126 typedef enum { AA_None = 0, AA_Grey, AA_RGB, AA_BGR, AA_VRGB, AA_VBGR, AA_MAXVALUE } AA_Type;
127
128 typedef struct
129 {
130 GlyphSet glyphset;
131 const WineXRenderFormat *font_format;
132 int nrealized;
133 BOOL *realized;
134 void **bitmaps;
135 XGlyphInfo *gis;
136 } gsCacheEntryFormat;
137
138 typedef struct
139 {
140 LFANDSIZE lfsz;
141 AA_Type aa_default;
142 gsCacheEntryFormat * format[AA_MAXVALUE];
143 INT count;
144 INT next;
145 } gsCacheEntry;
146
147 struct xrender_info
148 {
149 int cache_index;
150 Picture pict;
151 Picture pict_src;
152 const WineXRenderFormat *format;
153 };
154
155 static gsCacheEntry *glyphsetCache = NULL;
156 static DWORD glyphsetCacheSize = 0;
157 static INT lastfree = -1;
158 static INT mru = -1;
159
160 #define INIT_CACHE_SIZE 10
161
162 static int antialias = 1;
163
164 static void *xrender_handle;
165
166 #define MAKE_FUNCPTR(f) static typeof(f) * p##f;
167 MAKE_FUNCPTR(XRenderAddGlyphs)
168 MAKE_FUNCPTR(XRenderComposite)
169 MAKE_FUNCPTR(XRenderCompositeString8)
170 MAKE_FUNCPTR(XRenderCompositeString16)
171 MAKE_FUNCPTR(XRenderCompositeString32)
172 MAKE_FUNCPTR(XRenderCompositeText16)
173 MAKE_FUNCPTR(XRenderCreateGlyphSet)
174 MAKE_FUNCPTR(XRenderCreatePicture)
175 MAKE_FUNCPTR(XRenderFillRectangle)
176 MAKE_FUNCPTR(XRenderFindFormat)
177 MAKE_FUNCPTR(XRenderFindVisualFormat)
178 MAKE_FUNCPTR(XRenderFreeGlyphSet)
179 MAKE_FUNCPTR(XRenderFreePicture)
180 MAKE_FUNCPTR(XRenderSetPictureClipRectangles)
181 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
182 MAKE_FUNCPTR(XRenderSetPictureTransform)
183 #endif
184 MAKE_FUNCPTR(XRenderQueryExtension)
185
186 #ifdef SONAME_LIBFONTCONFIG
187 #include <fontconfig/fontconfig.h>
188 MAKE_FUNCPTR(FcConfigSubstitute)
189 MAKE_FUNCPTR(FcDefaultSubstitute)
190 MAKE_FUNCPTR(FcFontMatch)
191 MAKE_FUNCPTR(FcInit)
192 MAKE_FUNCPTR(FcPatternCreate)
193 MAKE_FUNCPTR(FcPatternDestroy)
194 MAKE_FUNCPTR(FcPatternAddInteger)
195 MAKE_FUNCPTR(FcPatternAddString)
196 MAKE_FUNCPTR(FcPatternGetBool)
197 MAKE_FUNCPTR(FcPatternGetInteger)
198 MAKE_FUNCPTR(FcPatternGetString)
199 static void *fontconfig_handle;
200 static BOOL fontconfig_installed;
201 #endif
202
203 #undef MAKE_FUNCPTR
204
205 static CRITICAL_SECTION xrender_cs;
206 static CRITICAL_SECTION_DEBUG critsect_debug =
207 {
208 0, 0, &xrender_cs,
209 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
210 0, 0, { (DWORD_PTR)(__FILE__ ": xrender_cs") }
211 };
212 static CRITICAL_SECTION xrender_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
213
214 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
215 ( ( (ULONG)_x4 << 24 ) | \
216 ( (ULONG)_x3 << 16 ) | \
217 ( (ULONG)_x2 << 8 ) | \
218 (ULONG)_x1 )
219
220 #define MS_GASP_TAG MS_MAKE_TAG('g', 'a', 's', 'p')
221
222 #define GASP_GRIDFIT 0x01
223 #define GASP_DOGRAY 0x02
224
225 #ifdef WORDS_BIGENDIAN
226 #define get_be_word(x) (x)
227 #define NATIVE_BYTE_ORDER MSBFirst
228 #else
229 #define get_be_word(x) RtlUshortByteSwap(x)
230 #define NATIVE_BYTE_ORDER LSBFirst
231 #endif
232
233 static WXRFormat get_format_without_alpha( WXRFormat format )
234 {
235 switch (format)
236 {
237 case WXR_FORMAT_A8R8G8B8: return WXR_FORMAT_X8R8G8B8;
238 case WXR_FORMAT_B8G8R8A8: return WXR_FORMAT_B8G8R8X8;
239 default: return format;
240 }
241 }
242
243 static BOOL get_xrender_template(const WineXRenderFormatTemplate *fmt, XRenderPictFormat *templ, unsigned long *mask)
244 {
245 templ->id = 0;
246 templ->type = PictTypeDirect;
247 templ->depth = fmt->depth;
248 templ->direct.alpha = fmt->alpha;
249 templ->direct.alphaMask = fmt->alphaMask;
250 templ->direct.red = fmt->red;
251 templ->direct.redMask = fmt->redMask;
252 templ->direct.green = fmt->green;
253 templ->direct.greenMask = fmt->greenMask;
254 templ->direct.blue = fmt->blue;
255 templ->direct.blueMask = fmt->blueMask;
256 templ->colormap = 0;
257
258 *mask = PictFormatType | PictFormatDepth | PictFormatAlpha | PictFormatAlphaMask | PictFormatRed | PictFormatRedMask | PictFormatGreen | PictFormatGreenMask | PictFormatBlue | PictFormatBlueMask;
259
260 return TRUE;
261 }
262
263 static BOOL is_wxrformat_compatible_with_default_visual(const WineXRenderFormatTemplate *fmt)
264 {
265 if(fmt->depth != screen_depth)
266 return FALSE;
267 if( (fmt->redMask << fmt->red) != visual->red_mask)
268 return FALSE;
269 if( (fmt->greenMask << fmt->green) != visual->green_mask)
270 return FALSE;
271 if( (fmt->blueMask << fmt->blue) != visual->blue_mask)
272 return FALSE;
273
274 /* We never select a default ARGB visual */
275 if(fmt->alphaMask)
276 return FALSE;
277
278 return TRUE;
279 }
280
281 static int load_xrender_formats(void)
282 {
283 unsigned int i;
284 for(i = 0; i < (sizeof(wxr_formats_template) / sizeof(wxr_formats_template[0])); i++)
285 {
286 XRenderPictFormat templ, *pict_format;
287
288 if(is_wxrformat_compatible_with_default_visual(&wxr_formats_template[i]))
289 {
290 wine_tsx11_lock();
291 pict_format = pXRenderFindVisualFormat(gdi_display, visual);
292 if(!pict_format)
293 {
294 /* Xrender doesn't like DirectColor visuals, try to find a TrueColor one instead */
295 if (visual->class == DirectColor)
296 {
297 XVisualInfo info;
298 if (XMatchVisualInfo( gdi_display, DefaultScreen(gdi_display),
299 screen_depth, TrueColor, &info ))
300 {
301 pict_format = pXRenderFindVisualFormat(gdi_display, info.visual);
302 if (pict_format) visual = info.visual;
303 }
304 }
305 }
306 wine_tsx11_unlock();
307
308 if(pict_format)
309 {
310 wxr_formats[WineXRenderFormatsListSize].format = wxr_formats_template[i].wxr_format;
311 wxr_formats[WineXRenderFormatsListSize].pict_format = pict_format;
312 default_format = &wxr_formats[WineXRenderFormatsListSize];
313 WineXRenderFormatsListSize++;
314 TRACE("Loaded pict_format with id=%#lx for wxr_format=%#x\n", pict_format->id, wxr_formats_template[i].wxr_format);
315 }
316 }
317 else
318 {
319 unsigned long mask = 0;
320 get_xrender_template(&wxr_formats_template[i], &templ, &mask);
321
322 wine_tsx11_lock();
323 pict_format = pXRenderFindFormat(gdi_display, mask, &templ, 0);
324 wine_tsx11_unlock();
325
326 if(pict_format)
327 {
328 wxr_formats[WineXRenderFormatsListSize].format = wxr_formats_template[i].wxr_format;
329 wxr_formats[WineXRenderFormatsListSize].pict_format = pict_format;
330 WineXRenderFormatsListSize++;
331 TRACE("Loaded pict_format with id=%#lx for wxr_format=%#x\n", pict_format->id, wxr_formats_template[i].wxr_format);
332 }
333 }
334 }
335 return WineXRenderFormatsListSize;
336 }
337
338 /***********************************************************************
339 * X11DRV_XRender_Init
340 *
341 * Let's see if our XServer has the extension available
342 *
343 */
344 void X11DRV_XRender_Init(void)
345 {
346 int event_base, i;
347
348 if (client_side_with_render &&
349 wine_dlopen(SONAME_LIBX11, RTLD_NOW|RTLD_GLOBAL, NULL, 0) &&
350 wine_dlopen(SONAME_LIBXEXT, RTLD_NOW|RTLD_GLOBAL, NULL, 0) &&
351 (xrender_handle = wine_dlopen(SONAME_LIBXRENDER, RTLD_NOW, NULL, 0)))
352 {
353
354 #define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(xrender_handle, #f, NULL, 0)) == NULL) goto sym_not_found;
355 LOAD_FUNCPTR(XRenderAddGlyphs)
356 LOAD_FUNCPTR(XRenderComposite)
357 LOAD_FUNCPTR(XRenderCompositeString8)
358 LOAD_FUNCPTR(XRenderCompositeString16)
359 LOAD_FUNCPTR(XRenderCompositeString32)
360 LOAD_FUNCPTR(XRenderCompositeText16)
361 LOAD_FUNCPTR(XRenderCreateGlyphSet)
362 LOAD_FUNCPTR(XRenderCreatePicture)
363 LOAD_FUNCPTR(XRenderFillRectangle)
364 LOAD_FUNCPTR(XRenderFindFormat)
365 LOAD_FUNCPTR(XRenderFindVisualFormat)
366 LOAD_FUNCPTR(XRenderFreeGlyphSet)
367 LOAD_FUNCPTR(XRenderFreePicture)
368 LOAD_FUNCPTR(XRenderSetPictureClipRectangles)
369 LOAD_FUNCPTR(XRenderQueryExtension)
370 #undef LOAD_FUNCPTR
371 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
372 #define LOAD_OPTIONAL_FUNCPTR(f) p##f = wine_dlsym(xrender_handle, #f, NULL, 0);
373 LOAD_OPTIONAL_FUNCPTR(XRenderSetPictureTransform)
374 #undef LOAD_OPTIONAL_FUNCPTR
375 #endif
376
377 wine_tsx11_lock();
378 X11DRV_XRender_Installed = pXRenderQueryExtension(gdi_display, &event_base, &xrender_error_base);
379 wine_tsx11_unlock();
380 if(X11DRV_XRender_Installed) {
381 TRACE("Xrender is up and running error_base = %d\n", xrender_error_base);
382 if(!load_xrender_formats()) /* This fails in buggy versions of libXrender.so */
383 {
384 wine_tsx11_unlock();
385 WINE_MESSAGE(
386 "Wine has detected that you probably have a buggy version\n"
387 "of libXrender.so . Because of this client side font rendering\n"
388 "will be disabled. Please upgrade this library.\n");
389 X11DRV_XRender_Installed = FALSE;
390 return;
391 }
392
393 if (!visual->red_mask || !visual->green_mask || !visual->blue_mask) {
394 WARN("one or more of the colour masks are 0, disabling XRENDER. Try running in 16-bit mode or higher.\n");
395 X11DRV_XRender_Installed = FALSE;
396 }
397 }
398 }
399
400 #ifdef SONAME_LIBFONTCONFIG
401 if ((fontconfig_handle = wine_dlopen(SONAME_LIBFONTCONFIG, RTLD_NOW, NULL, 0)))
402 {
403 #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;}
404 LOAD_FUNCPTR(FcConfigSubstitute);
405 LOAD_FUNCPTR(FcDefaultSubstitute);
406 LOAD_FUNCPTR(FcFontMatch);
407 LOAD_FUNCPTR(FcInit);
408 LOAD_FUNCPTR(FcPatternCreate);
409 LOAD_FUNCPTR(FcPatternDestroy);
410 LOAD_FUNCPTR(FcPatternAddInteger);
411 LOAD_FUNCPTR(FcPatternAddString);
412 LOAD_FUNCPTR(FcPatternGetBool);
413 LOAD_FUNCPTR(FcPatternGetInteger);
414 LOAD_FUNCPTR(FcPatternGetString);
415 #undef LOAD_FUNCPTR
416 fontconfig_installed = pFcInit();
417 }
418 else TRACE( "cannot find the fontconfig library " SONAME_LIBFONTCONFIG "\n" );
419 #endif
420
421 sym_not_found:
422 if(X11DRV_XRender_Installed || client_side_with_core)
423 {
424 glyphsetCache = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
425 sizeof(*glyphsetCache) * INIT_CACHE_SIZE);
426
427 glyphsetCacheSize = INIT_CACHE_SIZE;
428 lastfree = 0;
429 for(i = 0; i < INIT_CACHE_SIZE; i++) {
430 glyphsetCache[i].next = i + 1;
431 glyphsetCache[i].count = -1;
432 }
433 glyphsetCache[i-1].next = -1;
434 using_client_side_fonts = 1;
435
436 if(!X11DRV_XRender_Installed) {
437 TRACE("Xrender is not available on your XServer, client side rendering with the core protocol instead.\n");
438 if(screen_depth <= 8 || !client_side_antialias_with_core)
439 antialias = 0;
440 } else {
441 if(screen_depth <= 8 || !client_side_antialias_with_render)
442 antialias = 0;
443 }
444 }
445 else TRACE("Using X11 core fonts\n");
446 }
447
448 /* Helper function to convert from a color packed in a 32-bit integer to a XRenderColor */
449 static void get_xrender_color(const WineXRenderFormat *wxr_format, int src_color, XRenderColor *dst_color)
450 {
451 XRenderPictFormat *pf = wxr_format->pict_format;
452
453 if(pf->direct.redMask)
454 dst_color->red = ((src_color >> pf->direct.red) & pf->direct.redMask) * 65535/pf->direct.redMask;
455 else
456 dst_color->red = 0;
457
458 if(pf->direct.greenMask)
459 dst_color->green = ((src_color >> pf->direct.green) & pf->direct.greenMask) * 65535/pf->direct.greenMask;
460 else
461 dst_color->green = 0;
462
463 if(pf->direct.blueMask)
464 dst_color->blue = ((src_color >> pf->direct.blue) & pf->direct.blueMask) * 65535/pf->direct.blueMask;
465 else
466 dst_color->blue = 0;
467
468 dst_color->alpha = 0xffff;
469 }
470
471 static const WineXRenderFormat *get_xrender_format(WXRFormat format)
472 {
473 int i;
474 for(i=0; i<WineXRenderFormatsListSize; i++)
475 {
476 if(wxr_formats[i].format == format)
477 {
478 TRACE("Returning wxr_format=%#x\n", format);
479 return &wxr_formats[i];
480 }
481 }
482 return NULL;
483 }
484
485 static const WineXRenderFormat *get_xrender_format_from_color_shifts(int depth, ColorShifts *shifts)
486 {
487 int redMask, greenMask, blueMask;
488 unsigned int i;
489
490 if(depth == 1)
491 return get_xrender_format(WXR_FORMAT_MONO);
492
493 /* physDevs of a depth <=8, don't have color_shifts set and XRender can't handle those except for 1-bit */
494 if(!shifts)
495 return default_format;
496
497 redMask = shifts->physicalRed.max << shifts->physicalRed.shift;
498 greenMask = shifts->physicalGreen.max << shifts->physicalGreen.shift;
499 blueMask = shifts->physicalBlue.max << shifts->physicalBlue.shift;
500
501 /* Try to locate a format which matches the specification of the dibsection. */
502 for(i = 0; i < (sizeof(wxr_formats_template) / sizeof(wxr_formats_template[0])); i++)
503 {
504 if( depth == wxr_formats_template[i].depth &&
505 redMask == (wxr_formats_template[i].redMask << wxr_formats_template[i].red) &&
506 greenMask == (wxr_formats_template[i].greenMask << wxr_formats_template[i].green) &&
507 blueMask == (wxr_formats_template[i].blueMask << wxr_formats_template[i].blue) )
508
509 {
510 /* When we reach this stage the format was found in our template table but this doesn't mean that
511 * the Xserver also supports this format (e.g. its depth might be too low). The call below verifies that.
512 */
513 return get_xrender_format(wxr_formats_template[i].wxr_format);
514 }
515 }
516
517 /* This should not happen because when we reach 'shifts' must have been set and we only allows shifts which are backed by X */
518 ERR("No XRender format found!\n");
519 return NULL;
520 }
521
522 /* Set the x/y scaling and x/y offsets in the transformation matrix of the source picture */
523 static void set_xrender_transformation(Picture src_pict, double xscale, double yscale, int xoffset, int yoffset)
524 {
525 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
526 XTransform xform = {{
527 { XDoubleToFixed(xscale), XDoubleToFixed(0), XDoubleToFixed(xoffset) },
528 { XDoubleToFixed(0), XDoubleToFixed(yscale), XDoubleToFixed(yoffset) },
529 { XDoubleToFixed(0), XDoubleToFixed(0), XDoubleToFixed(1) }
530 }};
531
532 pXRenderSetPictureTransform(gdi_display, src_pict, &xform);
533 #endif
534 }
535
536 /* check if we can use repeating instead of scaling for the specified source DC */
537 static BOOL use_source_repeat( X11DRV_PDEVICE *physDev )
538 {
539 return (physDev->bitmap &&
540 physDev->drawable_rect.right - physDev->drawable_rect.left == 1 &&
541 physDev->drawable_rect.bottom - physDev->drawable_rect.top == 1);
542 }
543
544 static struct xrender_info *get_xrender_info(X11DRV_PDEVICE *physDev)
545 {
546 if(!physDev->xrender)
547 {
548 physDev->xrender = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*physDev->xrender));
549
550 if(!physDev->xrender)
551 {
552 ERR("Unable to allocate XRENDERINFO!\n");
553 return NULL;
554 }
555 physDev->xrender->cache_index = -1;
556 }
557 if (!physDev->xrender->format)
558 physDev->xrender->format = get_xrender_format_from_color_shifts(physDev->depth, physDev->color_shifts);
559
560 return physDev->xrender;
561 }
562
563 static Picture get_xrender_picture(X11DRV_PDEVICE *physDev)
564 {
565 struct xrender_info *info = get_xrender_info(physDev);
566 if (!info) return 0;
567
568 if (!info->pict && info->format)
569 {
570 XRenderPictureAttributes pa;
571 RGNDATA *clip = X11DRV_GetRegionData( physDev->region, 0 );
572
573 wine_tsx11_lock();
574 pa.subwindow_mode = IncludeInferiors;
575 info->pict = pXRenderCreatePicture(gdi_display, physDev->drawable, info->format->pict_format,
576 CPSubwindowMode, &pa);
577 if (info->pict && clip)
578 pXRenderSetPictureClipRectangles( gdi_display, info->pict,
579 physDev->dc_rect.left, physDev->dc_rect.top,
580 (XRectangle *)clip->Buffer, clip->rdh.nCount );
581 wine_tsx11_unlock();
582 TRACE("Allocing pict=%lx dc=%p drawable=%08lx\n", info->pict, physDev->hdc, physDev->drawable);
583 HeapFree( GetProcessHeap(), 0, clip );
584 }
585
586 return info->pict;
587 }
588
589 static Picture get_xrender_picture_source(X11DRV_PDEVICE *physDev, BOOL repeat)
590 {
591 struct xrender_info *info = get_xrender_info(physDev);
592 if (!info) return 0;
593
594 if (!info->pict_src && info->format)
595 {
596 XRenderPictureAttributes pa;
597
598 wine_tsx11_lock();
599 pa.subwindow_mode = IncludeInferiors;
600 pa.repeat = repeat ? RepeatNormal : RepeatNone;
601 info->pict_src = pXRenderCreatePicture(gdi_display, physDev->drawable, info->format->pict_format,
602 CPSubwindowMode|CPRepeat, &pa);
603 wine_tsx11_unlock();
604
605 TRACE("Allocing pict_src=%lx dc=%p drawable=%08lx repeat=%u\n",
606 info->pict_src, physDev->hdc, physDev->drawable, pa.repeat);
607 }
608
609 return info->pict_src;
610 }
611
612 /* return a mask picture used to force alpha to 0 */
613 static Picture get_no_alpha_mask(void)
614 {
615 static Pixmap pixmap;
616 static Picture pict;
617
618 wine_tsx11_lock();
619 if (!pict)
620 {
621 const WineXRenderFormat *fmt = get_xrender_format( WXR_FORMAT_A8R8G8B8 );
622 XRenderPictureAttributes pa;
623 XRenderColor col;
624
625 pixmap = XCreatePixmap( gdi_display, root_window, 1, 1, 32 );
626 pa.repeat = RepeatNormal;
627 pa.component_alpha = True;
628 pict = pXRenderCreatePicture( gdi_display, pixmap, fmt->pict_format,
629 CPRepeat|CPComponentAlpha, &pa );
630 col.red = col.green = col.blue = 0xffff;
631 col.alpha = 0;
632 pXRenderFillRectangle( gdi_display, PictOpSrc, pict, &col, 0, 0, 1, 1 );
633 }
634 wine_tsx11_unlock();
635 return pict;
636 }
637
638 static BOOL fontcmp(LFANDSIZE *p1, LFANDSIZE *p2)
639 {
640 if(p1->hash != p2->hash) return TRUE;
641 if(memcmp(&p1->devsize, &p2->devsize, sizeof(p1->devsize))) return TRUE;
642 if(memcmp(&p1->xform, &p2->xform, sizeof(p1->xform))) return TRUE;
643 if(memcmp(&p1->lf, &p2->lf, offsetof(LOGFONTW, lfFaceName))) return TRUE;
644 return strcmpiW(p1->lf.lfFaceName, p2->lf.lfFaceName);
645 }
646
647 #if 0
648 static void walk_cache(void)
649 {
650 int i;
651
652 EnterCriticalSection(&xrender_cs);
653 for(i=mru; i >= 0; i = glyphsetCache[i].next)
654 TRACE("item %d\n", i);
655 LeaveCriticalSection(&xrender_cs);
656 }
657 #endif
658
659 static int LookupEntry(LFANDSIZE *plfsz)
660 {
661 int i, prev_i = -1;
662
663 for(i = mru; i >= 0; i = glyphsetCache[i].next) {
664 TRACE("%d\n", i);
665 if(glyphsetCache[i].count == -1) { /* reached free list so stop */
666 i = -1;
667 break;
668 }
669
670 if(!fontcmp(&glyphsetCache[i].lfsz, plfsz)) {
671 glyphsetCache[i].count++;
672 if(prev_i >= 0) {
673 glyphsetCache[prev_i].next = glyphsetCache[i].next;
674 glyphsetCache[i].next = mru;
675 mru = i;
676 }
677 TRACE("found font in cache %d\n", i);
678 return i;
679 }
680 prev_i = i;
681 }
682 TRACE("font not in cache\n");
683 return -1;
684 }
685
686 static void FreeEntry(int entry)
687 {
688 int i, format;
689
690 for(format = 0; format < AA_MAXVALUE; format++) {
691 gsCacheEntryFormat * formatEntry;
692
693 if( !glyphsetCache[entry].format[format] )
694 continue;
695
696 formatEntry = glyphsetCache[entry].format[format];
697
698 if(formatEntry->glyphset) {
699 wine_tsx11_lock();
700 pXRenderFreeGlyphSet(gdi_display, formatEntry->glyphset);
701 wine_tsx11_unlock();
702 formatEntry->glyphset = 0;
703 }
704 if(formatEntry->nrealized) {
705 HeapFree(GetProcessHeap(), 0, formatEntry->realized);
706 formatEntry->realized = NULL;
707 if(formatEntry->bitmaps) {
708 for(i = 0; i < formatEntry->nrealized; i++)
709 HeapFree(GetProcessHeap(), 0, formatEntry->bitmaps[i]);
710 HeapFree(GetProcessHeap(), 0, formatEntry->bitmaps);
711 formatEntry->bitmaps = NULL;
712 }
713 HeapFree(GetProcessHeap(), 0, formatEntry->gis);
714 formatEntry->gis = NULL;
715 formatEntry->nrealized = 0;
716 }
717
718 HeapFree(GetProcessHeap(), 0, formatEntry);
719 glyphsetCache[entry].format[format] = NULL;
720 }
721 }
722
723 static int AllocEntry(void)
724 {
725 int best = -1, prev_best = -1, i, prev_i = -1;
726
727 if(lastfree >= 0) {
728 assert(glyphsetCache[lastfree].count == -1);
729 glyphsetCache[lastfree].count = 1;
730 best = lastfree;
731 lastfree = glyphsetCache[lastfree].next;
732 assert(best != mru);
733 glyphsetCache[best].next = mru;
734 mru = best;
735
736 TRACE("empty space at %d, next lastfree = %d\n", mru, lastfree);
737 return mru;
738 }
739
740 for(i = mru; i >= 0; i = glyphsetCache[i].next) {
741 if(glyphsetCache[i].count == 0) {
742 best = i;
743 prev_best = prev_i;
744 }
745 prev_i = i;
746 }
747
748 if(best >= 0) {
749 TRACE("freeing unused glyphset at cache %d\n", best);
750 FreeEntry(best);
751 glyphsetCache[best].count = 1;
752 if(prev_best >= 0) {
753 glyphsetCache[prev_best].next = glyphsetCache[best].next;
754 glyphsetCache[best].next = mru;
755 mru = best;
756 } else {
757 assert(mru == best);
758 }
759 return mru;
760 }
761
762 TRACE("Growing cache\n");
763
764 if (glyphsetCache)
765 glyphsetCache = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
766 glyphsetCache,
767 (glyphsetCacheSize + INIT_CACHE_SIZE)
768 * sizeof(*glyphsetCache));
769 else
770 glyphsetCache = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
771 (glyphsetCacheSize + INIT_CACHE_SIZE)
772 * sizeof(*glyphsetCache));
773
774 for(best = i = glyphsetCacheSize; i < glyphsetCacheSize + INIT_CACHE_SIZE;
775 i++) {
776 glyphsetCache[i].next = i + 1;
777 glyphsetCache[i].count = -1;
778 }
779 glyphsetCache[i-1].next = -1;
780 glyphsetCacheSize += INIT_CACHE_SIZE;
781
782 lastfree = glyphsetCache[best].next;
783 glyphsetCache[best].count = 1;
784 glyphsetCache[best].next = mru;
785 mru = best;
786 TRACE("new free cache slot at %d\n", mru);
787 return mru;
788 }
789
790 static BOOL get_gasp_flags(X11DRV_PDEVICE *physDev, WORD *flags)
791 {
792 DWORD size;
793 WORD *gasp, *buffer;
794 WORD num_recs;
795 DWORD ppem;
796 TEXTMETRICW tm;
797
798 *flags = 0;
799
800 size = GetFontData(physDev->hdc, MS_GASP_TAG, 0, NULL, 0);
801 if(size == GDI_ERROR)
802 return FALSE;
803
804 gasp = buffer = HeapAlloc(GetProcessHeap(), 0, size);
805 GetFontData(physDev->hdc, MS_GASP_TAG, 0, gasp, size);
806
807 GetTextMetricsW(physDev->hdc, &tm);
808 ppem = abs(X11DRV_YWStoDS(physDev, tm.tmAscent + tm.tmDescent - tm.tmInternalLeading));
809
810 gasp++;
811 num_recs = get_be_word(*gasp);
812 gasp++;
813 while(num_recs--)
814 {
815 *flags = get_be_word(*(gasp + 1));
816 if(ppem <= get_be_word(*gasp))
817 break;
818 gasp += 2;
819 }
820 TRACE("got flags %04x for ppem %d\n", *flags, ppem);
821
822 HeapFree(GetProcessHeap(), 0, buffer);
823 return TRUE;
824 }
825
826 static AA_Type get_antialias_type( X11DRV_PDEVICE *physDev, BOOL subpixel, BOOL hinter)
827 {
828 AA_Type ret;
829 WORD flags;
830 UINT font_smoothing_type, font_smoothing_orientation;
831
832 if (X11DRV_XRender_Installed && subpixel &&
833 SystemParametersInfoW( SPI_GETFONTSMOOTHINGTYPE, 0, &font_smoothing_type, 0) &&
834 font_smoothing_type == FE_FONTSMOOTHINGCLEARTYPE)
835 {
836 if ( SystemParametersInfoW( SPI_GETFONTSMOOTHINGORIENTATION, 0,
837 &font_smoothing_orientation, 0) &&
838 font_smoothing_orientation == FE_FONTSMOOTHINGORIENTATIONBGR)
839 {
840 ret = AA_BGR;
841 }
842 else
843 ret = AA_RGB;
844 /*FIXME
845 If the monitor is in portrait mode, ClearType is disabled in the MS Windows (MSDN).
846 But, Wine's subpixel rendering can support the portrait mode.
847 */
848 }
849 else if (!hinter || !get_gasp_flags(physDev, &flags) || flags & GASP_DOGRAY)
850 ret = AA_Grey;
851 else
852 ret = AA_None;
853
854 return ret;
855 }
856
857 static int GetCacheEntry(X11DRV_PDEVICE *physDev, LFANDSIZE *plfsz)
858 {
859 int ret;
860 int format;
861 gsCacheEntry *entry;
862 static int hinter = -1;
863 static int subpixel = -1;
864 BOOL font_smoothing;
865
866 if((ret = LookupEntry(plfsz)) != -1) return ret;
867
868 ret = AllocEntry();
869 entry = glyphsetCache + ret;
870 entry->lfsz = *plfsz;
871 for( format = 0; format < AA_MAXVALUE; format++ ) {
872 assert( !entry->format[format] );
873 }
874
875 if(antialias && plfsz->lf.lfQuality != NONANTIALIASED_QUALITY)
876 {
877 if(hinter == -1 || subpixel == -1)
878 {
879 RASTERIZER_STATUS status;
880 GetRasterizerCaps(&status, sizeof(status));
881 hinter = status.wFlags & WINE_TT_HINTER_ENABLED;
882 subpixel = status.wFlags & WINE_TT_SUBPIXEL_RENDERING_ENABLED;
883 }
884
885 switch (plfsz->lf.lfQuality)
886 {
887 case ANTIALIASED_QUALITY:
888 entry->aa_default = get_antialias_type( physDev, FALSE, hinter );
889 return ret; /* ignore further configuration */
890 case CLEARTYPE_QUALITY:
891 case CLEARTYPE_NATURAL_QUALITY:
892 entry->aa_default = get_antialias_type( physDev, subpixel, hinter );
893 break;
894 case DEFAULT_QUALITY:
895 case DRAFT_QUALITY:
896 case PROOF_QUALITY:
897 default:
898 if ( SystemParametersInfoW( SPI_GETFONTSMOOTHING, 0, &font_smoothing, 0) &&
899 font_smoothing)
900 {
901 entry->aa_default = get_antialias_type( physDev, subpixel, hinter );
902 }
903 else
904 entry->aa_default = AA_None;
905 break;
906 }
907
908 font_smoothing = TRUE; /* default to enabled */
909 #ifdef SONAME_LIBFONTCONFIG
910 if (fontconfig_installed)
911 {
912 FcPattern *match, *pattern = pFcPatternCreate();
913 FcResult result;
914 char family[LF_FACESIZE * 4];
915
916 WideCharToMultiByte( CP_UTF8, 0, plfsz->lf.lfFaceName, -1, family, sizeof(family), NULL, NULL );
917 pFcPatternAddString( pattern, FC_FAMILY, (FcChar8 *)family );
918 if (plfsz->lf.lfWeight != FW_DONTCARE)
919 {
920 int weight;
921 switch (plfsz->lf.lfWeight)
922 {
923 case FW_THIN: weight = FC_WEIGHT_THIN; break;
924 case FW_EXTRALIGHT: weight = FC_WEIGHT_EXTRALIGHT; break;
925 case FW_LIGHT: weight = FC_WEIGHT_LIGHT; break;
926 case FW_NORMAL: weight = FC_WEIGHT_NORMAL; break;
927 case FW_MEDIUM: weight = FC_WEIGHT_MEDIUM; break;
928 case FW_SEMIBOLD: weight = FC_WEIGHT_SEMIBOLD; break;
929 case FW_BOLD: weight = FC_WEIGHT_BOLD; break;
930 case FW_EXTRABOLD: weight = FC_WEIGHT_EXTRABOLD; break;
931 case FW_HEAVY: weight = FC_WEIGHT_HEAVY; break;
932 default: weight = (plfsz->lf.lfWeight - 80) / 4; break;
933 }
934 pFcPatternAddInteger( pattern, FC_WEIGHT, weight );
935 }
936 pFcPatternAddInteger( pattern, FC_SLANT, plfsz->lf.lfItalic ? FC_SLANT_ITALIC : FC_SLANT_ROMAN );
937 pFcConfigSubstitute( NULL, pattern, FcMatchPattern );
938 pFcDefaultSubstitute( pattern );
939 if ((match = pFcFontMatch( NULL, pattern, &result )))
940 {
941 int rgba;
942 FcBool antialias;
943
944 if (pFcPatternGetBool( match, FC_ANTIALIAS, 0, &antialias ) != FcResultMatch)
945 antialias = TRUE;
946 if (pFcPatternGetInteger( match, FC_RGBA, 0, &rgba ) == FcResultMatch)
947 {
948 FcChar8 *file;
949 if (pFcPatternGetString( match, FC_FILE, 0, &file ) != FcResultMatch) file = NULL;
950
951 TRACE( "fontconfig returned rgba %u antialias %u for font %s file %s\n",
952 rgba, antialias, debugstr_w(plfsz->lf.lfFaceName), debugstr_a((char *)file) );
953
954 switch (rgba)
955 {
956 case FC_RGBA_RGB: entry->aa_default = AA_RGB; break;
957 case FC_RGBA_BGR: entry->aa_default = AA_BGR; break;
958 case FC_RGBA_VRGB: entry->aa_default = AA_VRGB; break;
959 case FC_RGBA_VBGR: entry->aa_default = AA_VBGR; break;
960 case FC_RGBA_NONE: entry->aa_default = AA_Grey; break;
961 }
962 }
963 if (!antialias) font_smoothing = FALSE;
964 pFcPatternDestroy( match );
965 }
966 pFcPatternDestroy( pattern );
967 }
968 #endif /* SONAME_LIBFONTCONFIG */
969
970 /* now check Xft resources */
971 {
972 char *value;
973 BOOL antialias = TRUE;
974
975 wine_tsx11_lock();
976 if ((value = XGetDefault( gdi_display, "Xft", "antialias" )))
977 {
978 if (tolower(value[0]) == 'f' || tolower(value[0]) == 'n' ||
979 value[0] == '0' || !strcasecmp( value, "off" ))
980 antialias = FALSE;
981 }
982 if ((value = XGetDefault( gdi_display, "Xft", "rgba" )))
983 {
984 TRACE( "Xft resource returned rgba '%s' antialias %u\n", value, antialias );
985 if (!strcmp( value, "rgb" )) entry->aa_default = AA_RGB;
986 else if (!strcmp( value, "bgr" )) entry->aa_default = AA_BGR;
987 else if (!strcmp( value, "vrgb" )) entry->aa_default = AA_VRGB;
988 else if (!strcmp( value, "vbgr" )) entry->aa_default = AA_VBGR;
989 else if (!strcmp( value, "none" )) entry->aa_default = AA_Grey;
990 }
991 wine_tsx11_unlock();
992 if (!antialias) font_smoothing = FALSE;
993 }
994
995 if (!font_smoothing) entry->aa_default = AA_None;
996
997 /* we can't support subpixel without xrender */
998 if (!X11DRV_XRender_Installed && entry->aa_default > AA_Grey) entry->aa_default = AA_Grey;
999 }
1000 else
1001 entry->aa_default = AA_None;
1002
1003 return ret;
1004 }
1005
1006 static void dec_ref_cache(int index)
1007 {
1008 assert(index >= 0);
1009 TRACE("dec'ing entry %d to %d\n", index, glyphsetCache[index].count - 1);
1010 assert(glyphsetCache[index].count > 0);
1011 glyphsetCache[index].count--;
1012 }
1013
1014 static void lfsz_calc_hash(LFANDSIZE *plfsz)
1015 {
1016 DWORD hash = 0, *ptr, two_chars;
1017 WORD *pwc;
1018 int i;
1019
1020 hash ^= plfsz->devsize.cx;
1021 hash ^= plfsz->devsize.cy;
1022 for(i = 0, ptr = (DWORD*)&plfsz->xform; i < sizeof(XFORM)/sizeof(DWORD); i++, ptr++)
1023 hash ^= *ptr;
1024 for(i = 0, ptr = (DWORD*)&plfsz->lf; i < 7; i++, ptr++)
1025 hash ^= *ptr;
1026 for(i = 0, ptr = (DWORD*)plfsz->lf.lfFaceName; i < LF_FACESIZE/2; i++, ptr++) {
1027 two_chars = *ptr;
1028 pwc = (WCHAR *)&two_chars;
1029 if(!*pwc) break;
1030 *pwc = toupperW(*pwc);
1031 pwc++;
1032 *pwc = toupperW(*pwc);
1033 hash ^= two_chars;
1034 if(!*pwc) break;
1035 }
1036 plfsz->hash = hash;
1037 return;
1038 }
1039
1040 /***********************************************************************
1041 * X11DRV_XRender_Finalize
1042 */
1043 void X11DRV_XRender_Finalize(void)
1044 {
1045 int i;
1046
1047 EnterCriticalSection(&xrender_cs);
1048 for(i = mru; i >= 0; i = glyphsetCache[i].next)
1049 FreeEntry(i);
1050 LeaveCriticalSection(&xrender_cs);
1051 }
1052
1053
1054 /***********************************************************************
1055 * X11DRV_XRender_SelectFont
1056 */
1057 BOOL X11DRV_XRender_SelectFont(X11DRV_PDEVICE *physDev, HFONT hfont)
1058 {
1059 LFANDSIZE lfsz;
1060 struct xrender_info *info;
1061
1062 GetObjectW(hfont, sizeof(lfsz.lf), &lfsz.lf);
1063 TRACE("h=%d w=%d weight=%d it=%d charset=%d name=%s\n",
1064 lfsz.lf.lfHeight, lfsz.lf.lfWidth, lfsz.lf.lfWeight,
1065 lfsz.lf.lfItalic, lfsz.lf.lfCharSet, debugstr_w(lfsz.lf.lfFaceName));
1066 lfsz.lf.lfWidth = abs( lfsz.lf.lfWidth );
1067 lfsz.devsize.cx = X11DRV_XWStoDS( physDev, lfsz.lf.lfWidth );
1068 lfsz.devsize.cy = X11DRV_YWStoDS( physDev, lfsz.lf.lfHeight );
1069 GetWorldTransform( physDev->hdc, &lfsz.xform );
1070 lfsz_calc_hash(&lfsz);
1071
1072 info = get_xrender_info(physDev);
1073 if (!info) return 0;
1074
1075 EnterCriticalSection(&xrender_cs);
1076 if(info->cache_index != -1)
1077 dec_ref_cache(info->cache_index);
1078 info->cache_index = GetCacheEntry(physDev, &lfsz);
1079 LeaveCriticalSection(&xrender_cs);
1080 return 0;
1081 }
1082
1083 /***********************************************************************
1084 * X11DRV_XRender_SetDeviceClipping
1085 */
1086 void X11DRV_XRender_SetDeviceClipping(X11DRV_PDEVICE *physDev, const RGNDATA *data)
1087 {
1088 if (physDev->xrender->pict)
1089 {
1090 wine_tsx11_lock();
1091 pXRenderSetPictureClipRectangles( gdi_display, physDev->xrender->pict,
1092 physDev->dc_rect.left, physDev->dc_rect.top,
1093 (XRectangle *)data->Buffer, data->rdh.nCount );
1094 wine_tsx11_unlock();
1095 }
1096 }
1097
1098 /***********************************************************************
1099 * X11DRV_XRender_DeleteDC
1100 */
1101 void X11DRV_XRender_DeleteDC(X11DRV_PDEVICE *physDev)
1102 {
1103 X11DRV_XRender_UpdateDrawable(physDev);
1104
1105 EnterCriticalSection(&xrender_cs);
1106 if(physDev->xrender->cache_index != -1)
1107 dec_ref_cache(physDev->xrender->cache_index);
1108 LeaveCriticalSection(&xrender_cs);
1109
1110 HeapFree(GetProcessHeap(), 0, physDev->xrender);
1111 physDev->xrender = NULL;
1112 return;
1113 }
1114
1115 BOOL X11DRV_XRender_SetPhysBitmapDepth(X_PHYSBITMAP *physBitmap, int bits_pixel, const DIBSECTION *dib)
1116 {
1117 const WineXRenderFormat *fmt;
1118 ColorShifts shifts;
1119
1120 /* When XRender is not around we can only use the screen_depth and when needed we perform depth conversion
1121 * in software. Further we also return the screen depth for paletted formats or TrueColor formats with a low
1122 * number of bits because XRender can't handle paletted formats and 8-bit TrueColor does not exist for XRender. */
1123 if (!X11DRV_XRender_Installed || bits_pixel <= 8)
1124 return FALSE;
1125
1126 if (dib)
1127 {
1128 X11DRV_PALETTE_ComputeColorShifts(&shifts, dib->dsBitfields[0], dib->dsBitfields[1], dib->dsBitfields[2]);
1129 fmt = get_xrender_format_from_color_shifts(dib->dsBm.bmBitsPixel, &shifts);
1130
1131 /* Common formats should be in our picture format table. */
1132 if (!fmt)
1133 {
1134 TRACE("Unhandled dibsection format bpp=%d, redMask=%x, greenMask=%x, blueMask=%x\n",
1135 dib->dsBm.bmBitsPixel, dib->dsBitfields[0], dib->dsBitfields[1], dib->dsBitfields[2]);
1136 return FALSE;
1137 }
1138 }
1139 else
1140 {
1141 int red_mask, green_mask, blue_mask;
1142
1143 /* We are dealing with a DDB */
1144 switch (bits_pixel)
1145 {
1146 case 16:
1147 fmt = get_xrender_format(WXR_FORMAT_R5G6B5);
1148 break;
1149 case 24:
1150 fmt = get_xrender_format(WXR_FORMAT_R8G8B8);
1151 break;
1152 case 32:
1153 fmt = get_xrender_format(WXR_FORMAT_A8R8G8B8);
1154 break;
1155 default:
1156 fmt = NULL;
1157 }
1158
1159 if (!fmt)
1160 {
1161 TRACE("Unhandled DDB bits_pixel=%d\n", bits_pixel);
1162 return FALSE;
1163 }
1164
1165 red_mask = fmt->pict_format->direct.redMask << fmt->pict_format->direct.red;
1166 green_mask = fmt->pict_format->direct.greenMask << fmt->pict_format->direct.green;
1167 blue_mask = fmt->pict_format->direct.blueMask << fmt->pict_format->direct.blue;
1168 X11DRV_PALETTE_ComputeColorShifts(&shifts, red_mask, green_mask, blue_mask);
1169 }
1170
1171 physBitmap->pixmap_depth = fmt->pict_format->depth;
1172 physBitmap->trueColor = TRUE;
1173 physBitmap->pixmap_color_shifts = shifts;
1174 return TRUE;
1175 }
1176
1177 /***********************************************************************
1178 * X11DRV_XRender_UpdateDrawable
1179 *
1180 * Deletes the pict and tile when the drawable changes.
1181 */
1182 void X11DRV_XRender_UpdateDrawable(X11DRV_PDEVICE *physDev)
1183 {
1184 struct xrender_info *info = physDev->xrender;
1185
1186 if (info->pict || info->pict_src)
1187 {
1188 wine_tsx11_lock();
1189 XFlush( gdi_display );
1190 if (info->pict)
1191 {
1192 TRACE("freeing pict = %lx dc = %p\n", info->pict, physDev->hdc);
1193 pXRenderFreePicture(gdi_display, info->pict);
1194 info->pict = 0;
1195 }
1196 if(info->pict_src)
1197 {
1198 TRACE("freeing pict = %lx dc = %p\n", info->pict_src, physDev->hdc);
1199 pXRenderFreePicture(gdi_display, info->pict_src);
1200 info->pict_src = 0;
1201 }
1202 wine_tsx11_unlock();
1203 }
1204
1205 info->format = NULL;
1206 }
1207
1208 /************************************************************************
1209 * UploadGlyph
1210 *
1211 * Helper to ExtTextOut. Must be called inside xrender_cs
1212 */
1213 static void UploadGlyph(X11DRV_PDEVICE *physDev, int glyph, AA_Type format)
1214 {
1215 unsigned int buflen;
1216 char *buf;
1217 Glyph gid;
1218 GLYPHMETRICS gm;
1219 XGlyphInfo gi;
1220 gsCacheEntry *entry = glyphsetCache + physDev->xrender->cache_index;
1221 gsCacheEntryFormat *formatEntry;
1222 UINT ggo_format = GGO_GLYPH_INDEX;
1223 WXRFormat wxr_format;
1224 static const char zero[4];
1225 static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
1226
1227 switch(format) {
1228 case AA_Grey:
1229 ggo_format |= WINE_GGO_GRAY16_BITMAP;
1230 break;
1231 case AA_RGB:
1232 ggo_format |= WINE_GGO_HRGB_BITMAP;
1233 break;
1234 case AA_BGR:
1235 ggo_format |= WINE_GGO_HBGR_BITMAP;
1236 break;
1237 case AA_VRGB:
1238 ggo_format |= WINE_GGO_VRGB_BITMAP;
1239 break;
1240 case AA_VBGR:
1241 ggo_format |= WINE_GGO_VBGR_BITMAP;
1242 break;
1243
1244 default:
1245 ERR("aa = %d - not implemented\n", format);
1246 case AA_None:
1247 ggo_format |= GGO_BITMAP;
1248 break;
1249 }
1250
1251 buflen = GetGlyphOutlineW(physDev->hdc, glyph, ggo_format, &gm, 0, NULL, &identity);
1252 if(buflen == GDI_ERROR) {
1253 if(format != AA_None) {
1254 format = AA_None;
1255 entry->aa_default = AA_None;
1256 ggo_format = GGO_GLYPH_INDEX | GGO_BITMAP;
1257 buflen = GetGlyphOutlineW(physDev->hdc, glyph, ggo_format, &gm, 0, NULL, &identity);
1258 }
1259 if(buflen == GDI_ERROR) {
1260 WARN("GetGlyphOutlineW failed using default glyph\n");
1261 buflen = GetGlyphOutlineW(physDev->hdc, 0, ggo_format, &gm, 0, NULL, &identity);
1262 if(buflen == GDI_ERROR) {
1263 WARN("GetGlyphOutlineW failed for default glyph trying for space\n");
1264 buflen = GetGlyphOutlineW(physDev->hdc, 0x20, ggo_format, &gm, 0, NULL, &identity);
1265 if(buflen == GDI_ERROR) {
1266 ERR("GetGlyphOutlineW for all attempts unable to upload a glyph\n");
1267 return;
1268 }
1269 }
1270 }
1271 TRACE("Turning off antialiasing for this monochrome font\n");
1272 }
1273
1274 /* If there is nothing for the current type, we create the entry. */
1275 if( !entry->format[format] ) {
1276 entry->format[format] = HeapAlloc(GetProcessHeap(),
1277 HEAP_ZERO_MEMORY,
1278 sizeof(gsCacheEntryFormat));
1279 }
1280 formatEntry = entry->format[format];
1281
1282 if(formatEntry->nrealized <= glyph) {
1283 formatEntry->nrealized = (glyph / 128 + 1) * 128;
1284
1285 if (formatEntry->realized)
1286 formatEntry->realized = HeapReAlloc(GetProcessHeap(),
1287 HEAP_ZERO_MEMORY,
1288 formatEntry->realized,
1289 formatEntry->nrealized * sizeof(BOOL));
1290 else
1291 formatEntry->realized = HeapAlloc(GetProcessHeap(),
1292 HEAP_ZERO_MEMORY,
1293 formatEntry->nrealized * sizeof(BOOL));
1294
1295 if(!X11DRV_XRender_Installed) {
1296 if (formatEntry->bitmaps)
1297 formatEntry->bitmaps = HeapReAlloc(GetProcessHeap(),
1298 HEAP_ZERO_MEMORY,
1299 formatEntry->bitmaps,
1300 formatEntry->nrealized * sizeof(formatEntry->bitmaps[0]));
1301 else
1302 formatEntry->bitmaps = HeapAlloc(GetProcessHeap(),
1303 HEAP_ZERO_MEMORY,
1304 formatEntry->nrealized * sizeof(formatEntry->bitmaps[0]));
1305 }
1306 if (formatEntry->gis)
1307 formatEntry->gis = HeapReAlloc(GetProcessHeap(),
1308 HEAP_ZERO_MEMORY,
1309 formatEntry->gis,
1310 formatEntry->nrealized * sizeof(formatEntry->gis[0]));
1311 else
1312 formatEntry->gis = HeapAlloc(GetProcessHeap(),
1313 HEAP_ZERO_MEMORY,
1314 formatEntry->nrealized * sizeof(formatEntry->gis[0]));
1315 }
1316
1317
1318 if(formatEntry->glyphset == 0 && X11DRV_XRender_Installed) {
1319 switch(format) {
1320 case AA_Grey:
1321 wxr_format = WXR_FORMAT_GRAY;
1322 break;
1323
1324 case AA_RGB:
1325 case AA_BGR:
1326 case AA_VRGB:
1327 case AA_VBGR:
1328 wxr_format = WXR_FORMAT_A8R8G8B8;
1329 break;
1330
1331 default:
1332 ERR("aa = %d - not implemented\n", format);
1333 case AA_None:
1334 wxr_format = WXR_FORMAT_MONO;
1335 break;
1336 }
1337
1338 wine_tsx11_lock();
1339 formatEntry->font_format = get_xrender_format(wxr_format);
1340 formatEntry->glyphset = pXRenderCreateGlyphSet(gdi_display, formatEntry->font_format->pict_format);
1341 wine_tsx11_unlock();
1342 }
1343
1344
1345 buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buflen);
1346 GetGlyphOutlineW(physDev->hdc, glyph, ggo_format, &gm, buflen, buf, &identity);
1347 formatEntry->realized[glyph] = TRUE;
1348
1349 TRACE("buflen = %d. Got metrics: %dx%d adv=%d,%d origin=%d,%d\n",
1350 buflen,
1351 gm.gmBlackBoxX, gm.gmBlackBoxY, gm.gmCellIncX, gm.gmCellIncY,
1352 gm.gmptGlyphOrigin.x, gm.gmptGlyphOrigin.y);
1353
1354 gi.width = gm.gmBlackBoxX;
1355 gi.height = gm.gmBlackBoxY;
1356 gi.x = -gm.gmptGlyphOrigin.x;
1357 gi.y = gm.gmptGlyphOrigin.y;
1358 gi.xOff = gm.gmCellIncX;
1359 gi.yOff = gm.gmCellIncY;
1360
1361 if(TRACE_ON(xrender)) {
1362 int pitch, i, j;
1363 char output[300];
1364 unsigned char *line;
1365
1366 if(format == AA_None) {
1367 pitch = ((gi.width + 31) / 32) * 4;
1368 for(i = 0; i < gi.height; i++) {
1369 line = (unsigned char*) buf + i * pitch;
1370 output[0] = '\0';
1371 for(j = 0; j < pitch * 8; j++) {
1372 strcat(output, (line[j / 8] & (1 << (7 - (j % 8)))) ? "#" : " ");
1373 }
1374 TRACE("%s\n", output);
1375 }
1376 } else {
1377 static const char blks[] = " .:;!o*#";
1378 char str[2];
1379
1380 str[1] = '\0';
1381 pitch = ((gi.width + 3) / 4) * 4;
1382 for(i = 0; i < gi.height; i++) {
1383 line = (unsigned char*) buf + i * pitch;
1384 output[0] = '\0';
1385 for(j = 0; j < pitch; j++) {
1386 str[0] = blks[line[j] >> 5];
1387 strcat(output, str);
1388 }
1389 TRACE("%s\n", output);
1390 }
1391 }
1392 }
1393
1394
1395 if(formatEntry->glyphset) {
1396 if(format == AA_None && BitmapBitOrder(gdi_display) != MSBFirst) {
1397 unsigned char *byte = (unsigned char*) buf, c;
1398 int i = buflen;
1399
1400 while(i--) {
1401 c = *byte;
1402
1403 /* magic to flip bit order */
1404 c = ((c << 1) & 0xaa) | ((c >> 1) & 0x55);
1405 c = ((c << 2) & 0xcc) | ((c >> 2) & 0x33);
1406 c = ((c << 4) & 0xf0) | ((c >> 4) & 0x0f);
1407
1408 *byte++ = c;
1409 }
1410 }
1411 else if ( format != AA_Grey &&
1412 ImageByteOrder (gdi_display) != NATIVE_BYTE_ORDER)
1413 {
1414 unsigned int i, *data = (unsigned int *)buf;
1415 for (i = buflen / sizeof(int); i; i--, data++) *data = RtlUlongByteSwap(*data);
1416 }
1417 gid = glyph;
1418
1419 /*
1420 XRenderCompositeText seems to ignore 0x0 glyphs when
1421 AA_None, which means we lose the advance width of glyphs
1422 like the space. We'll pretend that such glyphs are 1x1
1423 bitmaps.
1424 */
1425
1426 if(buflen == 0)
1427 gi.width = gi.height = 1;
1428
1429 wine_tsx11_lock();
1430 pXRenderAddGlyphs(gdi_display, formatEntry->glyphset, &gid, &gi, 1,
1431 buflen ? buf : zero, buflen ? buflen : sizeof(zero));
1432 wine_tsx11_unlock();
1433 HeapFree(GetProcessHeap(), 0, buf);
1434 } else {
1435 formatEntry->bitmaps[glyph] = buf;
1436 }
1437
1438 formatEntry->gis[glyph] = gi;
1439 }
1440
1441 static void SharpGlyphMono(X11DRV_PDEVICE *physDev, INT x, INT y,
1442 void *bitmap, XGlyphInfo *gi)
1443 {
1444 unsigned char *srcLine = bitmap, *src;
1445 unsigned char bits, bitsMask;
1446 int width = gi->width;
1447 int stride = ((width + 31) & ~31) >> 3;
1448 int height = gi->height;
1449 int w;
1450 int xspan, lenspan;
1451
1452 TRACE("%d, %d\n", x, y);
1453 x -= gi->x;
1454 y -= gi->y;
1455 while (height--)
1456 {
1457 src = srcLine;
1458 srcLine += stride;
1459 w = width;
1460
1461 bitsMask = 0x80; /* FreeType is always MSB first */
1462 bits = *src++;
1463
1464 xspan = x;
1465 while (w)
1466 {
1467 if (bits & bitsMask)
1468 {
1469 lenspan = 0;
1470 do
1471 {
1472 lenspan++;
1473 if (lenspan == w)
1474 break;
1475 bitsMask = bitsMask >> 1;
1476 if (!bitsMask)
1477 {
1478 bits = *src++;
1479 bitsMask = 0x80;
1480 }
1481 } while (bits & bitsMask);
1482 XFillRectangle (gdi_display, physDev->drawable,
1483 physDev->gc, xspan, y, lenspan, 1);
1484 xspan += lenspan;
1485 w -= lenspan;
1486 }
1487 else
1488 {
1489 do
1490 {
1491 w--;
1492 xspan++;
1493 if (!w)
1494 break;
1495 bitsMask = bitsMask >> 1;
1496 if (!bitsMask)
1497 {
1498 bits = *src++;
1499 bitsMask = 0x80;
1500 }
1501 } while (!(bits & bitsMask));
1502 }
1503 }
1504 y++;
1505 }
1506 }
1507
1508 static void SharpGlyphGray(X11DRV_PDEVICE *physDev, INT x, INT y,
1509 void *bitmap, XGlyphInfo *gi)
1510 {
1511 unsigned char *srcLine = bitmap, *src, bits;
1512 int width = gi->width;
1513 int stride = ((width + 3) & ~3);
1514 int height = gi->height;
1515 int w;
1516 int xspan, lenspan;
1517
1518 x -= gi->x;
1519 y -= gi->y;
1520 while (height--)
1521 {
1522 src = srcLine;
1523 srcLine += stride;
1524 w = width;
1525
1526 bits = *src++;
1527 xspan = x;
1528 while (w)
1529 {
1530 if (bits >= 0x80)
1531 {
1532 lenspan = 0;
1533 do
1534 {
1535 lenspan++;
1536 if (lenspan == w)
1537 break;
1538 bits = *src++;
1539 } while (bits >= 0x80);
1540 XFillRectangle (gdi_display, physDev->drawable,
1541 physDev->gc, xspan, y, lenspan, 1);
1542 xspan += lenspan;
1543 w -= lenspan;
1544 }
1545 else
1546 {
1547 do
1548 {
1549 w--;
1550 xspan++;
1551 if (!w)
1552 break;
1553 bits = *src++;
1554 } while (bits < 0x80);
1555 }
1556 }
1557 y++;
1558 }
1559 }
1560
1561
1562 static void ExamineBitfield (DWORD mask, int *shift, int *len)
1563 {
1564 int s, l;
1565
1566 s = 0;
1567 while ((mask & 1) == 0)
1568 {
1569 mask >>= 1;
1570 s++;
1571 }
1572 l = 0;
1573 while ((mask & 1) == 1)
1574 {
1575 mask >>= 1;
1576 l++;
1577 }
1578 *shift = s;
1579 *len = l;
1580 }
1581
1582 static DWORD GetField (DWORD pixel, int shift, int len)
1583 {
1584 pixel = pixel & (((1 << (len)) - 1) << shift);
1585 pixel = pixel << (32 - (shift + len)) >> 24;
1586 while (len < 8)
1587 {
1588 pixel |= (pixel >> len);
1589 len <<= 1;
1590 }
1591 return pixel;
1592 }
1593
1594
1595 static DWORD PutField (DWORD pixel, int shift, int len)
1596 {
1597 shift = shift - (8 - len);
1598 if (len <= 8)
1599 pixel &= (((1 << len) - 1) << (8 - len));
1600 if (shift < 0)
1601 pixel >>= -shift;
1602 else
1603 pixel <<= shift;
1604 return pixel;
1605 }
1606
1607 static void SmoothGlyphGray(XImage *image, int x, int y, void *bitmap, XGlyphInfo *gi,
1608 int color)
1609 {
1610 int r_shift, r_len;
1611 int g_shift, g_len;
1612 int b_shift, b_len;
1613 BYTE *maskLine, *mask, m;
1614 int maskStride;
1615 DWORD pixel;
1616 int width, height;
1617 int w, tx;
1618 BYTE src_r, src_g, src_b;
1619
1620 x -= gi->x;
1621 y -= gi->y;
1622 width = gi->width;
1623 height = gi->height;
1624
1625 maskLine = bitmap;
1626 maskStride = (width + 3) & ~3;
1627
1628 ExamineBitfield (image->red_mask, &r_shift, &r_len);
1629 ExamineBitfield (image->green_mask, &g_shift, &g_len);
1630 ExamineBitfield (image->blue_mask, &b_shift, &b_len);
1631
1632 src_r = GetField(color, r_shift, r_len);
1633 src_g = GetField(color, g_shift, g_len);
1634 src_b = GetField(color, b_shift, b_len);
1635
1636 for(; height--; y++)
1637 {
1638 mask = maskLine;
1639 maskLine += maskStride;
1640 w = width;
1641 tx = x;
1642
1643 if(y < 0) continue;
1644 if(y >= image->height) break;
1645
1646 for(; w--; tx++)
1647 {
1648 if(tx >= image->width) break;
1649
1650 m = *mask++;
1651 if(tx < 0) continue;
1652
1653 if (m == 0xff)
1654 XPutPixel (image, tx, y, color);
1655 else if (m)
1656 {
1657 BYTE r, g, b;
1658
1659 pixel = XGetPixel (image, tx, y);
1660
1661 r = GetField(pixel, r_shift, r_len);
1662 r = ((BYTE)~m * (WORD)r + (BYTE)m * (WORD)src_r) >> 8;
1663 g = GetField(pixel, g_shift, g_len);
1664 g = ((BYTE)~m * (WORD)g + (BYTE)m * (WORD)src_g) >> 8;
1665 b = GetField(pixel, b_shift, b_len);
1666 b = ((BYTE)~m * (WORD)b + (BYTE)m * (WORD)src_b) >> 8;
1667
1668 pixel = (PutField (r, r_shift, r_len) |
1669 PutField (g, g_shift, g_len) |
1670 PutField (b, b_shift, b_len));
1671 XPutPixel (image, tx, y, pixel);
1672 }
1673 }
1674 }
1675 }
1676
1677 /*************************************************************
1678 * get_tile_pict
1679 *
1680 * Returns an appropriate Picture for tiling the text colour.
1681 * Call and use result within the xrender_cs
1682 */
1683 static Picture get_tile_pict(const WineXRenderFormat *wxr_format, int text_pixel)
1684 {
1685 static struct
1686 {
1687 Pixmap xpm;
1688 Picture pict;
1689 int current_color;
1690 } tiles[WXR_NB_FORMATS], *tile;
1691 XRenderColor col;
1692
1693 tile = &tiles[wxr_format->format];
1694
1695 if(!tile->xpm)
1696 {
1697 XRenderPictureAttributes pa;
1698
1699 wine_tsx11_lock();
1700 tile->xpm = XCreatePixmap(gdi_display, root_window, 1, 1, wxr_format->pict_format->depth);
1701
1702 pa.repeat = RepeatNormal;
1703 tile->pict = pXRenderCreatePicture(gdi_display, tile->xpm, wxr_format->pict_format, CPRepeat, &pa);
1704 wine_tsx11_unlock();
1705
1706 /* init current_color to something different from text_pixel */
1707 tile->current_color = ~text_pixel;
1708
1709 if(wxr_format->format == WXR_FORMAT_MONO)
1710 {
1711 /* for a 1bpp bitmap we always need a 1 in the tile */
1712 col.red = col.green = col.blue = 0;
1713 col.alpha = 0xffff;
1714 wine_tsx11_lock();
1715 pXRenderFillRectangle(gdi_display, PictOpSrc, tile->pict, &col, 0, 0, 1, 1);
1716 wine_tsx11_unlock();
1717 }
1718 }
1719
1720 if(text_pixel != tile->current_color && wxr_format->format != WXR_FORMAT_MONO)
1721 {
1722 get_xrender_color(wxr_format, text_pixel, &col);
1723 wine_tsx11_lock();
1724 pXRenderFillRectangle(gdi_display, PictOpSrc, tile->pict, &col, 0, 0, 1, 1);
1725 wine_tsx11_unlock();
1726 tile->current_color = text_pixel;
1727 }
1728 return tile->pict;
1729 }
1730
1731 /*************************************************************
1732 * get_mask_pict
1733 *
1734 * Returns an appropriate Picture for masking with the specified alpha.
1735 * Call and use result within the xrender_cs
1736 */
1737 static Picture get_mask_pict( int alpha )
1738 {
1739 static Pixmap pixmap;
1740 static Picture pict;
1741 static int current_alpha;
1742
1743 if (alpha == 0xffff) return 0; /* don't need a mask for alpha==1.0 */
1744
1745 if (!pixmap)
1746 {
1747 const WineXRenderFormat *fmt = get_xrender_format( WXR_FORMAT_A8R8G8B8 );
1748 XRenderPictureAttributes pa;
1749
1750 wine_tsx11_lock();
1751 pixmap = XCreatePixmap( gdi_display, root_window, 1, 1, 32 );
1752 pa.repeat = RepeatNormal;
1753 pict = pXRenderCreatePicture( gdi_display, pixmap, fmt->pict_format, CPRepeat, &pa );
1754 wine_tsx11_unlock();
1755 current_alpha = -1;
1756 }
1757
1758 if (alpha != current_alpha)
1759 {
1760 XRenderColor col;
1761 col.red = col.green = col.blue = 0;
1762 col.alpha = current_alpha = alpha;
1763 wine_tsx11_lock();
1764 pXRenderFillRectangle( gdi_display, PictOpSrc, pict, &col, 0, 0, 1, 1 );
1765 wine_tsx11_unlock();
1766 }
1767 return pict;
1768 }
1769
1770 static int XRenderErrorHandler(Display *dpy, XErrorEvent *event, void *arg)
1771 {
1772 return 1;
1773 }
1774
1775 /***********************************************************************
1776 * X11DRV_XRender_ExtTextOut
1777 */
1778 BOOL X11DRV_XRender_ExtTextOut( X11DRV_PDEVICE *physDev, INT x, INT y, UINT flags,
1779 const RECT *lprect, LPCWSTR wstr, UINT count,
1780 const INT *lpDx )
1781 {
1782 XGCValues xgcval;
1783 gsCacheEntry *entry;
1784 gsCacheEntryFormat *formatEntry;
1785 BOOL retv = FALSE;
1786 int textPixel, backgroundPixel;
1787 HRGN saved_region = 0;
1788 BOOL disable_antialias = FALSE;
1789 AA_Type aa_type = AA_None;
1790 DIBSECTION bmp;
1791 unsigned int idx;
1792 const WineXRenderFormat *dst_format = get_xrender_format_from_color_shifts(physDev->depth, physDev->color_shifts);
1793 Picture tile_pict = 0;
1794
1795 /* Do we need to disable antialiasing because of palette mode? */
1796 if( !physDev->bitmap || GetObjectW( physDev->bitmap->hbitmap, sizeof(bmp), &bmp ) != sizeof(bmp) ) {
1797 TRACE("bitmap is not a DIB\n");
1798 }
1799 else if (bmp.dsBmih.biBitCount <= 8) {
1800 TRACE("Disabling antialiasing\n");
1801 disable_antialias = TRUE;
1802 }
1803
1804 xgcval.function = GXcopy;
1805 xgcval.background = physDev->backgroundPixel;
1806 xgcval.fill_style = FillSolid;
1807 wine_tsx11_lock();
1808 XChangeGC( gdi_display, physDev->gc, GCFunction | GCBackground | GCFillStyle, &xgcval );
1809 wine_tsx11_unlock();
1810
1811 X11DRV_LockDIBSection( physDev, DIB_Status_GdiMod );
1812
1813 if(physDev->depth == 1) {
1814 if((physDev->textPixel & 0xffffff) == 0) {
1815 textPixel = 0;
1816 backgroundPixel = 1;
1817 } else {
1818 textPixel = 1;
1819 backgroundPixel = 0;
1820 }
1821 } else {
1822 textPixel = physDev->textPixel;
1823 backgroundPixel = physDev->backgroundPixel;
1824 }
1825
1826 if(flags & ETO_OPAQUE)
1827 {
1828 wine_tsx11_lock();
1829 XSetForeground( gdi_display, physDev->gc, backgroundPixel );
1830 XFillRectangle( gdi_display, physDev->drawable, physDev->gc,
1831 physDev->dc_rect.left + lprect->left, physDev->dc_rect.top + lprect->top,
1832 lprect->right - lprect->left, lprect->bottom - lprect->top );
1833 wine_tsx11_unlock();
1834 }
1835
1836 if(count == 0)
1837 {
1838 retv = TRUE;
1839 goto done_unlock;
1840 }
1841
1842 if (flags & ETO_CLIPPED)
1843 {
1844 HRGN clip_region;
1845
1846 clip_region = CreateRectRgnIndirect( lprect );
1847 /* make a copy of the current device region */
1848 saved_region = CreateRectRgn( 0, 0, 0, 0 );
1849 CombineRgn( saved_region, physDev->region, 0, RGN_COPY );
1850 X11DRV_SetDeviceClipping( physDev, saved_region, clip_region );
1851 DeleteObject( clip_region );
1852 }
1853
1854 EnterCriticalSection(&xrender_cs);
1855
1856 entry = glyphsetCache + physDev->xrender->cache_index;
1857 if( disable_antialias == FALSE )
1858 aa_type = entry->aa_default;
1859 formatEntry = entry->format[aa_type];
1860
1861 for(idx = 0; idx < count; idx++) {
1862 if( !formatEntry ) {
1863 UploadGlyph(physDev, wstr[idx], aa_type);
1864 /* re-evaluate antialias since aa_default may have changed */
1865 if( disable_antialias == FALSE )
1866 aa_type = entry->aa_default;
1867 formatEntry = entry->format[aa_type];
1868 } else if( wstr[idx] >= formatEntry->nrealized || formatEntry->realized[wstr[idx]] == FALSE) {
1869 UploadGlyph(physDev, wstr[idx], aa_type);
1870 }
1871 }
1872 if (!formatEntry)
1873 {
1874 WARN("could not upload requested glyphs\n");
1875 LeaveCriticalSection(&xrender_cs);
1876 goto done_unlock;
1877 }
1878
1879 TRACE("Writing %s at %d,%d\n", debugstr_wn(wstr,count),
1880 physDev->dc_rect.left + x, physDev->dc_rect.top + y);
1881
1882 if(X11DRV_XRender_Installed)
1883 {
1884 XGlyphElt16 *elts = HeapAlloc(GetProcessHeap(), 0, sizeof(XGlyphElt16) * count);
1885 POINT offset = {0, 0};
1886 POINT desired, current;
1887 int render_op = PictOpOver;
1888 Picture pict = get_xrender_picture(physDev);
1889
1890 /* There's a bug in XRenderCompositeText that ignores the xDst and yDst parameters.
1891 So we pass zeros to the function and move to our starting position using the first
1892 element of the elts array. */
1893
1894 desired.x = physDev->dc_rect.left + x;
1895 desired.y = physDev->dc_rect.top + y;
1896 current.x = current.y = 0;
1897
1898 tile_pict = get_tile_pict(dst_format, physDev->textPixel);
1899
1900 /* FIXME the mapping of Text/BkColor onto 1 or 0 needs investigation.
1901 */
1902 if((dst_format->format == WXR_FORMAT_MONO) && (textPixel == 0))
1903 render_op = PictOpOutReverse; /* This gives us 'black' text */
1904
1905 for(idx = 0; idx < count; idx++)
1906 {
1907 elts[idx].glyphset = formatEntry->glyphset;
1908 elts[idx].chars = wstr + idx;
1909 elts[idx].nchars = 1;
1910 elts[idx].xOff = desired.x - current.x;
1911 elts[idx].yOff = desired.y - current.y;
1912
1913 current.x += (elts[idx].xOff + formatEntry->gis[wstr[idx]].xOff);
1914 current.y += (elts[idx].yOff + formatEntry->gis[wstr[idx]].yOff);
1915
1916 if(!lpDx)
1917 {
1918 desired.x += formatEntry->gis[wstr[idx]].xOff;
1919 desired.y += formatEntry->gis[wstr[idx]].yOff;
1920 }
1921 else
1922 {
1923 if(flags & ETO_PDY)
1924 {
1925 offset.x += lpDx[idx * 2];
1926 offset.y += lpDx[idx * 2 + 1];
1927 }
1928 else
1929 offset.x += lpDx[idx];
1930 desired.x = physDev->dc_rect.left + x + offset.x;
1931 desired.y = physDev->dc_rect.top + y + offset.y;
1932 }
1933 }
1934 wine_tsx11_lock();
1935 /* Make sure we don't have any transforms set from a previous call */
1936 set_xrender_transformation(pict, 1, 1, 0, 0);
1937 pXRenderCompositeText16(gdi_display, render_op,
1938 tile_pict,
1939 pict,
1940 formatEntry->font_format->pict_format,
1941 0, 0, 0, 0, elts, count);
1942 wine_tsx11_unlock();
1943 HeapFree(GetProcessHeap(), 0, elts);
1944 } else {
1945 POINT offset = {0, 0};
1946 wine_tsx11_lock();
1947 XSetForeground( gdi_display, physDev->gc, textPixel );
1948
1949 if(aa_type == AA_None || physDev->depth == 1)
1950 {
1951 void (* sharp_glyph_fn)(X11DRV_PDEVICE *, INT, INT, void *, XGlyphInfo *);
1952
1953 if(aa_type == AA_None)
1954 sharp_glyph_fn = SharpGlyphMono;
1955 else
1956 sharp_glyph_fn = SharpGlyphGray;
1957
1958 for(idx = 0; idx < count; idx++) {
1959 sharp_glyph_fn(physDev,
1960 physDev->dc_rect.left + x + offset.x,
1961 physDev->dc_rect.top + y + offset.y,
1962 formatEntry->bitmaps[wstr[idx]],
1963 &formatEntry->gis[wstr[idx]]);
1964 if(lpDx)
1965 {
1966 if(flags & ETO_PDY)
1967 {
1968 offset.x += lpDx[idx * 2];
1969 offset.y += lpDx[idx * 2 + 1];
1970 }
1971 else
1972 offset.x += lpDx[idx];
1973 }
1974 else
1975 {
1976 offset.x += formatEntry->gis[wstr[idx]].xOff;
1977 offset.y += formatEntry->gis[wstr[idx]].yOff;
1978 }
1979 }
1980 } else {
1981 XImage *image;
1982 int image_x, image_y, image_off_x, image_off_y, image_w, image_h;
1983 RECT extents = {0, 0, 0, 0};
1984 POINT cur = {0, 0};
1985 int w = physDev->drawable_rect.right - physDev->drawable_rect.left;
1986 int h = physDev->drawable_rect.bottom - physDev->drawable_rect.top;
1987
1988 TRACE("drawable %dx%d\n", w, h);
1989
1990 for(idx = 0; idx < count; idx++) {
1991 if(extents.left > cur.x - formatEntry->gis[wstr[idx]].x)
1992 extents.left = cur.x - formatEntry->gis[wstr[idx]].x;
1993 if(extents.top > cur.y - formatEntry->gis[wstr[idx]].y)
1994 extents.top = cur.y - formatEntry->gis[wstr[idx]].y;
1995 if(extents.right < cur.x - formatEntry->gis[wstr[idx]].x + formatEntry->gis[wstr[idx]].width)
1996 extents.right = cur.x - formatEntry->gis[wstr[idx]].x + formatEntry->gis[wstr[idx]].width;
1997 if(extents.bottom < cur.y - formatEntry->gis[wstr[idx]].y + formatEntry->gis[wstr[idx]].height)
1998 extents.bottom = cur.y - formatEntry->gis[wstr[idx]].y + formatEntry->gis[wstr[idx]].height;
1999
2000 if(lpDx)
2001 {
2002 if(flags & ETO_PDY)
2003 {
2004 cur.x += lpDx[idx * 2];
2005 cur.y += lpDx[idx * 2 + 1];
2006 }
2007 else
2008 cur.x += lpDx[idx];
2009 }
2010 else
2011 {
2012 cur.x += formatEntry->gis[wstr[idx]].xOff;
2013 cur.y += formatEntry->gis[wstr[idx]].yOff;
2014 }
2015 }
2016 TRACE("glyph extents %d,%d - %d,%d drawable x,y %d,%d\n", extents.left, extents.top,
2017 extents.right, extents.bottom, physDev->dc_rect.left + x, physDev->dc_rect.top + y);
2018
2019 if(physDev->dc_rect.left + x + extents.left >= 0) {
2020 image_x = physDev->dc_rect.left + x + extents.left;
2021 image_off_x = 0;
2022 } else {
2023 image_x = 0;
2024 image_off_x = physDev->dc_rect.left + x + extents.left;
2025 }
2026 if(physDev->dc_rect.top + y + extents.top >= 0) {
2027 image_y = physDev->dc_rect.top + y + extents.top;
2028 image_off_y = 0;
2029 } else {
2030 image_y = 0;
2031 image_off_y = physDev->dc_rect.top + y + extents.top;
2032 }
2033 if(physDev->dc_rect.left + x + extents.right < w)
2034 image_w = physDev->dc_rect.left + x + extents.right - image_x;
2035 else
2036 image_w = w - image_x;
2037 if(physDev->dc_rect.top + y + extents.bottom < h)
2038 image_h = physDev->dc_rect.top + y + extents.bottom - image_y;
2039 else
2040 image_h = h - image_y;
2041
2042 if(image_w <= 0 || image_h <= 0) goto no_image;
2043
2044 X11DRV_expect_error(gdi_display, XRenderErrorHandler, NULL);
2045 image = XGetImage(gdi_display, physDev->drawable,
2046 image_x, image_y, image_w, image_h,
2047 AllPlanes, ZPixmap);
2048 X11DRV_check_error();
2049
2050 TRACE("XGetImage(%p, %x, %d, %d, %d, %d, %lx, %x) depth = %d rets %p\n",
2051 gdi_display, (int)physDev->drawable, image_x, image_y,
2052 image_w, image_h, AllPlanes, ZPixmap,
2053 physDev->depth, image);
2054 if(!image) {
2055 Pixmap xpm = XCreatePixmap(gdi_display, root_window, image_w, image_h,
2056 physDev->depth);
2057 GC gc;
2058 XGCValues gcv;
2059
2060 gcv.graphics_exposures = False;
2061 gc = XCreateGC(gdi_display, xpm, GCGraphicsExposures, &gcv);
2062 XCopyArea(gdi_display, physDev->drawable, xpm, gc, image_x, image_y,
2063 image_w, image_h, 0, 0);
2064 XFreeGC(gdi_display, gc);
2065 X11DRV_expect_error(gdi_display, XRenderErrorHandler, NULL);
2066 image = XGetImage(gdi_display, xpm, 0, 0, image_w, image_h, AllPlanes,
2067 ZPixmap);
2068 X11DRV_check_error();
2069 XFreePixmap(gdi_display, xpm);
2070 }
2071 if(!image) goto no_image;
2072
2073 image->red_mask = visual->red_mask;
2074 image->green_mask = visual->green_mask;
2075 image->blue_mask = visual->blue_mask;
2076
2077 for(idx = 0; idx < count; idx++) {
2078 SmoothGlyphGray(image,
2079 offset.x + image_off_x - extents.left,
2080 offset.y + image_off_y - extents.top,
2081 formatEntry->bitmaps[wstr[idx]],
2082 &formatEntry->gis[wstr[idx]],
2083 physDev->textPixel);
2084 if(lpDx)
2085 {
2086 if(flags & ETO_PDY)
2087 {
2088 offset.x += lpDx[idx * 2];
2089 offset.y += lpDx[idx * 2 + 1];
2090 }
2091 else
2092 offset.x += lpDx[idx];
2093 }
2094 else
2095 {
2096 offset.x += formatEntry->gis[wstr[idx]].xOff;
2097 offset.y += formatEntry->gis[wstr[idx]].yOff;
2098 }
2099 }
2100 XPutImage(gdi_display, physDev->drawable, physDev->gc, image, 0, 0,
2101 image_x, image_y, image_w, image_h);
2102 XDestroyImage(image);
2103 }
2104 no_image:
2105 wine_tsx11_unlock();
2106 }
2107 LeaveCriticalSection(&xrender_cs);
2108
2109 if (flags & ETO_CLIPPED)
2110 {
2111 /* restore the device region */
2112 X11DRV_SetDeviceClipping( physDev, saved_region, 0 );
2113 DeleteObject( saved_region );
2114 }
2115
2116 retv = TRUE;
2117
2118 done_unlock:
2119 X11DRV_UnlockDIBSection( physDev, TRUE );
2120 return retv;
2121 }
2122
2123 /* Helper function for (stretched) blitting using xrender */
2124 static void xrender_blit( int op, Picture src_pict, Picture mask_pict, Picture dst_pict,
2125 int x_src, int y_src, int x_dst, int y_dst,
2126 double xscale, double yscale, int width, int height )
2127 {
2128 int x_offset, y_offset;
2129
2130 /* When we need to scale we perform scaling and source_x / source_y translation using a transformation matrix.
2131 * This is needed because XRender is inaccurate in combination with scaled source coordinates passed to XRenderComposite.
2132 * In all other cases we do use XRenderComposite for translation as it is faster than using a transformation matrix. */
2133 if(xscale != 1.0 || yscale != 1.0)
2134 {
2135 /* In case of mirroring we need a source x- and y-offset because without the pixels will be
2136 * in the wrong quadrant of the x-y plane.
2137 */
2138 x_offset = (xscale < 0) ? -width : 0;
2139 y_offset = (yscale < 0) ? -height : 0;
2140 set_xrender_transformation(src_pict, xscale, yscale, x_src, y_src);
2141 }
2142 else
2143 {
2144 x_offset = x_src;
2145 y_offset = y_src;
2146 set_xrender_transformation(src_pict, 1, 1, 0, 0);
2147 }
2148 pXRenderComposite( gdi_display, op, src_pict, mask_pict, dst_pict,
2149 x_offset, y_offset, 0, 0, x_dst, y_dst, width, height );
2150 }
2151
2152 /* Helper function for (stretched) mono->color blitting using xrender */
2153 static void xrender_mono_blit( Picture src_pict, Picture mask_pict, Picture dst_pict,
2154 int x_src, int y_src, double xscale, double yscale, int width, int height )
2155 {
2156 int x_offset, y_offset;
2157
2158 /* When doing a mono->color blit, 'src_pict' contains a 1x1 picture for tiling, the actual
2159 * source data is in mask_pict. The 'src_pict' data effectively acts as an alpha channel to the
2160 * tile data. We need PictOpOver for correct rendering.
2161 * Note since the 'source data' is in the mask picture, we have to pass x_src / y_src using
2162 * mask_x / mask_y
2163 */
2164 if (xscale != 1.0 || yscale != 1.0)
2165 {
2166 /* In case of mirroring we need a source x- and y-offset because without the pixels will be
2167 * in the wrong quadrant of the x-y plane.
2168 */
2169 x_offset = (xscale < 0) ? -width : 0;
2170 y_offset = (yscale < 0) ? -height : 0;
2171 set_xrender_transformation(mask_pict, xscale, yscale, x_src, y_src);
2172 }
2173 else
2174 {
2175 x_offset = x_src;
2176 y_offset = y_src;
2177 set_xrender_transformation(mask_pict, 1, 1, 0, 0);
2178 }
2179 pXRenderComposite(gdi_display, PictOpOver, src_pict, mask_pict, dst_pict,
2180 0, 0, x_offset, y_offset, 0, 0, width, height);
2181 }
2182
2183 /******************************************************************************
2184 * AlphaBlend
2185 */
2186 BOOL XRender_AlphaBlend( X11DRV_PDEVICE *devDst, X11DRV_PDEVICE *devSrc,
2187 struct bitblt_coords *dst, struct bitblt_coords *src, BLENDFUNCTION blendfn )
2188 {
2189 Picture dst_pict, src_pict = 0, mask_pict = 0, tmp_pict = 0;
2190 struct xrender_info *src_info = get_xrender_info( devSrc );
2191 double xscale, yscale;
2192 BOOL use_repeat;
2193
2194 if(!X11DRV_XRender_Installed) {
2195 FIXME("Unable to AlphaBlend without Xrender\n");
2196 return FALSE;
2197 }
2198
2199 if (devSrc != devDst) X11DRV_LockDIBSection( devSrc, DIB_Status_GdiMod );
2200 X11DRV_LockDIBSection( devDst, DIB_Status_GdiMod );
2201
2202 dst_pict = get_xrender_picture( devDst );
2203
2204 use_repeat = use_source_repeat( devSrc );
2205 if (!use_repeat)
2206 {
2207 xscale = src->width / (double)dst->width;
2208 yscale = src->height / (double)dst->height;
2209 }
2210 else xscale = yscale = 1; /* no scaling needed with a repeating source */
2211
2212 if (!(blendfn.AlphaFormat & AC_SRC_ALPHA) && src_info->format)
2213 {
2214 /* we need a source picture with no alpha */
2215 WXRFormat format = get_format_without_alpha( src_info->format->format );
2216 if (format != src_info->format->format)
2217 {
2218 XRenderPictureAttributes pa;
2219 const WineXRenderFormat *fmt = get_xrender_format( format );
2220
2221 wine_tsx11_lock();
2222 pa.subwindow_mode = IncludeInferiors;
2223 pa.repeat = use_repeat ? RepeatNormal : RepeatNone;
2224 tmp_pict = pXRenderCreatePicture( gdi_display, devSrc->drawable, fmt->pict_format,
2225 CPSubwindowMode|CPRepeat, &pa );
2226 wine_tsx11_unlock();
2227 src_pict = tmp_pict;
2228 }
2229 }
2230
2231 if (!src_pict) src_pict = get_xrender_picture_source( devSrc, use_repeat );
2232
2233 EnterCriticalSection( &xrender_cs );
2234 mask_pict = get_mask_pict( blendfn.SourceConstantAlpha * 257 );
2235
2236 wine_tsx11_lock();
2237 xrender_blit( PictOpOver, src_pict, mask_pict, dst_pict,
2238 devSrc->dc_rect.left + src->visrect.left, devSrc->dc_rect.top + src->visrect.top,
2239 devDst->dc_rect.left + dst->visrect.left, devDst->dc_rect.top + dst->visrect.top,
2240 xscale, yscale,
2241 dst->visrect.right - dst->visrect.left, dst->visrect.bottom - dst->visrect.top );
2242 if (tmp_pict) pXRenderFreePicture( gdi_display, tmp_pict );
2243 wine_tsx11_unlock();
2244
2245 LeaveCriticalSection( &xrender_cs );
2246 if (devSrc != devDst) X11DRV_UnlockDIBSection( devSrc, FALSE );
2247 X11DRV_UnlockDIBSection( devDst, TRUE );
2248 return TRUE;
2249 }
2250
2251
2252 void X11DRV_XRender_CopyBrush(X11DRV_PDEVICE *physDev, X_PHYSBITMAP *physBitmap, int width, int height)
2253 {
2254 /* At depths >1, the depth of physBitmap and physDev might not be the same e.g. the physbitmap might be a 16-bit DIB while the physdev uses 24-bit */
2255 int depth = physBitmap->pixmap_depth == 1 ? 1 : physDev->depth;
2256 const WineXRenderFormat *src_format = get_xrender_format_from_color_shifts(physBitmap->pixmap_depth, &physBitmap->pixmap_color_shifts);
2257 const WineXRenderFormat *dst_format = get_xrender_format_from_color_shifts(physDev->depth, physDev->color_shifts);
2258
2259 wine_tsx11_lock();
2260 physDev->brush.pixmap = XCreatePixmap(gdi_display, root_window, width, height, depth);
2261
2262 /* Use XCopyArea when the physBitmap and brush.pixmap have the same format. */
2263 if( (physBitmap->pixmap_depth == 1) || (!X11DRV_XRender_Installed && physDev->depth == physBitmap->pixmap_depth) ||
2264 (src_format->format == dst_format->format) )
2265 {
2266 XCopyArea( gdi_display, physBitmap->pixmap, physDev->brush.pixmap,
2267 get_bitmap_gc(physBitmap->pixmap_depth), 0, 0, width, height, 0, 0 );
2268 }
2269 else /* We need depth conversion */
2270 {
2271 Picture src_pict, dst_pict;
2272 XRenderPictureAttributes pa;
2273 pa.subwindow_mode = IncludeInferiors;
2274 pa.repeat = RepeatNone;
2275
2276 src_pict = pXRenderCreatePicture(gdi_display, physBitmap->pixmap, src_format->pict_format, CPSubwindowMode|CPRepeat, &pa);
2277 dst_pict = pXRenderCreatePicture(gdi_display, physDev->brush.pixmap, dst_format->pict_format, CPSubwindowMode|CPRepeat, &pa);
2278
2279 xrender_blit(PictOpSrc, src_pict, 0, dst_pict, 0, 0, 0, 0, 1.0, 1.0, width, height);
2280 pXRenderFreePicture(gdi_display, src_pict);
2281 pXRenderFreePicture(gdi_display, dst_pict);
2282 }
2283 wine_tsx11_unlock();
2284 }
2285
2286 BOOL X11DRV_XRender_GetSrcAreaStretch(X11DRV_PDEVICE *physDevSrc, X11DRV_PDEVICE *physDevDst,
2287 Pixmap pixmap, GC gc,
2288 const struct bitblt_coords *src, const struct bitblt_coords *dst )
2289 {
2290 BOOL stretch = (src->width != dst->width) || (src->height != dst->height);
2291 int width = dst->visrect.right - dst->visrect.left;
2292 int height = dst->visrect.bottom - dst->visrect.top;
2293 int x_src = physDevSrc->dc_rect.left + src->visrect.left;
2294 int y_src = physDevSrc->dc_rect.top + src->visrect.top;
2295 struct xrender_info *src_info = get_xrender_info(physDevSrc);
2296 const WineXRenderFormat *dst_format = get_xrender_format_from_color_shifts(physDevDst->depth, physDevDst->color_shifts);
2297 Picture src_pict=0, dst_pict=0, mask_pict=0;
2298 BOOL use_repeat;
2299 double xscale, yscale;
2300
2301 XRenderPictureAttributes pa;
2302 pa.subwindow_mode = IncludeInferiors;
2303 pa.repeat = RepeatNone;
2304
2305 TRACE("src depth=%d widthSrc=%d heightSrc=%d xSrc=%d ySrc=%d\n",
2306 physDevSrc->depth, src->width, src->height, x_src, y_src);
2307 TRACE("dst depth=%d widthDst=%d heightDst=%d\n", physDevDst->depth, dst->width, dst->height);
2308
2309 if(!X11DRV_XRender_Installed)
2310 {
2311 TRACE("Not using XRender since it is not available or disabled\n");
2312 return FALSE;
2313 }
2314
2315 /* XRender can't handle palettes, so abort */
2316 if(X11DRV_PALETTE_XPixelToPalette)
2317 return FALSE;
2318
2319 /* XRender is of no use in this case */
2320 if((physDevDst->depth == 1) && (physDevSrc->depth > 1))
2321 return FALSE;
2322
2323 /* Just use traditional X copy when the formats match and we don't need stretching */
2324 if((src_info->format->format == dst_format->format) && !stretch)
2325 {
2326 TRACE("Source and destination depth match and no stretching needed falling back to XCopyArea\n");
2327 wine_tsx11_lock();
2328 XCopyArea( gdi_display, physDevSrc->drawable, pixmap, gc, x_src, y_src, width, height, 0, 0);
2329 wine_tsx11_unlock();
2330 return TRUE;
2331 }
2332
2333 use_repeat = use_source_repeat( physDevSrc );
2334 if (!use_repeat)
2335 {
2336 xscale = src->width / (double)dst->width;
2337 yscale = src->height / (double)dst->height;
2338 }
2339 else xscale = yscale = 1; /* no scaling needed with a repeating source */
2340
2341 /* mono -> color */
2342 if(physDevSrc->depth == 1 && physDevDst->depth > 1)
2343 {
2344 XRenderColor col;
2345 get_xrender_color(dst_format, physDevDst->textPixel, &col);
2346
2347 /* We use the source drawable as a mask */
2348 mask_pict = get_xrender_picture_source( physDevSrc, use_repeat );
2349
2350 /* Use backgroundPixel as the foreground color */
2351 EnterCriticalSection( &xrender_cs );
2352 src_pict = get_tile_pict(dst_format, physDevDst->backgroundPixel);
2353
2354 /* Create a destination picture and fill it with textPixel color as the background color */
2355 wine_tsx11_lock();
2356 dst_pict = pXRenderCreatePicture(gdi_display, pixmap, dst_format->pict_format, CPSubwindowMode|CPRepeat, &pa);
2357 pXRenderFillRectangle(gdi_display, PictOpSrc, dst_pict, &col, 0, 0, width, height);
2358
2359 xrender_mono_blit(src_pict, mask_pict, dst_pict, x_src, y_src, xscale, yscale, width, height);
2360
2361 if(dst_pict) pXRenderFreePicture(gdi_display, dst_pict);
2362 wine_tsx11_unlock();
2363 LeaveCriticalSection( &xrender_cs );
2364 }
2365 else /* color -> color (can be at different depths) or mono -> mono */
2366 {
2367 if (physDevDst->depth == 32 && physDevSrc->depth < 32) mask_pict = get_no_alpha_mask();
2368 src_pict = get_xrender_picture_source( physDevSrc, use_repeat );
2369
2370 wine_tsx11_lock();
2371 dst_pict = pXRenderCreatePicture(gdi_display,
2372 pixmap, dst_format->pict_format,
2373 CPSubwindowMode|CPRepeat, &pa);
2374
2375 xrender_blit(PictOpSrc, src_pict, mask_pict, dst_pict,
2376 x_src, y_src, 0, 0, xscale, yscale, width, height);
2377
2378 if(dst_pict) pXRenderFreePicture(gdi_display, dst_pict);
2379 wine_tsx11_unlock();
2380 }
2381 return TRUE;
2382 }
2383
2384 #else /* SONAME_LIBXRENDER */
2385
2386 void X11DRV_XRender_Init(void)
2387 {
2388 TRACE("XRender support not compiled in.\n");
2389 return;
2390 }
2391
2392 void X11DRV_XRender_Finalize(void)
2393 {
2394 }
2395
2396 BOOL X11DRV_XRender_SelectFont(X11DRV_PDEVICE *physDev, HFONT hfont)
2397 {
2398 assert(0);
2399 return FALSE;
2400 }
2401
2402 void X11DRV_XRender_DeleteDC(X11DRV_PDEVICE *physDev)
2403 {
2404 assert(0);
2405 return;
2406 }
2407
2408 void X11DRV_XRender_SetDeviceClipping(X11DRV_PDEVICE *physDev, const RGNDATA *data)
2409 {
2410 assert(0);
2411 return;
2412 }
2413
2414 BOOL X11DRV_XRender_ExtTextOut( X11DRV_PDEVICE *physDev, INT x, INT y, UINT flags,
2415 const RECT *lprect, LPCWSTR wstr, UINT count,
2416 const INT *lpDx )
2417 {
2418 assert(0);
2419 return FALSE;
2420 }
2421
2422 void X11DRV_XRender_UpdateDrawable(X11DRV_PDEVICE *physDev)
2423 {
2424 assert(0);
2425 return;
2426 }
2427
2428 BOOL XRender_AlphaBlend( X11DRV_PDEVICE *devDst, X11DRV_PDEVICE *devSrc,
2429 struct bitblt_coords *dst, struct bitblt_coords *src, BLENDFUNCTION blendfn )
2430 {
2431 FIXME("not supported - XRENDER headers were missing at compile time\n");
2432 return FALSE;
2433 }
2434
2435 void X11DRV_XRender_CopyBrush(X11DRV_PDEVICE *physDev, X_PHYSBITMAP *physBitmap, int width, int height)
2436 {
2437 wine_tsx11_lock();
2438 physDev->brush.pixmap = XCreatePixmap(gdi_display, root_window, width, height, physBitmap->pixmap_depth);
2439
2440 XCopyArea( gdi_display, physBitmap->pixmap, physDev->brush.pixmap,
2441 get_bitmap_gc(physBitmap->pixmap_depth), 0, 0, width, height, 0, 0 );
2442 wine_tsx11_unlock();
2443 }
2444
2445 BOOL X11DRV_XRender_SetPhysBitmapDepth(X_PHYSBITMAP *physBitmap, int bits_pixel, const DIBSECTION *dib)
2446 {
2447 return FALSE;
2448 }
2449
2450 BOOL X11DRV_XRender_GetSrcAreaStretch(X11DRV_PDEVICE *physDevSrc, X11DRV_PDEVICE *physDevDst,
2451 Pixmap pixmap, GC gc,
2452 const struct bitblt_coords *src, const struct bitblt_coords *dst )
2453 {
2454 return FALSE;
2455 }
2456 #endif /* SONAME_LIBXRENDER */
useful hacks and other patches not (yet) suitable for mainline