2 * Functions to use the XRender extension
4 * Copyright 2001, 2002 Huw D M Davies for CodeWeavers
7 * Copyright 2000 Keith Packard, member of The XFree86 Project, Inc.
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.
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.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 #include "wine/port.h"
37 #include "wine/library.h"
38 #include "wine/unicode.h"
39 #include "wine/debug.h"
41 static BOOL X11DRV_XRender_Installed
= FALSE
;
42 int using_client_side_fonts
= FALSE
;
44 WINE_DEFAULT_DEBUG_CHANNEL(xrender
);
46 #ifdef HAVE_X11_EXTENSIONS_XRENDER_H
49 #include <X11/extensions/Xrender.h>
51 static XRenderPictFormat
*screen_format
; /* format of screen */
52 static XRenderPictFormat
*mono_format
; /* format of mono bitmap */
57 SIZE devsize
; /* size in device coords */
61 #define INITIAL_REALIZED_BUF_SIZE 128
63 typedef enum { AA_None
= 0, AA_Grey
, AA_RGB
, AA_BGR
, AA_VRGB
, AA_VBGR
, AA_MAXVALUE
} AA_Type
;
68 XRenderPictFormat
*font_format
;
79 gsCacheEntryFormat
* format
[AA_MAXVALUE
];
90 COLORREF lastTextColor
;
94 static gsCacheEntry
*glyphsetCache
= NULL
;
95 static DWORD glyphsetCacheSize
= 0;
96 static INT lastfree
= -1;
99 #define INIT_CACHE_SIZE 10
101 static int antialias
= 1;
103 /* some default values just in case */
104 #ifndef SONAME_LIBX11
105 #define SONAME_LIBX11 "libX11.so"
107 #ifndef SONAME_LIBXEXT
108 #define SONAME_LIBXEXT "libXext.so"
110 #ifndef SONAME_LIBXRENDER
111 #define SONAME_LIBXRENDER "libXrender.so"
114 static void *xrender_handle
;
116 #define MAKE_FUNCPTR(f) static typeof(f) * p##f;
117 MAKE_FUNCPTR(XRenderAddGlyphs
)
118 MAKE_FUNCPTR(XRenderComposite
)
119 MAKE_FUNCPTR(XRenderCompositeString8
)
120 MAKE_FUNCPTR(XRenderCompositeString16
)
121 MAKE_FUNCPTR(XRenderCompositeString32
)
122 MAKE_FUNCPTR(XRenderCreateGlyphSet
)
123 MAKE_FUNCPTR(XRenderCreatePicture
)
124 MAKE_FUNCPTR(XRenderFillRectangle
)
125 MAKE_FUNCPTR(XRenderFindFormat
)
126 MAKE_FUNCPTR(XRenderFindVisualFormat
)
127 MAKE_FUNCPTR(XRenderFreeGlyphSet
)
128 MAKE_FUNCPTR(XRenderFreePicture
)
129 MAKE_FUNCPTR(XRenderSetPictureClipRectangles
)
130 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
131 MAKE_FUNCPTR(XRenderSetPictureTransform
)
133 MAKE_FUNCPTR(XRenderQueryExtension
)
136 static CRITICAL_SECTION xrender_cs
;
137 static CRITICAL_SECTION_DEBUG critsect_debug
=
140 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
141 0, 0, { (DWORD_PTR
)(__FILE__
": xrender_cs") }
143 static CRITICAL_SECTION xrender_cs
= { &critsect_debug
, -1, 0, 0, 0, 0 };
145 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
146 ( ( (ULONG)_x4 << 24 ) | \
147 ( (ULONG)_x3 << 16 ) | \
148 ( (ULONG)_x2 << 8 ) | \
151 #define MS_GASP_TAG MS_MAKE_TAG('g', 'a', 's', 'p')
153 #define GASP_GRIDFIT 0x01
154 #define GASP_DOGRAY 0x02
156 #ifdef WORDS_BIGENDIAN
157 #define get_be_word(x) (x)
159 #define get_be_word(x) RtlUshortByteSwap(x)
162 /***********************************************************************
163 * X11DRV_XRender_Init
165 * Let's see if our XServer has the extension available
168 void X11DRV_XRender_Init(void)
171 XRenderPictFormat pf
;
173 if (client_side_with_render
&&
174 wine_dlopen(SONAME_LIBX11
, RTLD_NOW
|RTLD_GLOBAL
, NULL
, 0) &&
175 wine_dlopen(SONAME_LIBXEXT
, RTLD_NOW
|RTLD_GLOBAL
, NULL
, 0) &&
176 (xrender_handle
= wine_dlopen(SONAME_LIBXRENDER
, RTLD_NOW
, NULL
, 0)))
179 #define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(xrender_handle, #f, NULL, 0)) == NULL) goto sym_not_found;
180 LOAD_FUNCPTR(XRenderAddGlyphs
)
181 LOAD_FUNCPTR(XRenderComposite
)
182 LOAD_FUNCPTR(XRenderCompositeString8
)
183 LOAD_FUNCPTR(XRenderCompositeString16
)
184 LOAD_FUNCPTR(XRenderCompositeString32
)
185 LOAD_FUNCPTR(XRenderCreateGlyphSet
)
186 LOAD_FUNCPTR(XRenderCreatePicture
)
187 LOAD_FUNCPTR(XRenderFillRectangle
)
188 LOAD_FUNCPTR(XRenderFindFormat
)
189 LOAD_FUNCPTR(XRenderFindVisualFormat
)
190 LOAD_FUNCPTR(XRenderFreeGlyphSet
)
191 LOAD_FUNCPTR(XRenderFreePicture
)
192 LOAD_FUNCPTR(XRenderSetPictureClipRectangles
)
193 LOAD_FUNCPTR(XRenderQueryExtension
)
195 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
196 #define LOAD_OPTIONAL_FUNCPTR(f) p##f = wine_dlsym(xrender_handle, #f, NULL, 0);
197 LOAD_OPTIONAL_FUNCPTR(XRenderSetPictureTransform
)
198 #undef LOAD_OPTIONAL_FUNCPTR
203 if(pXRenderQueryExtension(gdi_display
, &event_base
, &xrender_error_base
)) {
204 X11DRV_XRender_Installed
= TRUE
;
205 TRACE("Xrender is up and running error_base = %d\n", xrender_error_base
);
206 screen_format
= pXRenderFindVisualFormat(gdi_display
, visual
);
209 /* Xrender doesn't like DirectColor visuals, try to find a TrueColor one instead */
210 if (visual
->class == DirectColor
)
213 if (XMatchVisualInfo( gdi_display
, DefaultScreen(gdi_display
),
214 screen_depth
, TrueColor
, &info
))
216 screen_format
= pXRenderFindVisualFormat(gdi_display
, info
.visual
);
217 if (screen_format
) visual
= info
.visual
;
221 if(!screen_format
) /* This fails in buggy versions of libXrender.so */
225 "Wine has detected that you probably have a buggy version\n"
226 "of libXrender.so . Because of this client side font rendering\n"
227 "will be disabled. Please upgrade this library.\n");
228 X11DRV_XRender_Installed
= FALSE
;
231 pf
.type
= PictTypeDirect
;
234 pf
.direct
.alphaMask
= 1;
235 mono_format
= pXRenderFindFormat(gdi_display
, PictFormatType
|
236 PictFormatDepth
| PictFormatAlpha
|
237 PictFormatAlphaMask
, &pf
, 0);
239 ERR("mono_format == NULL?\n");
240 X11DRV_XRender_Installed
= FALSE
;
242 if (!visual
->red_mask
|| !visual
->green_mask
|| !visual
->blue_mask
) {
243 WARN("one or more of the colour masks are 0, disabling XRENDER. Try running in 16-bit mode or higher.\n");
244 X11DRV_XRender_Installed
= FALSE
;
251 if(X11DRV_XRender_Installed
|| client_side_with_core
)
253 glyphsetCache
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
254 sizeof(*glyphsetCache
) * INIT_CACHE_SIZE
);
256 glyphsetCacheSize
= INIT_CACHE_SIZE
;
258 for(i
= 0; i
< INIT_CACHE_SIZE
; i
++) {
259 glyphsetCache
[i
].next
= i
+ 1;
260 glyphsetCache
[i
].count
= -1;
262 glyphsetCache
[i
-1].next
= -1;
263 using_client_side_fonts
= 1;
265 if(!X11DRV_XRender_Installed
) {
266 TRACE("Xrender is not available on your XServer, client side rendering with the core protocol instead.\n");
267 if(screen_depth
<= 8 || !client_side_antialias_with_core
)
270 if(screen_depth
<= 8 || !client_side_antialias_with_render
)
274 else TRACE("Using X11 core fonts\n");
277 static BOOL
fontcmp(LFANDSIZE
*p1
, LFANDSIZE
*p2
)
279 if(p1
->hash
!= p2
->hash
) return TRUE
;
280 if(memcmp(&p1
->devsize
, &p2
->devsize
, sizeof(p1
->devsize
))) return TRUE
;
281 if(memcmp(&p1
->lf
, &p2
->lf
, offsetof(LOGFONTW
, lfFaceName
))) return TRUE
;
282 return strcmpW(p1
->lf
.lfFaceName
, p2
->lf
.lfFaceName
);
286 static void walk_cache(void)
290 EnterCriticalSection(&xrender_cs
);
291 for(i
=mru
; i
>= 0; i
= glyphsetCache
[i
].next
)
292 TRACE("item %d\n", i
);
293 LeaveCriticalSection(&xrender_cs
);
297 static int LookupEntry(LFANDSIZE
*plfsz
)
301 for(i
= mru
; i
>= 0; i
= glyphsetCache
[i
].next
) {
303 if(glyphsetCache
[i
].count
== -1) { /* reached free list so stop */
308 if(!fontcmp(&glyphsetCache
[i
].lfsz
, plfsz
)) {
309 glyphsetCache
[i
].count
++;
311 glyphsetCache
[prev_i
].next
= glyphsetCache
[i
].next
;
312 glyphsetCache
[i
].next
= mru
;
315 TRACE("found font in cache %d\n", i
);
320 TRACE("font not in cache\n");
324 static void FreeEntry(int entry
)
328 for(format
= 0; format
< AA_MAXVALUE
; format
++) {
329 gsCacheEntryFormat
* formatEntry
;
331 if( !glyphsetCache
[entry
].format
[format
] )
334 formatEntry
= glyphsetCache
[entry
].format
[format
];
336 if(formatEntry
->glyphset
) {
338 pXRenderFreeGlyphSet(gdi_display
, formatEntry
->glyphset
);
340 formatEntry
->glyphset
= 0;
342 if(formatEntry
->nrealized
) {
343 HeapFree(GetProcessHeap(), 0, formatEntry
->realized
);
344 formatEntry
->realized
= NULL
;
345 if(formatEntry
->bitmaps
) {
346 for(i
= 0; i
< formatEntry
->nrealized
; i
++)
347 HeapFree(GetProcessHeap(), 0, formatEntry
->bitmaps
[i
]);
348 HeapFree(GetProcessHeap(), 0, formatEntry
->bitmaps
);
349 formatEntry
->bitmaps
= NULL
;
350 HeapFree(GetProcessHeap(), 0, formatEntry
->gis
);
351 formatEntry
->gis
= NULL
;
353 formatEntry
->nrealized
= 0;
356 HeapFree(GetProcessHeap(), 0, formatEntry
);
357 glyphsetCache
[entry
].format
[format
] = NULL
;
361 static int AllocEntry(void)
363 int best
= -1, prev_best
= -1, i
, prev_i
= -1;
366 assert(glyphsetCache
[lastfree
].count
== -1);
367 glyphsetCache
[lastfree
].count
= 1;
369 lastfree
= glyphsetCache
[lastfree
].next
;
371 glyphsetCache
[best
].next
= mru
;
374 TRACE("empty space at %d, next lastfree = %d\n", mru
, lastfree
);
378 for(i
= mru
; i
>= 0; i
= glyphsetCache
[i
].next
) {
379 if(glyphsetCache
[i
].count
== 0) {
387 TRACE("freeing unused glyphset at cache %d\n", best
);
389 glyphsetCache
[best
].count
= 1;
391 glyphsetCache
[prev_best
].next
= glyphsetCache
[best
].next
;
392 glyphsetCache
[best
].next
= mru
;
400 TRACE("Growing cache\n");
403 glyphsetCache
= HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
405 (glyphsetCacheSize
+ INIT_CACHE_SIZE
)
406 * sizeof(*glyphsetCache
));
408 glyphsetCache
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
409 (glyphsetCacheSize
+ INIT_CACHE_SIZE
)
410 * sizeof(*glyphsetCache
));
412 for(best
= i
= glyphsetCacheSize
; i
< glyphsetCacheSize
+ INIT_CACHE_SIZE
;
414 glyphsetCache
[i
].next
= i
+ 1;
415 glyphsetCache
[i
].count
= -1;
417 glyphsetCache
[i
-1].next
= -1;
418 glyphsetCacheSize
+= INIT_CACHE_SIZE
;
420 lastfree
= glyphsetCache
[best
].next
;
421 glyphsetCache
[best
].count
= 1;
422 glyphsetCache
[best
].next
= mru
;
424 TRACE("new free cache slot at %d\n", mru
);
428 static BOOL
get_gasp_flags(X11DRV_PDEVICE
*physDev
, WORD
*flags
)
438 size
= GetFontData(physDev
->hdc
, MS_GASP_TAG
, 0, NULL
, 0);
439 if(size
== GDI_ERROR
)
442 gasp
= buffer
= HeapAlloc(GetProcessHeap(), 0, size
);
443 GetFontData(physDev
->hdc
, MS_GASP_TAG
, 0, gasp
, size
);
445 GetTextMetricsW(physDev
->hdc
, &tm
);
446 ppem
= abs(X11DRV_YWStoDS(physDev
, tm
.tmAscent
+ tm
.tmDescent
- tm
.tmInternalLeading
));
449 num_recs
= get_be_word(*gasp
);
453 *flags
= get_be_word(*(gasp
+ 1));
454 if(ppem
<= get_be_word(*gasp
))
458 TRACE("got flags %04x for ppem %ld\n", *flags
, ppem
);
460 HeapFree(GetProcessHeap(), 0, buffer
);
464 static int GetCacheEntry(X11DRV_PDEVICE
*physDev
, LFANDSIZE
*plfsz
)
470 static int hinter
= -1;
472 if((ret
= LookupEntry(plfsz
)) != -1) return ret
;
475 entry
= glyphsetCache
+ ret
;
476 entry
->lfsz
= *plfsz
;
477 for( format
= 0; format
< AA_MAXVALUE
; format
++ ) {
478 assert( !entry
->format
[format
] );
481 if(antialias
&& plfsz
->lf
.lfQuality
!= NONANTIALIASED_QUALITY
)
485 RASTERIZER_STATUS status
;
486 GetRasterizerCaps(&status
, sizeof(status
));
487 hinter
= status
.wFlags
& WINE_TT_HINTER_ENABLED
;
489 if(!hinter
|| !get_gasp_flags(physDev
, &flags
) || flags
& GASP_DOGRAY
)
490 entry
->aa_default
= AA_Grey
;
492 entry
->aa_default
= AA_None
;
495 entry
->aa_default
= AA_None
;
500 static void dec_ref_cache(int index
)
503 TRACE("dec'ing entry %d to %d\n", index
, glyphsetCache
[index
].count
- 1);
504 assert(glyphsetCache
[index
].count
> 0);
505 glyphsetCache
[index
].count
--;
508 static void lfsz_calc_hash(LFANDSIZE
*plfsz
)
510 DWORD hash
= 0, *ptr
;
513 hash
^= plfsz
->devsize
.cx
;
514 hash
^= plfsz
->devsize
.cy
;
515 for(i
= 0, ptr
= (DWORD
*)&plfsz
->lf
; i
< 7; i
++, ptr
++)
517 for(i
= 0, ptr
= (DWORD
*)&plfsz
->lf
.lfFaceName
; i
< LF_FACESIZE
/2; i
++, ptr
++) {
518 WCHAR
*pwc
= (WCHAR
*)ptr
;
528 /***********************************************************************
529 * X11DRV_XRender_Finalize
531 void X11DRV_XRender_Finalize(void)
535 EnterCriticalSection(&xrender_cs
);
536 for(i
= mru
; i
>= 0; i
= glyphsetCache
[i
].next
)
538 LeaveCriticalSection(&xrender_cs
);
542 /***********************************************************************
543 * X11DRV_XRender_SelectFont
545 BOOL
X11DRV_XRender_SelectFont(X11DRV_PDEVICE
*physDev
, HFONT hfont
)
549 GetObjectW(hfont
, sizeof(lfsz
.lf
), &lfsz
.lf
);
550 TRACE("h=%ld w=%ld weight=%ld it=%d charset=%d name=%s\n",
551 lfsz
.lf
.lfHeight
, lfsz
.lf
.lfWidth
, lfsz
.lf
.lfWeight
,
552 lfsz
.lf
.lfItalic
, lfsz
.lf
.lfCharSet
, debugstr_w(lfsz
.lf
.lfFaceName
));
553 lfsz
.devsize
.cx
= X11DRV_XWStoDS( physDev
, lfsz
.lf
.lfWidth
);
554 lfsz
.devsize
.cy
= X11DRV_YWStoDS( physDev
, lfsz
.lf
.lfHeight
);
555 lfsz_calc_hash(&lfsz
);
557 EnterCriticalSection(&xrender_cs
);
558 if(!physDev
->xrender
) {
559 physDev
->xrender
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
560 sizeof(*physDev
->xrender
));
561 physDev
->xrender
->cache_index
= -1;
563 else if(physDev
->xrender
->cache_index
!= -1)
564 dec_ref_cache(physDev
->xrender
->cache_index
);
565 physDev
->xrender
->cache_index
= GetCacheEntry(physDev
, &lfsz
);
566 LeaveCriticalSection(&xrender_cs
);
570 /***********************************************************************
571 * X11DRV_XRender_DeleteDC
573 void X11DRV_XRender_DeleteDC(X11DRV_PDEVICE
*physDev
)
576 if(physDev
->xrender
->tile_pict
)
577 pXRenderFreePicture(gdi_display
, physDev
->xrender
->tile_pict
);
579 if(physDev
->xrender
->tile_xpm
)
580 XFreePixmap(gdi_display
, physDev
->xrender
->tile_xpm
);
582 if(physDev
->xrender
->pict
) {
583 TRACE("freeing pict = %lx dc = %p\n", physDev
->xrender
->pict
, physDev
->hdc
);
584 pXRenderFreePicture(gdi_display
, physDev
->xrender
->pict
);
588 EnterCriticalSection(&xrender_cs
);
589 if(physDev
->xrender
->cache_index
!= -1)
590 dec_ref_cache(physDev
->xrender
->cache_index
);
591 LeaveCriticalSection(&xrender_cs
);
593 HeapFree(GetProcessHeap(), 0, physDev
->xrender
);
594 physDev
->xrender
= NULL
;
598 /***********************************************************************
599 * X11DRV_XRender_UpdateDrawable
601 * This gets called from X11DRV_SetDrawable and X11DRV_SelectBitmap.
602 * It deletes the pict when the drawable changes.
604 void X11DRV_XRender_UpdateDrawable(X11DRV_PDEVICE
*physDev
)
606 if(physDev
->xrender
->pict
) {
607 TRACE("freeing pict %08lx from dc %p drawable %08lx\n", physDev
->xrender
->pict
,
608 physDev
->hdc
, physDev
->drawable
);
611 pXRenderFreePicture(gdi_display
, physDev
->xrender
->pict
);
614 physDev
->xrender
->pict
= 0;
618 /************************************************************************
621 * Helper to ExtTextOut. Must be called inside xrender_cs
623 static BOOL
UploadGlyph(X11DRV_PDEVICE
*physDev
, int glyph
, AA_Type format
)
630 gsCacheEntry
*entry
= glyphsetCache
+ physDev
->xrender
->cache_index
;
631 gsCacheEntryFormat
*formatEntry
;
632 UINT ggo_format
= GGO_GLYPH_INDEX
;
633 XRenderPictFormat pf
;
635 /* If there is nothing for the current type, we create the entry. */
636 if( !entry
->format
[format
] ) {
637 entry
->format
[format
] = HeapAlloc(GetProcessHeap(),
639 sizeof(gsCacheEntryFormat
));
641 formatEntry
= entry
->format
[format
];
643 if(formatEntry
->nrealized
<= glyph
) {
644 formatEntry
->nrealized
= (glyph
/ 128 + 1) * 128;
646 if (formatEntry
->realized
)
647 formatEntry
->realized
= HeapReAlloc(GetProcessHeap(),
649 formatEntry
->realized
,
650 formatEntry
->nrealized
* sizeof(BOOL
));
652 formatEntry
->realized
= HeapAlloc(GetProcessHeap(),
654 formatEntry
->nrealized
* sizeof(BOOL
));
656 if(!X11DRV_XRender_Installed
) {
657 if (formatEntry
->bitmaps
)
658 formatEntry
->bitmaps
= HeapReAlloc(GetProcessHeap(),
660 formatEntry
->bitmaps
,
661 formatEntry
->nrealized
* sizeof(formatEntry
->bitmaps
[0]));
663 formatEntry
->bitmaps
= HeapAlloc(GetProcessHeap(),
665 formatEntry
->nrealized
* sizeof(formatEntry
->bitmaps
[0]));
667 if (formatEntry
->gis
)
668 formatEntry
->gis
= HeapReAlloc(GetProcessHeap(),
671 formatEntry
->nrealized
* sizeof(formatEntry
->gis
[0]));
673 formatEntry
->gis
= HeapAlloc(GetProcessHeap(),
675 formatEntry
->nrealized
* sizeof(formatEntry
->gis
[0]));
681 ggo_format
|= WINE_GGO_GRAY16_BITMAP
;
685 ERR("aa = %d - not implemented\n", format
);
687 ggo_format
|= GGO_BITMAP
;
691 buflen
= GetGlyphOutlineW(physDev
->hdc
, glyph
, ggo_format
, &gm
, 0, NULL
,
693 if(buflen
== GDI_ERROR
) {
694 if(format
!= AA_None
) {
696 entry
->aa_default
= AA_None
;
697 ggo_format
&= ~WINE_GGO_GRAY16_BITMAP
;
698 ggo_format
|= GGO_BITMAP
;
699 buflen
= GetGlyphOutlineW(physDev
->hdc
, glyph
, ggo_format
, &gm
, 0, NULL
,
702 if(buflen
== GDI_ERROR
) {
703 ERR("GetGlyphOutlineW failed\n");
706 TRACE("Turning off antialiasing for this monochrome font\n");
709 if(formatEntry
->glyphset
== 0 && X11DRV_XRender_Installed
) {
713 pf
.direct
.alphaMask
= 0xff;
717 ERR("aa = %d - not implemented\n", format
);
720 pf
.direct
.alphaMask
= 1;
724 pf
.type
= PictTypeDirect
;
728 formatEntry
->font_format
= pXRenderFindFormat(gdi_display
,
735 formatEntry
->glyphset
= pXRenderCreateGlyphSet(gdi_display
, formatEntry
->font_format
);
740 buf
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, buflen
);
741 GetGlyphOutlineW(physDev
->hdc
, glyph
, ggo_format
, &gm
, buflen
, buf
, NULL
);
742 formatEntry
->realized
[glyph
] = TRUE
;
744 TRACE("buflen = %d. Got metrics: %dx%d adv=%d,%d origin=%ld,%ld\n",
746 gm
.gmBlackBoxX
, gm
.gmBlackBoxY
, gm
.gmCellIncX
, gm
.gmCellIncY
,
747 gm
.gmptGlyphOrigin
.x
, gm
.gmptGlyphOrigin
.y
);
749 gi
.width
= gm
.gmBlackBoxX
;
750 gi
.height
= gm
.gmBlackBoxY
;
751 gi
.x
= -gm
.gmptGlyphOrigin
.x
;
752 gi
.y
= gm
.gmptGlyphOrigin
.y
;
753 gi
.xOff
= gm
.gmCellIncX
;
754 gi
.yOff
= gm
.gmCellIncY
;
756 if(TRACE_ON(xrender
)) {
761 if(format
== AA_None
) {
762 pitch
= ((gi
.width
+ 31) / 32) * 4;
763 for(i
= 0; i
< gi
.height
; i
++) {
764 line
= (unsigned char*) buf
+ i
* pitch
;
766 for(j
= 0; j
< pitch
* 8; j
++) {
767 strcat(output
, (line
[j
/ 8] & (1 << (7 - (j
% 8)))) ? "#" : " ");
769 strcat(output
, "\n");
773 static const char blks
[] = " .:;!o*#";
777 pitch
= ((gi
.width
+ 3) / 4) * 4;
778 for(i
= 0; i
< gi
.height
; i
++) {
779 line
= (unsigned char*) buf
+ i
* pitch
;
781 for(j
= 0; j
< pitch
; j
++) {
782 str
[0] = blks
[line
[j
] >> 5];
785 strcat(output
, "\n");
791 if(formatEntry
->glyphset
) {
792 if(format
== AA_None
&& BitmapBitOrder(gdi_display
) != MSBFirst
) {
793 unsigned char *byte
= (unsigned char*) buf
, c
;
799 /* magic to flip bit order */
800 c
= ((c
<< 1) & 0xaa) | ((c
>> 1) & 0x55);
801 c
= ((c
<< 2) & 0xcc) | ((c
>> 2) & 0x33);
802 c
= ((c
<< 4) & 0xf0) | ((c
>> 4) & 0x0f);
809 pXRenderAddGlyphs(gdi_display
, formatEntry
->glyphset
, &gid
, &gi
, 1,
812 HeapFree(GetProcessHeap(), 0, buf
);
814 formatEntry
->bitmaps
[glyph
] = buf
;
815 memcpy(&formatEntry
->gis
[glyph
], &gi
, sizeof(gi
));
820 static void SharpGlyphMono(X11DRV_PDEVICE
*physDev
, INT x
, INT y
,
821 void *bitmap
, XGlyphInfo
*gi
)
823 unsigned char *srcLine
= bitmap
, *src
;
824 unsigned char bits
, bitsMask
;
825 int width
= gi
->width
;
826 int stride
= ((width
+ 31) & ~31) >> 3;
827 int height
= gi
->height
;
831 TRACE("%d, %d\n", x
, y
);
840 bitsMask
= 0x80; /* FreeType is always MSB first */
854 bitsMask
= bitsMask
>> 1;
860 } while (bits
& bitsMask
);
861 XFillRectangle (gdi_display
, physDev
->drawable
,
862 physDev
->gc
, xspan
, y
, lenspan
, 1);
874 bitsMask
= bitsMask
>> 1;
880 } while (!(bits
& bitsMask
));
887 static void SharpGlyphGray(X11DRV_PDEVICE
*physDev
, INT x
, INT y
,
888 void *bitmap
, XGlyphInfo
*gi
)
890 unsigned char *srcLine
= bitmap
, *src
, bits
;
891 int width
= gi
->width
;
892 int stride
= ((width
+ 3) & ~3);
893 int height
= gi
->height
;
918 } while (bits
>= 0x80);
919 XFillRectangle (gdi_display
, physDev
->drawable
,
920 physDev
->gc
, xspan
, y
, lenspan
, 1);
933 } while (bits
< 0x80);
941 static void ExamineBitfield (DWORD mask
, int *shift
, int *len
)
946 while ((mask
& 1) == 0)
952 while ((mask
& 1) == 1)
961 static DWORD
GetField (DWORD pixel
, int shift
, int len
)
963 pixel
= pixel
& (((1 << (len
)) - 1) << shift
);
964 pixel
= pixel
<< (32 - (shift
+ len
)) >> 24;
967 pixel
|= (pixel
>> len
);
974 static DWORD
PutField (DWORD pixel
, int shift
, int len
)
976 shift
= shift
- (8 - len
);
978 pixel
&= (((1 << len
) - 1) << (8 - len
));
986 static void SmoothGlyphGray(XImage
*image
, int x
, int y
, void *bitmap
, XGlyphInfo
*gi
,
992 BYTE
*maskLine
, *mask
, m
;
997 BYTE src_r
, src_g
, src_b
;
1002 height
= gi
->height
;
1004 maskLine
= (unsigned char *) bitmap
;
1005 maskStride
= (width
+ 3) & ~3;
1007 ExamineBitfield (image
->red_mask
, &r_shift
, &r_len
);
1008 ExamineBitfield (image
->green_mask
, &g_shift
, &g_len
);
1009 ExamineBitfield (image
->blue_mask
, &b_shift
, &b_len
);
1011 src_r
= GetField(color
, r_shift
, r_len
);
1012 src_g
= GetField(color
, g_shift
, g_len
);
1013 src_b
= GetField(color
, b_shift
, b_len
);
1015 for(; height
--; y
++)
1018 maskLine
+= maskStride
;
1023 if(y
>= image
->height
) break;
1027 if(tx
>= image
->width
) break;
1030 if(tx
< 0) continue;
1033 XPutPixel (image
, tx
, y
, color
);
1038 pixel
= XGetPixel (image
, tx
, y
);
1040 r
= GetField(pixel
, r_shift
, r_len
);
1041 r
= ((BYTE
)~m
* (WORD
)r
+ (BYTE
)m
* (WORD
)src_r
) >> 8;
1042 g
= GetField(pixel
, g_shift
, g_len
);
1043 g
= ((BYTE
)~m
* (WORD
)g
+ (BYTE
)m
* (WORD
)src_g
) >> 8;
1044 b
= GetField(pixel
, b_shift
, b_len
);
1045 b
= ((BYTE
)~m
* (WORD
)b
+ (BYTE
)m
* (WORD
)src_b
) >> 8;
1047 pixel
= (PutField (r
, r_shift
, r_len
) |
1048 PutField (g
, g_shift
, g_len
) |
1049 PutField (b
, b_shift
, b_len
));
1050 XPutPixel (image
, tx
, y
, pixel
);
1056 static int XRenderErrorHandler(Display
*dpy
, XErrorEvent
*event
, void *arg
)
1061 /***********************************************************************
1062 * X11DRV_XRender_ExtTextOut
1064 BOOL
X11DRV_XRender_ExtTextOut( X11DRV_PDEVICE
*physDev
, INT x
, INT y
, UINT flags
,
1065 const RECT
*lprect
, LPCWSTR wstr
, UINT count
,
1071 int render_op
= PictOpOver
;
1072 gsCacheEntry
*entry
;
1073 gsCacheEntryFormat
*formatEntry
;
1075 HDC hdc
= physDev
->hdc
;
1076 int textPixel
, backgroundPixel
;
1077 HRGN saved_region
= 0;
1078 BOOL disable_antialias
= FALSE
;
1079 AA_Type antialias
= AA_None
;
1082 double cosEsc
, sinEsc
;
1085 /* Do we need to disable antialiasing because of palette mode? */
1086 if( !physDev
->bitmap
|| GetObjectW( physDev
->bitmap
->hbitmap
, sizeof(bmp
), &bmp
) != sizeof(bmp
) ) {
1087 TRACE("bitmap is not a DIB\n");
1089 else if (bmp
.dsBmih
.biBitCount
<= 8) {
1090 TRACE("Disabling antialiasing\n");
1091 disable_antialias
= TRUE
;
1094 xgcval
.function
= GXcopy
;
1095 xgcval
.background
= physDev
->backgroundPixel
;
1096 xgcval
.fill_style
= FillSolid
;
1098 XChangeGC( gdi_display
, physDev
->gc
, GCFunction
| GCBackground
| GCFillStyle
, &xgcval
);
1099 wine_tsx11_unlock();
1101 X11DRV_LockDIBSection( physDev
, DIB_Status_GdiMod
, FALSE
);
1103 if(physDev
->depth
== 1) {
1104 if((physDev
->textPixel
& 0xffffff) == 0) {
1106 backgroundPixel
= 1;
1109 backgroundPixel
= 0;
1112 textPixel
= physDev
->textPixel
;
1113 backgroundPixel
= physDev
->backgroundPixel
;
1116 if(flags
& ETO_OPAQUE
)
1119 XSetForeground( gdi_display
, physDev
->gc
, backgroundPixel
);
1120 XFillRectangle( gdi_display
, physDev
->drawable
, physDev
->gc
,
1121 physDev
->org
.x
+ lprect
->left
, physDev
->org
.y
+ lprect
->top
,
1122 lprect
->right
- lprect
->left
, lprect
->bottom
- lprect
->top
);
1123 wine_tsx11_unlock();
1133 GetObjectW(GetCurrentObject(physDev
->hdc
, OBJ_FONT
), sizeof(lf
), &lf
);
1134 if(lf
.lfEscapement
!= 0) {
1135 cosEsc
= cos(lf
.lfEscapement
* M_PI
/ 1800);
1136 sinEsc
= sin(lf
.lfEscapement
* M_PI
/ 1800);
1142 if (flags
& ETO_CLIPPED
)
1146 clip_region
= CreateRectRgnIndirect( lprect
);
1147 /* make a copy of the current device region */
1148 saved_region
= CreateRectRgn( 0, 0, 0, 0 );
1149 CombineRgn( saved_region
, physDev
->region
, 0, RGN_COPY
);
1150 X11DRV_SetDeviceClipping( physDev
, saved_region
, clip_region
);
1151 DeleteObject( clip_region
);
1154 if(X11DRV_XRender_Installed
) {
1155 if(!physDev
->xrender
->pict
) {
1156 XRenderPictureAttributes pa
;
1157 pa
.subwindow_mode
= IncludeInferiors
;
1160 physDev
->xrender
->pict
= pXRenderCreatePicture(gdi_display
,
1162 (physDev
->depth
== 1) ?
1163 mono_format
: screen_format
,
1164 CPSubwindowMode
, &pa
);
1165 wine_tsx11_unlock();
1167 TRACE("allocing pict = %lx dc = %p drawable = %08lx\n",
1168 physDev
->xrender
->pict
, hdc
, physDev
->drawable
);
1170 TRACE("using existing pict = %lx dc = %p drawable = %08lx\n",
1171 physDev
->xrender
->pict
, hdc
, physDev
->drawable
);
1174 if ((data
= X11DRV_GetRegionData( physDev
->region
, 0 )))
1177 pXRenderSetPictureClipRectangles( gdi_display
, physDev
->xrender
->pict
,
1178 physDev
->org
.x
, physDev
->org
.y
,
1179 (XRectangle
*)data
->Buffer
, data
->rdh
.nCount
);
1180 wine_tsx11_unlock();
1181 HeapFree( GetProcessHeap(), 0, data
);
1185 if(X11DRV_XRender_Installed
) {
1186 /* Create a 1x1 pixmap to tile over the font mask */
1187 if(!physDev
->xrender
->tile_xpm
) {
1188 XRenderPictureAttributes pa
;
1190 XRenderPictFormat
*format
= (physDev
->depth
== 1) ? mono_format
: screen_format
;
1192 physDev
->xrender
->tile_xpm
= XCreatePixmap(gdi_display
,
1197 physDev
->xrender
->tile_pict
= pXRenderCreatePicture(gdi_display
,
1198 physDev
->xrender
->tile_xpm
,
1201 wine_tsx11_unlock();
1202 TRACE("Created pixmap of depth %d\n", format
->depth
);
1203 /* init lastTextColor to something different from textPixel */
1204 physDev
->xrender
->lastTextColor
= ~physDev
->textPixel
;
1208 if(physDev
->textPixel
!= physDev
->xrender
->lastTextColor
) {
1209 if(physDev
->depth
!= 1) {
1210 /* Map 0 -- 0xff onto 0 -- 0xffff */
1215 ExamineBitfield (visual
->red_mask
, &r_shift
, &r_len
);
1216 ExamineBitfield (visual
->green_mask
, &g_shift
, &g_len
);
1217 ExamineBitfield (visual
->blue_mask
, &b_shift
, &b_len
);
1219 col
.red
= GetField(physDev
->textPixel
, r_shift
, r_len
);
1220 col
.red
|= col
.red
<< 8;
1221 col
.green
= GetField(physDev
->textPixel
, g_shift
, g_len
);
1222 col
.green
|= col
.green
<< 8;
1223 col
.blue
= GetField(physDev
->textPixel
, b_shift
, b_len
);
1224 col
.blue
|= col
.blue
<< 8;
1226 } else { /* for a 1bpp bitmap we always need a 1 in the tile */
1227 col
.red
= col
.green
= col
.blue
= 0;
1231 pXRenderFillRectangle(gdi_display
, PictOpSrc
,
1232 physDev
->xrender
->tile_pict
,
1234 wine_tsx11_unlock();
1235 physDev
->xrender
->lastTextColor
= physDev
->textPixel
;
1238 /* FIXME the mapping of Text/BkColor onto 1 or 0 needs investigation.
1240 if((physDev
->depth
== 1) && (textPixel
== 0))
1241 render_op
= PictOpOutReverse
; /* This gives us 'black' text */
1244 EnterCriticalSection(&xrender_cs
);
1245 entry
= glyphsetCache
+ physDev
->xrender
->cache_index
;
1246 if( disable_antialias
== FALSE
)
1247 antialias
= entry
->aa_default
;
1248 formatEntry
= entry
->format
[antialias
];
1250 for(idx
= 0; idx
< count
; idx
++) {
1251 if( !formatEntry
) {
1252 UploadGlyph(physDev
, wstr
[idx
], antialias
);
1253 formatEntry
= entry
->format
[antialias
];
1254 } else if( wstr
[idx
] >= formatEntry
->nrealized
|| formatEntry
->realized
[wstr
[idx
]] == FALSE
) {
1255 UploadGlyph(physDev
, wstr
[idx
], antialias
);
1258 assert(formatEntry
);
1260 TRACE("Writing %s at %ld,%ld\n", debugstr_wn(wstr
,count
),
1261 physDev
->org
.x
+ x
, physDev
->org
.y
+ y
);
1263 if(X11DRV_XRender_Installed
) {
1266 pXRenderCompositeString16(gdi_display
, render_op
,
1267 physDev
->xrender
->tile_pict
,
1268 physDev
->xrender
->pict
,
1269 formatEntry
->font_format
, formatEntry
->glyphset
,
1270 0, 0, physDev
->org
.x
+ x
, physDev
->org
.y
+ y
,
1273 INT offset
= 0, xoff
= 0, yoff
= 0;
1274 for(idx
= 0; idx
< count
; idx
++) {
1275 pXRenderCompositeString16(gdi_display
, render_op
,
1276 physDev
->xrender
->tile_pict
,
1277 physDev
->xrender
->pict
,
1278 formatEntry
->font_format
, formatEntry
->glyphset
,
1279 0, 0, physDev
->org
.x
+ x
+ xoff
,
1280 physDev
->org
.y
+ y
+ yoff
,
1282 offset
+= lpDx
[idx
];
1283 xoff
= offset
* cosEsc
;
1284 yoff
= offset
* -sinEsc
;
1287 wine_tsx11_unlock();
1290 INT offset
= 0, xoff
= 0, yoff
= 0;
1292 XSetForeground( gdi_display
, physDev
->gc
, textPixel
);
1294 if(antialias
== AA_None
) {
1295 for(idx
= 0; idx
< count
; idx
++) {
1296 SharpGlyphMono(physDev
, physDev
->org
.x
+ x
+ xoff
,
1297 physDev
->org
.y
+ y
+ yoff
,
1298 formatEntry
->bitmaps
[wstr
[idx
]],
1299 &formatEntry
->gis
[wstr
[idx
]]);
1301 offset
+= lpDx
[idx
];
1302 xoff
= offset
* cosEsc
;
1303 yoff
= offset
* -sinEsc
;
1305 xoff
+= formatEntry
->gis
[wstr
[idx
]].xOff
;
1306 yoff
+= formatEntry
->gis
[wstr
[idx
]].yOff
;
1309 } else if(physDev
->depth
== 1) {
1310 for(idx
= 0; idx
< count
; idx
++) {
1311 SharpGlyphGray(physDev
, physDev
->org
.x
+ x
+ xoff
,
1312 physDev
->org
.y
+ y
+ yoff
,
1313 formatEntry
->bitmaps
[wstr
[idx
]],
1314 &formatEntry
->gis
[wstr
[idx
]]);
1316 offset
+= lpDx
[idx
];
1317 xoff
= offset
* cosEsc
;
1318 yoff
= offset
* -sinEsc
;
1320 xoff
+= formatEntry
->gis
[wstr
[idx
]].xOff
;
1321 yoff
+= formatEntry
->gis
[wstr
[idx
]].yOff
;
1327 unsigned int w
, h
, dummy_uint
;
1328 Window dummy_window
;
1330 int image_x
, image_y
, image_off_x
, image_off_y
, image_w
, image_h
;
1331 RECT extents
= {0, 0, 0, 0};
1335 XGetGeometry(gdi_display
, physDev
->drawable
, &dummy_window
, &dummy_int
, &dummy_int
,
1336 &w
, &h
, &dummy_uint
, &dummy_uint
);
1337 TRACE("drawable %dx%d\n", w
, h
);
1339 for(idx
= 0; idx
< count
; idx
++) {
1340 if(extents
.left
> cur
.x
- formatEntry
->gis
[wstr
[idx
]].x
)
1341 extents
.left
= cur
.x
- formatEntry
->gis
[wstr
[idx
]].x
;
1342 if(extents
.top
> cur
.y
- formatEntry
->gis
[wstr
[idx
]].y
)
1343 extents
.top
= cur
.y
- formatEntry
->gis
[wstr
[idx
]].y
;
1344 if(extents
.right
< cur
.x
- formatEntry
->gis
[wstr
[idx
]].x
+ formatEntry
->gis
[wstr
[idx
]].width
)
1345 extents
.right
= cur
.x
- formatEntry
->gis
[wstr
[idx
]].x
+ formatEntry
->gis
[wstr
[idx
]].width
;
1346 if(extents
.bottom
< cur
.y
- formatEntry
->gis
[wstr
[idx
]].y
+ formatEntry
->gis
[wstr
[idx
]].height
)
1347 extents
.bottom
= cur
.y
- formatEntry
->gis
[wstr
[idx
]].y
+ formatEntry
->gis
[wstr
[idx
]].height
;
1349 offset
+= lpDx
[idx
];
1350 cur
.x
= offset
* cosEsc
;
1351 cur
.y
= offset
* -sinEsc
;
1353 cur
.x
+= formatEntry
->gis
[wstr
[idx
]].xOff
;
1354 cur
.y
+= formatEntry
->gis
[wstr
[idx
]].yOff
;
1357 TRACE("glyph extents %ld,%ld - %ld,%ld drawable x,y %ld,%ld\n", extents
.left
, extents
.top
,
1358 extents
.right
, extents
.bottom
, physDev
->org
.x
+ x
, physDev
->org
.y
+ y
);
1360 if(physDev
->org
.x
+ x
+ extents
.left
>= 0) {
1361 image_x
= physDev
->org
.x
+ x
+ extents
.left
;
1365 image_off_x
= physDev
->org
.x
+ x
+ extents
.left
;
1367 if(physDev
->org
.y
+ y
+ extents
.top
>= 0) {
1368 image_y
= physDev
->org
.y
+ y
+ extents
.top
;
1372 image_off_y
= physDev
->org
.y
+ y
+ extents
.top
;
1374 if(physDev
->org
.x
+ x
+ extents
.right
< w
)
1375 image_w
= physDev
->org
.x
+ x
+ extents
.right
- image_x
;
1377 image_w
= w
- image_x
;
1378 if(physDev
->org
.y
+ y
+ extents
.bottom
< h
)
1379 image_h
= physDev
->org
.y
+ y
+ extents
.bottom
- image_y
;
1381 image_h
= h
- image_y
;
1383 if(image_w
<= 0 || image_h
<= 0) goto no_image
;
1385 X11DRV_expect_error(gdi_display
, XRenderErrorHandler
, NULL
);
1386 image
= XGetImage(gdi_display
, physDev
->drawable
,
1387 image_x
, image_y
, image_w
, image_h
,
1388 AllPlanes
, ZPixmap
);
1389 X11DRV_check_error();
1391 TRACE("XGetImage(%p, %x, %d, %d, %d, %d, %lx, %x) depth = %d rets %p\n",
1392 gdi_display
, (int)physDev
->drawable
, image_x
, image_y
,
1393 image_w
, image_h
, AllPlanes
, ZPixmap
,
1394 physDev
->depth
, image
);
1396 Pixmap xpm
= XCreatePixmap(gdi_display
, physDev
->drawable
, image_w
, image_h
,
1401 gcv
.graphics_exposures
= False
;
1402 gc
= XCreateGC(gdi_display
, xpm
, GCGraphicsExposures
, &gcv
);
1403 XCopyArea(gdi_display
, physDev
->drawable
, xpm
, gc
, image_x
, image_y
,
1404 image_w
, image_h
, 0, 0);
1405 XFreeGC(gdi_display
, gc
);
1406 X11DRV_expect_error(gdi_display
, XRenderErrorHandler
, NULL
);
1407 image
= XGetImage(gdi_display
, xpm
, 0, 0, image_w
, image_h
, AllPlanes
,
1409 X11DRV_check_error();
1410 XFreePixmap(gdi_display
, xpm
);
1412 if(!image
) goto no_image
;
1414 image
->red_mask
= visual
->red_mask
;
1415 image
->green_mask
= visual
->green_mask
;
1416 image
->blue_mask
= visual
->blue_mask
;
1418 offset
= xoff
= yoff
= 0;
1419 for(idx
= 0; idx
< count
; idx
++) {
1420 SmoothGlyphGray(image
, xoff
+ image_off_x
- extents
.left
,
1421 yoff
+ image_off_y
- extents
.top
,
1422 formatEntry
->bitmaps
[wstr
[idx
]],
1423 &formatEntry
->gis
[wstr
[idx
]],
1424 physDev
->textPixel
);
1426 offset
+= lpDx
[idx
];
1427 xoff
= offset
* cosEsc
;
1428 yoff
= offset
* -sinEsc
;
1430 xoff
+= formatEntry
->gis
[wstr
[idx
]].xOff
;
1431 yoff
+= formatEntry
->gis
[wstr
[idx
]].yOff
;
1434 XPutImage(gdi_display
, physDev
->drawable
, physDev
->gc
, image
, 0, 0,
1435 image_x
, image_y
, image_w
, image_h
);
1436 XDestroyImage(image
);
1439 wine_tsx11_unlock();
1441 LeaveCriticalSection(&xrender_cs
);
1443 if (flags
& ETO_CLIPPED
)
1445 /* restore the device region */
1446 X11DRV_SetDeviceClipping( physDev
, saved_region
, 0 );
1447 DeleteObject( saved_region
);
1453 X11DRV_UnlockDIBSection( physDev
, TRUE
);
1457 /******************************************************************************
1458 * AlphaBlend (x11drv.@)
1460 BOOL
X11DRV_AlphaBlend(X11DRV_PDEVICE
*devDst
, INT xDst
, INT yDst
, INT widthDst
, INT heightDst
,
1461 X11DRV_PDEVICE
*devSrc
, INT xSrc
, INT ySrc
, INT widthSrc
, INT heightSrc
,
1462 BLENDFUNCTION blendfn
)
1464 XRenderPictureAttributes pa
;
1465 XRenderPictFormat
*src_format
;
1466 XRenderPictFormat argb32_templ
= {
1468 PictTypeDirect
, /* type */
1471 16, /* direct.red */
1472 0xff, /* direct.redMask */
1473 8, /* direct.green */
1474 0xff, /* direct.greenMask */
1475 0, /* direct.blue */
1476 0xff, /* direct.blueMask */
1477 24, /* direct.alpha */
1478 0xff, /* direct.alphaMask */
1482 unsigned long argb32_templ_mask
=
1488 PictFormatGreenMask
|
1490 PictFormatBlueMask
|
1492 PictFormatAlphaMask
;
1494 Picture dst_pict
, src_pict
;
1500 BYTE
*dstbits
, *data
;
1503 BOOL top_down
= FALSE
;
1506 if(!X11DRV_XRender_Installed
) {
1507 FIXME("Unable to AlphaBlend without Xrender\n");
1512 pts
[1].x
= xDst
+ widthDst
;
1513 pts
[1].y
= yDst
+ heightDst
;
1514 LPtoDP(devDst
->hdc
, pts
, 2);
1517 widthDst
= pts
[1].x
- pts
[0].x
;
1518 heightDst
= pts
[1].y
- pts
[0].y
;
1522 pts
[1].x
= xSrc
+ widthSrc
;
1523 pts
[1].y
= ySrc
+ heightSrc
;
1524 LPtoDP(devSrc
->hdc
, pts
, 2);
1527 widthSrc
= pts
[1].x
- pts
[0].x
;
1528 heightSrc
= pts
[1].y
- pts
[0].y
;
1529 if (!widthDst
|| !heightDst
|| !widthSrc
|| !heightSrc
) return TRUE
;
1531 #ifndef HAVE_XRENDERSETPICTURETRANSFORM
1532 if(widthDst
!= widthSrc
|| heightDst
!= heightSrc
)
1534 if(!pXRenderSetPictureTransform
)
1537 FIXME("Unable to Stretch, XRenderSetPictureTransform is currently required\n");
1541 if (!devSrc
->bitmap
|| GetObjectW( devSrc
->bitmap
->hbitmap
, sizeof(dib
), &dib
) != sizeof(dib
))
1543 FIXME("not a dibsection\n");
1547 if(dib
.dsBm
.bmBitsPixel
!= 32) {
1548 FIXME("not a 32 bpp dibsection\n");
1551 dstbits
= data
= HeapAlloc(GetProcessHeap(), 0, heightSrc
* widthSrc
* 4);
1553 if(dib
.dsBmih
.biHeight
< 0) { /* top-down dib */
1555 dstbits
+= widthSrc
* (heightSrc
- 1) * 4;
1557 y
= y2
+ heightSrc
- 1;
1561 y
= dib
.dsBmih
.biHeight
- ySrc
- 1;
1562 y2
= y
- heightSrc
+ 1;
1564 for(; y
>= y2
; y
--) {
1565 memcpy(dstbits
, (char *)dib
.dsBm
.bmBits
+ y
* dib
.dsBm
.bmWidthBytes
+ xSrc
* 4,
1567 dstbits
+= (top_down
? -1 : 1) * widthSrc
* 4;
1571 image
= XCreateImage(gdi_display
, visual
, 32, ZPixmap
, 0,
1572 (char*) data
, widthSrc
, heightSrc
, 32, widthSrc
* 4);
1575 Avoid using XRenderFindStandardFormat as older libraries don't have it
1576 src_format = pXRenderFindStandardFormat(gdi_display, PictStandardARGB32);
1578 src_format
= pXRenderFindFormat(gdi_display
, argb32_templ_mask
, &argb32_templ
, 0);
1580 TRACE("src_format %p\n", src_format
);
1582 pa
.subwindow_mode
= IncludeInferiors
;
1584 /* FIXME use devDst->xrender->pict ? */
1585 dst_pict
= pXRenderCreatePicture(gdi_display
,
1587 (devDst
->depth
== 1) ?
1588 mono_format
: screen_format
,
1589 CPSubwindowMode
, &pa
);
1590 TRACE("dst_pict %08lx\n", dst_pict
);
1591 TRACE("src_drawable = %08lx\n", devSrc
->drawable
);
1592 xpm
= XCreatePixmap(gdi_display
,
1594 widthSrc
, heightSrc
, 32);
1595 gcv
.graphics_exposures
= False
;
1596 gc
= XCreateGC(gdi_display
, xpm
, GCGraphicsExposures
, &gcv
);
1597 TRACE("xpm = %08lx\n", xpm
);
1598 XPutImage(gdi_display
, xpm
, gc
, image
, 0, 0, 0, 0, widthSrc
, heightSrc
);
1600 src_pict
= pXRenderCreatePicture(gdi_display
,
1602 CPSubwindowMode
, &pa
);
1603 TRACE("src_pict %08lx\n", src_pict
);
1605 if ((rgndata
= X11DRV_GetRegionData( devDst
->region
, 0 )))
1607 pXRenderSetPictureClipRectangles( gdi_display
, dst_pict
,
1608 devDst
->org
.x
, devDst
->org
.y
,
1609 (XRectangle
*)rgndata
->Buffer
,
1610 rgndata
->rdh
.nCount
);
1611 HeapFree( GetProcessHeap(), 0, rgndata
);
1614 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
1615 if(widthDst
!= widthSrc
|| heightDst
!= heightSrc
) {
1616 double xscale
= widthSrc
/(double)widthDst
;
1617 double yscale
= heightSrc
/(double)heightDst
;
1618 XTransform xform
= {{
1619 { XDoubleToFixed(xscale
), XDoubleToFixed(0), XDoubleToFixed(0) },
1620 { XDoubleToFixed(0), XDoubleToFixed(yscale
), XDoubleToFixed(0) },
1621 { XDoubleToFixed(0), XDoubleToFixed(0), XDoubleToFixed(1) }
1623 pXRenderSetPictureTransform(gdi_display
, src_pict
, &xform
);
1626 pXRenderComposite(gdi_display
, PictOpOver
, src_pict
, 0, dst_pict
,
1628 xDst
+ devDst
->org
.x
, yDst
+ devDst
->org
.y
, widthDst
, heightDst
);
1631 pXRenderFreePicture(gdi_display
, src_pict
);
1632 XFreePixmap(gdi_display
, xpm
);
1633 XFreeGC(gdi_display
, gc
);
1634 pXRenderFreePicture(gdi_display
, dst_pict
);
1636 XDestroyImage(image
);
1638 wine_tsx11_unlock();
1639 HeapFree(GetProcessHeap(), 0, data
);
1643 #else /* HAVE_X11_EXTENSIONS_XRENDER_H */
1645 void X11DRV_XRender_Init(void)
1647 TRACE("XRender support not compiled in.\n");
1651 void X11DRV_XRender_Finalize(void)
1655 BOOL
X11DRV_XRender_SelectFont(X11DRV_PDEVICE
*physDev
, HFONT hfont
)
1661 void X11DRV_XRender_DeleteDC(X11DRV_PDEVICE
*physDev
)
1667 BOOL
X11DRV_XRender_ExtTextOut( X11DRV_PDEVICE
*physDev
, INT x
, INT y
, UINT flags
,
1668 const RECT
*lprect
, LPCWSTR wstr
, UINT count
,
1675 void X11DRV_XRender_UpdateDrawable(X11DRV_PDEVICE
*physDev
)
1681 /******************************************************************************
1682 * AlphaBlend (x11drv.@)
1684 BOOL
X11DRV_AlphaBlend(X11DRV_PDEVICE
*devDst
, INT xDst
, INT yDst
, INT widthDst
, INT heightDst
,
1685 X11DRV_PDEVICE
*devSrc
, INT xSrc
, INT ySrc
, INT widthSrc
, INT heightSrc
,
1686 BLENDFUNCTION blendfn
)
1688 FIXME("not supported - XRENDER headers were missing at compile time\n");
1692 #endif /* HAVE_X11_EXTENSIONS_XRENDER_H */