?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version resources cleanup.
[wine/multimedia.git] / dlls / x11drv / xrender.c
bloba7e141b9c0c7178e4a12407ae3f169286d8ec705
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 int 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 x -= gi->x;
898 y -= gi->y;
899 width = gi->width;
900 height = gi->height;
901
902 maskLine = (unsigned char *) bitmap;
903 maskStride = (width + 3) & ~3;
904
905 ExamineBitfield (image->red_mask, &r_shift, &r_len);
906 ExamineBitfield (image->green_mask, &g_shift, &g_len);
907 ExamineBitfield (image->blue_mask, &b_shift, &b_len);
908
909 src_r = GetField(color, r_shift, r_len);
910 src_g = GetField(color, g_shift, g_len);
911 src_b = GetField(color, b_shift, b_len);
912
913 for(; height--; y++)
914 {
915 mask = maskLine;
916 maskLine += maskStride;
917 w = width;
918 tx = x;
919
920 if(y < 0) continue;
921 if(y >= image->height) break;
922
923 for(; w--; tx++)
924 {
925 if(tx >= image->width) break;
926
927 m = *mask++;
928 if(tx < 0) continue;
929
930 if (m == 0xff)
931 XPutPixel (image, tx, y, color);
932 else if (m)
933 {
934 BYTE r, g, b;
935
936 pixel = XGetPixel (image, tx, y);
937
938 r = GetField(pixel, r_shift, r_len);
939 r = ((BYTE)~m * (WORD)r + (BYTE)m * (WORD)src_r) >> 8;
940 g = GetField(pixel, g_shift, g_len);
941 g = ((BYTE)~m * (WORD)g + (BYTE)m * (WORD)src_g) >> 8;
942 b = GetField(pixel, b_shift, b_len);
943 b = ((BYTE)~m * (WORD)b + (BYTE)m * (WORD)src_b) >> 8;
944
945 pixel = (PutField (r, r_shift, r_len) |
946 PutField (g, g_shift, g_len) |
947 PutField (b, b_shift, b_len));
948 XPutPixel (image, tx, y, pixel);
949 }
950 }
951 }
952 }
953
954 static int XRenderErrorHandler(Display *dpy, XErrorEvent *event, void *arg)
955 {
956 return 1;
957 }
958
959 /***********************************************************************
960 * X11DRV_XRender_ExtTextOut
961 */
962 BOOL X11DRV_XRender_ExtTextOut( X11DRV_PDEVICE *physDev, INT x, INT y, UINT flags,
963 const RECT *lprect, LPCWSTR wstr, UINT count,
964 const INT *lpDx, INT breakExtra )
965 {
966 XRenderColor col;
967 unsigned int idx;
968 TEXTMETRICW tm;
969 RGNDATA *data;
970 SIZE sz;
971 RECT rc;
972 BOOL done_extents = FALSE;
973 INT width, xwidth, ywidth;
974 double cosEsc, sinEsc;
975 XGCValues xgcval;
976 LOGFONTW lf;
977 int render_op = PictOpOver;
978 WORD *glyphs;
979 POINT pt;
980 gsCacheEntry *entry;
981 BOOL retv = FALSE;
982 HDC hdc = physDev->hdc;
983 int textPixel, backgroundPixel;
984 INT *deltas = NULL;
985 INT char_extra;
986 HRGN saved_region = 0;
987 UINT align = GetTextAlign( hdc );
988
989 TRACE("%p, %d, %d, %08x, %p, %s, %d, %p)\n", hdc, x, y, flags,
990 lprect, debugstr_wn(wstr, count), count, lpDx);
991
992 if(flags & ETO_GLYPH_INDEX)
993 glyphs = (LPWORD)wstr;
994 else {
995 glyphs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(WCHAR));
996 GetGlyphIndicesW(hdc, wstr, count, glyphs, 0);
997 }
998
999 if(lprect)
1000 TRACE("rect: %ld,%ld - %ld,%ld\n", lprect->left, lprect->top, lprect->right,
1001 lprect->bottom);
1002 TRACE("align = %x bkmode = %x mapmode = %x\n", align, GetBkMode(hdc), GetMapMode(hdc));
1003
1004 if(align & TA_UPDATECP)
1005 {
1006 GetCurrentPositionEx( hdc, &pt );
1007 x = pt.x;
1008 y = pt.y;
1009 }
1010
1011 GetTextMetricsW(hdc, &tm);
1012 GetObjectW(GetCurrentObject(hdc, OBJ_FONT), sizeof(lf), &lf);
1013
1014 if(!(tm.tmPitchAndFamily & TMPF_VECTOR)) /* Non-scalable fonts shouldn't be rotated */
1015 lf.lfEscapement = 0;
1016
1017 if(lf.lfEscapement != 0) {
1018 cosEsc = cos(lf.lfEscapement * M_PI / 1800);
1019 sinEsc = sin(lf.lfEscapement * M_PI / 1800);
1020 } else {
1021 cosEsc = 1;
1022 sinEsc = 0;
1023 }
1024
1025 if(flags & (ETO_CLIPPED | ETO_OPAQUE)) {
1026 if(!lprect) {
1027 if(flags & ETO_CLIPPED) return FALSE;
1028 GetTextExtentPointI(hdc, glyphs, count, &sz);
1029 done_extents = TRUE;
1030 rc.left = x;
1031 rc.top = y;
1032 rc.right = x + sz.cx;
1033 rc.bottom = y + sz.cy;
1034 } else {
1035 rc = *lprect;
1036 }
1037
1038 LPtoDP(hdc, (POINT*)&rc, 2);
1039
1040 if(rc.left > rc.right) {INT tmp = rc.left; rc.left = rc.right; rc.right = tmp;}
1041 if(rc.top > rc.bottom) {INT tmp = rc.top; rc.top = rc.bottom; rc.bottom = tmp;}
1042 }
1043
1044 xgcval.function = GXcopy;
1045 xgcval.background = physDev->backgroundPixel;
1046 xgcval.fill_style = FillSolid;
1047 wine_tsx11_lock();
1048 XChangeGC( gdi_display, physDev->gc, GCFunction | GCBackground | GCFillStyle, &xgcval );
1049 wine_tsx11_unlock();
1050
1051 X11DRV_LockDIBSection( physDev, DIB_Status_GdiMod, FALSE );
1052
1053 if(physDev->depth == 1) {
1054 if((physDev->textPixel & 0xffffff) == 0) {
1055 textPixel = 0;
1056 backgroundPixel = 1;
1057 } else {
1058 textPixel = 1;
1059 backgroundPixel = 0;
1060 }
1061 } else {
1062 textPixel = physDev->textPixel;
1063 backgroundPixel = physDev->backgroundPixel;
1064 }
1065
1066 if(flags & ETO_OPAQUE) {
1067 wine_tsx11_lock();
1068 XSetForeground( gdi_display, physDev->gc, backgroundPixel );
1069 XFillRectangle( gdi_display, physDev->drawable, physDev->gc,
1070 physDev->org.x + rc.left, physDev->org.y + rc.top,
1071 rc.right - rc.left, rc.bottom - rc.top );
1072 wine_tsx11_unlock();
1073 }
1074
1075 if(count == 0) {
1076 retv = TRUE;
1077 goto done;
1078 }
1079
1080 pt.x = x;
1081 pt.y = y;
1082 LPtoDP(hdc, &pt, 1);
1083 x = pt.x;
1084 y = pt.y;
1085
1086 TRACE("real x,y %d,%d\n", x, y);
1087
1088 if((char_extra = GetTextCharacterExtra(hdc)) != 0) {
1089 UINT i;
1090 SIZE tmpsz;
1091 deltas = HeapAlloc(GetProcessHeap(), 0, count * sizeof(INT));
1092 for(i = 0; i < count; i++) {
1093 if(lpDx)
1094 deltas[i] = lpDx[i] + char_extra;
1095 else {
1096 GetTextExtentPointI(hdc, glyphs + i, 1, &tmpsz);
1097 deltas[i] = tmpsz.cx;
1098 }
1099 }
1100 } else if(lpDx)
1101 deltas = (INT*)lpDx;
1102
1103 if(deltas) {
1104 width = 0;
1105 for(idx = 0; idx < count; idx++)
1106 width += deltas[idx];
1107 } else {
1108 if(!done_extents) {
1109 GetTextExtentPointI(hdc, glyphs, count, &sz);
1110 done_extents = TRUE;
1111 }
1112 width = sz.cx;
1113 }
1114 width = X11DRV_XWStoDS(physDev, width);
1115 xwidth = width * cosEsc;
1116 ywidth = width * sinEsc;
1117
1118 tm.tmAscent = abs(X11DRV_YWStoDS(physDev, tm.tmAscent));
1119 tm.tmDescent = abs(X11DRV_YWStoDS(physDev, tm.tmDescent));
1120 switch( align & (TA_LEFT | TA_RIGHT | TA_CENTER) ) {
1121 case TA_LEFT:
1122 if (align & TA_UPDATECP) {
1123 pt.x = x + xwidth;
1124 pt.y = y - ywidth;
1125 DPtoLP(hdc, &pt, 1);
1126 MoveToEx(hdc, pt.x, pt.y, NULL);
1127 }
1128 break;
1129
1130 case TA_CENTER:
1131 x -= xwidth / 2;
1132 y += ywidth / 2;
1133 break;
1134
1135 case TA_RIGHT:
1136 x -= xwidth;
1137 y += ywidth;
1138 if (align & TA_UPDATECP) {
1139 pt.x = x;
1140 pt.y = y;
1141 DPtoLP(hdc, &pt, 1);
1142 MoveToEx(hdc, pt.x, pt.y, NULL);
1143 }
1144 break;
1145 }
1146
1147 switch( align & (TA_TOP | TA_BOTTOM | TA_BASELINE) ) {
1148 case TA_TOP:
1149 y += tm.tmAscent * cosEsc;
1150 x += tm.tmAscent * sinEsc;
1151 break;
1152
1153 case TA_BOTTOM:
1154 y -= tm.tmDescent * cosEsc;
1155 x -= tm.tmDescent * sinEsc;
1156 break;
1157
1158 case TA_BASELINE:
1159 break;
1160 }
1161
1162 if (flags & ETO_CLIPPED)
1163 {
1164 HRGN clip_region;
1165 RECT clip_rect = *lprect;
1166
1167 LPtoDP( hdc, (POINT *)&clip_rect, 2 );
1168 clip_region = CreateRectRgnIndirect( &clip_rect );
1169 /* make a copy of the current device region */
1170 saved_region = CreateRectRgn( 0, 0, 0, 0 );
1171 CombineRgn( saved_region, physDev->region, 0, RGN_COPY );
1172 X11DRV_SetDeviceClipping( physDev, saved_region, clip_region );
1173 DeleteObject( clip_region );
1174 }
1175
1176 if(X11DRV_XRender_Installed) {
1177 if(!physDev->xrender->pict) {
1178 XRenderPictureAttributes pa;
1179 pa.subwindow_mode = IncludeInferiors;
1180
1181 wine_tsx11_lock();
1182 physDev->xrender->pict = pXRenderCreatePicture(gdi_display,
1183 physDev->drawable,
1184 (physDev->depth == 1) ?
1185 mono_format : screen_format,
1186 CPSubwindowMode, &pa);
1187 wine_tsx11_unlock();
1188
1189 TRACE("allocing pict = %lx dc = %p drawable = %08lx\n",
1190 physDev->xrender->pict, hdc, physDev->drawable);
1191 } else {
1192 TRACE("using existing pict = %lx dc = %p drawable = %08lx\n",
1193 physDev->xrender->pict, hdc, physDev->drawable);
1194 }
1195
1196 if ((data = X11DRV_GetRegionData( physDev->region, 0 )))
1197 {
1198 wine_tsx11_lock();
1199 pXRenderSetPictureClipRectangles( gdi_display, physDev->xrender->pict,
1200 physDev->org.x, physDev->org.y,
1201 (XRectangle *)data->Buffer, data->rdh.nCount );
1202 wine_tsx11_unlock();
1203 HeapFree( GetProcessHeap(), 0, data );
1204 }
1205 }
1206
1207 if(GetBkMode(hdc) != TRANSPARENT) {
1208 if(!((flags & ETO_CLIPPED) && (flags & ETO_OPAQUE))) {
1209 if(!(flags & ETO_OPAQUE) || x < rc.left || x + width >= rc.right ||
1210 y - tm.tmAscent < rc.top || y + tm.tmDescent >= rc.bottom) {
1211 wine_tsx11_lock();
1212 XSetForeground( gdi_display, physDev->gc, backgroundPixel );
1213 XFillRectangle( gdi_display, physDev->drawable, physDev->gc,
1214 physDev->org.x + x, physDev->org.y + y - tm.tmAscent,
1215 width, tm.tmAscent + tm.tmDescent );
1216 wine_tsx11_unlock();
1217 }
1218 }
1219 }
1220
1221 if(X11DRV_XRender_Installed) {
1222 /* Create a 1x1 pixmap to tile over the font mask */
1223 if(!physDev->xrender->tile_xpm) {
1224 XRenderPictureAttributes pa;
1225
1226 XRenderPictFormat *format = (physDev->depth == 1) ? mono_format : screen_format;
1227 wine_tsx11_lock();
1228 physDev->xrender->tile_xpm = XCreatePixmap(gdi_display,
1229 physDev->drawable,
1230 1, 1,
1231 format->depth);
1232 pa.repeat = True;
1233 physDev->xrender->tile_pict = pXRenderCreatePicture(gdi_display,
1234 physDev->xrender->tile_xpm,
1235 format,
1236 CPRepeat, &pa);
1237 wine_tsx11_unlock();
1238 TRACE("Created pixmap of depth %d\n", format->depth);
1239 /* init lastTextColor to something different from textPixel */
1240 physDev->xrender->lastTextColor = ~physDev->textPixel;
1241
1242 }
1243
1244 if(physDev->textPixel != physDev->xrender->lastTextColor) {
1245 if(physDev->depth != 1) {
1246 /* Map 0 -- 0xff onto 0 -- 0xffff */
1247 int r_shift, r_len;
1248 int g_shift, g_len;
1249 int b_shift, b_len;
1250
1251 ExamineBitfield (visual->red_mask, &r_shift, &r_len );
1252 ExamineBitfield (visual->green_mask, &g_shift, &g_len);
1253 ExamineBitfield (visual->blue_mask, &b_shift, &b_len);
1254
1255 col.red = GetField(physDev->textPixel, r_shift, r_len);
1256 col.red |= col.red << 8;
1257 col.green = GetField(physDev->textPixel, g_shift, g_len);
1258 col.green |= col.green << 8;
1259 col.blue = GetField(physDev->textPixel, b_shift, b_len);
1260 col.blue |= col.blue << 8;
1261 col.alpha = 0x0;
1262 } else { /* for a 1bpp bitmap we always need a 1 in the tile */
1263 col.red = col.green = col.blue = 0;
1264 col.alpha = 0xffff;
1265 }
1266 wine_tsx11_lock();
1267 pXRenderFillRectangle(gdi_display, PictOpSrc,
1268 physDev->xrender->tile_pict,
1269 &col, 0, 0, 1, 1);
1270 wine_tsx11_unlock();
1271 physDev->xrender->lastTextColor = physDev->textPixel;
1272 }
1273
1274 /* FIXME the mapping of Text/BkColor onto 1 or 0 needs investigation.
1275 */
1276 if((physDev->depth == 1) && (textPixel == 0))
1277 render_op = PictOpOutReverse; /* This gives us 'black' text */
1278 }
1279
1280 EnterCriticalSection(&xrender_cs);
1281 entry = glyphsetCache + physDev->xrender->cache_index;
1282
1283 for(idx = 0; idx < count; idx++) {
1284 if(glyphs[idx] >= entry->nrealized || entry->realized[glyphs[idx]] == FALSE) {
1285 UploadGlyph(physDev, glyphs[idx]);
1286 }
1287 }
1288
1289
1290 TRACE("Writing %s at %ld,%ld\n", debugstr_wn(wstr,count),
1291 physDev->org.x + x, physDev->org.y + y);
1292
1293 if(X11DRV_XRender_Installed) {
1294 wine_tsx11_lock();
1295 if(!deltas)
1296 pXRenderCompositeString16(gdi_display, render_op,
1297 physDev->xrender->tile_pict,
1298 physDev->xrender->pict,
1299 entry->font_format, entry->glyphset,
1300 0, 0, physDev->org.x + x, physDev->org.y + y,
1301 glyphs, count);
1302
1303 else {
1304 INT offset = 0, xoff = 0, yoff = 0;
1305 for(idx = 0; idx < count; idx++) {
1306 pXRenderCompositeString16(gdi_display, render_op,
1307 physDev->xrender->tile_pict,
1308 physDev->xrender->pict,
1309 entry->font_format, entry->glyphset,
1310 0, 0, physDev->org.x + x + xoff,
1311 physDev->org.y + y + yoff,
1312 glyphs + idx, 1);
1313 offset += X11DRV_XWStoDS(physDev, deltas[idx]);
1314 xoff = offset * cosEsc;
1315 yoff = offset * -sinEsc;
1316 }
1317 }
1318 wine_tsx11_unlock();
1319
1320 } else {
1321 INT offset = 0, xoff = 0, yoff = 0;
1322 wine_tsx11_lock();
1323 XSetForeground( gdi_display, physDev->gc, textPixel );
1324
1325 if(entry->aa == AA_None) {
1326 for(idx = 0; idx < count; idx++) {
1327 SharpGlyphMono(physDev, physDev->org.x + x + xoff,
1328 physDev->org.y + y + yoff,
1329 entry->bitmaps[glyphs[idx]],
1330 &entry->gis[glyphs[idx]]);
1331 if(deltas) {
1332 offset += X11DRV_XWStoDS(physDev, deltas[idx]);
1333 xoff = offset * cosEsc;
1334 yoff = offset * -sinEsc;
1335
1336 } else {
1337 xoff += entry->gis[glyphs[idx]].xOff;
1338 yoff += entry->gis[glyphs[idx]].yOff;
1339 }
1340 }
1341 } else if(physDev->depth == 1) {
1342 for(idx = 0; idx < count; idx++) {
1343 SharpGlyphGray(physDev, physDev->org.x + x + xoff,
1344 physDev->org.y + y + yoff,
1345 entry->bitmaps[glyphs[idx]],
1346 &entry->gis[glyphs[idx]]);
1347 if(deltas) {
1348 offset += X11DRV_XWStoDS(physDev, deltas[idx]);
1349 xoff = offset * cosEsc;
1350 yoff = offset * -sinEsc;
1351
1352 } else {
1353 xoff += entry->gis[glyphs[idx]].xOff;
1354 yoff += entry->gis[glyphs[idx]].yOff;
1355 }
1356
1357 }
1358 } else {
1359 XImage *image;
1360 unsigned int w, h, dummy_uint;
1361 Window dummy_window;
1362 int dummy_int;
1363 int image_x, image_y, image_off_x, image_off_y, image_w, image_h;
1364 RECT extents = {0, 0, 0, 0};
1365 POINT cur = {0, 0};
1366
1367
1368 XGetGeometry(gdi_display, physDev->drawable, &dummy_window, &dummy_int, &dummy_int,
1369 &w, &h, &dummy_uint, &dummy_uint);
1370 TRACE("drawable %dx%d\n", w, h);
1371
1372 for(idx = 0; idx < count; idx++) {
1373 if(extents.left > cur.x - entry->gis[glyphs[idx]].x)
1374 extents.left = cur.x - entry->gis[glyphs[idx]].x;
1375 if(extents.top > cur.y - entry->gis[glyphs[idx]].y)
1376 extents.top = cur.y - entry->gis[glyphs[idx]].y;
1377 if(extents.right < cur.x - entry->gis[glyphs[idx]].x + entry->gis[glyphs[idx]].width)
1378 extents.right = cur.x - entry->gis[glyphs[idx]].x + entry->gis[glyphs[idx]].width;
1379 if(extents.bottom < cur.y - entry->gis[glyphs[idx]].y + entry->gis[glyphs[idx]].height)
1380 extents.bottom = cur.y - entry->gis[glyphs[idx]].y + entry->gis[glyphs[idx]].height;
1381 if(deltas) {
1382 offset += X11DRV_XWStoDS(physDev, deltas[idx]);
1383 cur.x = offset * cosEsc;
1384 cur.y = offset * -sinEsc;
1385 } else {
1386 cur.x += entry->gis[glyphs[idx]].xOff;
1387 cur.y += entry->gis[glyphs[idx]].yOff;
1388 }
1389 }
1390 TRACE("glyph extents %ld,%ld - %ld,%ld drawable x,y %ld,%ld\n", extents.left, extents.top,
1391 extents.right, extents.bottom, physDev->org.x + x, physDev->org.y + y);
1392
1393 if(physDev->org.x + x + extents.left >= 0) {
1394 image_x = physDev->org.x + x + extents.left;
1395 image_off_x = 0;
1396 } else {
1397 image_x = 0;
1398 image_off_x = physDev->org.x + x + extents.left;
1399 }
1400 if(physDev->org.y + y + extents.top >= 0) {
1401 image_y = physDev->org.y + y + extents.top;
1402 image_off_y = 0;
1403 } else {
1404 image_y = 0;
1405 image_off_y = physDev->org.y + y + extents.top;
1406 }
1407 if(physDev->org.x + x + extents.right < w)
1408 image_w = physDev->org.x + x + extents.right - image_x;
1409 else
1410 image_w = w - image_x;
1411 if(physDev->org.y + y + extents.bottom < h)
1412 image_h = physDev->org.y + y + extents.bottom - image_y;
1413 else
1414 image_h = h - image_y;
1415
1416 if(image_w <= 0 || image_h <= 0) goto no_image;
1417
1418 X11DRV_expect_error(gdi_display, XRenderErrorHandler, NULL);
1419 image = XGetImage(gdi_display, physDev->drawable,
1420 image_x, image_y, image_w, image_h,
1421 AllPlanes, ZPixmap);
1422 X11DRV_check_error();
1423
1424 TRACE("XGetImage(%p, %x, %d, %d, %d, %d, %lx, %x) depth = %d rets %p\n",
1425 gdi_display, (int)physDev->drawable, image_x, image_y,
1426 image_w, image_h, AllPlanes, ZPixmap,
1427 physDev->depth, image);
1428 if(!image) {
1429 Pixmap xpm = XCreatePixmap(gdi_display, physDev->drawable, image_w, image_h,
1430 physDev->depth);
1431 GC gc;
1432 XGCValues gcv;
1433
1434 gcv.graphics_exposures = False;
1435 gc = XCreateGC(gdi_display, xpm, GCGraphicsExposures, &gcv);
1436 XCopyArea(gdi_display, physDev->drawable, xpm, gc, image_x, image_y,
1437 image_w, image_h, 0, 0);
1438 XFreeGC(gdi_display, gc);
1439 X11DRV_expect_error(gdi_display, XRenderErrorHandler, NULL);
1440 image = XGetImage(gdi_display, xpm, 0, 0, image_w, image_h, AllPlanes,
1441 ZPixmap);
1442 X11DRV_check_error();
1443 XFreePixmap(gdi_display, xpm);
1444 }
1445 if(!image) goto no_image;
1446
1447 image->red_mask = visual->red_mask;
1448 image->green_mask = visual->green_mask;
1449 image->blue_mask = visual->blue_mask;
1450
1451 offset = xoff = yoff = 0;
1452 for(idx = 0; idx < count; idx++) {
1453 SmoothGlyphGray(image, xoff + image_off_x - extents.left,
1454 yoff + image_off_y - extents.top,
1455 entry->bitmaps[glyphs[idx]],
1456 &entry->gis[glyphs[idx]],
1457 physDev->textPixel);
1458 if(deltas) {
1459 offset += X11DRV_XWStoDS(physDev, deltas[idx]);
1460 xoff = offset * cosEsc;
1461 yoff = offset * -sinEsc;
1462 } else {
1463 xoff += entry->gis[glyphs[idx]].xOff;
1464 yoff += entry->gis[glyphs[idx]].yOff;
1465 }
1466
1467 }
1468 XPutImage(gdi_display, physDev->drawable, physDev->gc, image, 0, 0,
1469 image_x, image_y, image_w, image_h);
1470 XDestroyImage(image);
1471 }
1472 no_image:
1473 wine_tsx11_unlock();
1474 }
1475 LeaveCriticalSection(&xrender_cs);
1476
1477 if (lf.lfUnderline || lf.lfStrikeOut) {
1478 int underlinePos, strikeoutPos;
1479 int underlineWidth, strikeoutWidth;
1480 UINT nMetricsSize = GetOutlineTextMetricsW(hdc, 0, NULL);
1481 OUTLINETEXTMETRICW* otm = NULL;
1482
1483 if(!nMetricsSize) {
1484 underlinePos = 0;
1485 underlineWidth = tm.tmAscent / 20 + 1;
1486 strikeoutPos = tm.tmAscent / 2;
1487 strikeoutWidth = underlineWidth;
1488 } else {
1489 otm = HeapAlloc(GetProcessHeap(), 0, nMetricsSize);
1490 if (!otm) goto done;
1491
1492 GetOutlineTextMetricsW(hdc, nMetricsSize, otm);
1493 underlinePos = otm->otmsUnderscorePosition;
1494 underlineWidth = otm->otmsUnderscoreSize;
1495 strikeoutPos = otm->otmsStrikeoutPosition;
1496 strikeoutWidth = otm->otmsStrikeoutSize;
1497 }
1498
1499 wine_tsx11_lock();
1500 XSetForeground( gdi_display, physDev->gc, physDev->textPixel );
1501
1502 if (lf.lfUnderline) {
1503 underlinePos = X11DRV_YWStoDS(physDev, underlinePos);
1504 underlineWidth = X11DRV_YWStoDS(physDev, underlineWidth);
1505
1506 XSetLineAttributes( gdi_display, physDev->gc, underlineWidth,
1507 LineSolid, CapProjecting, JoinBevel );
1508 XDrawLine( gdi_display, physDev->drawable, physDev->gc,
1509 physDev->org.x + x - underlinePos * sinEsc,
1510 physDev->org.y + y - underlinePos * cosEsc,
1511 physDev->org.x + x + width * cosEsc - underlinePos * sinEsc,
1512 physDev->org.y + y - width * sinEsc - underlinePos * cosEsc );
1513 }
1514
1515 if (lf.lfStrikeOut) {
1516 strikeoutPos = X11DRV_YWStoDS(physDev, strikeoutPos);
1517 strikeoutWidth = X11DRV_YWStoDS(physDev, strikeoutWidth);
1518
1519 XSetLineAttributes( gdi_display, physDev->gc, strikeoutWidth,
1520 LineSolid, CapProjecting, JoinBevel );
1521 XDrawLine( gdi_display, physDev->drawable, physDev->gc,
1522 physDev->org.x + x - strikeoutPos * sinEsc,
1523 physDev->org.y + y - strikeoutPos * cosEsc,
1524 physDev->org.x + x + width * cosEsc - strikeoutPos * sinEsc,
1525 physDev->org.y + y - width * sinEsc - strikeoutPos * cosEsc);
1526 }
1527 wine_tsx11_unlock();
1528 if(otm)
1529 HeapFree(GetProcessHeap(), 0, otm);
1530 }
1531
1532 if(deltas && deltas != lpDx)
1533 HeapFree(GetProcessHeap(), 0, deltas);
1534
1535 if (flags & ETO_CLIPPED)
1536 {
1537 /* restore the device region */
1538 X11DRV_SetDeviceClipping( physDev, saved_region, 0 );
1539 DeleteObject( saved_region );
1540 }
1541
1542 retv = TRUE;
1543
1544 done:
1545 X11DRV_UnlockDIBSection( physDev, TRUE );
1546 if(glyphs != wstr) HeapFree(GetProcessHeap(), 0, glyphs);
1547 return retv;
1548 }
1549
1550 BOOL X11DRV_AlphaBlend(X11DRV_PDEVICE *devDst, INT xDst, INT yDst, INT widthDst, INT heightDst,
1551 X11DRV_PDEVICE *devSrc, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc,
1552 BLENDFUNCTION blendfn)
1553 {
1554 XRenderPictureAttributes pa;
1555 XRenderPictFormat *src_format;
1556 Picture dst_pict, src_pict;
1557 Pixmap xpm;
1558 HBITMAP hBitmap;
1559 BITMAPOBJ *bmp;
1560 XImage *image;
1561 GC gc;
1562 XGCValues gcv;
1563 char *dstbits, *data;
1564 int y;
1565 POINT pts[2];
1566 BOOL top_down = FALSE;
1567
1568 if(!X11DRV_XRender_Installed) {
1569 FIXME("Unable to AlphaBlend without Xrender\n");
1570 return FALSE;
1571 }
1572 pts[0].x = xDst;
1573 pts[0].y = yDst;
1574 pts[1].x = xDst + widthDst;
1575 pts[1].y = yDst + heightDst;
1576 LPtoDP(devDst->hdc, pts, 2);
1577 xDst = pts[0].x;
1578 yDst = pts[0].y;
1579 widthDst = pts[1].x - pts[0].x;
1580 heightDst = pts[1].y - pts[0].y;
1581
1582 pts[0].x = xSrc;
1583 pts[0].y = ySrc;
1584 pts[1].x = xSrc + widthSrc;
1585 pts[1].y = ySrc + heightSrc;
1586 LPtoDP(devSrc->hdc, pts, 2);
1587 xSrc = pts[0].x;
1588 ySrc = pts[0].y;
1589 widthSrc = pts[1].x - pts[0].x;
1590 heightSrc = pts[1].y - pts[0].y;
1591
1592 #ifndef HAVE_XRENDERSETPICTURETRANSFORM
1593 if(widthDst != widthSrc || heightDst != heightSrc)
1594 #else
1595 if(!pXRenderSetPictureTransform)
1596 #endif
1597 {
1598 FIXME("Unable to Stretch, XRenderSetPictureTransform is currently required\n");
1599 return FALSE;
1600 }
1601
1602 hBitmap = GetCurrentObject( devSrc->hdc, OBJ_BITMAP );
1603 bmp = (BITMAPOBJ *)GDI_GetObjPtr( hBitmap, BITMAP_MAGIC );
1604 if(!bmp || !bmp->dib) {
1605 FIXME("not a dibsection\n");
1606 GDI_ReleaseObj( hBitmap );
1607 return FALSE;
1608 }
1609
1610 if(bmp->dib->dsBm.bmBitsPixel != 32) {
1611 FIXME("not a 32 bpp dibsection\n");
1612 GDI_ReleaseObj( hBitmap );
1613 return FALSE;
1614 }
1615 dstbits = data = HeapAlloc(GetProcessHeap(), 0, heightSrc * widthSrc * 4);
1616
1617 if(bmp->dib->dsBmih.biHeight < 0) { /* top-down dib */
1618 top_down = TRUE;
1619 dstbits += widthSrc * (heightSrc - 1) * 4;
1620 }
1621 for(y = ySrc + heightSrc - 1; y >= ySrc; y--) {
1622 memcpy(dstbits, (char *)bmp->dib->dsBm.bmBits + y * bmp->dib->dsBm.bmWidthBytes + xSrc * 4,
1623 widthSrc * 4);
1624 dstbits += (top_down ? -1 : 1) * widthSrc * 4;
1625 }
1626
1627 wine_tsx11_lock();
1628 image = XCreateImage(gdi_display, visual, 32, ZPixmap, 0,
1629 data, widthSrc, heightSrc, 32, widthSrc * 4);
1630
1631 src_format = pXRenderFindStandardFormat(gdi_display, PictStandardARGB32);
1632
1633
1634 TRACE("src_format %p\n", src_format);
1635
1636 pa.subwindow_mode = IncludeInferiors;
1637
1638 /* FIXME use devDst->xrender->pict ? */
1639 dst_pict = pXRenderCreatePicture(gdi_display,
1640 devDst->drawable,
1641 (devDst->depth == 1) ?
1642 mono_format : screen_format,
1643 CPSubwindowMode, &pa);
1644 TRACE("dst_pict %08lx\n", dst_pict);
1645 TRACE("src_drawable = %08lx\n", devSrc->drawable);
1646 xpm = XCreatePixmap(gdi_display,
1647 devSrc->drawable,
1648 widthSrc, heightSrc, 32);
1649 gcv.graphics_exposures = False;
1650 gc = XCreateGC(gdi_display, xpm, GCGraphicsExposures, &gcv);
1651 TRACE("xpm = %08lx\n", xpm);
1652 XPutImage(gdi_display, xpm, gc, image, 0, 0, 0, 0, widthSrc, heightSrc);
1653
1654 src_pict = pXRenderCreatePicture(gdi_display,
1655 xpm, src_format,
1656 CPSubwindowMode, &pa);
1657 TRACE("src_pict %08lx\n", src_pict);
1658
1659 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
1660 if(widthDst != widthSrc || heightDst != heightSrc) {
1661 double xscale = widthSrc/(double)widthDst;
1662 double yscale = heightSrc/(double)heightDst;
1663 XTransform xform = {{
1664 { XDoubleToFixed(xscale), XDoubleToFixed(0), XDoubleToFixed(0) },
1665 { XDoubleToFixed(0), XDoubleToFixed(yscale), XDoubleToFixed(0) },
1666 { XDoubleToFixed(0), XDoubleToFixed(0), XDoubleToFixed(1) }
1667 }};
1668 pXRenderSetPictureTransform(gdi_display, src_pict, &xform);
1669 }
1670 #endif
1671 pXRenderComposite(gdi_display, PictOpOver, src_pict, 0, dst_pict,
1672 xSrc, ySrc, 0, 0,
1673 xDst + devDst->org.x, yDst + devDst->org.y, widthDst, heightDst);
1674
1675
1676 pXRenderFreePicture(gdi_display, src_pict);
1677 XFreePixmap(gdi_display, xpm);
1678 XFreeGC(gdi_display, gc);
1679 pXRenderFreePicture(gdi_display, dst_pict);
1680 image->data = NULL;
1681 XDestroyImage(image);
1682
1683 wine_tsx11_unlock();
1684 HeapFree(GetProcessHeap(), 0, data);
1685 GDI_ReleaseObj( hBitmap );
1686 return TRUE;
1687 }
1688
1689 #else /* HAVE_X11_EXTENSIONS_XRENDER_H */
1690
1691 void X11DRV_XRender_Init(void)
1692 {
1693 TRACE("XRender support not compiled in.\n");
1694 return;
1695 }
1696
1697 void X11DRV_XRender_Finalize(void)
1698 {
1699 }
1700
1701 BOOL X11DRV_XRender_SelectFont(X11DRV_PDEVICE *physDev, HFONT hfont)
1702 {
1703 assert(0);
1704 return FALSE;
1705 }
1706
1707 void X11DRV_XRender_DeleteDC(X11DRV_PDEVICE *physDev)
1708 {
1709 assert(0);
1710 return;
1711 }
1712
1713 BOOL X11DRV_XRender_ExtTextOut( X11DRV_PDEVICE *physDev, INT x, INT y, UINT flags,
1714 const RECT *lprect, LPCWSTR wstr, UINT count,
1715 const INT *lpDx, INT breakExtra )
1716 {
1717 assert(0);
1718 return FALSE;
1719 }
1720
1721 void X11DRV_XRender_UpdateDrawable(X11DRV_PDEVICE *physDev)
1722 {
1723 assert(0);
1724 return;
1725 }
1726
1727 BOOL X11DRV_AlphaBlend(X11DRV_PDEVICE *devDst, INT xDst, INT yDst, INT widthDst, INT heightDst,
1728 X11DRV_PDEVICE *devSrc, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc,
1729 BLENDFUNCTION blendfn)
1730 {
1731 FIXME("not supported - XRENDER headers were missing at compile time\n");
1732 return FALSE;
1733 }
1734
1735 #endif /* HAVE_X11_EXTENSIONS_XRENDER_H */
Maarten's multimedia branch