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