/* * Functions to use the XRender extension * * Copyright 2001, 2002 Huw D M Davies for CodeWeavers * * Some parts also: * Copyright 2000 Keith Packard, member of The XFree86 Project, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" #include "wine/port.h" #include #include #include #include #include "windef.h" #include "winbase.h" #include "wownt32.h" #include "x11drv.h" #include "winternl.h" #include "wine/library.h" #include "wine/unicode.h" #include "wine/debug.h" static BOOL X11DRV_XRender_Installed = FALSE; int using_client_side_fonts = FALSE; WINE_DEFAULT_DEBUG_CHANNEL(xrender); #ifdef HAVE_X11_EXTENSIONS_XRENDER_H #include #include static XRenderPictFormat *screen_format; /* format of screen */ static XRenderPictFormat *mono_format; /* format of mono bitmap */ typedef struct { LOGFONTW lf; SIZE devsize; /* size in device coords */ DWORD hash; } LFANDSIZE; #define INITIAL_REALIZED_BUF_SIZE 128 typedef enum { AA_None = 0, AA_Grey, AA_RGB, AA_BGR, AA_VRGB, AA_VBGR, AA_MAXVALUE } AA_Type; typedef struct { GlyphSet glyphset; XRenderPictFormat *font_format; int nrealized; BOOL *realized; void **bitmaps; XGlyphInfo *gis; } gsCacheEntryFormat; typedef struct { LFANDSIZE lfsz; AA_Type aa_default; gsCacheEntryFormat * format[AA_MAXVALUE]; INT count; INT next; } gsCacheEntry; struct tagXRENDERINFO { int cache_index; Picture pict; Picture tile_pict; Pixmap tile_xpm; COLORREF lastTextColor; }; static gsCacheEntry *glyphsetCache = NULL; static DWORD glyphsetCacheSize = 0; static INT lastfree = -1; static INT mru = -1; #define INIT_CACHE_SIZE 10 static int antialias = 1; /* some default values just in case */ #ifndef SONAME_LIBX11 #define SONAME_LIBX11 "libX11.so" #endif #ifndef SONAME_LIBXEXT #define SONAME_LIBXEXT "libXext.so" #endif #ifndef SONAME_LIBXRENDER #define SONAME_LIBXRENDER "libXrender.so" #endif static void *xrender_handle; #define MAKE_FUNCPTR(f) static typeof(f) * p##f; MAKE_FUNCPTR(XRenderAddGlyphs) MAKE_FUNCPTR(XRenderComposite) MAKE_FUNCPTR(XRenderCompositeString8) MAKE_FUNCPTR(XRenderCompositeString16) MAKE_FUNCPTR(XRenderCompositeString32) MAKE_FUNCPTR(XRenderCreateGlyphSet) MAKE_FUNCPTR(XRenderCreatePicture) MAKE_FUNCPTR(XRenderFillRectangle) MAKE_FUNCPTR(XRenderFindFormat) MAKE_FUNCPTR(XRenderFindVisualFormat) MAKE_FUNCPTR(XRenderFreeGlyphSet) MAKE_FUNCPTR(XRenderFreePicture) MAKE_FUNCPTR(XRenderSetPictureClipRectangles) #ifdef HAVE_XRENDERSETPICTURETRANSFORM MAKE_FUNCPTR(XRenderSetPictureTransform) #endif MAKE_FUNCPTR(XRenderQueryExtension) #undef MAKE_FUNCPTR static CRITICAL_SECTION xrender_cs; static CRITICAL_SECTION_DEBUG critsect_debug = { 0, 0, &xrender_cs, { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList }, 0, 0, { (DWORD_PTR)(__FILE__ ": xrender_cs") } }; static CRITICAL_SECTION xrender_cs = { &critsect_debug, -1, 0, 0, 0, 0 }; #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \ ( ( (ULONG)_x4 << 24 ) | \ ( (ULONG)_x3 << 16 ) | \ ( (ULONG)_x2 << 8 ) | \ (ULONG)_x1 ) #define MS_GASP_TAG MS_MAKE_TAG('g', 'a', 's', 'p') #define GASP_GRIDFIT 0x01 #define GASP_DOGRAY 0x02 #ifdef WORDS_BIGENDIAN #define get_be_word(x) (x) #else #define get_be_word(x) RtlUshortByteSwap(x) #endif /*********************************************************************** * X11DRV_XRender_Init * * Let's see if our XServer has the extension available * */ void X11DRV_XRender_Init(void) { int event_base, i; XRenderPictFormat pf; if (client_side_with_render && wine_dlopen(SONAME_LIBX11, RTLD_NOW|RTLD_GLOBAL, NULL, 0) && wine_dlopen(SONAME_LIBXEXT, RTLD_NOW|RTLD_GLOBAL, NULL, 0) && (xrender_handle = wine_dlopen(SONAME_LIBXRENDER, RTLD_NOW, NULL, 0))) { #define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(xrender_handle, #f, NULL, 0)) == NULL) goto sym_not_found; LOAD_FUNCPTR(XRenderAddGlyphs) LOAD_FUNCPTR(XRenderComposite) LOAD_FUNCPTR(XRenderCompositeString8) LOAD_FUNCPTR(XRenderCompositeString16) LOAD_FUNCPTR(XRenderCompositeString32) LOAD_FUNCPTR(XRenderCreateGlyphSet) LOAD_FUNCPTR(XRenderCreatePicture) LOAD_FUNCPTR(XRenderFillRectangle) LOAD_FUNCPTR(XRenderFindFormat) LOAD_FUNCPTR(XRenderFindVisualFormat) LOAD_FUNCPTR(XRenderFreeGlyphSet) LOAD_FUNCPTR(XRenderFreePicture) LOAD_FUNCPTR(XRenderSetPictureClipRectangles) LOAD_FUNCPTR(XRenderQueryExtension) #undef LOAD_FUNCPTR #ifdef HAVE_XRENDERSETPICTURETRANSFORM #define LOAD_OPTIONAL_FUNCPTR(f) p##f = wine_dlsym(xrender_handle, #f, NULL, 0); LOAD_OPTIONAL_FUNCPTR(XRenderSetPictureTransform) #undef LOAD_OPTIONAL_FUNCPTR #endif wine_tsx11_lock(); if(pXRenderQueryExtension(gdi_display, &event_base, &xrender_error_base)) { X11DRV_XRender_Installed = TRUE; TRACE("Xrender is up and running error_base = %d\n", xrender_error_base); screen_format = pXRenderFindVisualFormat(gdi_display, visual); if(!screen_format) { /* Xrender doesn't like DirectColor visuals, try to find a TrueColor one instead */ if (visual->class == DirectColor) { XVisualInfo info; if (XMatchVisualInfo( gdi_display, DefaultScreen(gdi_display), screen_depth, TrueColor, &info )) { screen_format = pXRenderFindVisualFormat(gdi_display, info.visual); if (screen_format) visual = info.visual; } } } if(!screen_format) /* This fails in buggy versions of libXrender.so */ { wine_tsx11_unlock(); WINE_MESSAGE( "Wine has detected that you probably have a buggy version\n" "of libXrender.so . Because of this client side font rendering\n" "will be disabled. Please upgrade this library.\n"); X11DRV_XRender_Installed = FALSE; return; } pf.type = PictTypeDirect; pf.depth = 1; pf.direct.alpha = 0; pf.direct.alphaMask = 1; mono_format = pXRenderFindFormat(gdi_display, PictFormatType | PictFormatDepth | PictFormatAlpha | PictFormatAlphaMask, &pf, 0); if(!mono_format) { ERR("mono_format == NULL?\n"); X11DRV_XRender_Installed = FALSE; } if (!visual->red_mask || !visual->green_mask || !visual->blue_mask) { WARN("one or more of the colour masks are 0, disabling XRENDER. Try running in 16-bit mode or higher.\n"); X11DRV_XRender_Installed = FALSE; } } wine_tsx11_unlock(); } sym_not_found: if(X11DRV_XRender_Installed || client_side_with_core) { glyphsetCache = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*glyphsetCache) * INIT_CACHE_SIZE); glyphsetCacheSize = INIT_CACHE_SIZE; lastfree = 0; for(i = 0; i < INIT_CACHE_SIZE; i++) { glyphsetCache[i].next = i + 1; glyphsetCache[i].count = -1; } glyphsetCache[i-1].next = -1; using_client_side_fonts = 1; if(!X11DRV_XRender_Installed) { TRACE("Xrender is not available on your XServer, client side rendering with the core protocol instead.\n"); if(screen_depth <= 8 || !client_side_antialias_with_core) antialias = 0; } else { if(screen_depth <= 8 || !client_side_antialias_with_render) antialias = 0; } } else TRACE("Using X11 core fonts\n"); } static BOOL fontcmp(LFANDSIZE *p1, LFANDSIZE *p2) { if(p1->hash != p2->hash) return TRUE; if(memcmp(&p1->devsize, &p2->devsize, sizeof(p1->devsize))) return TRUE; if(memcmp(&p1->lf, &p2->lf, offsetof(LOGFONTW, lfFaceName))) return TRUE; return strcmpW(p1->lf.lfFaceName, p2->lf.lfFaceName); } #if 0 static void walk_cache(void) { int i; EnterCriticalSection(&xrender_cs); for(i=mru; i >= 0; i = glyphsetCache[i].next) TRACE("item %d\n", i); LeaveCriticalSection(&xrender_cs); } #endif static int LookupEntry(LFANDSIZE *plfsz) { int i, prev_i = -1; for(i = mru; i >= 0; i = glyphsetCache[i].next) { TRACE("%d\n", i); if(glyphsetCache[i].count == -1) { /* reached free list so stop */ i = -1; break; } if(!fontcmp(&glyphsetCache[i].lfsz, plfsz)) { glyphsetCache[i].count++; if(prev_i >= 0) { glyphsetCache[prev_i].next = glyphsetCache[i].next; glyphsetCache[i].next = mru; mru = i; } TRACE("found font in cache %d\n", i); return i; } prev_i = i; } TRACE("font not in cache\n"); return -1; } static void FreeEntry(int entry) { int i, format; for(format = 0; format < AA_MAXVALUE; format++) { gsCacheEntryFormat * formatEntry; if( !glyphsetCache[entry].format[format] ) continue; formatEntry = glyphsetCache[entry].format[format]; if(formatEntry->glyphset) { wine_tsx11_lock(); pXRenderFreeGlyphSet(gdi_display, formatEntry->glyphset); wine_tsx11_unlock(); formatEntry->glyphset = 0; } if(formatEntry->nrealized) { HeapFree(GetProcessHeap(), 0, formatEntry->realized); formatEntry->realized = NULL; if(formatEntry->bitmaps) { for(i = 0; i < formatEntry->nrealized; i++) HeapFree(GetProcessHeap(), 0, formatEntry->bitmaps[i]); HeapFree(GetProcessHeap(), 0, formatEntry->bitmaps); formatEntry->bitmaps = NULL; HeapFree(GetProcessHeap(), 0, formatEntry->gis); formatEntry->gis = NULL; } formatEntry->nrealized = 0; } HeapFree(GetProcessHeap(), 0, formatEntry); glyphsetCache[entry].format[format] = NULL; } } static int AllocEntry(void) { int best = -1, prev_best = -1, i, prev_i = -1; if(lastfree >= 0) { assert(glyphsetCache[lastfree].count == -1); glyphsetCache[lastfree].count = 1; best = lastfree; lastfree = glyphsetCache[lastfree].next; assert(best != mru); glyphsetCache[best].next = mru; mru = best; TRACE("empty space at %d, next lastfree = %d\n", mru, lastfree); return mru; } for(i = mru; i >= 0; i = glyphsetCache[i].next) { if(glyphsetCache[i].count == 0) { best = i; prev_best = prev_i; } prev_i = i; } if(best >= 0) { TRACE("freeing unused glyphset at cache %d\n", best); FreeEntry(best); glyphsetCache[best].count = 1; if(prev_best >= 0) { glyphsetCache[prev_best].next = glyphsetCache[best].next; glyphsetCache[best].next = mru; mru = best; } else { assert(mru == best); } return mru; } TRACE("Growing cache\n"); if (glyphsetCache) glyphsetCache = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, glyphsetCache, (glyphsetCacheSize + INIT_CACHE_SIZE) * sizeof(*glyphsetCache)); else glyphsetCache = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (glyphsetCacheSize + INIT_CACHE_SIZE) * sizeof(*glyphsetCache)); for(best = i = glyphsetCacheSize; i < glyphsetCacheSize + INIT_CACHE_SIZE; i++) { glyphsetCache[i].next = i + 1; glyphsetCache[i].count = -1; } glyphsetCache[i-1].next = -1; glyphsetCacheSize += INIT_CACHE_SIZE; lastfree = glyphsetCache[best].next; glyphsetCache[best].count = 1; glyphsetCache[best].next = mru; mru = best; TRACE("new free cache slot at %d\n", mru); return mru; } static BOOL get_gasp_flags(X11DRV_PDEVICE *physDev, WORD *flags) { DWORD size; WORD *gasp, *buffer; WORD num_recs; DWORD ppem; TEXTMETRICW tm; *flags = 0; size = GetFontData(physDev->hdc, MS_GASP_TAG, 0, NULL, 0); if(size == GDI_ERROR) return FALSE; gasp = buffer = HeapAlloc(GetProcessHeap(), 0, size); GetFontData(physDev->hdc, MS_GASP_TAG, 0, gasp, size); GetTextMetricsW(physDev->hdc, &tm); ppem = abs(X11DRV_YWStoDS(physDev, tm.tmAscent + tm.tmDescent - tm.tmInternalLeading)); gasp++; num_recs = get_be_word(*gasp); gasp++; while(num_recs--) { *flags = get_be_word(*(gasp + 1)); if(ppem <= get_be_word(*gasp)) break; gasp += 2; } TRACE("got flags %04x for ppem %d\n", *flags, ppem); HeapFree(GetProcessHeap(), 0, buffer); return TRUE; } static int GetCacheEntry(X11DRV_PDEVICE *physDev, LFANDSIZE *plfsz) { int ret; int format; gsCacheEntry *entry; WORD flags; static int hinter = -1; if((ret = LookupEntry(plfsz)) != -1) return ret; ret = AllocEntry(); entry = glyphsetCache + ret; entry->lfsz = *plfsz; for( format = 0; format < AA_MAXVALUE; format++ ) { assert( !entry->format[format] ); } if(antialias && plfsz->lf.lfQuality != NONANTIALIASED_QUALITY) { if(hinter == -1) { RASTERIZER_STATUS status; GetRasterizerCaps(&status, sizeof(status)); hinter = status.wFlags & WINE_TT_HINTER_ENABLED; } if(!hinter || !get_gasp_flags(physDev, &flags) || flags & GASP_DOGRAY) entry->aa_default = AA_Grey; else entry->aa_default = AA_None; } else entry->aa_default = AA_None; return ret; } static void dec_ref_cache(int index) { assert(index >= 0); TRACE("dec'ing entry %d to %d\n", index, glyphsetCache[index].count - 1); assert(glyphsetCache[index].count > 0); glyphsetCache[index].count--; } static void lfsz_calc_hash(LFANDSIZE *plfsz) { DWORD hash = 0, *ptr; int i; hash ^= plfsz->devsize.cx; hash ^= plfsz->devsize.cy; for(i = 0, ptr = (DWORD*)&plfsz->lf; i < 7; i++, ptr++) hash ^= *ptr; for(i = 0, ptr = (DWORD*)&plfsz->lf.lfFaceName; i < LF_FACESIZE/2; i++, ptr++) { WCHAR *pwc = (WCHAR *)ptr; if(!*pwc) break; hash ^= *ptr; pwc++; if(!*pwc) break; } plfsz->hash = hash; return; } /*********************************************************************** * X11DRV_XRender_Finalize */ void X11DRV_XRender_Finalize(void) { int i; EnterCriticalSection(&xrender_cs); for(i = mru; i >= 0; i = glyphsetCache[i].next) FreeEntry(i); LeaveCriticalSection(&xrender_cs); } /*********************************************************************** * X11DRV_XRender_SelectFont */ BOOL X11DRV_XRender_SelectFont(X11DRV_PDEVICE *physDev, HFONT hfont) { LFANDSIZE lfsz; GetObjectW(hfont, sizeof(lfsz.lf), &lfsz.lf); TRACE("h=%d w=%d weight=%d it=%d charset=%d name=%s\n", lfsz.lf.lfHeight, lfsz.lf.lfWidth, lfsz.lf.lfWeight, lfsz.lf.lfItalic, lfsz.lf.lfCharSet, debugstr_w(lfsz.lf.lfFaceName)); lfsz.devsize.cx = X11DRV_XWStoDS( physDev, lfsz.lf.lfWidth ); lfsz.devsize.cy = X11DRV_YWStoDS( physDev, lfsz.lf.lfHeight ); lfsz_calc_hash(&lfsz); EnterCriticalSection(&xrender_cs); if(!physDev->xrender) { physDev->xrender = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*physDev->xrender)); physDev->xrender->cache_index = -1; } else if(physDev->xrender->cache_index != -1) dec_ref_cache(physDev->xrender->cache_index); physDev->xrender->cache_index = GetCacheEntry(physDev, &lfsz); LeaveCriticalSection(&xrender_cs); return 0; } /*********************************************************************** * X11DRV_XRender_DeleteDC */ void X11DRV_XRender_DeleteDC(X11DRV_PDEVICE *physDev) { wine_tsx11_lock(); if(physDev->xrender->tile_pict) pXRenderFreePicture(gdi_display, physDev->xrender->tile_pict); if(physDev->xrender->tile_xpm) XFreePixmap(gdi_display, physDev->xrender->tile_xpm); if(physDev->xrender->pict) { TRACE("freeing pict = %lx dc = %p\n", physDev->xrender->pict, physDev->hdc); pXRenderFreePicture(gdi_display, physDev->xrender->pict); } wine_tsx11_unlock(); EnterCriticalSection(&xrender_cs); if(physDev->xrender->cache_index != -1) dec_ref_cache(physDev->xrender->cache_index); LeaveCriticalSection(&xrender_cs); HeapFree(GetProcessHeap(), 0, physDev->xrender); physDev->xrender = NULL; return; } /*********************************************************************** * X11DRV_XRender_UpdateDrawable * * This gets called from X11DRV_SetDrawable and X11DRV_SelectBitmap. * It deletes the pict when the drawable changes. */ void X11DRV_XRender_UpdateDrawable(X11DRV_PDEVICE *physDev) { if(physDev->xrender->pict) { TRACE("freeing pict %08lx from dc %p drawable %08lx\n", physDev->xrender->pict, physDev->hdc, physDev->drawable); wine_tsx11_lock(); XFlush(gdi_display); pXRenderFreePicture(gdi_display, physDev->xrender->pict); wine_tsx11_unlock(); } physDev->xrender->pict = 0; return; } /************************************************************************ * UploadGlyph * * Helper to ExtTextOut. Must be called inside xrender_cs */ static BOOL UploadGlyph(X11DRV_PDEVICE *physDev, int glyph, AA_Type format) { unsigned int buflen; char *buf; Glyph gid; GLYPHMETRICS gm; XGlyphInfo gi; gsCacheEntry *entry = glyphsetCache + physDev->xrender->cache_index; gsCacheEntryFormat *formatEntry; UINT ggo_format = GGO_GLYPH_INDEX; XRenderPictFormat pf; switch(format) { case AA_Grey: ggo_format |= WINE_GGO_GRAY16_BITMAP; break; default: ERR("aa = %d - not implemented\n", format); case AA_None: ggo_format |= GGO_BITMAP; break; } buflen = GetGlyphOutlineW(physDev->hdc, glyph, ggo_format, &gm, 0, NULL, NULL); if(buflen == GDI_ERROR) { if(format != AA_None) { format = AA_None; entry->aa_default = AA_None; ggo_format &= ~WINE_GGO_GRAY16_BITMAP; ggo_format |= GGO_BITMAP; buflen = GetGlyphOutlineW(physDev->hdc, glyph, ggo_format, &gm, 0, NULL, NULL); } if(buflen == GDI_ERROR) { WARN("GetGlyphOutlineW failed\n"); return FALSE; } TRACE("Turning off antialiasing for this monochrome font\n"); } /* If there is nothing for the current type, we create the entry. */ if( !entry->format[format] ) { entry->format[format] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(gsCacheEntryFormat)); } formatEntry = entry->format[format]; if(formatEntry->nrealized <= glyph) { formatEntry->nrealized = (glyph / 128 + 1) * 128; if (formatEntry->realized) formatEntry->realized = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, formatEntry->realized, formatEntry->nrealized * sizeof(BOOL)); else formatEntry->realized = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, formatEntry->nrealized * sizeof(BOOL)); if(!X11DRV_XRender_Installed) { if (formatEntry->bitmaps) formatEntry->bitmaps = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, formatEntry->bitmaps, formatEntry->nrealized * sizeof(formatEntry->bitmaps[0])); else formatEntry->bitmaps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, formatEntry->nrealized * sizeof(formatEntry->bitmaps[0])); if (formatEntry->gis) formatEntry->gis = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, formatEntry->gis, formatEntry->nrealized * sizeof(formatEntry->gis[0])); else formatEntry->gis = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, formatEntry->nrealized * sizeof(formatEntry->gis[0])); } } if(formatEntry->glyphset == 0 && X11DRV_XRender_Installed) { switch(format) { case AA_Grey: pf.depth = 8; pf.direct.alphaMask = 0xff; break; default: ERR("aa = %d - not implemented\n", format); case AA_None: pf.depth = 1; pf.direct.alphaMask = 1; break; } pf.type = PictTypeDirect; pf.direct.alpha = 0; wine_tsx11_lock(); formatEntry->font_format = pXRenderFindFormat(gdi_display, PictFormatType | PictFormatDepth | PictFormatAlpha | PictFormatAlphaMask, &pf, 0); formatEntry->glyphset = pXRenderCreateGlyphSet(gdi_display, formatEntry->font_format); wine_tsx11_unlock(); } buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buflen); GetGlyphOutlineW(physDev->hdc, glyph, ggo_format, &gm, buflen, buf, NULL); formatEntry->realized[glyph] = TRUE; TRACE("buflen = %d. Got metrics: %dx%d adv=%d,%d origin=%d,%d\n", buflen, gm.gmBlackBoxX, gm.gmBlackBoxY, gm.gmCellIncX, gm.gmCellIncY, gm.gmptGlyphOrigin.x, gm.gmptGlyphOrigin.y); gi.width = gm.gmBlackBoxX; gi.height = gm.gmBlackBoxY; gi.x = -gm.gmptGlyphOrigin.x; gi.y = gm.gmptGlyphOrigin.y; gi.xOff = gm.gmCellIncX; gi.yOff = gm.gmCellIncY; if(TRACE_ON(xrender)) { int pitch, i, j; char output[300]; unsigned char *line; if(format == AA_None) { pitch = ((gi.width + 31) / 32) * 4; for(i = 0; i < gi.height; i++) { line = (unsigned char*) buf + i * pitch; output[0] = '\0'; for(j = 0; j < pitch * 8; j++) { strcat(output, (line[j / 8] & (1 << (7 - (j % 8)))) ? "#" : " "); } strcat(output, "\n"); TRACE(output); } } else { static const char blks[] = " .:;!o*#"; char str[2]; str[1] = '\0'; pitch = ((gi.width + 3) / 4) * 4; for(i = 0; i < gi.height; i++) { line = (unsigned char*) buf + i * pitch; output[0] = '\0'; for(j = 0; j < pitch; j++) { str[0] = blks[line[j] >> 5]; strcat(output, str); } strcat(output, "\n"); TRACE(output); } } } if(formatEntry->glyphset) { if(format == AA_None && BitmapBitOrder(gdi_display) != MSBFirst) { unsigned char *byte = (unsigned char*) buf, c; int i = buflen; while(i--) { c = *byte; /* magic to flip bit order */ c = ((c << 1) & 0xaa) | ((c >> 1) & 0x55); c = ((c << 2) & 0xcc) | ((c >> 2) & 0x33); c = ((c << 4) & 0xf0) | ((c >> 4) & 0x0f); *byte++ = c; } } gid = glyph; wine_tsx11_lock(); pXRenderAddGlyphs(gdi_display, formatEntry->glyphset, &gid, &gi, 1, buf, buflen); wine_tsx11_unlock(); HeapFree(GetProcessHeap(), 0, buf); } else { formatEntry->bitmaps[glyph] = buf; memcpy(&formatEntry->gis[glyph], &gi, sizeof(gi)); } return TRUE; } static void SharpGlyphMono(X11DRV_PDEVICE *physDev, INT x, INT y, void *bitmap, XGlyphInfo *gi) { unsigned char *srcLine = bitmap, *src; unsigned char bits, bitsMask; int width = gi->width; int stride = ((width + 31) & ~31) >> 3; int height = gi->height; int w; int xspan, lenspan; TRACE("%d, %d\n", x, y); x -= gi->x; y -= gi->y; while (height--) { src = srcLine; srcLine += stride; w = width; bitsMask = 0x80; /* FreeType is always MSB first */ bits = *src++; xspan = x; while (w) { if (bits & bitsMask) { lenspan = 0; do { lenspan++; if (lenspan == w) break; bitsMask = bitsMask >> 1; if (!bitsMask) { bits = *src++; bitsMask = 0x80; } } while (bits & bitsMask); XFillRectangle (gdi_display, physDev->drawable, physDev->gc, xspan, y, lenspan, 1); xspan += lenspan; w -= lenspan; } else { do { w--; xspan++; if (!w) break; bitsMask = bitsMask >> 1; if (!bitsMask) { bits = *src++; bitsMask = 0x80; } } while (!(bits & bitsMask)); } } y++; } } static void SharpGlyphGray(X11DRV_PDEVICE *physDev, INT x, INT y, void *bitmap, XGlyphInfo *gi) { unsigned char *srcLine = bitmap, *src, bits; int width = gi->width; int stride = ((width + 3) & ~3); int height = gi->height; int w; int xspan, lenspan; x -= gi->x; y -= gi->y; while (height--) { src = srcLine; srcLine += stride; w = width; bits = *src++; xspan = x; while (w) { if (bits >= 0x80) { lenspan = 0; do { lenspan++; if (lenspan == w) break; bits = *src++; } while (bits >= 0x80); XFillRectangle (gdi_display, physDev->drawable, physDev->gc, xspan, y, lenspan, 1); xspan += lenspan; w -= lenspan; } else { do { w--; xspan++; if (!w) break; bits = *src++; } while (bits < 0x80); } } y++; } } static void ExamineBitfield (DWORD mask, int *shift, int *len) { int s, l; s = 0; while ((mask & 1) == 0) { mask >>= 1; s++; } l = 0; while ((mask & 1) == 1) { mask >>= 1; l++; } *shift = s; *len = l; } static DWORD GetField (DWORD pixel, int shift, int len) { pixel = pixel & (((1 << (len)) - 1) << shift); pixel = pixel << (32 - (shift + len)) >> 24; while (len < 8) { pixel |= (pixel >> len); len <<= 1; } return pixel; } static DWORD PutField (DWORD pixel, int shift, int len) { shift = shift - (8 - len); if (len <= 8) pixel &= (((1 << len) - 1) << (8 - len)); if (shift < 0) pixel >>= -shift; else pixel <<= shift; return pixel; } static void SmoothGlyphGray(XImage *image, int x, int y, void *bitmap, XGlyphInfo *gi, int color) { int r_shift, r_len; int g_shift, g_len; int b_shift, b_len; BYTE *maskLine, *mask, m; int maskStride; DWORD pixel; int width, height; int w, tx; BYTE src_r, src_g, src_b; x -= gi->x; y -= gi->y; width = gi->width; height = gi->height; maskLine = (unsigned char *) bitmap; maskStride = (width + 3) & ~3; ExamineBitfield (image->red_mask, &r_shift, &r_len); ExamineBitfield (image->green_mask, &g_shift, &g_len); ExamineBitfield (image->blue_mask, &b_shift, &b_len); src_r = GetField(color, r_shift, r_len); src_g = GetField(color, g_shift, g_len); src_b = GetField(color, b_shift, b_len); for(; height--; y++) { mask = maskLine; maskLine += maskStride; w = width; tx = x; if(y < 0) continue; if(y >= image->height) break; for(; w--; tx++) { if(tx >= image->width) break; m = *mask++; if(tx < 0) continue; if (m == 0xff) XPutPixel (image, tx, y, color); else if (m) { BYTE r, g, b; pixel = XGetPixel (image, tx, y); r = GetField(pixel, r_shift, r_len); r = ((BYTE)~m * (WORD)r + (BYTE)m * (WORD)src_r) >> 8; g = GetField(pixel, g_shift, g_len); g = ((BYTE)~m * (WORD)g + (BYTE)m * (WORD)src_g) >> 8; b = GetField(pixel, b_shift, b_len); b = ((BYTE)~m * (WORD)b + (BYTE)m * (WORD)src_b) >> 8; pixel = (PutField (r, r_shift, r_len) | PutField (g, g_shift, g_len) | PutField (b, b_shift, b_len)); XPutPixel (image, tx, y, pixel); } } } } static int XRenderErrorHandler(Display *dpy, XErrorEvent *event, void *arg) { return 1; } /*********************************************************************** * X11DRV_XRender_ExtTextOut */ BOOL X11DRV_XRender_ExtTextOut( X11DRV_PDEVICE *physDev, INT x, INT y, UINT flags, const RECT *lprect, LPCWSTR wstr, UINT count, const INT *lpDx ) { XRenderColor col; RGNDATA *data; XGCValues xgcval; int render_op = PictOpOver; gsCacheEntry *entry; gsCacheEntryFormat *formatEntry; BOOL retv = FALSE; HDC hdc = physDev->hdc; int textPixel, backgroundPixel; HRGN saved_region = 0; BOOL disable_antialias = FALSE; AA_Type antialias = AA_None; DIBSECTION bmp; unsigned int idx; double cosEsc, sinEsc; LOGFONTW lf; /* Do we need to disable antialiasing because of palette mode? */ if( !physDev->bitmap || GetObjectW( physDev->bitmap->hbitmap, sizeof(bmp), &bmp ) != sizeof(bmp) ) { TRACE("bitmap is not a DIB\n"); } else if (bmp.dsBmih.biBitCount <= 8) { TRACE("Disabling antialiasing\n"); disable_antialias = TRUE; } xgcval.function = GXcopy; xgcval.background = physDev->backgroundPixel; xgcval.fill_style = FillSolid; wine_tsx11_lock(); XChangeGC( gdi_display, physDev->gc, GCFunction | GCBackground | GCFillStyle, &xgcval ); wine_tsx11_unlock(); X11DRV_LockDIBSection( physDev, DIB_Status_GdiMod, FALSE ); if(physDev->depth == 1) { if((physDev->textPixel & 0xffffff) == 0) { textPixel = 0; backgroundPixel = 1; } else { textPixel = 1; backgroundPixel = 0; } } else { textPixel = physDev->textPixel; backgroundPixel = physDev->backgroundPixel; } if(flags & ETO_OPAQUE) { wine_tsx11_lock(); XSetForeground( gdi_display, physDev->gc, backgroundPixel ); XFillRectangle( gdi_display, physDev->drawable, physDev->gc, physDev->dc_rect.left + lprect->left, physDev->dc_rect.top + lprect->top, lprect->right - lprect->left, lprect->bottom - lprect->top ); wine_tsx11_unlock(); } if(count == 0) { retv = TRUE; goto done_unlock; } GetObjectW(GetCurrentObject(physDev->hdc, OBJ_FONT), sizeof(lf), &lf); if(lf.lfEscapement != 0) { cosEsc = cos(lf.lfEscapement * M_PI / 1800); sinEsc = sin(lf.lfEscapement * M_PI / 1800); } else { cosEsc = 1; sinEsc = 0; } if (flags & ETO_CLIPPED) { HRGN clip_region; clip_region = CreateRectRgnIndirect( lprect ); /* make a copy of the current device region */ saved_region = CreateRectRgn( 0, 0, 0, 0 ); CombineRgn( saved_region, physDev->region, 0, RGN_COPY ); X11DRV_SetDeviceClipping( physDev, saved_region, clip_region ); DeleteObject( clip_region ); } if(X11DRV_XRender_Installed) { if(!physDev->xrender->pict) { XRenderPictureAttributes pa; pa.subwindow_mode = IncludeInferiors; wine_tsx11_lock(); physDev->xrender->pict = pXRenderCreatePicture(gdi_display, physDev->drawable, (physDev->depth == 1) ? mono_format : screen_format, CPSubwindowMode, &pa); wine_tsx11_unlock(); TRACE("allocing pict = %lx dc = %p drawable = %08lx\n", physDev->xrender->pict, hdc, physDev->drawable); } else { TRACE("using existing pict = %lx dc = %p drawable = %08lx\n", physDev->xrender->pict, hdc, physDev->drawable); } if ((data = X11DRV_GetRegionData( physDev->region, 0 ))) { wine_tsx11_lock(); pXRenderSetPictureClipRectangles( gdi_display, physDev->xrender->pict, physDev->dc_rect.left, physDev->dc_rect.top, (XRectangle *)data->Buffer, data->rdh.nCount ); wine_tsx11_unlock(); HeapFree( GetProcessHeap(), 0, data ); } } if(X11DRV_XRender_Installed) { /* Create a 1x1 pixmap to tile over the font mask */ if(!physDev->xrender->tile_xpm) { XRenderPictureAttributes pa; XRenderPictFormat *format = (physDev->depth == 1) ? mono_format : screen_format; wine_tsx11_lock(); physDev->xrender->tile_xpm = XCreatePixmap(gdi_display, physDev->drawable, 1, 1, format->depth); pa.repeat = True; physDev->xrender->tile_pict = pXRenderCreatePicture(gdi_display, physDev->xrender->tile_xpm, format, CPRepeat, &pa); wine_tsx11_unlock(); TRACE("Created pixmap of depth %d\n", format->depth); /* init lastTextColor to something different from textPixel */ physDev->xrender->lastTextColor = ~physDev->textPixel; } if(physDev->textPixel != physDev->xrender->lastTextColor) { if(physDev->depth != 1) { /* Map 0 -- 0xff onto 0 -- 0xffff */ int r_shift, r_len; int g_shift, g_len; int b_shift, b_len; ExamineBitfield (visual->red_mask, &r_shift, &r_len ); ExamineBitfield (visual->green_mask, &g_shift, &g_len); ExamineBitfield (visual->blue_mask, &b_shift, &b_len); col.red = GetField(physDev->textPixel, r_shift, r_len); col.red |= col.red << 8; col.green = GetField(physDev->textPixel, g_shift, g_len); col.green |= col.green << 8; col.blue = GetField(physDev->textPixel, b_shift, b_len); col.blue |= col.blue << 8; col.alpha = 0x0; } else { /* for a 1bpp bitmap we always need a 1 in the tile */ col.red = col.green = col.blue = 0; col.alpha = 0xffff; } wine_tsx11_lock(); pXRenderFillRectangle(gdi_display, PictOpSrc, physDev->xrender->tile_pict, &col, 0, 0, 1, 1); wine_tsx11_unlock(); physDev->xrender->lastTextColor = physDev->textPixel; } /* FIXME the mapping of Text/BkColor onto 1 or 0 needs investigation. */ if((physDev->depth == 1) && (textPixel == 0)) render_op = PictOpOutReverse; /* This gives us 'black' text */ } EnterCriticalSection(&xrender_cs); entry = glyphsetCache + physDev->xrender->cache_index; if( disable_antialias == FALSE ) antialias = entry->aa_default; formatEntry = entry->format[antialias]; for(idx = 0; idx < count; idx++) { if( !formatEntry ) { UploadGlyph(physDev, wstr[idx], antialias); /* re-evaluate antialias since aa_default may have changed */ if( disable_antialias == FALSE ) antialias = entry->aa_default; formatEntry = entry->format[antialias]; } else if( wstr[idx] >= formatEntry->nrealized || formatEntry->realized[wstr[idx]] == FALSE) { UploadGlyph(physDev, wstr[idx], antialias); } } if (!formatEntry) { WARN("could not upload requested glyphs\n"); LeaveCriticalSection(&xrender_cs); goto done_unlock; } TRACE("Writing %s at %d,%d\n", debugstr_wn(wstr,count), physDev->dc_rect.left + x, physDev->dc_rect.top + y); if(X11DRV_XRender_Installed) { wine_tsx11_lock(); if(!lpDx) pXRenderCompositeString16(gdi_display, render_op, physDev->xrender->tile_pict, physDev->xrender->pict, formatEntry->font_format, formatEntry->glyphset, 0, 0, physDev->dc_rect.left + x, physDev->dc_rect.top + y, wstr, count); else { INT offset = 0, xoff = 0, yoff = 0; for(idx = 0; idx < count; idx++) { pXRenderCompositeString16(gdi_display, render_op, physDev->xrender->tile_pict, physDev->xrender->pict, formatEntry->font_format, formatEntry->glyphset, 0, 0, physDev->dc_rect.left + x + xoff, physDev->dc_rect.top + y + yoff, wstr + idx, 1); offset += lpDx[idx]; xoff = offset * cosEsc; yoff = offset * -sinEsc; } } wine_tsx11_unlock(); } else { INT offset = 0, xoff = 0, yoff = 0; wine_tsx11_lock(); XSetForeground( gdi_display, physDev->gc, textPixel ); if(antialias == AA_None) { for(idx = 0; idx < count; idx++) { SharpGlyphMono(physDev, physDev->dc_rect.left + x + xoff, physDev->dc_rect.top + y + yoff, formatEntry->bitmaps[wstr[idx]], &formatEntry->gis[wstr[idx]]); if(lpDx) { offset += lpDx[idx]; xoff = offset * cosEsc; yoff = offset * -sinEsc; } else { xoff += formatEntry->gis[wstr[idx]].xOff; yoff += formatEntry->gis[wstr[idx]].yOff; } } } else if(physDev->depth == 1) { for(idx = 0; idx < count; idx++) { SharpGlyphGray(physDev, physDev->dc_rect.left + x + xoff, physDev->dc_rect.top + y + yoff, formatEntry->bitmaps[wstr[idx]], &formatEntry->gis[wstr[idx]]); if(lpDx) { offset += lpDx[idx]; xoff = offset * cosEsc; yoff = offset * -sinEsc; } else { xoff += formatEntry->gis[wstr[idx]].xOff; yoff += formatEntry->gis[wstr[idx]].yOff; } } } else { XImage *image; int image_x, image_y, image_off_x, image_off_y, image_w, image_h; RECT extents = {0, 0, 0, 0}; POINT cur = {0, 0}; int w = physDev->drawable_rect.right - physDev->drawable_rect.left; int h = physDev->drawable_rect.bottom - physDev->drawable_rect.top; TRACE("drawable %dx%d\n", w, h); for(idx = 0; idx < count; idx++) { if(extents.left > cur.x - formatEntry->gis[wstr[idx]].x) extents.left = cur.x - formatEntry->gis[wstr[idx]].x; if(extents.top > cur.y - formatEntry->gis[wstr[idx]].y) extents.top = cur.y - formatEntry->gis[wstr[idx]].y; if(extents.right < cur.x - formatEntry->gis[wstr[idx]].x + formatEntry->gis[wstr[idx]].width) extents.right = cur.x - formatEntry->gis[wstr[idx]].x + formatEntry->gis[wstr[idx]].width; if(extents.bottom < cur.y - formatEntry->gis[wstr[idx]].y + formatEntry->gis[wstr[idx]].height) extents.bottom = cur.y - formatEntry->gis[wstr[idx]].y + formatEntry->gis[wstr[idx]].height; if(lpDx) { offset += lpDx[idx]; cur.x = offset * cosEsc; cur.y = offset * -sinEsc; } else { cur.x += formatEntry->gis[wstr[idx]].xOff; cur.y += formatEntry->gis[wstr[idx]].yOff; } } TRACE("glyph extents %d,%d - %d,%d drawable x,y %d,%d\n", extents.left, extents.top, extents.right, extents.bottom, physDev->dc_rect.left + x, physDev->dc_rect.top + y); if(physDev->dc_rect.left + x + extents.left >= 0) { image_x = physDev->dc_rect.left + x + extents.left; image_off_x = 0; } else { image_x = 0; image_off_x = physDev->dc_rect.left + x + extents.left; } if(physDev->dc_rect.top + y + extents.top >= 0) { image_y = physDev->dc_rect.top + y + extents.top; image_off_y = 0; } else { image_y = 0; image_off_y = physDev->dc_rect.top + y + extents.top; } if(physDev->dc_rect.left + x + extents.right < w) image_w = physDev->dc_rect.left + x + extents.right - image_x; else image_w = w - image_x; if(physDev->dc_rect.top + y + extents.bottom < h) image_h = physDev->dc_rect.top + y + extents.bottom - image_y; else image_h = h - image_y; if(image_w <= 0 || image_h <= 0) goto no_image; X11DRV_expect_error(gdi_display, XRenderErrorHandler, NULL); image = XGetImage(gdi_display, physDev->drawable, image_x, image_y, image_w, image_h, AllPlanes, ZPixmap); X11DRV_check_error(); TRACE("XGetImage(%p, %x, %d, %d, %d, %d, %lx, %x) depth = %d rets %p\n", gdi_display, (int)physDev->drawable, image_x, image_y, image_w, image_h, AllPlanes, ZPixmap, physDev->depth, image); if(!image) { Pixmap xpm = XCreatePixmap(gdi_display, physDev->drawable, image_w, image_h, physDev->depth); GC gc; XGCValues gcv; gcv.graphics_exposures = False; gc = XCreateGC(gdi_display, xpm, GCGraphicsExposures, &gcv); XCopyArea(gdi_display, physDev->drawable, xpm, gc, image_x, image_y, image_w, image_h, 0, 0); XFreeGC(gdi_display, gc); X11DRV_expect_error(gdi_display, XRenderErrorHandler, NULL); image = XGetImage(gdi_display, xpm, 0, 0, image_w, image_h, AllPlanes, ZPixmap); X11DRV_check_error(); XFreePixmap(gdi_display, xpm); } if(!image) goto no_image; image->red_mask = visual->red_mask; image->green_mask = visual->green_mask; image->blue_mask = visual->blue_mask; offset = xoff = yoff = 0; for(idx = 0; idx < count; idx++) { SmoothGlyphGray(image, xoff + image_off_x - extents.left, yoff + image_off_y - extents.top, formatEntry->bitmaps[wstr[idx]], &formatEntry->gis[wstr[idx]], physDev->textPixel); if(lpDx) { offset += lpDx[idx]; xoff = offset * cosEsc; yoff = offset * -sinEsc; } else { xoff += formatEntry->gis[wstr[idx]].xOff; yoff += formatEntry->gis[wstr[idx]].yOff; } } XPutImage(gdi_display, physDev->drawable, physDev->gc, image, 0, 0, image_x, image_y, image_w, image_h); XDestroyImage(image); } no_image: wine_tsx11_unlock(); } LeaveCriticalSection(&xrender_cs); if (flags & ETO_CLIPPED) { /* restore the device region */ X11DRV_SetDeviceClipping( physDev, saved_region, 0 ); DeleteObject( saved_region ); } retv = TRUE; done_unlock: X11DRV_UnlockDIBSection( physDev, TRUE ); return retv; } /****************************************************************************** * AlphaBlend (x11drv.@) */ BOOL X11DRV_AlphaBlend(X11DRV_PDEVICE *devDst, INT xDst, INT yDst, INT widthDst, INT heightDst, X11DRV_PDEVICE *devSrc, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc, BLENDFUNCTION blendfn) { XRenderPictureAttributes pa; XRenderPictFormat *src_format; XRenderPictFormat argb32_templ = { 0, /* id */ PictTypeDirect, /* type */ 32, /* depth */ { /* direct */ 16, /* direct.red */ 0xff, /* direct.redMask */ 8, /* direct.green */ 0xff, /* direct.greenMask */ 0, /* direct.blue */ 0xff, /* direct.blueMask */ 24, /* direct.alpha */ 0xff, /* direct.alphaMask */ }, 0, /* colormap */ }; unsigned long argb32_templ_mask = PictFormatType | PictFormatDepth | PictFormatRed | PictFormatRedMask | PictFormatGreen | PictFormatGreenMask | PictFormatBlue | PictFormatBlueMask | PictFormatAlpha | PictFormatAlphaMask; Picture dst_pict, src_pict; Pixmap xpm; DIBSECTION dib; XImage *image; GC gc; XGCValues gcv; BYTE *dstbits, *data; int y, y2; POINT pts[2]; BOOL top_down = FALSE; RGNDATA *rgndata; if(!X11DRV_XRender_Installed) { FIXME("Unable to AlphaBlend without Xrender\n"); return FALSE; } pts[0].x = xDst; pts[0].y = yDst; pts[1].x = xDst + widthDst; pts[1].y = yDst + heightDst; LPtoDP(devDst->hdc, pts, 2); xDst = pts[0].x; yDst = pts[0].y; widthDst = pts[1].x - pts[0].x; heightDst = pts[1].y - pts[0].y; pts[0].x = xSrc; pts[0].y = ySrc; pts[1].x = xSrc + widthSrc; pts[1].y = ySrc + heightSrc; LPtoDP(devSrc->hdc, pts, 2); xSrc = pts[0].x; ySrc = pts[0].y; widthSrc = pts[1].x - pts[0].x; heightSrc = pts[1].y - pts[0].y; if (!widthDst || !heightDst || !widthSrc || !heightSrc) return TRUE; #ifndef HAVE_XRENDERSETPICTURETRANSFORM if(widthDst != widthSrc || heightDst != heightSrc) #else if(!pXRenderSetPictureTransform) #endif { FIXME("Unable to Stretch, XRenderSetPictureTransform is currently required\n"); return FALSE; } if (!devSrc->bitmap || GetObjectW( devSrc->bitmap->hbitmap, sizeof(dib), &dib ) != sizeof(dib)) { FIXME("not a dibsection\n"); return FALSE; } if(dib.dsBm.bmBitsPixel != 32) { FIXME("not a 32 bpp dibsection\n"); return FALSE; } dstbits = data = HeapAlloc(GetProcessHeap(), 0, heightSrc * widthSrc * 4); if(dib.dsBmih.biHeight < 0) { /* top-down dib */ top_down = TRUE; dstbits += widthSrc * (heightSrc - 1) * 4; y2 = ySrc; y = y2 + heightSrc - 1; } else { y = dib.dsBmih.biHeight - ySrc - 1; y2 = y - heightSrc + 1; } for(; y >= y2; y--) { memcpy(dstbits, (char *)dib.dsBm.bmBits + y * dib.dsBm.bmWidthBytes + xSrc * 4, widthSrc * 4); dstbits += (top_down ? -1 : 1) * widthSrc * 4; } wine_tsx11_lock(); image = XCreateImage(gdi_display, visual, 32, ZPixmap, 0, (char*) data, widthSrc, heightSrc, 32, widthSrc * 4); /* Avoid using XRenderFindStandardFormat as older libraries don't have it src_format = pXRenderFindStandardFormat(gdi_display, PictStandardARGB32); */ src_format = pXRenderFindFormat(gdi_display, argb32_templ_mask, &argb32_templ, 0); TRACE("src_format %p\n", src_format); pa.subwindow_mode = IncludeInferiors; /* FIXME use devDst->xrender->pict ? */ dst_pict = pXRenderCreatePicture(gdi_display, devDst->drawable, (devDst->depth == 1) ? mono_format : screen_format, CPSubwindowMode, &pa); TRACE("dst_pict %08lx\n", dst_pict); TRACE("src_drawable = %08lx\n", devSrc->drawable); xpm = XCreatePixmap(gdi_display, devSrc->drawable, widthSrc, heightSrc, 32); gcv.graphics_exposures = False; gc = XCreateGC(gdi_display, xpm, GCGraphicsExposures, &gcv); TRACE("xpm = %08lx\n", xpm); XPutImage(gdi_display, xpm, gc, image, 0, 0, 0, 0, widthSrc, heightSrc); src_pict = pXRenderCreatePicture(gdi_display, xpm, src_format, CPSubwindowMode, &pa); TRACE("src_pict %08lx\n", src_pict); if ((rgndata = X11DRV_GetRegionData( devDst->region, 0 ))) { pXRenderSetPictureClipRectangles( gdi_display, dst_pict, devDst->dc_rect.left, devDst->dc_rect.top, (XRectangle *)rgndata->Buffer, rgndata->rdh.nCount ); HeapFree( GetProcessHeap(), 0, rgndata ); } #ifdef HAVE_XRENDERSETPICTURETRANSFORM if(widthDst != widthSrc || heightDst != heightSrc) { double xscale = widthSrc/(double)widthDst; double yscale = heightSrc/(double)heightDst; XTransform xform = {{ { XDoubleToFixed(xscale), XDoubleToFixed(0), XDoubleToFixed(0) }, { XDoubleToFixed(0), XDoubleToFixed(yscale), XDoubleToFixed(0) }, { XDoubleToFixed(0), XDoubleToFixed(0), XDoubleToFixed(1) } }}; pXRenderSetPictureTransform(gdi_display, src_pict, &xform); } #endif pXRenderComposite(gdi_display, PictOpOver, src_pict, 0, dst_pict, 0, 0, 0, 0, xDst + devDst->dc_rect.left, yDst + devDst->dc_rect.top, widthDst, heightDst); pXRenderFreePicture(gdi_display, src_pict); XFreePixmap(gdi_display, xpm); XFreeGC(gdi_display, gc); pXRenderFreePicture(gdi_display, dst_pict); image->data = NULL; XDestroyImage(image); wine_tsx11_unlock(); HeapFree(GetProcessHeap(), 0, data); return TRUE; } #else /* HAVE_X11_EXTENSIONS_XRENDER_H */ void X11DRV_XRender_Init(void) { TRACE("XRender support not compiled in.\n"); return; } void X11DRV_XRender_Finalize(void) { } BOOL X11DRV_XRender_SelectFont(X11DRV_PDEVICE *physDev, HFONT hfont) { assert(0); return FALSE; } void X11DRV_XRender_DeleteDC(X11DRV_PDEVICE *physDev) { assert(0); return; } BOOL X11DRV_XRender_ExtTextOut( X11DRV_PDEVICE *physDev, INT x, INT y, UINT flags, const RECT *lprect, LPCWSTR wstr, UINT count, const INT *lpDx ) { assert(0); return FALSE; } void X11DRV_XRender_UpdateDrawable(X11DRV_PDEVICE *physDev) { assert(0); return; } /****************************************************************************** * AlphaBlend (x11drv.@) */ BOOL X11DRV_AlphaBlend(X11DRV_PDEVICE *devDst, INT xDst, INT yDst, INT widthDst, INT heightDst, X11DRV_PDEVICE *devSrc, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc, BLENDFUNCTION blendfn) { FIXME("not supported - XRENDER headers were missing at compile time\n"); return FALSE; } #endif /* HAVE_X11_EXTENSIONS_XRENDER_H */