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