?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
save old text color during a call of DrawCaptionTempW
[wine/kumbayo.git] / dlls / winex11.drv / xrender.c
blobc5b4af57745487ce7241a4171bf34ead80c2babc
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 strcat(output, "\n");
750 TRACE(output);
751 }
752 } else {
753 static const char blks[] = " .:;!o*#";
754 char str[2];
755
756 str[1] = '\0';
757 pitch = ((gi.width + 3) / 4) * 4;
758 for(i = 0; i < gi.height; i++) {
759 line = (unsigned char*) buf + i * pitch;
760 output[0] = '\0';
761 for(j = 0; j < pitch; j++) {
762 str[0] = blks[line[j] >> 5];
763 strcat(output, str);
764 }
765 strcat(output, "\n");
766 TRACE(output);
767 }
768 }
769 }
770
771
772 if(formatEntry->glyphset) {
773 if(format == AA_None && BitmapBitOrder(gdi_display) != MSBFirst) {
774 unsigned char *byte = (unsigned char*) buf, c;
775 int i = buflen;
776
777 while(i--) {
778 c = *byte;
779
780 /* magic to flip bit order */
781 c = ((c << 1) & 0xaa) | ((c >> 1) & 0x55);
782 c = ((c << 2) & 0xcc) | ((c >> 2) & 0x33);
783 c = ((c << 4) & 0xf0) | ((c >> 4) & 0x0f);
784
785 *byte++ = c;
786 }
787 }
788 gid = glyph;
789
790 /*
791 XRenderCompositeText seems to ignore 0x0 glyphs when
792 AA_None, which means we lose the advance width of glyphs
793 like the space. We'll pretend that such glyphs are 1x1
794 bitmaps.
795 */
796
797 if(buflen == 0)
798 gi.width = gi.height = 1;
799
800 wine_tsx11_lock();
801 pXRenderAddGlyphs(gdi_display, formatEntry->glyphset, &gid, &gi, 1,
802 buflen ? buf : zero, buflen ? buflen : sizeof(zero));
803 wine_tsx11_unlock();
804 HeapFree(GetProcessHeap(), 0, buf);
805 } else {
806 formatEntry->bitmaps[glyph] = buf;
807 }
808
809 memcpy(&formatEntry->gis[glyph], &gi, sizeof(gi));
810
811 return TRUE;
812 }
813
814 static void SharpGlyphMono(X11DRV_PDEVICE *physDev, INT x, INT y,
815 void *bitmap, XGlyphInfo *gi)
816 {
817 unsigned char *srcLine = bitmap, *src;
818 unsigned char bits, bitsMask;
819 int width = gi->width;
820 int stride = ((width + 31) & ~31) >> 3;
821 int height = gi->height;
822 int w;
823 int xspan, lenspan;
824
825 TRACE("%d, %d\n", x, y);
826 x -= gi->x;
827 y -= gi->y;
828 while (height--)
829 {
830 src = srcLine;
831 srcLine += stride;
832 w = width;
833
834 bitsMask = 0x80; /* FreeType is always MSB first */
835 bits = *src++;
836
837 xspan = x;
838 while (w)
839 {
840 if (bits & bitsMask)
841 {
842 lenspan = 0;
843 do
844 {
845 lenspan++;
846 if (lenspan == w)
847 break;
848 bitsMask = bitsMask >> 1;
849 if (!bitsMask)
850 {
851 bits = *src++;
852 bitsMask = 0x80;
853 }
854 } while (bits & bitsMask);
855 XFillRectangle (gdi_display, physDev->drawable,
856 physDev->gc, xspan, y, lenspan, 1);
857 xspan += lenspan;
858 w -= lenspan;
859 }
860 else
861 {
862 do
863 {
864 w--;
865 xspan++;
866 if (!w)
867 break;
868 bitsMask = bitsMask >> 1;
869 if (!bitsMask)
870 {
871 bits = *src++;
872 bitsMask = 0x80;
873 }
874 } while (!(bits & bitsMask));
875 }
876 }
877 y++;
878 }
879 }
880
881 static void SharpGlyphGray(X11DRV_PDEVICE *physDev, INT x, INT y,
882 void *bitmap, XGlyphInfo *gi)
883 {
884 unsigned char *srcLine = bitmap, *src, bits;
885 int width = gi->width;
886 int stride = ((width + 3) & ~3);
887 int height = gi->height;
888 int w;
889 int xspan, lenspan;
890
891 x -= gi->x;
892 y -= gi->y;
893 while (height--)
894 {
895 src = srcLine;
896 srcLine += stride;
897 w = width;
898
899 bits = *src++;
900 xspan = x;
901 while (w)
902 {
903 if (bits >= 0x80)
904 {
905 lenspan = 0;
906 do
907 {
908 lenspan++;
909 if (lenspan == w)
910 break;
911 bits = *src++;
912 } while (bits >= 0x80);
913 XFillRectangle (gdi_display, physDev->drawable,
914 physDev->gc, xspan, y, lenspan, 1);
915 xspan += lenspan;
916 w -= lenspan;
917 }
918 else
919 {
920 do
921 {
922 w--;
923 xspan++;
924 if (!w)
925 break;
926 bits = *src++;
927 } while (bits < 0x80);
928 }
929 }
930 y++;
931 }
932 }
933
934
935 static void ExamineBitfield (DWORD mask, int *shift, int *len)
936 {
937 int s, l;
938
939 s = 0;
940 while ((mask & 1) == 0)
941 {
942 mask >>= 1;
943 s++;
944 }
945 l = 0;
946 while ((mask & 1) == 1)
947 {
948 mask >>= 1;
949 l++;
950 }
951 *shift = s;
952 *len = l;
953 }
954
955 static DWORD GetField (DWORD pixel, int shift, int len)
956 {
957 pixel = pixel & (((1 << (len)) - 1) << shift);
958 pixel = pixel << (32 - (shift + len)) >> 24;
959 while (len < 8)
960 {
961 pixel |= (pixel >> len);
962 len <<= 1;
963 }
964 return pixel;
965 }
966
967
968 static DWORD PutField (DWORD pixel, int shift, int len)
969 {
970 shift = shift - (8 - len);
971 if (len <= 8)
972 pixel &= (((1 << len) - 1) << (8 - len));
973 if (shift < 0)
974 pixel >>= -shift;
975 else
976 pixel <<= shift;
977 return pixel;
978 }
979
980 static void SmoothGlyphGray(XImage *image, int x, int y, void *bitmap, XGlyphInfo *gi,
981 int color)
982 {
983 int r_shift, r_len;
984 int g_shift, g_len;
985 int b_shift, b_len;
986 BYTE *maskLine, *mask, m;
987 int maskStride;
988 DWORD pixel;
989 int width, height;
990 int w, tx;
991 BYTE src_r, src_g, src_b;
992
993 x -= gi->x;
994 y -= gi->y;
995 width = gi->width;
996 height = gi->height;
997
998 maskLine = (unsigned char *) bitmap;
999 maskStride = (width + 3) & ~3;
1000
1001 ExamineBitfield (image->red_mask, &r_shift, &r_len);
1002 ExamineBitfield (image->green_mask, &g_shift, &g_len);
1003 ExamineBitfield (image->blue_mask, &b_shift, &b_len);
1004
1005 src_r = GetField(color, r_shift, r_len);
1006 src_g = GetField(color, g_shift, g_len);
1007 src_b = GetField(color, b_shift, b_len);
1008
1009 for(; height--; y++)
1010 {
1011 mask = maskLine;
1012 maskLine += maskStride;
1013 w = width;
1014 tx = x;
1015
1016 if(y < 0) continue;
1017 if(y >= image->height) break;
1018
1019 for(; w--; tx++)
1020 {
1021 if(tx >= image->width) break;
1022
1023 m = *mask++;
1024 if(tx < 0) continue;
1025
1026 if (m == 0xff)
1027 XPutPixel (image, tx, y, color);
1028 else if (m)
1029 {
1030 BYTE r, g, b;
1031
1032 pixel = XGetPixel (image, tx, y);
1033
1034 r = GetField(pixel, r_shift, r_len);
1035 r = ((BYTE)~m * (WORD)r + (BYTE)m * (WORD)src_r) >> 8;
1036 g = GetField(pixel, g_shift, g_len);
1037 g = ((BYTE)~m * (WORD)g + (BYTE)m * (WORD)src_g) >> 8;
1038 b = GetField(pixel, b_shift, b_len);
1039 b = ((BYTE)~m * (WORD)b + (BYTE)m * (WORD)src_b) >> 8;
1040
1041 pixel = (PutField (r, r_shift, r_len) |
1042 PutField (g, g_shift, g_len) |
1043 PutField (b, b_shift, b_len));
1044 XPutPixel (image, tx, y, pixel);
1045 }
1046 }
1047 }
1048 }
1049
1050 /*************************************************************
1051 * get_tile_pict
1052 *
1053 * Returns an appropiate Picture for tiling the text colour.
1054 * Call and use result within the xrender_cs
1055 */
1056 static Picture get_tile_pict(enum drawable_depth_type type, int text_pixel)
1057 {
1058 static struct
1059 {
1060 Pixmap xpm;
1061 Picture pict;
1062 int current_color;
1063 } tiles[2], *tile;
1064 XRenderColor col;
1065
1066 tile = &tiles[type];
1067
1068 if(!tile->xpm)
1069 {
1070 XRenderPictureAttributes pa;
1071
1072 wine_tsx11_lock();
1073 tile->xpm = XCreatePixmap(gdi_display, root_window, 1, 1, pict_formats[type]->depth);
1074
1075 pa.repeat = True;
1076 tile->pict = pXRenderCreatePicture(gdi_display, tile->xpm, pict_formats[type], CPRepeat, &pa);
1077 wine_tsx11_unlock();
1078
1079 /* init current_color to something different from text_pixel */
1080 tile->current_color = ~text_pixel;
1081
1082 if(type == mono_drawable)
1083 {
1084 /* for a 1bpp bitmap we always need a 1 in the tile */
1085 col.red = col.green = col.blue = 0;
1086 col.alpha = 0xffff;
1087 wine_tsx11_lock();
1088 pXRenderFillRectangle(gdi_display, PictOpSrc, tile->pict, &col, 0, 0, 1, 1);
1089 wine_tsx11_unlock();
1090 }
1091 }
1092
1093 if(text_pixel != tile->current_color && type == color_drawable)
1094 {
1095 /* Map 0 -- 0xff onto 0 -- 0xffff */
1096 int r_shift, r_len;
1097 int g_shift, g_len;
1098 int b_shift, b_len;
1099
1100 ExamineBitfield (visual->red_mask, &r_shift, &r_len );
1101 ExamineBitfield (visual->green_mask, &g_shift, &g_len);
1102 ExamineBitfield (visual->blue_mask, &b_shift, &b_len);
1103
1104 col.red = GetField(text_pixel, r_shift, r_len);
1105 col.red |= col.red << 8;
1106 col.green = GetField(text_pixel, g_shift, g_len);
1107 col.green |= col.green << 8;
1108 col.blue = GetField(text_pixel, b_shift, b_len);
1109 col.blue |= col.blue << 8;
1110 col.alpha = 0x0;
1111
1112 wine_tsx11_lock();
1113 pXRenderFillRectangle(gdi_display, PictOpSrc, tile->pict, &col, 0, 0, 1, 1);
1114 wine_tsx11_unlock();
1115 tile->current_color = text_pixel;
1116 }
1117 return tile->pict;
1118 }
1119
1120 static int XRenderErrorHandler(Display *dpy, XErrorEvent *event, void *arg)
1121 {
1122 return 1;
1123 }
1124
1125 /***********************************************************************
1126 * X11DRV_XRender_ExtTextOut
1127 */
1128 BOOL X11DRV_XRender_ExtTextOut( X11DRV_PDEVICE *physDev, INT x, INT y, UINT flags,
1129 const RECT *lprect, LPCWSTR wstr, UINT count,
1130 const INT *lpDx )
1131 {
1132 RGNDATA *data;
1133 XGCValues xgcval;
1134 gsCacheEntry *entry;
1135 gsCacheEntryFormat *formatEntry;
1136 BOOL retv = FALSE;
1137 HDC hdc = physDev->hdc;
1138 int textPixel, backgroundPixel;
1139 HRGN saved_region = 0;
1140 BOOL disable_antialias = FALSE;
1141 AA_Type aa_type = AA_None;
1142 DIBSECTION bmp;
1143 unsigned int idx;
1144 double cosEsc, sinEsc;
1145 LOGFONTW lf;
1146 enum drawable_depth_type depth_type = (physDev->depth == 1) ? mono_drawable : color_drawable;
1147 Picture tile_pict = 0;
1148
1149 /* Do we need to disable antialiasing because of palette mode? */
1150 if( !physDev->bitmap || GetObjectW( physDev->bitmap->hbitmap, sizeof(bmp), &bmp ) != sizeof(bmp) ) {
1151 TRACE("bitmap is not a DIB\n");
1152 }
1153 else if (bmp.dsBmih.biBitCount <= 8) {
1154 TRACE("Disabling antialiasing\n");
1155 disable_antialias = TRUE;
1156 }
1157
1158 xgcval.function = GXcopy;
1159 xgcval.background = physDev->backgroundPixel;
1160 xgcval.fill_style = FillSolid;
1161 wine_tsx11_lock();
1162 XChangeGC( gdi_display, physDev->gc, GCFunction | GCBackground | GCFillStyle, &xgcval );
1163 wine_tsx11_unlock();
1164
1165 X11DRV_LockDIBSection( physDev, DIB_Status_GdiMod );
1166
1167 if(physDev->depth == 1) {
1168 if((physDev->textPixel & 0xffffff) == 0) {
1169 textPixel = 0;
1170 backgroundPixel = 1;
1171 } else {
1172 textPixel = 1;
1173 backgroundPixel = 0;
1174 }
1175 } else {
1176 textPixel = physDev->textPixel;
1177 backgroundPixel = physDev->backgroundPixel;
1178 }
1179
1180 if(flags & ETO_OPAQUE)
1181 {
1182 wine_tsx11_lock();
1183 XSetForeground( gdi_display, physDev->gc, backgroundPixel );
1184 XFillRectangle( gdi_display, physDev->drawable, physDev->gc,
1185 physDev->dc_rect.left + lprect->left, physDev->dc_rect.top + lprect->top,
1186 lprect->right - lprect->left, lprect->bottom - lprect->top );
1187 wine_tsx11_unlock();
1188 }
1189
1190 if(count == 0)
1191 {
1192 retv = TRUE;
1193 goto done_unlock;
1194 }
1195
1196
1197 GetObjectW(GetCurrentObject(physDev->hdc, OBJ_FONT), sizeof(lf), &lf);
1198 if(lf.lfEscapement != 0) {
1199 cosEsc = cos(lf.lfEscapement * M_PI / 1800);
1200 sinEsc = sin(lf.lfEscapement * M_PI / 1800);
1201 } else {
1202 cosEsc = 1;
1203 sinEsc = 0;
1204 }
1205
1206 if (flags & ETO_CLIPPED)
1207 {
1208 HRGN clip_region;
1209
1210 clip_region = CreateRectRgnIndirect( lprect );
1211 /* make a copy of the current device region */
1212 saved_region = CreateRectRgn( 0, 0, 0, 0 );
1213 CombineRgn( saved_region, physDev->region, 0, RGN_COPY );
1214 X11DRV_SetDeviceClipping( physDev, saved_region, clip_region );
1215 DeleteObject( clip_region );
1216 }
1217
1218 if(X11DRV_XRender_Installed) {
1219 if(!physDev->xrender->pict) {
1220 XRenderPictureAttributes pa;
1221 pa.subwindow_mode = IncludeInferiors;
1222
1223 wine_tsx11_lock();
1224 physDev->xrender->pict = pXRenderCreatePicture(gdi_display,
1225 physDev->drawable,
1226 pict_formats[depth_type],
1227 CPSubwindowMode, &pa);
1228 wine_tsx11_unlock();
1229
1230 TRACE("allocing pict = %lx dc = %p drawable = %08lx\n",
1231 physDev->xrender->pict, hdc, physDev->drawable);
1232 } else {
1233 TRACE("using existing pict = %lx dc = %p drawable = %08lx\n",
1234 physDev->xrender->pict, hdc, physDev->drawable);
1235 }
1236
1237 if ((data = X11DRV_GetRegionData( physDev->region, 0 )))
1238 {
1239 wine_tsx11_lock();
1240 pXRenderSetPictureClipRectangles( gdi_display, physDev->xrender->pict,
1241 physDev->dc_rect.left, physDev->dc_rect.top,
1242 (XRectangle *)data->Buffer, data->rdh.nCount );
1243 wine_tsx11_unlock();
1244 HeapFree( GetProcessHeap(), 0, data );
1245 }
1246 }
1247
1248 EnterCriticalSection(&xrender_cs);
1249
1250 entry = glyphsetCache + physDev->xrender->cache_index;
1251 if( disable_antialias == FALSE )
1252 aa_type = entry->aa_default;
1253 formatEntry = entry->format[aa_type];
1254
1255 for(idx = 0; idx < count; idx++) {
1256 if( !formatEntry ) {
1257 UploadGlyph(physDev, wstr[idx], aa_type);
1258 /* re-evaluate antialias since aa_default may have changed */
1259 if( disable_antialias == FALSE )
1260 aa_type = entry->aa_default;
1261 formatEntry = entry->format[aa_type];
1262 } else if( wstr[idx] >= formatEntry->nrealized || formatEntry->realized[wstr[idx]] == FALSE) {
1263 UploadGlyph(physDev, wstr[idx], aa_type);
1264 }
1265 }
1266 if (!formatEntry)
1267 {
1268 WARN("could not upload requested glyphs\n");
1269 LeaveCriticalSection(&xrender_cs);
1270 goto done_unlock;
1271 }
1272
1273 TRACE("Writing %s at %d,%d\n", debugstr_wn(wstr,count),
1274 physDev->dc_rect.left + x, physDev->dc_rect.top + y);
1275
1276 if(X11DRV_XRender_Installed)
1277 {
1278 XGlyphElt16 *elts = HeapAlloc(GetProcessHeap(), 0, sizeof(XGlyphElt16) * count);
1279 INT offset = 0;
1280 POINT desired, current;
1281 int render_op = PictOpOver;
1282
1283 /* There's a bug in XRenderCompositeText that ignores the xDst and yDst parameters.
1284 So we pass zeros to the function and move to our starting position using the first
1285 element of the elts array. */
1286
1287 desired.x = physDev->dc_rect.left + x;
1288 desired.y = physDev->dc_rect.top + y;
1289 current.x = current.y = 0;
1290
1291 tile_pict = get_tile_pict(depth_type, physDev->textPixel);
1292
1293 /* FIXME the mapping of Text/BkColor onto 1 or 0 needs investigation.
1294 */
1295 if((depth_type == mono_drawable) && (textPixel == 0))
1296 render_op = PictOpOutReverse; /* This gives us 'black' text */
1297
1298 for(idx = 0; idx < count; idx++)
1299 {
1300 elts[idx].glyphset = formatEntry->glyphset;
1301 elts[idx].chars = wstr + idx;
1302 elts[idx].nchars = 1;
1303 elts[idx].xOff = desired.x - current.x;
1304 elts[idx].yOff = desired.y - current.y;
1305
1306 current.x += (elts[idx].xOff + formatEntry->gis[wstr[idx]].xOff);
1307 current.y += (elts[idx].yOff + formatEntry->gis[wstr[idx]].yOff);
1308
1309 if(!lpDx)
1310 {
1311 desired.x += formatEntry->gis[wstr[idx]].xOff;
1312 desired.y += formatEntry->gis[wstr[idx]].yOff;
1313 }
1314 else
1315 {
1316 offset += lpDx[idx];
1317 desired.x = physDev->dc_rect.left + x + offset * cosEsc;
1318 desired.y = physDev->dc_rect.top + y - offset * sinEsc;
1319 }
1320 }
1321 wine_tsx11_lock();
1322 pXRenderCompositeText16(gdi_display, render_op,
1323 tile_pict,
1324 physDev->xrender->pict,
1325 formatEntry->font_format,
1326 0, 0, 0, 0, elts, count);
1327 wine_tsx11_unlock();
1328 HeapFree(GetProcessHeap(), 0, elts);
1329 } else {
1330 INT offset = 0, xoff = 0, yoff = 0;
1331 wine_tsx11_lock();
1332 XSetForeground( gdi_display, physDev->gc, textPixel );
1333
1334 if(aa_type == AA_None || physDev->depth == 1)
1335 {
1336 void (* sharp_glyph_fn)(X11DRV_PDEVICE *, INT, INT, void *, XGlyphInfo *);
1337
1338 if(aa_type == AA_None)
1339 sharp_glyph_fn = SharpGlyphMono;
1340 else
1341 sharp_glyph_fn = SharpGlyphGray;
1342
1343 for(idx = 0; idx < count; idx++) {
1344 sharp_glyph_fn(physDev, physDev->dc_rect.left + x + xoff,
1345 physDev->dc_rect.top + y + yoff,
1346 formatEntry->bitmaps[wstr[idx]],
1347 &formatEntry->gis[wstr[idx]]);
1348 if(lpDx) {
1349 offset += lpDx[idx];
1350 xoff = offset * cosEsc;
1351 yoff = offset * -sinEsc;
1352 } else {
1353 xoff += formatEntry->gis[wstr[idx]].xOff;
1354 yoff += formatEntry->gis[wstr[idx]].yOff;
1355 }
1356 }
1357 } else {
1358 XImage *image;
1359 int image_x, image_y, image_off_x, image_off_y, image_w, image_h;
1360 RECT extents = {0, 0, 0, 0};
1361 POINT cur = {0, 0};
1362 int w = physDev->drawable_rect.right - physDev->drawable_rect.left;
1363 int h = physDev->drawable_rect.bottom - physDev->drawable_rect.top;
1364
1365 TRACE("drawable %dx%d\n", w, h);
1366
1367 for(idx = 0; idx < count; idx++) {
1368 if(extents.left > cur.x - formatEntry->gis[wstr[idx]].x)
1369 extents.left = cur.x - formatEntry->gis[wstr[idx]].x;
1370 if(extents.top > cur.y - formatEntry->gis[wstr[idx]].y)
1371 extents.top = cur.y - formatEntry->gis[wstr[idx]].y;
1372 if(extents.right < cur.x - formatEntry->gis[wstr[idx]].x + formatEntry->gis[wstr[idx]].width)
1373 extents.right = cur.x - formatEntry->gis[wstr[idx]].x + formatEntry->gis[wstr[idx]].width;
1374 if(extents.bottom < cur.y - formatEntry->gis[wstr[idx]].y + formatEntry->gis[wstr[idx]].height)
1375 extents.bottom = cur.y - formatEntry->gis[wstr[idx]].y + formatEntry->gis[wstr[idx]].height;
1376 if(lpDx) {
1377 offset += lpDx[idx];
1378 cur.x = offset * cosEsc;
1379 cur.y = offset * -sinEsc;
1380 } else {
1381 cur.x += formatEntry->gis[wstr[idx]].xOff;
1382 cur.y += formatEntry->gis[wstr[idx]].yOff;
1383 }
1384 }
1385 TRACE("glyph extents %d,%d - %d,%d drawable x,y %d,%d\n", extents.left, extents.top,
1386 extents.right, extents.bottom, physDev->dc_rect.left + x, physDev->dc_rect.top + y);
1387
1388 if(physDev->dc_rect.left + x + extents.left >= 0) {
1389 image_x = physDev->dc_rect.left + x + extents.left;
1390 image_off_x = 0;
1391 } else {
1392 image_x = 0;
1393 image_off_x = physDev->dc_rect.left + x + extents.left;
1394 }
1395 if(physDev->dc_rect.top + y + extents.top >= 0) {
1396 image_y = physDev->dc_rect.top + y + extents.top;
1397 image_off_y = 0;
1398 } else {
1399 image_y = 0;
1400 image_off_y = physDev->dc_rect.top + y + extents.top;
1401 }
1402 if(physDev->dc_rect.left + x + extents.right < w)
1403 image_w = physDev->dc_rect.left + x + extents.right - image_x;
1404 else
1405 image_w = w - image_x;
1406 if(physDev->dc_rect.top + y + extents.bottom < h)
1407 image_h = physDev->dc_rect.top + y + extents.bottom - image_y;
1408 else
1409 image_h = h - image_y;
1410
1411 if(image_w <= 0 || image_h <= 0) goto no_image;
1412
1413 X11DRV_expect_error(gdi_display, XRenderErrorHandler, NULL);
1414 image = XGetImage(gdi_display, physDev->drawable,
1415 image_x, image_y, image_w, image_h,
1416 AllPlanes, ZPixmap);
1417 X11DRV_check_error();
1418
1419 TRACE("XGetImage(%p, %x, %d, %d, %d, %d, %lx, %x) depth = %d rets %p\n",
1420 gdi_display, (int)physDev->drawable, image_x, image_y,
1421 image_w, image_h, AllPlanes, ZPixmap,
1422 physDev->depth, image);
1423 if(!image) {
1424 Pixmap xpm = XCreatePixmap(gdi_display, root_window, image_w, image_h,
1425 physDev->depth);
1426 GC gc;
1427 XGCValues gcv;
1428
1429 gcv.graphics_exposures = False;
1430 gc = XCreateGC(gdi_display, xpm, GCGraphicsExposures, &gcv);
1431 XCopyArea(gdi_display, physDev->drawable, xpm, gc, image_x, image_y,
1432 image_w, image_h, 0, 0);
1433 XFreeGC(gdi_display, gc);
1434 X11DRV_expect_error(gdi_display, XRenderErrorHandler, NULL);
1435 image = XGetImage(gdi_display, xpm, 0, 0, image_w, image_h, AllPlanes,
1436 ZPixmap);
1437 X11DRV_check_error();
1438 XFreePixmap(gdi_display, xpm);
1439 }
1440 if(!image) goto no_image;
1441
1442 image->red_mask = visual->red_mask;
1443 image->green_mask = visual->green_mask;
1444 image->blue_mask = visual->blue_mask;
1445
1446 offset = xoff = yoff = 0;
1447 for(idx = 0; idx < count; idx++) {
1448 SmoothGlyphGray(image, xoff + image_off_x - extents.left,
1449 yoff + image_off_y - extents.top,
1450 formatEntry->bitmaps[wstr[idx]],
1451 &formatEntry->gis[wstr[idx]],
1452 physDev->textPixel);
1453 if(lpDx) {
1454 offset += lpDx[idx];
1455 xoff = offset * cosEsc;
1456 yoff = offset * -sinEsc;
1457 } else {
1458 xoff += formatEntry->gis[wstr[idx]].xOff;
1459 yoff += formatEntry->gis[wstr[idx]].yOff;
1460 }
1461 }
1462 XPutImage(gdi_display, physDev->drawable, physDev->gc, image, 0, 0,
1463 image_x, image_y, image_w, image_h);
1464 XDestroyImage(image);
1465 }
1466 no_image:
1467 wine_tsx11_unlock();
1468 }
1469 LeaveCriticalSection(&xrender_cs);
1470
1471 if (flags & ETO_CLIPPED)
1472 {
1473 /* restore the device region */
1474 X11DRV_SetDeviceClipping( physDev, saved_region, 0 );
1475 DeleteObject( saved_region );
1476 }
1477
1478 retv = TRUE;
1479
1480 done_unlock:
1481 X11DRV_UnlockDIBSection( physDev, TRUE );
1482 return retv;
1483 }
1484
1485 /******************************************************************************
1486 * AlphaBlend (x11drv.@)
1487 */
1488 BOOL X11DRV_AlphaBlend(X11DRV_PDEVICE *devDst, INT xDst, INT yDst, INT widthDst, INT heightDst,
1489 X11DRV_PDEVICE *devSrc, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc,
1490 BLENDFUNCTION blendfn)
1491 {
1492 XRenderPictureAttributes pa;
1493 XRenderPictFormat *src_format;
1494 XRenderPictFormat argb32_templ = {
1495 0, /* id */
1496 PictTypeDirect, /* type */
1497 32, /* depth */
1498 { /* direct */
1499 16, /* direct.red */
1500 0xff, /* direct.redMask */
1501 8, /* direct.green */
1502 0xff, /* direct.greenMask */
1503 0, /* direct.blue */
1504 0xff, /* direct.blueMask */
1505 24, /* direct.alpha */
1506 0xff, /* direct.alphaMask */
1507 },
1508 0, /* colormap */
1509 };
1510 unsigned long argb32_templ_mask =
1511 PictFormatType |
1512 PictFormatDepth |
1513 PictFormatRed |
1514 PictFormatRedMask |
1515 PictFormatGreen |
1516 PictFormatGreenMask |
1517 PictFormatBlue |
1518 PictFormatBlueMask |
1519 PictFormatAlpha |
1520 PictFormatAlphaMask;
1521
1522 Picture dst_pict, src_pict;
1523 Pixmap xpm;
1524 DIBSECTION dib;
1525 XImage *image;
1526 GC gc;
1527 XGCValues gcv;
1528 DWORD *dstbits, *data;
1529 int y, y2;
1530 POINT pts[2];
1531 BOOL top_down = FALSE;
1532 RGNDATA *rgndata;
1533 enum drawable_depth_type dst_depth_type = (devDst->depth == 1) ? mono_drawable : color_drawable;
1534
1535 if(!X11DRV_XRender_Installed) {
1536 FIXME("Unable to AlphaBlend without Xrender\n");
1537 return FALSE;
1538 }
1539 pts[0].x = xDst;
1540 pts[0].y = yDst;
1541 pts[1].x = xDst + widthDst;
1542 pts[1].y = yDst + heightDst;
1543 LPtoDP(devDst->hdc, pts, 2);
1544 xDst = pts[0].x;
1545 yDst = pts[0].y;
1546 widthDst = pts[1].x - pts[0].x;
1547 heightDst = pts[1].y - pts[0].y;
1548
1549 pts[0].x = xSrc;
1550 pts[0].y = ySrc;
1551 pts[1].x = xSrc + widthSrc;
1552 pts[1].y = ySrc + heightSrc;
1553 LPtoDP(devSrc->hdc, pts, 2);
1554 xSrc = pts[0].x;
1555 ySrc = pts[0].y;
1556 widthSrc = pts[1].x - pts[0].x;
1557 heightSrc = pts[1].y - pts[0].y;
1558 if (!widthDst || !heightDst || !widthSrc || !heightSrc) return TRUE;
1559
1560 #ifndef HAVE_XRENDERSETPICTURETRANSFORM
1561 if(widthDst != widthSrc || heightDst != heightSrc)
1562 #else
1563 if(!pXRenderSetPictureTransform)
1564 #endif
1565 {
1566 FIXME("Unable to Stretch, XRenderSetPictureTransform is currently required\n");
1567 return FALSE;
1568 }
1569
1570 if (!devSrc->bitmap || GetObjectW( devSrc->bitmap->hbitmap, sizeof(dib), &dib ) != sizeof(dib))
1571 {
1572 FIXME("not a dibsection\n");
1573 return FALSE;
1574 }
1575
1576 if (xSrc < 0 || ySrc < 0 || widthSrc < 0 || heightSrc < 0 || xSrc + widthSrc > dib.dsBmih.biWidth
1577 || ySrc + heightSrc > abs(dib.dsBmih.biHeight))
1578 {
1579 WARN("Invalid src coords: (%d,%d), size %dx%d\n", xSrc, ySrc, widthSrc, heightSrc);
1580 SetLastError(ERROR_INVALID_PARAMETER);
1581 return FALSE;
1582 }
1583
1584 if ((blendfn.AlphaFormat & AC_SRC_ALPHA) && blendfn.SourceConstantAlpha != 0xff)
1585 FIXME("Ignoring SourceConstantAlpha %d for AC_SRC_ALPHA\n", blendfn.SourceConstantAlpha);
1586
1587 if(dib.dsBm.bmBitsPixel != 32) {
1588 FIXME("not a 32 bpp dibsection\n");
1589 return FALSE;
1590 }
1591 dstbits = data = HeapAlloc(GetProcessHeap(), 0, heightSrc * widthSrc * 4);
1592
1593 if(dib.dsBmih.biHeight < 0) { /* top-down dib */
1594 top_down = TRUE;
1595 dstbits += widthSrc * (heightSrc - 1);
1596 y2 = ySrc;
1597 y = y2 + heightSrc - 1;
1598 }
1599 else
1600 {
1601 y = dib.dsBmih.biHeight - ySrc - 1;
1602 y2 = y - heightSrc + 1;
1603 }
1604
1605 if (blendfn.AlphaFormat & AC_SRC_ALPHA)
1606 {
1607 for(; y >= y2; y--)
1608 {
1609 memcpy(dstbits, (char *)dib.dsBm.bmBits + y * dib.dsBm.bmWidthBytes + xSrc * 4,
1610 widthSrc * 4);
1611 dstbits += (top_down ? -1 : 1) * widthSrc;
1612 }
1613 }
1614 else
1615 {
1616 DWORD source_alpha = (DWORD)blendfn.SourceConstantAlpha << 24;
1617 int x;
1618
1619 for(; y >= y2; y--)
1620 {
1621 DWORD *srcbits = (DWORD *)((char *)dib.dsBm.bmBits + y * dib.dsBm.bmWidthBytes) + xSrc;
1622 for (x = 0; x < widthSrc; x++)
1623 {
1624 DWORD argb = *srcbits++;
1625 argb = (argb & 0xffffff) | source_alpha;
1626 *dstbits++ = argb;
1627 }
1628 if (top_down) /* we traversed the row forward so we should go back by two rows */
1629 dstbits -= 2 * widthSrc;
1630 }
1631
1632 }
1633
1634 rgndata = X11DRV_GetRegionData( devDst->region, 0 );
1635
1636 wine_tsx11_lock();
1637 image = XCreateImage(gdi_display, visual, 32, ZPixmap, 0,
1638 (char*) data, widthSrc, heightSrc, 32, widthSrc * 4);
1639
1640 /*
1641 Avoid using XRenderFindStandardFormat as older libraries don't have it
1642 src_format = pXRenderFindStandardFormat(gdi_display, PictStandardARGB32);
1643 */
1644 src_format = pXRenderFindFormat(gdi_display, argb32_templ_mask, &argb32_templ, 0);
1645
1646 TRACE("src_format %p\n", src_format);
1647
1648 pa.subwindow_mode = IncludeInferiors;
1649
1650 /* FIXME use devDst->xrender->pict ? */
1651 dst_pict = pXRenderCreatePicture(gdi_display,
1652 devDst->drawable,
1653 pict_formats[dst_depth_type],
1654 CPSubwindowMode, &pa);
1655 TRACE("dst_pict %08lx\n", dst_pict);
1656 TRACE("src_drawable = %08lx\n", devSrc->drawable);
1657 xpm = XCreatePixmap(gdi_display,
1658 root_window,
1659 widthSrc, heightSrc, 32);
1660 gcv.graphics_exposures = False;
1661 gc = XCreateGC(gdi_display, xpm, GCGraphicsExposures, &gcv);
1662 TRACE("xpm = %08lx\n", xpm);
1663 XPutImage(gdi_display, xpm, gc, image, 0, 0, 0, 0, widthSrc, heightSrc);
1664
1665 src_pict = pXRenderCreatePicture(gdi_display,
1666 xpm, src_format,
1667 CPSubwindowMode, &pa);
1668 TRACE("src_pict %08lx\n", src_pict);
1669
1670 if (rgndata)
1671 {
1672 pXRenderSetPictureClipRectangles( gdi_display, dst_pict,
1673 devDst->dc_rect.left, devDst->dc_rect.top,
1674 (XRectangle *)rgndata->Buffer,
1675 rgndata->rdh.nCount );
1676 HeapFree( GetProcessHeap(), 0, rgndata );
1677 }
1678
1679 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
1680 if(widthDst != widthSrc || heightDst != heightSrc) {
1681 double xscale = widthSrc/(double)widthDst;
1682 double yscale = heightSrc/(double)heightDst;
1683 XTransform xform = {{
1684 { XDoubleToFixed(xscale), XDoubleToFixed(0), XDoubleToFixed(0) },
1685 { XDoubleToFixed(0), XDoubleToFixed(yscale), XDoubleToFixed(0) },
1686 { XDoubleToFixed(0), XDoubleToFixed(0), XDoubleToFixed(1) }
1687 }};
1688 pXRenderSetPictureTransform(gdi_display, src_pict, &xform);
1689 }
1690 #endif
1691 pXRenderComposite(gdi_display, PictOpOver, src_pict, 0, dst_pict,
1692 0, 0, 0, 0,
1693 xDst + devDst->dc_rect.left, yDst + devDst->dc_rect.top, widthDst, heightDst);
1694
1695
1696 pXRenderFreePicture(gdi_display, src_pict);
1697 XFreePixmap(gdi_display, xpm);
1698 XFreeGC(gdi_display, gc);
1699 pXRenderFreePicture(gdi_display, dst_pict);
1700 image->data = NULL;
1701 XDestroyImage(image);
1702
1703 wine_tsx11_unlock();
1704 HeapFree(GetProcessHeap(), 0, data);
1705 return TRUE;
1706 }
1707
1708 #else /* SONAME_LIBXRENDER */
1709
1710 void X11DRV_XRender_Init(void)
1711 {
1712 TRACE("XRender support not compiled in.\n");
1713 return;
1714 }
1715
1716 void X11DRV_XRender_Finalize(void)
1717 {
1718 }
1719
1720 BOOL X11DRV_XRender_SelectFont(X11DRV_PDEVICE *physDev, HFONT hfont)
1721 {
1722 assert(0);
1723 return FALSE;
1724 }
1725
1726 void X11DRV_XRender_DeleteDC(X11DRV_PDEVICE *physDev)
1727 {
1728 assert(0);
1729 return;
1730 }
1731
1732 BOOL X11DRV_XRender_ExtTextOut( X11DRV_PDEVICE *physDev, INT x, INT y, UINT flags,
1733 const RECT *lprect, LPCWSTR wstr, UINT count,
1734 const INT *lpDx )
1735 {
1736 assert(0);
1737 return FALSE;
1738 }
1739
1740 void X11DRV_XRender_UpdateDrawable(X11DRV_PDEVICE *physDev)
1741 {
1742 assert(0);
1743 return;
1744 }
1745
1746 /******************************************************************************
1747 * AlphaBlend (x11drv.@)
1748 */
1749 BOOL X11DRV_AlphaBlend(X11DRV_PDEVICE *devDst, INT xDst, INT yDst, INT widthDst, INT heightDst,
1750 X11DRV_PDEVICE *devSrc, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc,
1751 BLENDFUNCTION blendfn)
1752 {
1753 FIXME("not supported - XRENDER headers were missing at compile time\n");
1754 return FALSE;
1755 }
1756
1757 #endif /* SONAME_LIBXRENDER */
various (hopefully) useful wine hacks