?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 337eb2e2d902d84a5d689451984c5832d7e04fc4
[wine/hacks.git] / dlls / winex11.drv / xrender.c
blob3bad0a3bc99645b92e20849fe5aaf16c2cb45506
1 /*
2 * Functions to use the XRender extension
3 *
4 * Copyright 2001, 2002 Huw D M Davies for CodeWeavers
5 *
6 * Some parts also:
7 * Copyright 2000 Keith Packard, member of The XFree86 Project, Inc.
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <assert.h>
27 #include <stdarg.h>
28 #include <string.h>
29 #include <stdlib.h>
30
31 #include "windef.h"
32 #include "winbase.h"
33 #include "x11drv.h"
34 #include "winternl.h"
35 #include "wine/library.h"
36 #include "wine/unicode.h"
37 #include "wine/debug.h"
38
39 int using_client_side_fonts = FALSE;
40
41 WINE_DEFAULT_DEBUG_CHANNEL(xrender);
42
43 #ifdef SONAME_LIBXRENDER
44
45 static BOOL X11DRV_XRender_Installed = FALSE;
46
47 #include <X11/Xlib.h>
48 #include <X11/extensions/Xrender.h>
49
50
51 enum drawable_depth_type {mono_drawable, color_drawable};
52 static XRenderPictFormat *pict_formats[2];
53
54 typedef struct
55 {
56 LOGFONTW lf;
57 SIZE devsize; /* size in device coords */
58 DWORD hash;
59 } LFANDSIZE;
60
61 #define INITIAL_REALIZED_BUF_SIZE 128
62
63 typedef enum { AA_None = 0, AA_Grey, AA_RGB, AA_BGR, AA_VRGB, AA_VBGR, AA_MAXVALUE } AA_Type;
64
65 typedef struct
66 {
67 GlyphSet glyphset;
68 XRenderPictFormat *font_format;
69 int nrealized;
70 BOOL *realized;
71 void **bitmaps;
72 XGlyphInfo *gis;
73 } gsCacheEntryFormat;
74
75 typedef struct
76 {
77 LFANDSIZE lfsz;
78 AA_Type aa_default;
79 gsCacheEntryFormat * format[AA_MAXVALUE];
80 INT count;
81 INT next;
82 } gsCacheEntry;
83
84 struct tagXRENDERINFO
85 {
86 int cache_index;
87 Picture pict;
88 };
89
90
91 static gsCacheEntry *glyphsetCache = NULL;
92 static DWORD glyphsetCacheSize = 0;
93 static INT lastfree = -1;
94 static INT mru = -1;
95
96 #define INIT_CACHE_SIZE 10
97
98 static int antialias = 1;
99
100 static void *xrender_handle;
101
102 #define MAKE_FUNCPTR(f) static typeof(f) * p##f;
103 MAKE_FUNCPTR(XRenderAddGlyphs)
104 MAKE_FUNCPTR(XRenderComposite)
105 MAKE_FUNCPTR(XRenderCompositeString8)
106 MAKE_FUNCPTR(XRenderCompositeString16)
107 MAKE_FUNCPTR(XRenderCompositeString32)
108 MAKE_FUNCPTR(XRenderCompositeText16)
109 MAKE_FUNCPTR(XRenderCreateGlyphSet)
110 MAKE_FUNCPTR(XRenderCreatePicture)
111 MAKE_FUNCPTR(XRenderFillRectangle)
112 MAKE_FUNCPTR(XRenderFindFormat)
113 MAKE_FUNCPTR(XRenderFindVisualFormat)
114 MAKE_FUNCPTR(XRenderFreeGlyphSet)
115 MAKE_FUNCPTR(XRenderFreePicture)
116 MAKE_FUNCPTR(XRenderSetPictureClipRectangles)
117 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
118 MAKE_FUNCPTR(XRenderSetPictureTransform)
119 #endif
120 MAKE_FUNCPTR(XRenderQueryExtension)
121 #undef MAKE_FUNCPTR
122
123 static CRITICAL_SECTION xrender_cs;
124 static CRITICAL_SECTION_DEBUG critsect_debug =
125 {
126 0, 0, &xrender_cs,
127 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
128 0, 0, { (DWORD_PTR)(__FILE__ ": xrender_cs") }
129 };
130 static CRITICAL_SECTION xrender_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
131
132 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
133 ( ( (ULONG)_x4 << 24 ) | \
134 ( (ULONG)_x3 << 16 ) | \
135 ( (ULONG)_x2 << 8 ) | \
136 (ULONG)_x1 )
137
138 #define MS_GASP_TAG MS_MAKE_TAG('g', 'a', 's', 'p')
139
140 #define GASP_GRIDFIT 0x01
141 #define GASP_DOGRAY 0x02
142
143 #ifdef WORDS_BIGENDIAN
144 #define get_be_word(x) (x)
145 #else
146 #define get_be_word(x) RtlUshortByteSwap(x)
147 #endif
148
149 /***********************************************************************
150 * X11DRV_XRender_Init
151 *
152 * Let's see if our XServer has the extension available
153 *
154 */
155 void X11DRV_XRender_Init(void)
156 {
157 int event_base, i;
158 XRenderPictFormat pf;
159
160 if (client_side_with_render &&
161 wine_dlopen(SONAME_LIBX11, RTLD_NOW|RTLD_GLOBAL, NULL, 0) &&
162 wine_dlopen(SONAME_LIBXEXT, RTLD_NOW|RTLD_GLOBAL, NULL, 0) &&
163 (xrender_handle = wine_dlopen(SONAME_LIBXRENDER, RTLD_NOW, NULL, 0)))
164 {
165
166 #define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(xrender_handle, #f, NULL, 0)) == NULL) goto sym_not_found;
167 LOAD_FUNCPTR(XRenderAddGlyphs)
168 LOAD_FUNCPTR(XRenderComposite)
169 LOAD_FUNCPTR(XRenderCompositeString8)
170 LOAD_FUNCPTR(XRenderCompositeString16)
171 LOAD_FUNCPTR(XRenderCompositeString32)
172 LOAD_FUNCPTR(XRenderCompositeText16)
173 LOAD_FUNCPTR(XRenderCreateGlyphSet)
174 LOAD_FUNCPTR(XRenderCreatePicture)
175 LOAD_FUNCPTR(XRenderFillRectangle)
176 LOAD_FUNCPTR(XRenderFindFormat)
177 LOAD_FUNCPTR(XRenderFindVisualFormat)
178 LOAD_FUNCPTR(XRenderFreeGlyphSet)
179 LOAD_FUNCPTR(XRenderFreePicture)
180 LOAD_FUNCPTR(XRenderSetPictureClipRectangles)
181 LOAD_FUNCPTR(XRenderQueryExtension)
182 #undef LOAD_FUNCPTR
183 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
184 #define LOAD_OPTIONAL_FUNCPTR(f) p##f = wine_dlsym(xrender_handle, #f, NULL, 0);
185 LOAD_OPTIONAL_FUNCPTR(XRenderSetPictureTransform)
186 #undef LOAD_OPTIONAL_FUNCPTR
187 #endif
188
189
190 wine_tsx11_lock();
191 if(pXRenderQueryExtension(gdi_display, &event_base, &xrender_error_base)) {
192 X11DRV_XRender_Installed = TRUE;
193 TRACE("Xrender is up and running error_base = %d\n", xrender_error_base);
194 pict_formats[color_drawable] = pXRenderFindVisualFormat(gdi_display, visual);
195 if(!pict_formats[color_drawable])
196 {
197 /* Xrender doesn't like DirectColor visuals, try to find a TrueColor one instead */
198 if (visual->class == DirectColor)
199 {
200 XVisualInfo info;
201 if (XMatchVisualInfo( gdi_display, DefaultScreen(gdi_display),
202 screen_depth, TrueColor, &info ))
203 {
204 pict_formats[color_drawable] = pXRenderFindVisualFormat(gdi_display, info.visual);
205 if (pict_formats[color_drawable]) visual = info.visual;
206 }
207 }
208 }
209 if(!pict_formats[color_drawable]) /* This fails in buggy versions of libXrender.so */
210 {
211 wine_tsx11_unlock();
212 WINE_MESSAGE(
213 "Wine has detected that you probably have a buggy version\n"
214 "of libXrender.so . Because of this client side font rendering\n"
215 "will be disabled. Please upgrade this library.\n");
216 X11DRV_XRender_Installed = FALSE;
217 return;
218 }
219 pf.type = PictTypeDirect;
220 pf.depth = 1;
221 pf.direct.alpha = 0;
222 pf.direct.alphaMask = 1;
223 pict_formats[mono_drawable] = pXRenderFindFormat(gdi_display, PictFormatType |
224 PictFormatDepth | PictFormatAlpha |
225 PictFormatAlphaMask, &pf, 0);
226 if(!pict_formats[mono_drawable]) {
227 ERR("mono_format == NULL?\n");
228 X11DRV_XRender_Installed = FALSE;
229 }
230 if (!visual->red_mask || !visual->green_mask || !visual->blue_mask) {
231 WARN("one or more of the colour masks are 0, disabling XRENDER. Try running in 16-bit mode or higher.\n");
232 X11DRV_XRender_Installed = FALSE;
233 }
234 }
235 wine_tsx11_unlock();
236 }
237
238 sym_not_found:
239 if(X11DRV_XRender_Installed || client_side_with_core)
240 {
241 glyphsetCache = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
242 sizeof(*glyphsetCache) * INIT_CACHE_SIZE);
243
244 glyphsetCacheSize = INIT_CACHE_SIZE;
245 lastfree = 0;
246 for(i = 0; i < INIT_CACHE_SIZE; i++) {
247 glyphsetCache[i].next = i + 1;
248 glyphsetCache[i].count = -1;
249 }
250 glyphsetCache[i-1].next = -1;
251 using_client_side_fonts = 1;
252
253 if(!X11DRV_XRender_Installed) {
254 TRACE("Xrender is not available on your XServer, client side rendering with the core protocol instead.\n");
255 if(screen_depth <= 8 || !client_side_antialias_with_core)
256 antialias = 0;
257 } else {
258 if(screen_depth <= 8 || !client_side_antialias_with_render)
259 antialias = 0;
260 }
261 }
262 else TRACE("Using X11 core fonts\n");
263 }
264
265 static BOOL fontcmp(LFANDSIZE *p1, LFANDSIZE *p2)
266 {
267 if(p1->hash != p2->hash) return TRUE;
268 if(memcmp(&p1->devsize, &p2->devsize, sizeof(p1->devsize))) return TRUE;
269 if(memcmp(&p1->lf, &p2->lf, offsetof(LOGFONTW, lfFaceName))) return TRUE;
270 return strcmpW(p1->lf.lfFaceName, p2->lf.lfFaceName);
271 }
272
273 #if 0
274 static void walk_cache(void)
275 {
276 int i;
277
278 EnterCriticalSection(&xrender_cs);
279 for(i=mru; i >= 0; i = glyphsetCache[i].next)
280 TRACE("item %d\n", i);
281 LeaveCriticalSection(&xrender_cs);
282 }
283 #endif
284
285 static int LookupEntry(LFANDSIZE *plfsz)
286 {
287 int i, prev_i = -1;
288
289 for(i = mru; i >= 0; i = glyphsetCache[i].next) {
290 TRACE("%d\n", i);
291 if(glyphsetCache[i].count == -1) { /* reached free list so stop */
292 i = -1;
293 break;
294 }
295
296 if(!fontcmp(&glyphsetCache[i].lfsz, plfsz)) {
297 glyphsetCache[i].count++;
298 if(prev_i >= 0) {
299 glyphsetCache[prev_i].next = glyphsetCache[i].next;
300 glyphsetCache[i].next = mru;
301 mru = i;
302 }
303 TRACE("found font in cache %d\n", i);
304 return i;
305 }
306 prev_i = i;
307 }
308 TRACE("font not in cache\n");
309 return -1;
310 }
311
312 static void FreeEntry(int entry)
313 {
314 int i, format;
315
316 for(format = 0; format < AA_MAXVALUE; format++) {
317 gsCacheEntryFormat * formatEntry;
318
319 if( !glyphsetCache[entry].format[format] )
320 continue;
321
322 formatEntry = glyphsetCache[entry].format[format];
323
324 if(formatEntry->glyphset) {
325 wine_tsx11_lock();
326 pXRenderFreeGlyphSet(gdi_display, formatEntry->glyphset);
327 wine_tsx11_unlock();
328 formatEntry->glyphset = 0;
329 }
330 if(formatEntry->nrealized) {
331 HeapFree(GetProcessHeap(), 0, formatEntry->realized);
332 formatEntry->realized = NULL;
333 if(formatEntry->bitmaps) {
334 for(i = 0; i < formatEntry->nrealized; i++)
335 HeapFree(GetProcessHeap(), 0, formatEntry->bitmaps[i]);
336 HeapFree(GetProcessHeap(), 0, formatEntry->bitmaps);
337 formatEntry->bitmaps = NULL;
338 }
339 HeapFree(GetProcessHeap(), 0, formatEntry->gis);
340 formatEntry->gis = NULL;
341 formatEntry->nrealized = 0;
342 }
343
344 HeapFree(GetProcessHeap(), 0, formatEntry);
345 glyphsetCache[entry].format[format] = NULL;
346 }
347 }
348
349 static int AllocEntry(void)
350 {
351 int best = -1, prev_best = -1, i, prev_i = -1;
352
353 if(lastfree >= 0) {
354 assert(glyphsetCache[lastfree].count == -1);
355 glyphsetCache[lastfree].count = 1;
356 best = lastfree;
357 lastfree = glyphsetCache[lastfree].next;
358 assert(best != mru);
359 glyphsetCache[best].next = mru;
360 mru = best;
361
362 TRACE("empty space at %d, next lastfree = %d\n", mru, lastfree);
363 return mru;
364 }
365
366 for(i = mru; i >= 0; i = glyphsetCache[i].next) {
367 if(glyphsetCache[i].count == 0) {
368 best = i;
369 prev_best = prev_i;
370 }
371 prev_i = i;
372 }
373
374 if(best >= 0) {
375 TRACE("freeing unused glyphset at cache %d\n", best);
376 FreeEntry(best);
377 glyphsetCache[best].count = 1;
378 if(prev_best >= 0) {
379 glyphsetCache[prev_best].next = glyphsetCache[best].next;
380 glyphsetCache[best].next = mru;
381 mru = best;
382 } else {
383 assert(mru == best);
384 }
385 return mru;
386 }
387
388 TRACE("Growing cache\n");
389
390 if (glyphsetCache)
391 glyphsetCache = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
392 glyphsetCache,
393 (glyphsetCacheSize + INIT_CACHE_SIZE)
394 * sizeof(*glyphsetCache));
395 else
396 glyphsetCache = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
397 (glyphsetCacheSize + INIT_CACHE_SIZE)
398 * sizeof(*glyphsetCache));
399
400 for(best = i = glyphsetCacheSize; i < glyphsetCacheSize + INIT_CACHE_SIZE;
401 i++) {
402 glyphsetCache[i].next = i + 1;
403 glyphsetCache[i].count = -1;
404 }
405 glyphsetCache[i-1].next = -1;
406 glyphsetCacheSize += INIT_CACHE_SIZE;
407
408 lastfree = glyphsetCache[best].next;
409 glyphsetCache[best].count = 1;
410 glyphsetCache[best].next = mru;
411 mru = best;
412 TRACE("new free cache slot at %d\n", mru);
413 return mru;
414 }
415
416 static BOOL get_gasp_flags(X11DRV_PDEVICE *physDev, WORD *flags)
417 {
418 DWORD size;
419 WORD *gasp, *buffer;
420 WORD num_recs;
421 DWORD ppem;
422 TEXTMETRICW tm;
423
424 *flags = 0;
425
426 size = GetFontData(physDev->hdc, MS_GASP_TAG, 0, NULL, 0);
427 if(size == GDI_ERROR)
428 return FALSE;
429
430 gasp = buffer = HeapAlloc(GetProcessHeap(), 0, size);
431 GetFontData(physDev->hdc, MS_GASP_TAG, 0, gasp, size);
432
433 GetTextMetricsW(physDev->hdc, &tm);
434 ppem = abs(X11DRV_YWStoDS(physDev, tm.tmAscent + tm.tmDescent - tm.tmInternalLeading));
435
436 gasp++;
437 num_recs = get_be_word(*gasp);
438 gasp++;
439 while(num_recs--)
440 {
441 *flags = get_be_word(*(gasp + 1));
442 if(ppem <= get_be_word(*gasp))
443 break;
444 gasp += 2;
445 }
446 TRACE("got flags %04x for ppem %d\n", *flags, ppem);
447
448 HeapFree(GetProcessHeap(), 0, buffer);
449 return TRUE;
450 }
451
452 static int GetCacheEntry(X11DRV_PDEVICE *physDev, LFANDSIZE *plfsz)
453 {
454 int ret;
455 int format;
456 gsCacheEntry *entry;
457 WORD flags;
458 static int hinter = -1;
459
460 if((ret = LookupEntry(plfsz)) != -1) return ret;
461
462 ret = AllocEntry();
463 entry = glyphsetCache + ret;
464 entry->lfsz = *plfsz;
465 for( format = 0; format < AA_MAXVALUE; format++ ) {
466 assert( !entry->format[format] );
467 }
468
469 if(antialias && plfsz->lf.lfQuality != NONANTIALIASED_QUALITY)
470 {
471 if(hinter == -1)
472 {
473 RASTERIZER_STATUS status;
474 GetRasterizerCaps(&status, sizeof(status));
475 hinter = status.wFlags & WINE_TT_HINTER_ENABLED;
476 }
477 if(!hinter || !get_gasp_flags(physDev, &flags) || flags & GASP_DOGRAY)
478 entry->aa_default = AA_Grey;
479 else
480 entry->aa_default = AA_None;
481 }
482 else
483 entry->aa_default = AA_None;
484
485 return ret;
486 }
487
488 static void dec_ref_cache(int index)
489 {
490 assert(index >= 0);
491 TRACE("dec'ing entry %d to %d\n", index, glyphsetCache[index].count - 1);
492 assert(glyphsetCache[index].count > 0);
493 glyphsetCache[index].count--;
494 }
495
496 static void lfsz_calc_hash(LFANDSIZE *plfsz)
497 {
498 DWORD hash = 0, *ptr;
499 int i;
500
501 hash ^= plfsz->devsize.cx;
502 hash ^= plfsz->devsize.cy;
503 for(i = 0, ptr = (DWORD*)&plfsz->lf; i < 7; i++, ptr++)
504 hash ^= *ptr;
505 for(i = 0, ptr = (DWORD*)plfsz->lf.lfFaceName; i < LF_FACESIZE/2; i++, ptr++) {
506 WCHAR *pwc = (WCHAR *)ptr;
507 if(!*pwc) break;
508 hash ^= *ptr;
509 pwc++;
510 if(!*pwc) break;
511 }
512 plfsz->hash = hash;
513 return;
514 }
515
516 /***********************************************************************
517 * X11DRV_XRender_Finalize
518 */
519 void X11DRV_XRender_Finalize(void)
520 {
521 int i;
522
523 EnterCriticalSection(&xrender_cs);
524 for(i = mru; i >= 0; i = glyphsetCache[i].next)
525 FreeEntry(i);
526 LeaveCriticalSection(&xrender_cs);
527 }
528
529
530 /***********************************************************************
531 * X11DRV_XRender_SelectFont
532 */
533 BOOL X11DRV_XRender_SelectFont(X11DRV_PDEVICE *physDev, HFONT hfont)
534 {
535 LFANDSIZE lfsz;
536
537 GetObjectW(hfont, sizeof(lfsz.lf), &lfsz.lf);
538 TRACE("h=%d w=%d weight=%d it=%d charset=%d name=%s\n",
539 lfsz.lf.lfHeight, lfsz.lf.lfWidth, lfsz.lf.lfWeight,
540 lfsz.lf.lfItalic, lfsz.lf.lfCharSet, debugstr_w(lfsz.lf.lfFaceName));
541 lfsz.devsize.cx = X11DRV_XWStoDS( physDev, lfsz.lf.lfWidth );
542 lfsz.devsize.cy = X11DRV_YWStoDS( physDev, lfsz.lf.lfHeight );
543 lfsz_calc_hash(&lfsz);
544
545 EnterCriticalSection(&xrender_cs);
546 if(!physDev->xrender) {
547 physDev->xrender = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
548 sizeof(*physDev->xrender));
549 physDev->xrender->cache_index = -1;
550 }
551 else if(physDev->xrender->cache_index != -1)
552 dec_ref_cache(physDev->xrender->cache_index);
553 physDev->xrender->cache_index = GetCacheEntry(physDev, &lfsz);
554 LeaveCriticalSection(&xrender_cs);
555 return 0;
556 }
557
558 /***********************************************************************
559 * X11DRV_XRender_DeleteDC
560 */
561 void X11DRV_XRender_DeleteDC(X11DRV_PDEVICE *physDev)
562 {
563 X11DRV_XRender_UpdateDrawable(physDev);
564
565 EnterCriticalSection(&xrender_cs);
566 if(physDev->xrender->cache_index != -1)
567 dec_ref_cache(physDev->xrender->cache_index);
568 LeaveCriticalSection(&xrender_cs);
569
570 HeapFree(GetProcessHeap(), 0, physDev->xrender);
571 physDev->xrender = NULL;
572 return;
573 }
574
575 /***********************************************************************
576 * X11DRV_XRender_UpdateDrawable
577 *
578 * This gets called from X11DRV_SetDrawable and X11DRV_SelectBitmap.
579 * It deletes the pict and tile when the drawable changes.
580 */
581 void X11DRV_XRender_UpdateDrawable(X11DRV_PDEVICE *physDev)
582 {
583 wine_tsx11_lock();
584
585 if(physDev->xrender->pict)
586 {
587 TRACE("freeing pict = %lx dc = %p\n", physDev->xrender->pict, physDev->hdc);
588 XFlush(gdi_display);
589 pXRenderFreePicture(gdi_display, physDev->xrender->pict);
590 physDev->xrender->pict = 0;
591 }
592 wine_tsx11_unlock();
593
594 return;
595 }
596
597 /************************************************************************
598 * UploadGlyph
599 *
600 * Helper to ExtTextOut. Must be called inside xrender_cs
601 */
602 static BOOL UploadGlyph(X11DRV_PDEVICE *physDev, int glyph, AA_Type format)
603 {
604 unsigned int buflen;
605 char *buf;
606 Glyph gid;
607 GLYPHMETRICS gm;
608 XGlyphInfo gi;
609 gsCacheEntry *entry = glyphsetCache + physDev->xrender->cache_index;
610 gsCacheEntryFormat *formatEntry;
611 UINT ggo_format = GGO_GLYPH_INDEX;
612 XRenderPictFormat pf;
613 static const char zero[4];
614
615 switch(format) {
616 case AA_Grey:
617 ggo_format |= WINE_GGO_GRAY16_BITMAP;
618 break;
619
620 default:
621 ERR("aa = %d - not implemented\n", format);
622 case AA_None:
623 ggo_format |= GGO_BITMAP;
624 break;
625 }
626
627 buflen = GetGlyphOutlineW(physDev->hdc, glyph, ggo_format, &gm, 0, NULL,
628 NULL);
629 if(buflen == GDI_ERROR) {
630 if(format != AA_None) {
631 format = AA_None;
632 entry->aa_default = AA_None;
633 ggo_format &= ~WINE_GGO_GRAY16_BITMAP;
634 ggo_format |= GGO_BITMAP;
635 buflen = GetGlyphOutlineW(physDev->hdc, glyph, ggo_format, &gm, 0, NULL,
636 NULL);
637 }
638 if(buflen == GDI_ERROR) {
639 WARN("GetGlyphOutlineW failed\n");
640 return FALSE;
641 }
642 TRACE("Turning off antialiasing for this monochrome font\n");
643 }
644
645 /* If there is nothing for the current type, we create the entry. */
646 if( !entry->format[format] ) {
647 entry->format[format] = HeapAlloc(GetProcessHeap(),
648 HEAP_ZERO_MEMORY,
649 sizeof(gsCacheEntryFormat));
650 }
651 formatEntry = entry->format[format];
652
653 if(formatEntry->nrealized <= glyph) {
654 formatEntry->nrealized = (glyph / 128 + 1) * 128;
655
656 if (formatEntry->realized)
657 formatEntry->realized = HeapReAlloc(GetProcessHeap(),
658 HEAP_ZERO_MEMORY,
659 formatEntry->realized,
660 formatEntry->nrealized * sizeof(BOOL));
661 else
662 formatEntry->realized = HeapAlloc(GetProcessHeap(),
663 HEAP_ZERO_MEMORY,
664 formatEntry->nrealized * sizeof(BOOL));
665
666 if(!X11DRV_XRender_Installed) {
667 if (formatEntry->bitmaps)
668 formatEntry->bitmaps = HeapReAlloc(GetProcessHeap(),
669 HEAP_ZERO_MEMORY,
670 formatEntry->bitmaps,
671 formatEntry->nrealized * sizeof(formatEntry->bitmaps[0]));
672 else
673 formatEntry->bitmaps = HeapAlloc(GetProcessHeap(),
674 HEAP_ZERO_MEMORY,
675 formatEntry->nrealized * sizeof(formatEntry->bitmaps[0]));
676 }
677 if (formatEntry->gis)
678 formatEntry->gis = HeapReAlloc(GetProcessHeap(),
679 HEAP_ZERO_MEMORY,
680 formatEntry->gis,
681 formatEntry->nrealized * sizeof(formatEntry->gis[0]));
682 else
683 formatEntry->gis = HeapAlloc(GetProcessHeap(),
684 HEAP_ZERO_MEMORY,
685 formatEntry->nrealized * sizeof(formatEntry->gis[0]));
686 }
687
688
689 if(formatEntry->glyphset == 0 && X11DRV_XRender_Installed) {
690 switch(format) {
691 case AA_Grey:
692 pf.depth = 8;
693 pf.direct.alphaMask = 0xff;
694 break;
695
696 default:
697 ERR("aa = %d - not implemented\n", format);
698 case AA_None:
699 pf.depth = 1;
700 pf.direct.alphaMask = 1;
701 break;
702 }
703
704 pf.type = PictTypeDirect;
705 pf.direct.alpha = 0;
706
707 wine_tsx11_lock();
708 formatEntry->font_format = pXRenderFindFormat(gdi_display,
709 PictFormatType |
710 PictFormatDepth |
711 PictFormatAlpha |
712 PictFormatAlphaMask,
713 &pf, 0);
714
715 formatEntry->glyphset = pXRenderCreateGlyphSet(gdi_display, formatEntry->font_format);
716 wine_tsx11_unlock();
717 }
718
719
720 buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buflen);
721 GetGlyphOutlineW(physDev->hdc, glyph, ggo_format, &gm, buflen, buf, NULL);
722 formatEntry->realized[glyph] = TRUE;
723
724 TRACE("buflen = %d. Got metrics: %dx%d adv=%d,%d origin=%d,%d\n",
725 buflen,
726 gm.gmBlackBoxX, gm.gmBlackBoxY, gm.gmCellIncX, gm.gmCellIncY,
727 gm.gmptGlyphOrigin.x, gm.gmptGlyphOrigin.y);
728
729 gi.width = gm.gmBlackBoxX;
730 gi.height = gm.gmBlackBoxY;
731 gi.x = -gm.gmptGlyphOrigin.x;
732 gi.y = gm.gmptGlyphOrigin.y;
733 gi.xOff = gm.gmCellIncX;
734 gi.yOff = gm.gmCellIncY;
735
736 if(TRACE_ON(xrender)) {
737 int pitch, i, j;
738 char output[300];
739 unsigned char *line;
740
741 if(format == AA_None) {
742 pitch = ((gi.width + 31) / 32) * 4;
743 for(i = 0; i < gi.height; i++) {
744 line = (unsigned char*) buf + i * pitch;
745 output[0] = '\0';
746 for(j = 0; j < pitch * 8; j++) {
747 strcat(output, (line[j / 8] & (1 << (7 - (j % 8)))) ? "#" : " ");
748 }
749 TRACE("%s\n", output);
750 }
751 } else {
752 static const char blks[] = " .:;!o*#";
753 char str[2];
754
755 str[1] = '\0';
756 pitch = ((gi.width + 3) / 4) * 4;
757 for(i = 0; i < gi.height; i++) {
758 line = (unsigned char*) buf + i * pitch;
759 output[0] = '\0';
760 for(j = 0; j < pitch; j++) {
761 str[0] = blks[line[j] >> 5];
762 strcat(output, str);
763 }
764 TRACE("%s\n", output);
765 }
766 }
767 }
768
769
770 if(formatEntry->glyphset) {
771 if(format == AA_None && BitmapBitOrder(gdi_display) != MSBFirst) {
772 unsigned char *byte = (unsigned char*) buf, c;
773 int i = buflen;
774
775 while(i--) {
776 c = *byte;
777
778 /* magic to flip bit order */
779 c = ((c << 1) & 0xaa) | ((c >> 1) & 0x55);
780 c = ((c << 2) & 0xcc) | ((c >> 2) & 0x33);
781 c = ((c << 4) & 0xf0) | ((c >> 4) & 0x0f);
782
783 *byte++ = c;
784 }
785 }
786 gid = glyph;
787
788 /*
789 XRenderCompositeText seems to ignore 0x0 glyphs when
790 AA_None, which means we lose the advance width of glyphs
791 like the space. We'll pretend that such glyphs are 1x1
792 bitmaps.
793 */
794
795 if(buflen == 0)
796 gi.width = gi.height = 1;
797
798 wine_tsx11_lock();
799 pXRenderAddGlyphs(gdi_display, formatEntry->glyphset, &gid, &gi, 1,
800 buflen ? buf : zero, buflen ? buflen : sizeof(zero));
801 wine_tsx11_unlock();
802 HeapFree(GetProcessHeap(), 0, buf);
803 } else {
804 formatEntry->bitmaps[glyph] = buf;
805 }
806
807 formatEntry->gis[glyph] = gi;
808
809 return TRUE;
810 }
811
812 static void SharpGlyphMono(X11DRV_PDEVICE *physDev, INT x, INT y,
813 void *bitmap, XGlyphInfo *gi)
814 {
815 unsigned char *srcLine = bitmap, *src;
816 unsigned char bits, bitsMask;
817 int width = gi->width;
818 int stride = ((width + 31) & ~31) >> 3;
819 int height = gi->height;
820 int w;
821 int xspan, lenspan;
822
823 TRACE("%d, %d\n", x, y);
824 x -= gi->x;
825 y -= gi->y;
826 while (height--)
827 {
828 src = srcLine;
829 srcLine += stride;
830 w = width;
831
832 bitsMask = 0x80; /* FreeType is always MSB first */
833 bits = *src++;
834
835 xspan = x;
836 while (w)
837 {
838 if (bits & bitsMask)
839 {
840 lenspan = 0;
841 do
842 {
843 lenspan++;
844 if (lenspan == w)
845 break;
846 bitsMask = bitsMask >> 1;
847 if (!bitsMask)
848 {
849 bits = *src++;
850 bitsMask = 0x80;
851 }
852 } while (bits & bitsMask);
853 XFillRectangle (gdi_display, physDev->drawable,
854 physDev->gc, xspan, y, lenspan, 1);
855 xspan += lenspan;
856 w -= lenspan;
857 }
858 else
859 {
860 do
861 {
862 w--;
863 xspan++;
864 if (!w)
865 break;
866 bitsMask = bitsMask >> 1;
867 if (!bitsMask)
868 {
869 bits = *src++;
870 bitsMask = 0x80;
871 }
872 } while (!(bits & bitsMask));
873 }
874 }
875 y++;
876 }
877 }
878
879 static void SharpGlyphGray(X11DRV_PDEVICE *physDev, INT x, INT y,
880 void *bitmap, XGlyphInfo *gi)
881 {
882 unsigned char *srcLine = bitmap, *src, bits;
883 int width = gi->width;
884 int stride = ((width + 3) & ~3);
885 int height = gi->height;
886 int w;
887 int xspan, lenspan;
888
889 x -= gi->x;
890 y -= gi->y;
891 while (height--)
892 {
893 src = srcLine;
894 srcLine += stride;
895 w = width;
896
897 bits = *src++;
898 xspan = x;
899 while (w)
900 {
901 if (bits >= 0x80)
902 {
903 lenspan = 0;
904 do
905 {
906 lenspan++;
907 if (lenspan == w)
908 break;
909 bits = *src++;
910 } while (bits >= 0x80);
911 XFillRectangle (gdi_display, physDev->drawable,
912 physDev->gc, xspan, y, lenspan, 1);
913 xspan += lenspan;
914 w -= lenspan;
915 }
916 else
917 {
918 do
919 {
920 w--;
921 xspan++;
922 if (!w)
923 break;
924 bits = *src++;
925 } while (bits < 0x80);
926 }
927 }
928 y++;
929 }
930 }
931
932
933 static void ExamineBitfield (DWORD mask, int *shift, int *len)
934 {
935 int s, l;
936
937 s = 0;
938 while ((mask & 1) == 0)
939 {
940 mask >>= 1;
941 s++;
942 }
943 l = 0;
944 while ((mask & 1) == 1)
945 {
946 mask >>= 1;
947 l++;
948 }
949 *shift = s;
950 *len = l;
951 }
952
953 static DWORD GetField (DWORD pixel, int shift, int len)
954 {
955 pixel = pixel & (((1 << (len)) - 1) << shift);
956 pixel = pixel << (32 - (shift + len)) >> 24;
957 while (len < 8)
958 {
959 pixel |= (pixel >> len);
960 len <<= 1;
961 }
962 return pixel;
963 }
964
965
966 static DWORD PutField (DWORD pixel, int shift, int len)
967 {
968 shift = shift - (8 - len);
969 if (len <= 8)
970 pixel &= (((1 << len) - 1) << (8 - len));
971 if (shift < 0)
972 pixel >>= -shift;
973 else
974 pixel <<= shift;
975 return pixel;
976 }
977
978 static void SmoothGlyphGray(XImage *image, int x, int y, void *bitmap, XGlyphInfo *gi,
979 int color)
980 {
981 int r_shift, r_len;
982 int g_shift, g_len;
983 int b_shift, b_len;
984 BYTE *maskLine, *mask, m;
985 int maskStride;
986 DWORD pixel;
987 int width, height;
988 int w, tx;
989 BYTE src_r, src_g, src_b;
990
991 x -= gi->x;
992 y -= gi->y;
993 width = gi->width;
994 height = gi->height;
995
996 maskLine = (unsigned char *) bitmap;
997 maskStride = (width + 3) & ~3;
998
999 ExamineBitfield (image->red_mask, &r_shift, &r_len);
1000 ExamineBitfield (image->green_mask, &g_shift, &g_len);
1001 ExamineBitfield (image->blue_mask, &b_shift, &b_len);
1002
1003 src_r = GetField(color, r_shift, r_len);
1004 src_g = GetField(color, g_shift, g_len);
1005 src_b = GetField(color, b_shift, b_len);
1006
1007 for(; height--; y++)
1008 {
1009 mask = maskLine;
1010 maskLine += maskStride;
1011 w = width;
1012 tx = x;
1013
1014 if(y < 0) continue;
1015 if(y >= image->height) break;
1016
1017 for(; w--; tx++)
1018 {
1019 if(tx >= image->width) break;
1020
1021 m = *mask++;
1022 if(tx < 0) continue;
1023
1024 if (m == 0xff)
1025 XPutPixel (image, tx, y, color);
1026 else if (m)
1027 {
1028 BYTE r, g, b;
1029
1030 pixel = XGetPixel (image, tx, y);
1031
1032 r = GetField(pixel, r_shift, r_len);
1033 r = ((BYTE)~m * (WORD)r + (BYTE)m * (WORD)src_r) >> 8;
1034 g = GetField(pixel, g_shift, g_len);
1035 g = ((BYTE)~m * (WORD)g + (BYTE)m * (WORD)src_g) >> 8;
1036 b = GetField(pixel, b_shift, b_len);
1037 b = ((BYTE)~m * (WORD)b + (BYTE)m * (WORD)src_b) >> 8;
1038
1039 pixel = (PutField (r, r_shift, r_len) |
1040 PutField (g, g_shift, g_len) |
1041 PutField (b, b_shift, b_len));
1042 XPutPixel (image, tx, y, pixel);
1043 }
1044 }
1045 }
1046 }
1047
1048 /*************************************************************
1049 * get_tile_pict
1050 *
1051 * Returns an appropriate Picture for tiling the text colour.
1052 * Call and use result within the xrender_cs
1053 */
1054 static Picture get_tile_pict(enum drawable_depth_type type, int text_pixel)
1055 {
1056 static struct
1057 {
1058 Pixmap xpm;
1059 Picture pict;
1060 int current_color;
1061 } tiles[2], *tile;
1062 XRenderColor col;
1063
1064 tile = &tiles[type];
1065
1066 if(!tile->xpm)
1067 {
1068 XRenderPictureAttributes pa;
1069
1070 wine_tsx11_lock();
1071 tile->xpm = XCreatePixmap(gdi_display, root_window, 1, 1, pict_formats[type]->depth);
1072
1073 pa.repeat = True;
1074 tile->pict = pXRenderCreatePicture(gdi_display, tile->xpm, pict_formats[type], CPRepeat, &pa);
1075 wine_tsx11_unlock();
1076
1077 /* init current_color to something different from text_pixel */
1078 tile->current_color = ~text_pixel;
1079
1080 if(type == mono_drawable)
1081 {
1082 /* for a 1bpp bitmap we always need a 1 in the tile */
1083 col.red = col.green = col.blue = 0;
1084 col.alpha = 0xffff;
1085 wine_tsx11_lock();
1086 pXRenderFillRectangle(gdi_display, PictOpSrc, tile->pict, &col, 0, 0, 1, 1);
1087 wine_tsx11_unlock();
1088 }
1089 }
1090
1091 if(text_pixel != tile->current_color && type == color_drawable)
1092 {
1093 /* Map 0 -- 0xff onto 0 -- 0xffff */
1094 int r_shift, r_len;
1095 int g_shift, g_len;
1096 int b_shift, b_len;
1097
1098 ExamineBitfield (visual->red_mask, &r_shift, &r_len );
1099 ExamineBitfield (visual->green_mask, &g_shift, &g_len);
1100 ExamineBitfield (visual->blue_mask, &b_shift, &b_len);
1101
1102 col.red = GetField(text_pixel, r_shift, r_len);
1103 col.red |= col.red << 8;
1104 col.green = GetField(text_pixel, g_shift, g_len);
1105 col.green |= col.green << 8;
1106 col.blue = GetField(text_pixel, b_shift, b_len);
1107 col.blue |= col.blue << 8;
1108 col.alpha = 0xffff;
1109
1110 wine_tsx11_lock();
1111 pXRenderFillRectangle(gdi_display, PictOpSrc, tile->pict, &col, 0, 0, 1, 1);
1112 wine_tsx11_unlock();
1113 tile->current_color = text_pixel;
1114 }
1115 return tile->pict;
1116 }
1117
1118 static int XRenderErrorHandler(Display *dpy, XErrorEvent *event, void *arg)
1119 {
1120 return 1;
1121 }
1122
1123 /***********************************************************************
1124 * X11DRV_XRender_ExtTextOut
1125 */
1126 BOOL X11DRV_XRender_ExtTextOut( X11DRV_PDEVICE *physDev, INT x, INT y, UINT flags,
1127 const RECT *lprect, LPCWSTR wstr, UINT count,
1128 const INT *lpDx )
1129 {
1130 RGNDATA *data;
1131 XGCValues xgcval;
1132 gsCacheEntry *entry;
1133 gsCacheEntryFormat *formatEntry;
1134 BOOL retv = FALSE;
1135 HDC hdc = physDev->hdc;
1136 int textPixel, backgroundPixel;
1137 HRGN saved_region = 0;
1138 BOOL disable_antialias = FALSE;
1139 AA_Type aa_type = AA_None;
1140 DIBSECTION bmp;
1141 unsigned int idx;
1142 double cosEsc, sinEsc;
1143 LOGFONTW lf;
1144 enum drawable_depth_type depth_type = (physDev->depth == 1) ? mono_drawable : color_drawable;
1145 Picture tile_pict = 0;
1146
1147 /* Do we need to disable antialiasing because of palette mode? */
1148 if( !physDev->bitmap || GetObjectW( physDev->bitmap->hbitmap, sizeof(bmp), &bmp ) != sizeof(bmp) ) {
1149 TRACE("bitmap is not a DIB\n");
1150 }
1151 else if (bmp.dsBmih.biBitCount <= 8) {
1152 TRACE("Disabling antialiasing\n");
1153 disable_antialias = TRUE;
1154 }
1155
1156 xgcval.function = GXcopy;
1157 xgcval.background = physDev->backgroundPixel;
1158 xgcval.fill_style = FillSolid;
1159 wine_tsx11_lock();
1160 XChangeGC( gdi_display, physDev->gc, GCFunction | GCBackground | GCFillStyle, &xgcval );
1161 wine_tsx11_unlock();
1162
1163 X11DRV_LockDIBSection( physDev, DIB_Status_GdiMod );
1164
1165 if(physDev->depth == 1) {
1166 if((physDev->textPixel & 0xffffff) == 0) {
1167 textPixel = 0;
1168 backgroundPixel = 1;
1169 } else {
1170 textPixel = 1;
1171 backgroundPixel = 0;
1172 }
1173 } else {
1174 textPixel = physDev->textPixel;
1175 backgroundPixel = physDev->backgroundPixel;
1176 }
1177
1178 if(flags & ETO_OPAQUE)
1179 {
1180 wine_tsx11_lock();
1181 XSetForeground( gdi_display, physDev->gc, backgroundPixel );
1182 XFillRectangle( gdi_display, physDev->drawable, physDev->gc,
1183 physDev->dc_rect.left + lprect->left, physDev->dc_rect.top + lprect->top,
1184 lprect->right - lprect->left, lprect->bottom - lprect->top );
1185 wine_tsx11_unlock();
1186 }
1187
1188 if(count == 0)
1189 {
1190 retv = TRUE;
1191 goto done_unlock;
1192 }
1193
1194
1195 GetObjectW(GetCurrentObject(physDev->hdc, OBJ_FONT), sizeof(lf), &lf);
1196 if(lf.lfEscapement != 0) {
1197 cosEsc = cos(lf.lfEscapement * M_PI / 1800);
1198 sinEsc = sin(lf.lfEscapement * M_PI / 1800);
1199 } else {
1200 cosEsc = 1;
1201 sinEsc = 0;
1202 }
1203
1204 if (flags & ETO_CLIPPED)
1205 {
1206 HRGN clip_region;
1207
1208 clip_region = CreateRectRgnIndirect( lprect );
1209 /* make a copy of the current device region */
1210 saved_region = CreateRectRgn( 0, 0, 0, 0 );
1211 CombineRgn( saved_region, physDev->region, 0, RGN_COPY );
1212 X11DRV_SetDeviceClipping( physDev, saved_region, clip_region );
1213 DeleteObject( clip_region );
1214 }
1215
1216 if(X11DRV_XRender_Installed) {
1217 if(!physDev->xrender->pict) {
1218 XRenderPictureAttributes pa;
1219 pa.subwindow_mode = IncludeInferiors;
1220
1221 wine_tsx11_lock();
1222 physDev->xrender->pict = pXRenderCreatePicture(gdi_display,
1223 physDev->drawable,
1224 pict_formats[depth_type],
1225 CPSubwindowMode, &pa);
1226 wine_tsx11_unlock();
1227
1228 TRACE("allocing pict = %lx dc = %p drawable = %08lx\n",
1229 physDev->xrender->pict, hdc, physDev->drawable);
1230 } else {
1231 TRACE("using existing pict = %lx dc = %p drawable = %08lx\n",
1232 physDev->xrender->pict, hdc, physDev->drawable);
1233 }
1234
1235 if ((data = X11DRV_GetRegionData( physDev->region, 0 )))
1236 {
1237 wine_tsx11_lock();
1238 pXRenderSetPictureClipRectangles( gdi_display, physDev->xrender->pict,
1239 physDev->dc_rect.left, physDev->dc_rect.top,
1240 (XRectangle *)data->Buffer, data->rdh.nCount );
1241 wine_tsx11_unlock();
1242 HeapFree( GetProcessHeap(), 0, data );
1243 }
1244 }
1245
1246 EnterCriticalSection(&xrender_cs);
1247
1248 entry = glyphsetCache + physDev->xrender->cache_index;
1249 if( disable_antialias == FALSE )
1250 aa_type = entry->aa_default;
1251 formatEntry = entry->format[aa_type];
1252
1253 for(idx = 0; idx < count; idx++) {
1254 if( !formatEntry ) {
1255 UploadGlyph(physDev, wstr[idx], aa_type);
1256 /* re-evaluate antialias since aa_default may have changed */
1257 if( disable_antialias == FALSE )
1258 aa_type = entry->aa_default;
1259 formatEntry = entry->format[aa_type];
1260 } else if( wstr[idx] >= formatEntry->nrealized || formatEntry->realized[wstr[idx]] == FALSE) {
1261 UploadGlyph(physDev, wstr[idx], aa_type);
1262 }
1263 }
1264 if (!formatEntry)
1265 {
1266 WARN("could not upload requested glyphs\n");
1267 LeaveCriticalSection(&xrender_cs);
1268 goto done_unlock;
1269 }
1270
1271 TRACE("Writing %s at %d,%d\n", debugstr_wn(wstr,count),
1272 physDev->dc_rect.left + x, physDev->dc_rect.top + y);
1273
1274 if(X11DRV_XRender_Installed)
1275 {
1276 XGlyphElt16 *elts = HeapAlloc(GetProcessHeap(), 0, sizeof(XGlyphElt16) * count);
1277 INT offset = 0;
1278 POINT desired, current;
1279 int render_op = PictOpOver;
1280
1281 /* There's a bug in XRenderCompositeText that ignores the xDst and yDst parameters.
1282 So we pass zeros to the function and move to our starting position using the first
1283 element of the elts array. */
1284
1285 desired.x = physDev->dc_rect.left + x;
1286 desired.y = physDev->dc_rect.top + y;
1287 current.x = current.y = 0;
1288
1289 tile_pict = get_tile_pict(depth_type, physDev->textPixel);
1290
1291 /* FIXME the mapping of Text/BkColor onto 1 or 0 needs investigation.
1292 */
1293 if((depth_type == mono_drawable) && (textPixel == 0))
1294 render_op = PictOpOutReverse; /* This gives us 'black' text */
1295
1296 for(idx = 0; idx < count; idx++)
1297 {
1298 elts[idx].glyphset = formatEntry->glyphset;
1299 elts[idx].chars = wstr + idx;
1300 elts[idx].nchars = 1;
1301 elts[idx].xOff = desired.x - current.x;
1302 elts[idx].yOff = desired.y - current.y;
1303
1304 current.x += (elts[idx].xOff + formatEntry->gis[wstr[idx]].xOff);
1305 current.y += (elts[idx].yOff + formatEntry->gis[wstr[idx]].yOff);
1306
1307 if(!lpDx)
1308 {
1309 desired.x += formatEntry->gis[wstr[idx]].xOff;
1310 desired.y += formatEntry->gis[wstr[idx]].yOff;
1311 }
1312 else
1313 {
1314 offset += lpDx[idx];
1315 desired.x = physDev->dc_rect.left + x + offset * cosEsc;
1316 desired.y = physDev->dc_rect.top + y - offset * sinEsc;
1317 }
1318 }
1319 wine_tsx11_lock();
1320 pXRenderCompositeText16(gdi_display, render_op,
1321 tile_pict,
1322 physDev->xrender->pict,
1323 formatEntry->font_format,
1324 0, 0, 0, 0, elts, count);
1325 wine_tsx11_unlock();
1326 HeapFree(GetProcessHeap(), 0, elts);
1327 } else {
1328 INT offset = 0, xoff = 0, yoff = 0;
1329 wine_tsx11_lock();
1330 XSetForeground( gdi_display, physDev->gc, textPixel );
1331
1332 if(aa_type == AA_None || physDev->depth == 1)
1333 {
1334 void (* sharp_glyph_fn)(X11DRV_PDEVICE *, INT, INT, void *, XGlyphInfo *);
1335
1336 if(aa_type == AA_None)
1337 sharp_glyph_fn = SharpGlyphMono;
1338 else
1339 sharp_glyph_fn = SharpGlyphGray;
1340
1341 for(idx = 0; idx < count; idx++) {
1342 sharp_glyph_fn(physDev, physDev->dc_rect.left + x + xoff,
1343 physDev->dc_rect.top + y + yoff,
1344 formatEntry->bitmaps[wstr[idx]],
1345 &formatEntry->gis[wstr[idx]]);
1346 if(lpDx) {
1347 offset += lpDx[idx];
1348 xoff = offset * cosEsc;
1349 yoff = offset * -sinEsc;
1350 } else {
1351 xoff += formatEntry->gis[wstr[idx]].xOff;
1352 yoff += formatEntry->gis[wstr[idx]].yOff;
1353 }
1354 }
1355 } else {
1356 XImage *image;
1357 int image_x, image_y, image_off_x, image_off_y, image_w, image_h;
1358 RECT extents = {0, 0, 0, 0};
1359 POINT cur = {0, 0};
1360 int w = physDev->drawable_rect.right - physDev->drawable_rect.left;
1361 int h = physDev->drawable_rect.bottom - physDev->drawable_rect.top;
1362
1363 TRACE("drawable %dx%d\n", w, h);
1364
1365 for(idx = 0; idx < count; idx++) {
1366 if(extents.left > cur.x - formatEntry->gis[wstr[idx]].x)
1367 extents.left = cur.x - formatEntry->gis[wstr[idx]].x;
1368 if(extents.top > cur.y - formatEntry->gis[wstr[idx]].y)
1369 extents.top = cur.y - formatEntry->gis[wstr[idx]].y;
1370 if(extents.right < cur.x - formatEntry->gis[wstr[idx]].x + formatEntry->gis[wstr[idx]].width)
1371 extents.right = cur.x - formatEntry->gis[wstr[idx]].x + formatEntry->gis[wstr[idx]].width;
1372 if(extents.bottom < cur.y - formatEntry->gis[wstr[idx]].y + formatEntry->gis[wstr[idx]].height)
1373 extents.bottom = cur.y - formatEntry->gis[wstr[idx]].y + formatEntry->gis[wstr[idx]].height;
1374 if(lpDx) {
1375 offset += lpDx[idx];
1376 cur.x = offset * cosEsc;
1377 cur.y = offset * -sinEsc;
1378 } else {
1379 cur.x += formatEntry->gis[wstr[idx]].xOff;
1380 cur.y += formatEntry->gis[wstr[idx]].yOff;
1381 }
1382 }
1383 TRACE("glyph extents %d,%d - %d,%d drawable x,y %d,%d\n", extents.left, extents.top,
1384 extents.right, extents.bottom, physDev->dc_rect.left + x, physDev->dc_rect.top + y);
1385
1386 if(physDev->dc_rect.left + x + extents.left >= 0) {
1387 image_x = physDev->dc_rect.left + x + extents.left;
1388 image_off_x = 0;
1389 } else {
1390 image_x = 0;
1391 image_off_x = physDev->dc_rect.left + x + extents.left;
1392 }
1393 if(physDev->dc_rect.top + y + extents.top >= 0) {
1394 image_y = physDev->dc_rect.top + y + extents.top;
1395 image_off_y = 0;
1396 } else {
1397 image_y = 0;
1398 image_off_y = physDev->dc_rect.top + y + extents.top;
1399 }
1400 if(physDev->dc_rect.left + x + extents.right < w)
1401 image_w = physDev->dc_rect.left + x + extents.right - image_x;
1402 else
1403 image_w = w - image_x;
1404 if(physDev->dc_rect.top + y + extents.bottom < h)
1405 image_h = physDev->dc_rect.top + y + extents.bottom - image_y;
1406 else
1407 image_h = h - image_y;
1408
1409 if(image_w <= 0 || image_h <= 0) goto no_image;
1410
1411 X11DRV_expect_error(gdi_display, XRenderErrorHandler, NULL);
1412 image = XGetImage(gdi_display, physDev->drawable,
1413 image_x, image_y, image_w, image_h,
1414 AllPlanes, ZPixmap);
1415 X11DRV_check_error();
1416
1417 TRACE("XGetImage(%p, %x, %d, %d, %d, %d, %lx, %x) depth = %d rets %p\n",
1418 gdi_display, (int)physDev->drawable, image_x, image_y,
1419 image_w, image_h, AllPlanes, ZPixmap,
1420 physDev->depth, image);
1421 if(!image) {
1422 Pixmap xpm = XCreatePixmap(gdi_display, root_window, image_w, image_h,
1423 physDev->depth);
1424 GC gc;
1425 XGCValues gcv;
1426
1427 gcv.graphics_exposures = False;
1428 gc = XCreateGC(gdi_display, xpm, GCGraphicsExposures, &gcv);
1429 XCopyArea(gdi_display, physDev->drawable, xpm, gc, image_x, image_y,
1430 image_w, image_h, 0, 0);
1431 XFreeGC(gdi_display, gc);
1432 X11DRV_expect_error(gdi_display, XRenderErrorHandler, NULL);
1433 image = XGetImage(gdi_display, xpm, 0, 0, image_w, image_h, AllPlanes,
1434 ZPixmap);
1435 X11DRV_check_error();
1436 XFreePixmap(gdi_display, xpm);
1437 }
1438 if(!image) goto no_image;
1439
1440 image->red_mask = visual->red_mask;
1441 image->green_mask = visual->green_mask;
1442 image->blue_mask = visual->blue_mask;
1443
1444 offset = xoff = yoff = 0;
1445 for(idx = 0; idx < count; idx++) {
1446 SmoothGlyphGray(image, xoff + image_off_x - extents.left,
1447 yoff + image_off_y - extents.top,
1448 formatEntry->bitmaps[wstr[idx]],
1449 &formatEntry->gis[wstr[idx]],
1450 physDev->textPixel);
1451 if(lpDx) {
1452 offset += lpDx[idx];
1453 xoff = offset * cosEsc;
1454 yoff = offset * -sinEsc;
1455 } else {
1456 xoff += formatEntry->gis[wstr[idx]].xOff;
1457 yoff += formatEntry->gis[wstr[idx]].yOff;
1458 }
1459 }
1460 XPutImage(gdi_display, physDev->drawable, physDev->gc, image, 0, 0,
1461 image_x, image_y, image_w, image_h);
1462 XDestroyImage(image);
1463 }
1464 no_image:
1465 wine_tsx11_unlock();
1466 }
1467 LeaveCriticalSection(&xrender_cs);
1468
1469 if (flags & ETO_CLIPPED)
1470 {
1471 /* restore the device region */
1472 X11DRV_SetDeviceClipping( physDev, saved_region, 0 );
1473 DeleteObject( saved_region );
1474 }
1475
1476 retv = TRUE;
1477
1478 done_unlock:
1479 X11DRV_UnlockDIBSection( physDev, TRUE );
1480 return retv;
1481 }
1482
1483 /******************************************************************************
1484 * AlphaBlend (x11drv.@)
1485 */
1486 BOOL X11DRV_AlphaBlend(X11DRV_PDEVICE *devDst, INT xDst, INT yDst, INT widthDst, INT heightDst,
1487 X11DRV_PDEVICE *devSrc, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc,
1488 BLENDFUNCTION blendfn)
1489 {
1490 XRenderPictureAttributes pa;
1491 XRenderPictFormat *src_format;
1492 XRenderPictFormat argb32_templ = {
1493 0, /* id */
1494 PictTypeDirect, /* type */
1495 32, /* depth */
1496 { /* direct */
1497 16, /* direct.red */
1498 0xff, /* direct.redMask */
1499 8, /* direct.green */
1500 0xff, /* direct.greenMask */
1501 0, /* direct.blue */
1502 0xff, /* direct.blueMask */
1503 24, /* direct.alpha */
1504 0xff, /* direct.alphaMask */
1505 },
1506 0, /* colormap */
1507 };
1508 unsigned long argb32_templ_mask =
1509 PictFormatType |
1510 PictFormatDepth |
1511 PictFormatRed |
1512 PictFormatRedMask |
1513 PictFormatGreen |
1514 PictFormatGreenMask |
1515 PictFormatBlue |
1516 PictFormatBlueMask |
1517 PictFormatAlpha |
1518 PictFormatAlphaMask;
1519
1520 Picture dst_pict, src_pict;
1521 Pixmap xpm;
1522 DIBSECTION dib;
1523 XImage *image;
1524 GC gc;
1525 XGCValues gcv;
1526 DWORD *dstbits, *data;
1527 int y, y2;
1528 POINT pts[2];
1529 BOOL top_down = FALSE;
1530 RGNDATA *rgndata;
1531 enum drawable_depth_type dst_depth_type = (devDst->depth == 1) ? mono_drawable : color_drawable;
1532
1533 if(!X11DRV_XRender_Installed) {
1534 FIXME("Unable to AlphaBlend without Xrender\n");
1535 return FALSE;
1536 }
1537 pts[0].x = xDst;
1538 pts[0].y = yDst;
1539 pts[1].x = xDst + widthDst;
1540 pts[1].y = yDst + heightDst;
1541 LPtoDP(devDst->hdc, pts, 2);
1542 xDst = pts[0].x;
1543 yDst = pts[0].y;
1544 widthDst = pts[1].x - pts[0].x;
1545 heightDst = pts[1].y - pts[0].y;
1546
1547 pts[0].x = xSrc;
1548 pts[0].y = ySrc;
1549 pts[1].x = xSrc + widthSrc;
1550 pts[1].y = ySrc + heightSrc;
1551 LPtoDP(devSrc->hdc, pts, 2);
1552 xSrc = pts[0].x;
1553 ySrc = pts[0].y;
1554 widthSrc = pts[1].x - pts[0].x;
1555 heightSrc = pts[1].y - pts[0].y;
1556 if (!widthDst || !heightDst || !widthSrc || !heightSrc) return TRUE;
1557
1558 #ifndef HAVE_XRENDERSETPICTURETRANSFORM
1559 if(widthDst != widthSrc || heightDst != heightSrc)
1560 #else
1561 if(!pXRenderSetPictureTransform)
1562 #endif
1563 {
1564 FIXME("Unable to Stretch, XRenderSetPictureTransform is currently required\n");
1565 return FALSE;
1566 }
1567
1568 if (!devSrc->bitmap || GetObjectW( devSrc->bitmap->hbitmap, sizeof(dib), &dib ) != sizeof(dib))
1569 {
1570 static BOOL out = FALSE;
1571 if (!out)
1572 {
1573 FIXME("not a dibsection\n");
1574 out = TRUE;
1575 }
1576 return FALSE;
1577 }
1578
1579 if (xSrc < 0 || ySrc < 0 || widthSrc < 0 || heightSrc < 0 || xSrc + widthSrc > dib.dsBmih.biWidth
1580 || ySrc + heightSrc > abs(dib.dsBmih.biHeight))
1581 {
1582 WARN("Invalid src coords: (%d,%d), size %dx%d\n", xSrc, ySrc, widthSrc, heightSrc);
1583 SetLastError(ERROR_INVALID_PARAMETER);
1584 return FALSE;
1585 }
1586
1587 if ((blendfn.AlphaFormat & AC_SRC_ALPHA) && blendfn.SourceConstantAlpha != 0xff)
1588 FIXME("Ignoring SourceConstantAlpha %d for AC_SRC_ALPHA\n", blendfn.SourceConstantAlpha);
1589
1590 if(dib.dsBm.bmBitsPixel != 32) {
1591 FIXME("not a 32 bpp dibsection\n");
1592 return FALSE;
1593 }
1594 dstbits = data = HeapAlloc(GetProcessHeap(), 0, heightSrc * widthSrc * 4);
1595
1596 if(dib.dsBmih.biHeight < 0) { /* top-down dib */
1597 top_down = TRUE;
1598 dstbits += widthSrc * (heightSrc - 1);
1599 y2 = ySrc;
1600 y = y2 + heightSrc - 1;
1601 }
1602 else
1603 {
1604 y = dib.dsBmih.biHeight - ySrc - 1;
1605 y2 = y - heightSrc + 1;
1606 }
1607
1608 if (blendfn.AlphaFormat & AC_SRC_ALPHA)
1609 {
1610 for(; y >= y2; y--)
1611 {
1612 memcpy(dstbits, (char *)dib.dsBm.bmBits + y * dib.dsBm.bmWidthBytes + xSrc * 4,
1613 widthSrc * 4);
1614 dstbits += (top_down ? -1 : 1) * widthSrc;
1615 }
1616 }
1617 else
1618 {
1619 DWORD source_alpha = (DWORD)blendfn.SourceConstantAlpha << 24;
1620 int x;
1621
1622 for(; y >= y2; y--)
1623 {
1624 DWORD *srcbits = (DWORD *)((char *)dib.dsBm.bmBits + y * dib.dsBm.bmWidthBytes) + xSrc;
1625 for (x = 0; x < widthSrc; x++)
1626 {
1627 DWORD argb = *srcbits++;
1628 argb = (argb & 0xffffff) | source_alpha;
1629 *dstbits++ = argb;
1630 }
1631 if (top_down) /* we traversed the row forward so we should go back by two rows */
1632 dstbits -= 2 * widthSrc;
1633 }
1634
1635 }
1636
1637 rgndata = X11DRV_GetRegionData( devDst->region, 0 );
1638
1639 wine_tsx11_lock();
1640 image = XCreateImage(gdi_display, visual, 32, ZPixmap, 0,
1641 (char*) data, widthSrc, heightSrc, 32, widthSrc * 4);
1642
1643 /*
1644 Avoid using XRenderFindStandardFormat as older libraries don't have it
1645 src_format = pXRenderFindStandardFormat(gdi_display, PictStandardARGB32);
1646 */
1647 src_format = pXRenderFindFormat(gdi_display, argb32_templ_mask, &argb32_templ, 0);
1648
1649 TRACE("src_format %p\n", src_format);
1650
1651 pa.subwindow_mode = IncludeInferiors;
1652
1653 /* FIXME use devDst->xrender->pict ? */
1654 dst_pict = pXRenderCreatePicture(gdi_display,
1655 devDst->drawable,
1656 pict_formats[dst_depth_type],
1657 CPSubwindowMode, &pa);
1658 TRACE("dst_pict %08lx\n", dst_pict);
1659 TRACE("src_drawable = %08lx\n", devSrc->drawable);
1660 xpm = XCreatePixmap(gdi_display,
1661 root_window,
1662 widthSrc, heightSrc, 32);
1663 gcv.graphics_exposures = False;
1664 gc = XCreateGC(gdi_display, xpm, GCGraphicsExposures, &gcv);
1665 TRACE("xpm = %08lx\n", xpm);
1666 XPutImage(gdi_display, xpm, gc, image, 0, 0, 0, 0, widthSrc, heightSrc);
1667
1668 src_pict = pXRenderCreatePicture(gdi_display,
1669 xpm, src_format,
1670 CPSubwindowMode, &pa);
1671 TRACE("src_pict %08lx\n", src_pict);
1672
1673 if (rgndata)
1674 {
1675 pXRenderSetPictureClipRectangles( gdi_display, dst_pict,
1676 devDst->dc_rect.left, devDst->dc_rect.top,
1677 (XRectangle *)rgndata->Buffer,
1678 rgndata->rdh.nCount );
1679 HeapFree( GetProcessHeap(), 0, rgndata );
1680 }
1681
1682 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
1683 if(widthDst != widthSrc || heightDst != heightSrc) {
1684 double xscale = widthSrc/(double)widthDst;
1685 double yscale = heightSrc/(double)heightDst;
1686 XTransform xform = {{
1687 { XDoubleToFixed(xscale), XDoubleToFixed(0), XDoubleToFixed(0) },
1688 { XDoubleToFixed(0), XDoubleToFixed(yscale), XDoubleToFixed(0) },
1689 { XDoubleToFixed(0), XDoubleToFixed(0), XDoubleToFixed(1) }
1690 }};
1691 pXRenderSetPictureTransform(gdi_display, src_pict, &xform);
1692 }
1693 #endif
1694 pXRenderComposite(gdi_display, PictOpOver, src_pict, 0, dst_pict,
1695 0, 0, 0, 0,
1696 xDst + devDst->dc_rect.left, yDst + devDst->dc_rect.top, widthDst, heightDst);
1697
1698
1699 pXRenderFreePicture(gdi_display, src_pict);
1700 XFreePixmap(gdi_display, xpm);
1701 XFreeGC(gdi_display, gc);
1702 pXRenderFreePicture(gdi_display, dst_pict);
1703 image->data = NULL;
1704 XDestroyImage(image);
1705
1706 wine_tsx11_unlock();
1707 HeapFree(GetProcessHeap(), 0, data);
1708 return TRUE;
1709 }
1710
1711 #else /* SONAME_LIBXRENDER */
1712
1713 void X11DRV_XRender_Init(void)
1714 {
1715 TRACE("XRender support not compiled in.\n");
1716 return;
1717 }
1718
1719 void X11DRV_XRender_Finalize(void)
1720 {
1721 }
1722
1723 BOOL X11DRV_XRender_SelectFont(X11DRV_PDEVICE *physDev, HFONT hfont)
1724 {
1725 assert(0);
1726 return FALSE;
1727 }
1728
1729 void X11DRV_XRender_DeleteDC(X11DRV_PDEVICE *physDev)
1730 {
1731 assert(0);
1732 return;
1733 }
1734
1735 BOOL X11DRV_XRender_ExtTextOut( X11DRV_PDEVICE *physDev, INT x, INT y, UINT flags,
1736 const RECT *lprect, LPCWSTR wstr, UINT count,
1737 const INT *lpDx )
1738 {
1739 assert(0);
1740 return FALSE;
1741 }
1742
1743 void X11DRV_XRender_UpdateDrawable(X11DRV_PDEVICE *physDev)
1744 {
1745 assert(0);
1746 return;
1747 }
1748
1749 /******************************************************************************
1750 * AlphaBlend (x11drv.@)
1751 */
1752 BOOL X11DRV_AlphaBlend(X11DRV_PDEVICE *devDst, INT xDst, INT yDst, INT widthDst, INT heightDst,
1753 X11DRV_PDEVICE *devSrc, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc,
1754 BLENDFUNCTION blendfn)
1755 {
1756 FIXME("not supported - XRENDER headers were missing at compile time\n");
1757 return FALSE;
1758 }
1759
1760 #endif /* SONAME_LIBXRENDER */
useful hacks and other patches not (yet) suitable for mainline