4 files changed, 2952 insertions, 2929 deletions

diff --git a/libXft/src/makefile b/libXft/src/makefile
new file mode 100644
index 000000000..39693fd19
--- /dev/null
+++ b/libXft/src/makefile
@@ -0,0 +1,23 @@
+INCLUDES += ..\include\X11\Xft
+
+LIBRARY = libXft
+
+CSRCS = \
+                    xftcolor.c \
+                    xftcore.c \
+                    xftdbg.c \
+                    xftdpy.c \
+                    xftdraw.c \
+                    xftextent.c \
+                    xftfont.c \
+                    xftfreetype.c \
+                    xftglyphs.c \
+                    xftinit.c \
+                    xftlist.c \
+                    xftname.c \
+                    xftrender.c \
+                    xftstr.c \
+                    xftswap.c \
+                    xftxlfd.c
+
+INCLUDES += $(MHMAKECONF)\freetype\include $(MHMAKECONF)\fontconfig
diff --git a/libXft/src/xftcore.c b/libXft/src/xftcore.c
index a0103cf26..04fa47640 100644
--- a/libXft/src/xftcore.c
+++ b/libXft/src/xftcore.c
@@ -1,1383 +1,1383 @@
-/*
- * Copyright © 2000 Keith Packard
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
- * representations about the suitability of this software for any purpose.  It
- * is provided "as is" without express or implied warranty.
- *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include "xftint.h"
-
-_X_HIDDEN void
-XftRectCore (XftDraw		*draw,
-	     _Xconst XftColor	*color,
-	     int		x, 
-	     int		y,
-	     unsigned int	width,
-	     unsigned int	height)
-{
-    if (color->color.alpha >= 0x8000)
-    {
-	XSetForeground (draw->dpy, draw->core.gc, color->pixel);
-	XFillRectangle (draw->dpy, draw->drawable, draw->core.gc,
-			x, y, width, height);
-    }
-}
-
-/*
- * Use the core protocol to draw the glyphs
- */
-
-static void
-_XftSharpGlyphMono (XftDraw	*draw,
-		    XftGlyph	*glyph,
-		    int		x,
-		    int		y)
-{
-    unsigned char   *srcLine = glyph->bitmap, *src;
-    unsigned char   bits, bitsMask;
-    int		    width = glyph->metrics.width;
-    int		    stride = ((width + 31) & ~31) >> 3;
-    int		    height = glyph->metrics.height;
-    int		    w;
-    int		    xspan, lenspan;
-
-    x -= glyph->metrics.x;
-    y -= glyph->metrics.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 (draw->dpy, draw->drawable, 
-				draw->core.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++;
-    }
-}
-
-/*
- * Draw solid color text from an anti-aliased bitmap.  This is a
- * fallback for cases where a particular drawable has no AA code
- */
-static void
-_XftSharpGlyphGray (XftDraw	*draw,
-		    XftGlyph	*glyph,
-		    int		x,
-		    int		y)
-{
-    unsigned char   *srcLine = glyph->bitmap, *src, bits;
-    int		    width = glyph->metrics.width;
-    int		    stride = ((width + 3) & ~3);
-    int		    height = glyph->metrics.height;
-    int		    w;
-    int		    xspan, lenspan;
-
-    x -= glyph->metrics.x;
-    y -= glyph->metrics.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 (draw->dpy, draw->drawable, 
-				draw->core.gc, xspan, y, lenspan, 1);
-		xspan += lenspan;
-		w -= lenspan;
-	    }
-	    else
-	    {
-		do
-		{
-		    w--;
-		    xspan++;
-		    if (!w)
-			break;
-		    bits = *src++;
-		} while (bits < 0x80);
-	    }
-	}
-	y++;
-    }
-}
-
-static void
-_XftSharpGlyphRgba (XftDraw	*draw,
-		    XftGlyph	*glyph,
-		    int		x,
-		    int		y)
-{
-    CARD32	    *srcLine = glyph->bitmap, *src, bits;
-    int		    width = glyph->metrics.width;
-    int		    stride = ((width + 3) & ~3);
-    int		    height = glyph->metrics.height;
-    int		    w;
-    int		    xspan, lenspan;
-
-    x -= glyph->metrics.x;
-    y -= glyph->metrics.y;
-    while (height--)
-    {
-	src = srcLine;
-	srcLine += stride;
-	w = width;
-	
-	bits = *src++;
-	xspan = x;
-	while (w)
-	{
-	    if (bits >= 0x80000000)
-	    {
-		lenspan = 0;
-		do
-		{
-		    lenspan++;
-		    if (lenspan == w)
-			break;
-		    bits = *src++;
-		} while (bits >= 0x80000000);
-		XFillRectangle (draw->dpy, draw->drawable, 
-				draw->core.gc, xspan, y, lenspan, 1);
-		xspan += lenspan;
-		w -= lenspan;
-	    }
-	    else
-	    {
-		do
-		{
-		    w--;
-		    xspan++;
-		    if (!w)
-			break;
-		    bits = *src++;
-		} while (bits < 0x80000000);
-	    }
-	}
-	y++;
-    }
-}
-
-typedef void (*XftSharpGlyph) (XftDraw	*draw,
-			       XftGlyph	*glyph,
-			       int	x,
-			       int	y);
-
-static XftSharpGlyph
-_XftSharpGlyphFind (XftDraw *draw, XftFont *public)
-{
-    XftFontInt *font = (XftFontInt *) public;
-
-    if (!font->info.antialias)
-	return _XftSharpGlyphMono;
-    else switch (font->info.rgba) {
-    case FC_RGBA_RGB:
-    case FC_RGBA_BGR:
-    case FC_RGBA_VRGB:
-    case FC_RGBA_VBGR:
-	return _XftSharpGlyphRgba;
-    default:
-	return _XftSharpGlyphGray;
-    }
-}
-
-/*
- * Draw glyphs to a target that supports anti-aliasing
- */
-
-/*
- * Primitives for converting between RGB values and TrueColor pixels
- */
- 
-static void
-_XftExamineBitfield (unsigned long 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 CARD32
-_XftGetField (unsigned long l_pixel, int shift, int len)
-{
-    CARD32  pixel = (CARD32) l_pixel;
-    
-    pixel = pixel & (((1 << (len)) - 1) << shift);
-    pixel = pixel << (32 - (shift + len)) >> 24;
-    while (len < 8)
-    {
-	pixel |= (pixel >> len);
-	len <<= 1;
-    }
-    return pixel;
-}
-
-static unsigned long
-_XftPutField (CARD32 pixel, int shift, int len)
-{
-    unsigned long   l_pixel = (unsigned long) pixel;
-
-    shift = shift - (8 - len);
-    if (len <= 8)
-	l_pixel &= (((1 << len) - 1) << (8 - len));
-    if (shift < 0)
-	l_pixel >>= -shift;
-    else
-	l_pixel <<= shift;
-    return l_pixel;
-}
-
-/*
- * This is used when doing XftCharFontSpec/XftGlyphFontSpec where
- * some of the fonts are bitmaps and some are anti-aliased to handle
- * the bitmap portions
- */
-static void
-_XftSmoothGlyphMono (XImage		*image,
-		     _Xconst XftGlyph	*xftg,
-		     int		x,
-		     int		y,
-		     _Xconst XftColor   *color)
-{
-    unsigned char   *srcLine = xftg->bitmap, *src;
-    unsigned char   bits, bitsMask;
-    int		    width = xftg->metrics.width;
-    int		    stride = ((width + 31) & ~31) >> 3;
-    int		    height = xftg->metrics.height;
-    int		    w;
-    int		    xspan;
-    int		    r_shift, r_len;
-    int		    g_shift, g_len;
-    int		    b_shift, b_len;
-    unsigned long   pixel;
-
-    _XftExamineBitfield (image->red_mask, &r_shift, &r_len);
-    _XftExamineBitfield (image->green_mask, &g_shift, &g_len);
-    _XftExamineBitfield (image->blue_mask, &b_shift, &b_len);
-    pixel = (_XftPutField (color->color.red >> 8, r_shift, r_len) |
-	     _XftPutField (color->color.green >> 8, g_shift, g_len) |
-	     _XftPutField (color->color.blue >> 8, b_shift, b_len));
-    x -= xftg->metrics.x;
-    y -= xftg->metrics.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)
-		XPutPixel (image, xspan, y, pixel);
-    	    bitsMask = bitsMask >> 1;
-    	    if (!bitsMask)
-    	    {
-    		bits = *src++;
-    		bitsMask = 0x80;
-    	    }
-	    xspan++;
-	}
-	y++;
-    }
-}
-
-/*
- * As simple anti-aliasing is likely to be common, there are three
- * optimized versions for the usual true color pixel formats (888, 565, 555).
- * Other formats are handled by the general case
- */
-
-#define cvt8888to0565(s)    ((((s) >> 3) & 0x001f) | \
-			     (((s) >> 5) & 0x07e0) | \
-			     (((s) >> 8) & 0xf800))
-
-#define cvt0565to8888(s)    (((((s) << 3) & 0xf8) | (((s) >> 2) & 0x7)) | \
-			     ((((s) << 5) & 0xfc00) | (((s) >> 1) & 0x300)) | \
-			     ((((s) << 8) & 0xf80000) | (((s) << 3) & 0x70000)))
-
-#define cvt8888to0555(s)    ((((s) >> 3) & 0x001f) | \
-			     (((s) >> 6) & 0x03e0) | \
-			     (((s) >> 7) & 0x7c00))
-
-#define cvt0555to8888(s)    (((((s) << 3) & 0xf8) | (((s) >> 2) & 0x7)) | \
-			     ((((s) << 6) & 0xf800) | (((s) >> 0) & 0x300)) | \
-			     ((((s) << 9) & 0xf80000) | (((s) << 4) & 0x70000)))
-
-
-#define XftIntMult(a,b,t) ( (t) = (a) * (b) + 0x80, ( ( ( (t)>>8 ) + (t) )>>8 ) )
-#define XftIntDiv(a,b)	 (((CARD16) (a) * 255) / (b))
-
-#define XftGet8(v,i)   ((CARD16) (CARD8) ((v) >> i))
-
-/*
- * There are two ways of handling alpha -- either as a single unified value or
- * a separate value for each component, hence each macro must have two
- * versions.  The unified alpha version has a 'U' at the end of the name,
- * the component version has a 'C'.  Similarly, functions which deal with
- * this difference will have two versions using the same convention.
- */
-
-#define XftOverU(x,y,i,a,t) ((t) = XftIntMult(XftGet8(y,i),(a),(t)) + XftGet8(x,i),\
-			   (CARD32) ((CARD8) ((t) | (0 - ((t) >> 8)))) << (i))
-
-#define XftOverC(x,y,i,a,t) ((t) = XftIntMult(XftGet8(y,i),XftGet8(a,i),(t)) + XftGet8(x,i),\
-			    (CARD32) ((CARD8) ((t) | (0 - ((t) >> 8)))) << (i))
-
-#define XftInU(x,i,a,t) ((CARD32) XftIntMult(XftGet8(x,i),(a),(t)) << (i))
-
-#define XftInC(x,i,a,t) ((CARD32) XftIntMult(XftGet8(x,i),XftGet8(a,i),(t)) << (i))
-
-#define XftGen(x,y,i,ax,ay,t,u,v) ((t) = (XftIntMult(XftGet8(y,i),ay,(u)) + \
-					 XftIntMult(XftGet8(x,i),ax,(v))),\
-				  (CARD32) ((CARD8) ((t) | \
-						     (0 - ((t) >> 8)))) << (i))
-
-#define XftAdd(x,y,i,t)	((t) = XftGet8(x,i) + XftGet8(y,i), \
-			 (CARD32) ((CARD8) ((t) | (0 - ((t) >> 8)))) << (i))
-
-
-static CARD32
-fbOver24 (CARD32 x, CARD32 y)
-{
-    CARD16  a = ~x >> 24;
-    CARD16  t;
-    CARD32  m,n,o;
-
-    m = XftOverU(x,y,0,a,t);
-    n = XftOverU(x,y,8,a,t);
-    o = XftOverU(x,y,16,a,t);
-    return m|n|o;
-}
-
-static CARD32
-fbIn (CARD32 x, CARD8 y)
-{
-    CARD16  a = y;
-    CARD16  t;
-    CARD32  m,n,o,p;
-
-    m = XftInU(x,0,a,t);
-    n = XftInU(x,8,a,t);
-    o = XftInU(x,16,a,t);
-    p = XftInU(x,24,a,t);
-    return m|n|o|p;
-}
-
-static void
-_XftSmoothGlyphGray8888 (XImage		    *image,
-			 _Xconst XftGlyph   *xftg,
-			 int		    x,
-			 int		    y,
-			 _Xconst XftColor   *color)
-{
-    CARD32	src, srca;
-    CARD32	r, g, b;
-    CARD32	*dstLine, *dst, d;
-    CARD8	*maskLine, *mask, m;
-    int		dstStride, maskStride;
-    int		width, height;
-    int		w;
-
-    srca = color->color.alpha >> 8;
-    
-    /* This handles only RGB and BGR */
-    g = (color->color.green & 0xff00);
-    if (image->red_mask == 0xff0000)
-    {
-	r = (color->color.red & 0xff00) << 8;
-	b = color->color.blue >> 8;
-    }
-    else
-    {
-	r = color->color.red >> 8;
-	b = (color->color.blue & 0xff00) << 8;
-    }
-    src = (srca << 24) | r | g | b;
-    
-    width = xftg->metrics.width;
-    height = xftg->metrics.height;
-    
-    x -= xftg->metrics.x;
-    y -= xftg->metrics.y;
-
-    dstLine = (CARD32 *) (image->data + image->bytes_per_line * y + (x << 2));
-    dstStride = image->bytes_per_line >> 2;
-    maskLine = (unsigned char *) xftg->bitmap;
-    maskStride = (width + 3) & ~3;
-    
-    while (height--)
-    {
-	dst = dstLine;
-	dstLine += dstStride;
-	mask = maskLine;
-	maskLine += maskStride;
-	w = width;
-
-	while (w--)
-	{
-	    m = *mask++;
-	    if (m == 0xff)
-	    {
-		if (srca == 0xff)
-		    *dst = src;
-		else
-		    *dst = fbOver24 (src, *dst);
-	    }
-	    else if (m)
-	    {
-		d = fbIn (src, m);
-		*dst = fbOver24 (d, *dst);
-	    }
-	    dst++;
-	}
-    }
-}
-
-static void
-_XftSmoothGlyphGray565 (XImage		    *image,
-			_Xconst XftGlyph    *xftg,
-			int		    x,
-			int		    y,
-			_Xconst XftColor    *color)
-{
-    CARD32	src, srca;
-    CARD32	r, g, b;
-    CARD32	d;
-    CARD16	*dstLine, *dst;
-    CARD8	*maskLine, *mask, m;
-    int		dstStride, maskStride;
-    int		width, height;
-    int		w;
-
-    srca = color->color.alpha >> 8;
-    
-    /* This handles only RGB and BGR */
-    g = (color->color.green & 0xff00);
-    if (image->red_mask == 0xf800)
-    {
-	r = (color->color.red & 0xff00) << 8;
-	b = color->color.blue >> 8;
-    }
-    else
-    {
-	r = color->color.red >> 8;
-	b = (color->color.blue & 0xff00) << 8;
-    }
-    src = (srca << 24) | r | g | b;
-    
-    width = xftg->metrics.width;
-    height = xftg->metrics.height;
-    
-    x -= xftg->metrics.x;
-    y -= xftg->metrics.y;
-
-    dstLine = (CARD16 *) (image->data + image->bytes_per_line * y + (x << 1));
-    dstStride = image->bytes_per_line >> 1;
-    maskLine = (unsigned char *) xftg->bitmap;
-    maskStride = (width + 3) & ~3;
-    
-    while (height--)
-    {
-	dst = dstLine;
-	dstLine += dstStride;
-	mask = maskLine;
-	maskLine += maskStride;
-	w = width;
-
-	while (w--)
-	{
-	    m = *mask++;
-	    if (m == 0xff)
-	    {
-		if (srca == 0xff)
-		    d = src;
-		else
-		{
-		    d = *dst;
-		    d = fbOver24 (src, cvt0565to8888(d));
-		}
-		*dst = cvt8888to0565(d);
-	    }
-	    else if (m)
-	    {
-		d = *dst;
-		d = fbOver24 (fbIn(src,m), cvt0565to8888(d));
-		*dst = cvt8888to0565(d);
-	    }
-	    dst++;
-	}
-    }
-}
-
-static void
-_XftSmoothGlyphGray555 (XImage		    *image,
-			_Xconst XftGlyph    *xftg,
-			int		    x,
-			int		    y,
-			_Xconst XftColor    *color)
-{
-    CARD32	src, srca;
-    CARD32	r, g, b;
-    CARD32	d;
-    CARD16	*dstLine, *dst;
-    CARD8	*maskLine, *mask, m;
-    int		dstStride, maskStride;
-    int		width, height;
-    int		w;
-
-    srca = color->color.alpha >> 8;
-    
-    /* This handles only RGB and BGR */
-    g = (color->color.green & 0xff00);
-    if (image->red_mask == 0xf800)
-    {
-	r = (color->color.red & 0xff00) << 8;
-	b = color->color.blue >> 8;
-    }
-    else
-    {
-	r = color->color.red >> 8;
-	b = (color->color.blue & 0xff00) << 8;
-    }
-    src = (srca << 24) | r | g | b;
-    
-    width = xftg->metrics.width;
-    height = xftg->metrics.height;
-    
-    x -= xftg->metrics.x;
-    y -= xftg->metrics.y;
-
-    dstLine = (CARD16 *) (image->data + image->bytes_per_line * y + (x << 1));
-    dstStride = image->bytes_per_line >> 1;
-    maskLine = (unsigned char *) xftg->bitmap;
-    maskStride = (width + 3) & ~3;
-    
-    while (height--)
-    {
-	dst = dstLine;
-	dstLine += dstStride;
-	mask = maskLine;
-	maskLine += maskStride;
-	w = width;
-
-	while (w--)
-	{
-	    m = *mask++;
-	    if (m == 0xff)
-	    {
-		if (srca == 0xff)
-		    d = src;
-		else
-		{
-		    d = *dst;
-		    d = fbOver24 (src, cvt0555to8888(d));
-		}
-		*dst = cvt8888to0555(d);
-	    }
-	    else if (m)
-	    {
-		d = *dst;
-		d = fbOver24 (fbIn(src,m), cvt0555to8888(d));
-		*dst = cvt8888to0555(d);
-	    }
-	    dst++;
-	}
-    }
-}
-
-static void
-_XftSmoothGlyphGray (XImage		*image,
-		     _Xconst XftGlyph	*xftg,
-		     int		x,
-		     int		y,
-		     _Xconst XftColor   *color)
-{
-    CARD32	    src, srca;
-    int		    r_shift, r_len;
-    int		    g_shift, g_len;
-    int		    b_shift, b_len;
-    CARD8	    *maskLine, *mask, m;
-    int		    maskStride;
-    CARD32	    d;
-    unsigned long   pixel;
-    int		    width, height;
-    int		    w, tx;
-    
-    srca = color->color.alpha >> 8;
-    src = (srca << 24 |
-	   (color->color.red & 0xff00) << 8 |
-	   (color->color.green & 0xff00) |
-	   (color->color.blue) >> 8);
-    x -= xftg->metrics.x;
-    y -= xftg->metrics.y;
-    width = xftg->metrics.width;
-    height = xftg->metrics.height;
-    
-    maskLine = (unsigned char *) xftg->bitmap;
-    maskStride = (width + 3) & ~3;
-
-    _XftExamineBitfield (image->red_mask, &r_shift, &r_len);
-    _XftExamineBitfield (image->green_mask, &g_shift, &g_len);
-    _XftExamineBitfield (image->blue_mask, &b_shift, &b_len);
-    while (height--)
-    {
-	mask = maskLine;
-	maskLine += maskStride;
-	w = width;
-	tx = x;
-	
-	while (w--)
-	{
-	    m = *mask++;
-	    if (m == 0xff)
-	    {
-		if (srca == 0xff)
-		    d = src;
-		else
-		{
-		    pixel = XGetPixel (image, tx, y);
-		    d = (_XftGetField (pixel, r_shift, r_len) << 16 |
-			 _XftGetField (pixel, g_shift, g_len) << 8 |
-			 _XftGetField (pixel, b_shift, b_len));
-		    d = fbOver24 (src, d);
-		}
-		pixel = (_XftPutField ((d >> 16) & 0xff, r_shift, r_len) |
-			 _XftPutField ((d >>  8) & 0xff, g_shift, g_len) |
-			 _XftPutField ((d      ) & 0xff, b_shift, b_len));
-		XPutPixel (image, tx, y, pixel);
-	    }
-	    else if (m)
-	    {
-		pixel = XGetPixel (image, tx, y);
-		d = (_XftGetField (pixel, r_shift, r_len) << 16 |
-		     _XftGetField (pixel, g_shift, g_len) << 8 |
-		     _XftGetField (pixel, b_shift, b_len));
-		d = fbOver24 (fbIn(src,m), d);
-		pixel = (_XftPutField ((d >> 16) & 0xff, r_shift, r_len) |
-			 _XftPutField ((d >>  8) & 0xff, g_shift, g_len) |
-			 _XftPutField ((d      ) & 0xff, b_shift, b_len));
-		XPutPixel (image, tx, y, pixel);
-	    }
-	    tx++;
-	}
-	y++;
-    }
-}
-
-static void
-_XftSmoothGlyphRgba (XImage		*image,
-		     _Xconst XftGlyph	*xftg,
-		     int		x,
-		     int		y,
-		     _Xconst XftColor   *color)
-{
-    CARD32	    src, srca;
-    int		    r_shift, r_len;
-    int		    g_shift, g_len;
-    int		    b_shift, b_len;
-    CARD32	    *mask, ma;
-    CARD32	    d;
-    unsigned long   pixel;
-    int		    width, height;
-    int		    w, tx;
-    
-    srca = color->color.alpha >> 8;
-    src = (srca << 24 |
-	   (color->color.red & 0xff00) << 8 |
-	   (color->color.green & 0xff00) |
-	   (color->color.blue) >> 8);
-    x -= xftg->metrics.x;
-    y -= xftg->metrics.y;
-    width = xftg->metrics.width;
-    height = xftg->metrics.height;
-    
-    mask = (CARD32 *) xftg->bitmap;
-
-    _XftExamineBitfield (image->red_mask, &r_shift, &r_len);
-    _XftExamineBitfield (image->green_mask, &g_shift, &g_len);
-    _XftExamineBitfield (image->blue_mask, &b_shift, &b_len);
-    while (height--)
-    {
-	w = width;
-	tx = x;
-	
-	while (w--)
-	{
-	    ma = *mask++;
-	    if (ma == 0xffffffff)
-	    {
-		if (srca == 0xff)
-		    d = src;
-		else
-		{
-		    pixel = XGetPixel (image, tx, y);
-		    d = (_XftGetField (pixel, r_shift, r_len) << 16 |
-			 _XftGetField (pixel, g_shift, g_len) << 8 |
-			 _XftGetField (pixel, b_shift, b_len));
-		    d = fbOver24 (src, d);
-		}
-		pixel = (_XftPutField ((d >> 16) & 0xff, r_shift, r_len) |
-			 _XftPutField ((d >>  8) & 0xff, g_shift, g_len) |
-			 _XftPutField ((d      ) & 0xff, b_shift, b_len));
-		XPutPixel (image, tx, y, pixel);
-	    }
-	    else if (ma)
-	    {
-		CARD32	m,n,o;
-		pixel = XGetPixel (image, tx, y);
-		d = (_XftGetField (pixel, r_shift, r_len) << 16 |
-		     _XftGetField (pixel, g_shift, g_len) << 8 |
-		     _XftGetField (pixel, b_shift, b_len));
-#define XftInOverC(src,srca,msk,dst,i,result) { \
-    CARD16  __a = XftGet8(msk,i); \
-    CARD32  __t, __ta; \
-    CARD32  __i; \
-    __t = XftIntMult (XftGet8(src,i), __a,__i); \
-    __ta = (CARD8) ~XftIntMult (srca, __a,__i); \
-    __t = __t + XftIntMult(XftGet8(dst,i),__ta,__i); \
-    __t = (CARD32) (CARD8) (__t | (-(__t >> 8))); \
-    result = __t << (i); \
-}
-		XftInOverC(src,srca,ma,d,0,m);
-		XftInOverC(src,srca,ma,d,8,n);
-		XftInOverC(src,srca,ma,d,16,o);
-		d = m | n | o;
-		pixel = (_XftPutField ((d >> 16) & 0xff, r_shift, r_len) |
-			 _XftPutField ((d >>  8) & 0xff, g_shift, g_len) |
-			 _XftPutField ((d      ) & 0xff, b_shift, b_len));
-		XPutPixel (image, tx, y, pixel);
-	    }
-	    tx++;
-	}
-	y++;
-    }
-}
-
-static FcBool
-_XftSmoothGlyphPossible (XftDraw *draw)
-{
-    if (!draw->visual)
-	return FcFalse;
-    if (draw->visual->class != TrueColor)
-	return FcFalse;
-    return FcTrue;
-}
-
-typedef	void (*XftSmoothGlyph) (XImage		    *image, 
-				_Xconst XftGlyph    *xftg,
-				int		    x,
-				int		    y,
-				_Xconst XftColor    *color);
-
-static XftSmoothGlyph
-_XftSmoothGlyphFind (XftDraw *draw, XftFont *public)
-{
-    XftFontInt *font = (XftFontInt *) public;
-
-    if (!font->info.antialias)
-	return _XftSmoothGlyphMono;
-    else switch (font->info.rgba) {
-    case FC_RGBA_RGB:
-    case FC_RGBA_BGR:
-    case FC_RGBA_VRGB:
-    case FC_RGBA_VBGR:
-	return _XftSmoothGlyphRgba;
-    default:
-	switch (XftDrawBitsPerPixel (draw)) {
-	case 32:
-	    if ((draw->visual->red_mask   == 0xff0000 &&
-		 draw->visual->green_mask == 0x00ff00 &&
-		 draw->visual->blue_mask  == 0x0000ff) ||
-		(draw->visual->red_mask   == 0x0000ff &&
-		 draw->visual->green_mask == 0x00ff00 &&
-		 draw->visual->blue_mask  == 0xff0000))
-	    {
-		return _XftSmoothGlyphGray8888;
-	    }
-	    break;
-	case 16:
-	    if ((draw->visual->red_mask   == 0xf800 &&
-		 draw->visual->green_mask == 0x07e0 &&
-		 draw->visual->blue_mask  == 0x001f) ||
-		(draw->visual->red_mask   == 0x001f &&
-		 draw->visual->green_mask == 0x07e0 &&
-		 draw->visual->blue_mask  == 0xf800))
-	    {
-		return _XftSmoothGlyphGray565;
-	    }
-	    if ((draw->visual->red_mask   == 0x7c00 &&
-		 draw->visual->green_mask == 0x03e0 &&
-		 draw->visual->blue_mask  == 0x001f) ||
-		(draw->visual->red_mask   == 0x001f &&
-		 draw->visual->green_mask == 0x03e0 &&
-		 draw->visual->blue_mask  == 0x7c00))
-	    {
-		return _XftSmoothGlyphGray555;
-	    }
-	    break;
-	default:
-	    break;
-	}
-	return _XftSmoothGlyphGray;
-    }
-}
-
-static XftGlyph *
-_XftGlyphDefault (Display *dpy, XftFont   *public)
-{
-    XftFontInt	    *font = (XftFontInt *) public;
-    FT_UInt	    missing[XFT_NMISSING];
-    int		    nmissing;
-    FcBool	    glyphs_loaded = FcFalse;
-
-    if (XftFontCheckGlyph (dpy, public, FcTrue, 0, missing, &nmissing))
-	glyphs_loaded = FcTrue;
-    if (nmissing)
-	XftFontLoadGlyphs (dpy, public, glyphs_loaded, missing, nmissing);
-    return font->glyphs[0];
-}
-
-static int XftGetImageErrorHandler (Display *dpy, XErrorEvent *error_event)
-{
-    return 0;
-}
-
-_X_HIDDEN void
-XftGlyphCore (XftDraw		*draw,
-	      _Xconst XftColor	*color,
-	      XftFont		*public,
-	      int		x,
-	      int		y,
-	      _Xconst FT_UInt	*glyphs,
-	      int		nglyphs)
-{
-    Display	    *dpy = draw->dpy;
-    XftFontInt	    *font = (XftFontInt *) public;
-    XftGlyph	    *xftg;
-    FT_UInt	    glyph;
-    _Xconst FT_UInt *g;
-    FT_UInt	    missing[XFT_NMISSING];
-    FcBool	    glyphs_loaded;
-    int		    nmissing;
-    int		    n;
-    XErrorHandler   prev_error;
-
-    /*
-     * Load missing glyphs
-     */
-    g = glyphs;
-    n = nglyphs;
-    nmissing = 0;
-    glyphs_loaded = FcFalse;
-    while (n--)
-	if (XftFontCheckGlyph (dpy, public, FcTrue, *g++, missing, &nmissing))
-	    glyphs_loaded = FcTrue;
-    if (nmissing)
-	XftFontLoadGlyphs (dpy, public, FcTrue, missing, nmissing);
-    
-    g = glyphs;
-    n = nglyphs;
-    if ((font->info.antialias || color->color.alpha != 0xffff) &&
-	_XftSmoothGlyphPossible (draw))
-    {
-	XGlyphInfo	gi;
-	XImage		*image;
-        unsigned int    depth;
-	int		ox, oy;
-	XftSmoothGlyph	smooth = _XftSmoothGlyphFind (draw, public);
-	
-	XftGlyphExtents (dpy, public, glyphs, nglyphs, &gi);
-	if (!gi.width || !gi.height)
-	    goto bail1;
-	ox = x - gi.x;
-	oy = y - gi.y;
-	/*
-	 * Try to get bits directly from the drawable; if that fails,
-	 * use a temporary pixmap.  When it does fail, assume it
-	 * will probably fail for a while and keep using temporary
-	 * pixmaps for a while to avoid double round trips.
-	 */
-	if (draw->core.use_pixmap == 0)
-	{
-	    prev_error = XSetErrorHandler (XftGetImageErrorHandler);
-	    image = XGetImage (dpy, draw->drawable,
-			       ox, oy,
-			       gi.width, gi.height, AllPlanes,
-			       ZPixmap);
-	    XSetErrorHandler (prev_error);
-	    if (!image)
-		draw->core.use_pixmap = XFT_ASSUME_PIXMAP;
-	}
-	else
-	{
-	    draw->core.use_pixmap--;
-	    image = NULL;
-	}
-	if (!image && (depth = XftDrawDepth (draw)))
-	{
-	    Pixmap	pix;
-	    GC		gc;
-	    XGCValues	gcv;
-
-	    pix = XCreatePixmap (dpy, draw->drawable,
-				 gi.width, gi.height, depth);
-	    gcv.graphics_exposures = False;
-	    gc = XCreateGC (dpy, pix, GCGraphicsExposures, &gcv);
-	    XCopyArea (dpy, draw->drawable, pix, gc, ox, oy,
-		       gi.width, gi.height, 0, 0);
-	    XFreeGC (dpy, gc);
-	    image = XGetImage (dpy, pix, 0, 0, gi.width, gi.height, AllPlanes,
-			       ZPixmap);
-	    XFreePixmap (dpy, pix);
-	}
-	if (!image)
-	    goto bail1;
-	image->red_mask = draw->visual->red_mask;
-	image->green_mask = draw->visual->green_mask;
-	image->blue_mask = draw->visual->blue_mask;
-	if (image->byte_order != XftNativeByteOrder ())
-	    XftSwapImage (image);
-	while (n--)
-	{
-	    glyph = *g++;
-	    if (glyph >= font->num_glyphs || !(xftg = font->glyphs[glyph]))
-		xftg = _XftGlyphDefault (dpy, public);
-	    if (xftg)
-	    {
-		(*smooth) (image, xftg, x - ox, y - oy, color);
-		x += xftg->metrics.xOff;
-		y += xftg->metrics.yOff;
-	    }
-	}
-	if (image->byte_order != XftNativeByteOrder ())
-	    XftSwapImage (image);
-	XPutImage (dpy, draw->drawable, draw->core.gc, image, 0, 0, ox, oy,
-		   gi.width, gi.height);
-	XDestroyImage (image);
-    }
-    else
-    {
-	XftSharpGlyph	sharp = _XftSharpGlyphFind (draw, public);
-	while (n--)
-	{
-	    glyph = *g++;
-	    if (glyph >= font->num_glyphs || !(xftg = font->glyphs[glyph]))
-		xftg = _XftGlyphDefault (dpy, public);
-	    if (xftg)
-	    {
-		(*sharp) (draw, xftg, x, y);
-		x += xftg->metrics.xOff;
-		y += xftg->metrics.yOff;
-	    }
-	}
-    }
-bail1:
-    if (glyphs_loaded)
-	_XftFontManageMemory (dpy, public);
-}
-
-#define NUM_LOCAL   1024
-
-_X_HIDDEN void
-XftGlyphSpecCore (XftDraw		*draw,
-		  _Xconst XftColor	*color,
-		  XftFont		*public,
-		  _Xconst XftGlyphSpec	*glyphs,
-		  int			nglyphs)
-{
-    Display	    *dpy = draw->dpy;
-    XftFontInt	    *font = (XftFontInt *) public;
-    XftGlyph	    *xftg;
-    FT_UInt	    missing[XFT_NMISSING];
-    FcBool	    glyphs_loaded;
-    int		    nmissing;
-    int		    i;
-    XErrorHandler   prev_error;
-    int		    x1, y1, x2, y2;
-
-    /*
-     * Load missing glyphs
-     */
-    glyphs_loaded = FcFalse;
-    x1 = y1 = x2 = y2 = 0;
-    for (i = 0; i < nglyphs; i++)
-    {
-	XGlyphInfo	gi;
-	int		g_x1, g_x2, g_y1, g_y2;
-	
-	nmissing = 0;
-	if (XftFontCheckGlyph (dpy, public, FcTrue, glyphs[i].glyph, missing, &nmissing))
-	    glyphs_loaded = FcTrue;
-	if (nmissing)
-	    XftFontLoadGlyphs (dpy, public, FcTrue, missing, nmissing);
-
-	XftGlyphExtents (dpy, public, &glyphs[i].glyph, 1, &gi);
-	g_x1 = glyphs[i].x - gi.x;
-	g_y1 = glyphs[i].y - gi.y;
-	g_x2 = g_x1 + gi.width;
-	g_y2 = g_y1 + gi.height;
-	if (i)
-	{
-	    if (g_x1 < x1)
-		x1 = g_x1;
-	    if (g_y1 < y1)
-		y1 = g_y1;
-	    if (g_x2 > x2)
-		x2 = g_x2;
-	    if (g_y2 > y2)
-		y2 = g_y2;
-	}
-	else
-	{
-	    x1 = g_x1;
-	    y1 = g_y1;
-	    x2 = g_x2;
-	    y2 = g_y2;
-	}
-    }
-    
-    if (x1 == x2 || y1 == y2)
-	goto bail1;
-
-    if ((font->info.antialias || color->color.alpha != 0xffff) &&
-	_XftSmoothGlyphPossible (draw))
-    {
-	XImage		*image;
-        unsigned int    depth;
-	int		width = x2 - x1, height = y2 - y1;
-	XftSmoothGlyph	smooth = _XftSmoothGlyphFind (draw, public);
-
-	/*
-	 * Try to get bits directly from the drawable; if that fails,
-	 * use a temporary pixmap.  When it does fail, assume it
-	 * will probably fail for a while and keep using temporary
-	 * pixmaps for a while to avoid double round trips.
-	 */
-	if (draw->core.use_pixmap == 0)
-	{
-	    prev_error = XSetErrorHandler (XftGetImageErrorHandler);
-	    image = XGetImage (dpy, draw->drawable,
-			       x1, y1,
-			       width, height, AllPlanes,
-			       ZPixmap);
-	    XSetErrorHandler (prev_error);
-	    if (!image)
-		draw->core.use_pixmap = XFT_ASSUME_PIXMAP;
-	}
-	else
-	{
-	    draw->core.use_pixmap--;
-	    image = NULL;
-	}
-	if (!image && (depth = XftDrawDepth (draw)))
-	{
-	    Pixmap	pix;
-	    GC		gc;
-	    XGCValues	gcv;
-
-	    pix = XCreatePixmap (dpy, draw->drawable,
-				 width, height, depth);
-	    gcv.graphics_exposures = False;
-	    gc = XCreateGC (dpy, pix, GCGraphicsExposures, &gcv);
-	    XCopyArea (dpy, draw->drawable, pix, gc, x1, y1,
-		       width, height, 0, 0);
-	    XFreeGC (dpy, gc);
-	    image = XGetImage (dpy, pix, 0, 0, width, height, AllPlanes,
-			       ZPixmap);
-	    XFreePixmap (dpy, pix);
-	}
-	if (!image)
-	    goto bail1;
-	image->red_mask = draw->visual->red_mask;
-	image->green_mask = draw->visual->green_mask;
-	image->blue_mask = draw->visual->blue_mask;
-	if (image->byte_order != XftNativeByteOrder ())
-	    XftSwapImage (image);
-	for (i = 0; i < nglyphs; i++)
-	{
-	    FT_UInt glyph = glyphs[i].glyph;
-	    if (glyph >= font->num_glyphs || !(xftg = font->glyphs[glyph]))
-		xftg = _XftGlyphDefault (dpy, public);
-	    if (xftg)
-	    {
-		(*smooth) (image, xftg, glyphs[i].x - x1, 
-			   glyphs[i].y - y1, color);
-	    }
-	}
-	if (image->byte_order != XftNativeByteOrder ())
-	    XftSwapImage (image);
-	XPutImage (dpy, draw->drawable, draw->core.gc, image, 0, 0, x1, y1,
-		   width, height);
-	XDestroyImage (image);
-    }
-    else
-    {
-	XftSharpGlyph	sharp = _XftSharpGlyphFind (draw, public);
-	for (i = 0; i < nglyphs; i++)
-	{
-	    FT_UInt glyph = glyphs[i].glyph;
-	    if (glyph >= font->num_glyphs || !(xftg = font->glyphs[glyph]))
-		xftg = _XftGlyphDefault (dpy, public);
-	    if (xftg)
-		(*sharp) (draw, xftg, glyphs[i].x, glyphs[i].y);
-	}
-    }
-bail1:
-    if (glyphs_loaded)
-	_XftFontManageMemory (dpy, public);
-}
-
-_X_HIDDEN void
-XftGlyphFontSpecCore (XftDraw			*draw,
-		      _Xconst XftColor		*color,
-		      _Xconst XftGlyphFontSpec	*glyphs,
-		      int			nglyphs)
-{
-    Display	    *dpy = draw->dpy;
-    XftGlyph	    *xftg;
-    FT_UInt	    missing[XFT_NMISSING];
-    FcBool	    glyphs_loaded;
-    int		    nmissing;
-    int		    i;
-    XErrorHandler   prev_error;
-    int		    x1, y1, x2, y2;
-
-    /*
-     * Load missing glyphs
-     */
-    glyphs_loaded = FcFalse;
-    x1 = y1 = x2 = y2 = 0;
-    for (i = 0; i < nglyphs; i++)
-    {
-	XftFont		*public = glyphs[i].font;
-	XGlyphInfo	gi;
-	int		g_x1, g_x2, g_y1, g_y2;
-	
-	nmissing = 0;
-	if (XftFontCheckGlyph (dpy, public, FcTrue, glyphs[i].glyph, missing, &nmissing))
-	    glyphs_loaded = FcTrue;
-	if (nmissing)
-	    XftFontLoadGlyphs (dpy, public, FcTrue, missing, nmissing);
-	
-	XftGlyphExtents (dpy, public, &glyphs[i].glyph, 1, &gi);
-	g_x1 = glyphs[i].x - gi.x;
-	g_y1 = glyphs[i].y - gi.y;
-	g_x2 = g_x1 + gi.width;
-	g_y2 = g_y1 + gi.height;
-	if (i)
-	{
-	    if (g_x1 < x1)
-	    {
-		if (g_x1 < 0)
-		{
-		    /* do nothing if the given glyphs are out of range */
-		    short t = glyphs[i-1].font->max_advance_width
-			+ glyphs[i-1].x;
-		    if (t < 0 && glyphs[i-1].x > 0)
-			goto bail1;
-		}
-		x1 = g_x1;
-	    }
-	    if (g_y1 < y1)
-		y1 = g_y1;
-	    if (g_x2 > x2)
-		x2 = g_x2;
-	    if (g_y2 > y2)
-		y2 = g_y2;
-	}
-	else
-	{
-	    x1 = g_x1;
-	    y1 = g_y1;
-	    x2 = g_x2;
-	    y2 = g_y2;
-	}
-    }
-    
-    if (x1 == x2 || y1 == y2)
-	goto bail1;
-
-    for (i = 0; i < nglyphs; i++)
-	if (((XftFontInt *) glyphs[i].font)->info.antialias)
-	    break;
-    
-    if ((i != nglyphs || color->color.alpha != 0xffff) &&
-	_XftSmoothGlyphPossible (draw))
-    {
-	XImage		*image;
-        unsigned int    depth;
-	int		width = x2 - x1, height = y2 - y1;
-
-	/*
-	 * Try to get bits directly from the drawable; if that fails,
-	 * use a temporary pixmap.  When it does fail, assume it
-	 * will probably fail for a while and keep using temporary
-	 * pixmaps for a while to avoid double round trips.
-	 */
-	if (draw->core.use_pixmap == 0)
-	{
-	    prev_error = XSetErrorHandler (XftGetImageErrorHandler);
-	    image = XGetImage (dpy, draw->drawable,
-			       x1, y1,
-			       width, height, AllPlanes,
-			       ZPixmap);
-	    XSetErrorHandler (prev_error);
-	    if (!image)
-		draw->core.use_pixmap = XFT_ASSUME_PIXMAP;
-	}
-	else
-	{
-	    draw->core.use_pixmap--;
-	    image = NULL;
-	}
-	if (!image && (depth = XftDrawDepth (draw)))
-	{
-	    Pixmap	pix;
-	    GC		gc;
-	    XGCValues	gcv;
-
-	    pix = XCreatePixmap (dpy, draw->drawable,
-				 width, height, depth);
-	    gcv.graphics_exposures = False;
-	    gc = XCreateGC (dpy, pix, GCGraphicsExposures, &gcv);
-	    XCopyArea (dpy, draw->drawable, pix, gc, x1, y1,
-		       width, height, 0, 0);
-	    XFreeGC (dpy, gc);
-	    image = XGetImage (dpy, pix, 0, 0, width, height, AllPlanes,
-			       ZPixmap);
-	    XFreePixmap (dpy, pix);
-	}
-	if (!image)
-	    goto bail1;
-	image->red_mask = draw->visual->red_mask;
-	image->green_mask = draw->visual->green_mask;
-	image->blue_mask = draw->visual->blue_mask;
-	if (image->byte_order != XftNativeByteOrder ())
-	    XftSwapImage (image);
-	for (i = 0; i < nglyphs; i++)
-	{
-	    XftFont	    *public = glyphs[i].font;
-	    XftFontInt	    *font = (XftFontInt *) public;
-	    XftSmoothGlyph  smooth = _XftSmoothGlyphFind (draw, public);
-	    FT_UInt	    glyph = glyphs[i].glyph;
-	    
-	    if (glyph >= font->num_glyphs || !(xftg = font->glyphs[glyph]))
-		xftg = _XftGlyphDefault (dpy, public);
-	    if (xftg)
-	    {
-		(*smooth) (image, xftg, glyphs[i].x - x1, 
-			   glyphs[i].y - y1, color);
-	    }
-	}
-	if (image->byte_order != XftNativeByteOrder ())
-	    XftSwapImage (image);
-	XPutImage (dpy, draw->drawable, draw->core.gc, image, 0, 0, x1, y1,
-		   width, height);
-	XDestroyImage (image);
-    }
-    else
-    {
-	for (i = 0; i < nglyphs; i++)
-	{
-	    XftFont		*public = glyphs[i].font;
-	    XftFontInt		*font = (XftFontInt *) public;
-	    XftSharpGlyph	sharp = _XftSharpGlyphFind (draw, public);
-	    FT_UInt		glyph = glyphs[i].glyph;
-	    
-	    if (glyph >= font->num_glyphs || !(xftg = font->glyphs[glyph]))
-		xftg = _XftGlyphDefault (dpy, public);
-	    if (xftg)
-		(*sharp) (draw, xftg, glyphs[i].x, glyphs[i].y);
-	}
-    }
-bail1:
-    if (glyphs_loaded)
-	for (i = 0; i < nglyphs; i++)
-	    _XftFontManageMemory (dpy, glyphs[i].font);
-}
+/*

+ * Copyright © 2000 Keith Packard

+ *

+ * Permission to use, copy, modify, distribute, and sell this software and its

+ * documentation for any purpose is hereby granted without fee, provided that

+ * the above copyright notice appear in all copies and that both that

+ * copyright notice and this permission notice appear in supporting

+ * documentation, and that the name of Keith Packard not be used in

+ * advertising or publicity pertaining to distribution of the software without

+ * specific, written prior permission.  Keith Packard makes no

+ * representations about the suitability of this software for any purpose.  It

+ * is provided "as is" without express or implied warranty.

+ *

+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR

+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,

+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

+ * PERFORMANCE OF THIS SOFTWARE.

+ */

+

+#include "xftint.h"

+

+_X_HIDDEN void

+XftRectCore (XftDraw		*draw,

+	     _Xconst XftColor	*color,

+	     int		x, 

+	     int		y,

+	     unsigned int	width,

+	     unsigned int	height)

+{

+    if (color->color.alpha >= 0x8000)

+    {

+	XSetForeground (draw->dpy, draw->core.gc, color->pixel);

+	XFillRectangle (draw->dpy, draw->drawable, draw->core.gc,

+			x, y, width, height);

+    }

+}

+

+/*

+ * Use the core protocol to draw the glyphs

+ */

+

+static void

+_XftSharpGlyphMono (XftDraw	*draw,

+		    XftGlyph	*glyph,

+		    int		x,

+		    int		y)

+{

+    unsigned char   *srcLine = glyph->bitmap, *src;

+    unsigned char   bits, bitsMask;

+    int		    width = glyph->metrics.width;

+    int		    stride = ((width + 31) & ~31) >> 3;

+    int		    height = glyph->metrics.height;

+    int		    w;

+    int		    xspan, lenspan;

+

+    x -= glyph->metrics.x;

+    y -= glyph->metrics.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 (draw->dpy, draw->drawable, 

+				draw->core.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++;

+    }

+}

+

+/*

+ * Draw solid color text from an anti-aliased bitmap.  This is a

+ * fallback for cases where a particular drawable has no AA code

+ */

+static void

+_XftSharpGlyphGray (XftDraw	*draw,

+		    XftGlyph	*glyph,

+		    int		x,

+		    int		y)

+{

+    unsigned char   *srcLine = glyph->bitmap, *src, bits;

+    int		    width = glyph->metrics.width;

+    int		    stride = ((width + 3) & ~3);

+    int		    height = glyph->metrics.height;

+    int		    w;

+    int		    xspan, lenspan;

+

+    x -= glyph->metrics.x;

+    y -= glyph->metrics.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 (draw->dpy, draw->drawable, 

+				draw->core.gc, xspan, y, lenspan, 1);

+		xspan += lenspan;

+		w -= lenspan;

+	    }

+	    else

+	    {

+		do

+		{

+		    w--;

+		    xspan++;

+		    if (!w)

+			break;

+		    bits = *src++;

+		} while (bits < 0x80);

+	    }

+	}

+	y++;

+    }

+}

+

+static void

+_XftSharpGlyphRgba (XftDraw	*draw,

+		    XftGlyph	*glyph,

+		    int		x,

+		    int		y)

+{

+    CARD32	    *srcLine = glyph->bitmap, *src, bits;

+    int		    width = glyph->metrics.width;

+    int		    stride = ((width + 3) & ~3);

+    int		    height = glyph->metrics.height;

+    int		    w;

+    int		    xspan, lenspan;

+

+    x -= glyph->metrics.x;

+    y -= glyph->metrics.y;

+    while (height--)

+    {

+	src = srcLine;

+	srcLine += stride;

+	w = width;

+	

+	bits = *src++;

+	xspan = x;

+	while (w)

+	{

+	    if (bits >= 0x80000000)

+	    {

+		lenspan = 0;

+		do

+		{

+		    lenspan++;

+		    if (lenspan == w)

+			break;

+		    bits = *src++;

+		} while (bits >= 0x80000000);

+		XFillRectangle (draw->dpy, draw->drawable, 

+				draw->core.gc, xspan, y, lenspan, 1);

+		xspan += lenspan;

+		w -= lenspan;

+	    }

+	    else

+	    {

+		do

+		{

+		    w--;

+		    xspan++;

+		    if (!w)

+			break;

+		    bits = *src++;

+		} while (bits < 0x80000000);

+	    }

+	}

+	y++;

+    }

+}

+

+typedef void (*XftSharpGlyph) (XftDraw	*draw,

+			       XftGlyph	*glyph,

+			       int	x,

+			       int	y);

+

+static XftSharpGlyph

+_XftSharpGlyphFind (XftDraw *draw, XftFont *public)

+{

+    XftFontInt *font = (XftFontInt *) public;

+

+    if (!font->info.antialias)

+	return _XftSharpGlyphMono;

+    else switch (font->info.rgba) {

+    case FC_RGBA_RGB:

+    case FC_RGBA_BGR:

+    case FC_RGBA_VRGB:

+    case FC_RGBA_VBGR:

+	return _XftSharpGlyphRgba;

+    default:

+	return _XftSharpGlyphGray;

+    }

+}

+

+/*

+ * Draw glyphs to a target that supports anti-aliasing

+ */

+

+/*

+ * Primitives for converting between RGB values and TrueColor pixels

+ */

+ 

+static void

+_XftExamineBitfield (unsigned long 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 CARD32

+_XftGetField (unsigned long l_pixel, int shift, int len)

+{

+    CARD32  pixel = (CARD32) l_pixel;

+    

+    pixel = pixel & (((1 << (len)) - 1) << shift);

+    pixel = pixel << (32 - (shift + len)) >> 24;

+    while (len < 8)

+    {

+	pixel |= (pixel >> len);

+	len <<= 1;

+    }

+    return pixel;

+}

+

+static unsigned long

+_XftPutField (CARD32 pixel, int shift, int len)

+{

+    unsigned long   l_pixel = (unsigned long) pixel;

+

+    shift = shift - (8 - len);

+    if (len <= 8)

+	l_pixel &= (((1 << len) - 1) << (8 - len));

+    if (shift < 0)

+	l_pixel >>= -shift;

+    else

+	l_pixel <<= shift;

+    return l_pixel;

+}

+

+/*

+ * This is used when doing XftCharFontSpec/XftGlyphFontSpec where

+ * some of the fonts are bitmaps and some are anti-aliased to handle

+ * the bitmap portions

+ */

+static void

+_XftSmoothGlyphMono (XImage		*image,

+		     _Xconst XftGlyph	*xftg,

+		     int		x,

+		     int		y,

+		     _Xconst XftColor   *color)

+{

+    unsigned char   *srcLine = xftg->bitmap, *src;

+    unsigned char   bits, bitsMask;

+    int		    width = xftg->metrics.width;

+    int		    stride = ((width + 31) & ~31) >> 3;

+    int		    height = xftg->metrics.height;

+    int		    w;

+    int		    xspan;

+    int		    r_shift, r_len;

+    int		    g_shift, g_len;

+    int		    b_shift, b_len;

+    unsigned long   pixel;

+

+    _XftExamineBitfield (image->red_mask, &r_shift, &r_len);

+    _XftExamineBitfield (image->green_mask, &g_shift, &g_len);

+    _XftExamineBitfield (image->blue_mask, &b_shift, &b_len);

+    pixel = (_XftPutField (color->color.red >> 8, r_shift, r_len) |

+	     _XftPutField (color->color.green >> 8, g_shift, g_len) |

+	     _XftPutField (color->color.blue >> 8, b_shift, b_len));

+    x -= xftg->metrics.x;

+    y -= xftg->metrics.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)

+		XPutPixel (image, xspan, y, pixel);

+    	    bitsMask = bitsMask >> 1;

+    	    if (!bitsMask)

+    	    {

+    		bits = *src++;

+    		bitsMask = 0x80;

+    	    }

+	    xspan++;

+	}

+	y++;

+    }

+}

+

+/*

+ * As simple anti-aliasing is likely to be common, there are three

+ * optimized versions for the usual true color pixel formats (888, 565, 555).

+ * Other formats are handled by the general case

+ */

+

+#define cvt8888to0565(s)    ((((s) >> 3) & 0x001f) | \

+			     (((s) >> 5) & 0x07e0) | \

+			     (((s) >> 8) & 0xf800))

+

+#define cvt0565to8888(s)    (((((s) << 3) & 0xf8) | (((s) >> 2) & 0x7)) | \

+			     ((((s) << 5) & 0xfc00) | (((s) >> 1) & 0x300)) | \

+			     ((((s) << 8) & 0xf80000) | (((s) << 3) & 0x70000)))

+

+#define cvt8888to0555(s)    ((((s) >> 3) & 0x001f) | \

+			     (((s) >> 6) & 0x03e0) | \

+			     (((s) >> 7) & 0x7c00))

+

+#define cvt0555to8888(s)    (((((s) << 3) & 0xf8) | (((s) >> 2) & 0x7)) | \

+			     ((((s) << 6) & 0xf800) | (((s) >> 0) & 0x300)) | \

+			     ((((s) << 9) & 0xf80000) | (((s) << 4) & 0x70000)))

+

+

+#define XftIntMult(a,b,t) ( (t) = (a) * (b) + 0x80, ( ( ( (t)>>8 ) + (t) )>>8 ) )

+#define XftIntDiv(a,b)	 (((CARD16) (a) * 255) / (b))

+

+#define XftGet8(v,i)   ((CARD16) (CARD8) ((v) >> i))

+

+/*

+ * There are two ways of handling alpha -- either as a single unified value or

+ * a separate value for each component, hence each macro must have two

+ * versions.  The unified alpha version has a 'U' at the end of the name,

+ * the component version has a 'C'.  Similarly, functions which deal with

+ * this difference will have two versions using the same convention.

+ */

+

+#define XftOverU(x,y,i,a,t) ((t) = XftIntMult(XftGet8(y,i),(a),(t)) + XftGet8(x,i),\

+			   (CARD32) ((CARD8) ((t) | (0 - ((t) >> 8)))) << (i))

+

+#define XftOverC(x,y,i,a,t) ((t) = XftIntMult(XftGet8(y,i),XftGet8(a,i),(t)) + XftGet8(x,i),\

+			    (CARD32) ((CARD8) ((t) | (0 - ((t) >> 8)))) << (i))

+

+#define XftInU(x,i,a,t) ((CARD32) XftIntMult(XftGet8(x,i),(a),(t)) << (i))

+

+#define XftInC(x,i,a,t) ((CARD32) XftIntMult(XftGet8(x,i),XftGet8(a,i),(t)) << (i))

+

+#define XftGen(x,y,i,ax,ay,t,u,v) ((t) = (XftIntMult(XftGet8(y,i),ay,(u)) + \

+					 XftIntMult(XftGet8(x,i),ax,(v))),\

+				  (CARD32) ((CARD8) ((t) | \

+						     (0 - ((t) >> 8)))) << (i))

+

+#define XftAdd(x,y,i,t)	((t) = XftGet8(x,i) + XftGet8(y,i), \

+			 (CARD32) ((CARD8) ((t) | (0 - ((t) >> 8)))) << (i))

+

+

+static CARD32

+fbOver24 (CARD32 x, CARD32 y)

+{

+    CARD16  a = ~x >> 24;

+    CARD16  t;

+    CARD32  m,n,o;

+

+    m = XftOverU(x,y,0,a,t);

+    n = XftOverU(x,y,8,a,t);

+    o = XftOverU(x,y,16,a,t);

+    return m|n|o;

+}

+

+static CARD32

+fbIn (CARD32 x, CARD8 y)

+{

+    CARD16  a = y;

+    CARD16  t;

+    CARD32  m,n,o,p;

+

+    m = XftInU(x,0,a,t);

+    n = XftInU(x,8,a,t);

+    o = XftInU(x,16,a,t);

+    p = XftInU(x,24,a,t);

+    return m|n|o|p;

+}

+

+static void

+_XftSmoothGlyphGray8888 (XImage		    *image,

+			 _Xconst XftGlyph   *xftg,

+			 int		    x,

+			 int		    y,

+			 _Xconst XftColor   *color)

+{

+    CARD32	src, srca;

+    CARD32	r, g, b;

+    CARD32	*dstLine, *dst, d;

+    CARD8	*maskLine, *mask, m;

+    int		dstStride, maskStride;

+    int		width, height;

+    int		w;

+

+    srca = color->color.alpha >> 8;

+    

+    /* This handles only RGB and BGR */

+    g = (color->color.green & 0xff00);

+    if (image->red_mask == 0xff0000)

+    {

+	r = (color->color.red & 0xff00) << 8;

+	b = color->color.blue >> 8;

+    }

+    else

+    {

+	r = color->color.red >> 8;

+	b = (color->color.blue & 0xff00) << 8;

+    }

+    src = (srca << 24) | r | g | b;

+    

+    width = xftg->metrics.width;

+    height = xftg->metrics.height;

+    

+    x -= xftg->metrics.x;

+    y -= xftg->metrics.y;

+

+    dstLine = (CARD32 *) (image->data + image->bytes_per_line * y + (x << 2));

+    dstStride = image->bytes_per_line >> 2;

+    maskLine = (unsigned char *) xftg->bitmap;

+    maskStride = (width + 3) & ~3;

+    

+    while (height--)

+    {

+	dst = dstLine;

+	dstLine += dstStride;

+	mask = maskLine;

+	maskLine += maskStride;

+	w = width;

+

+	while (w--)

+	{

+	    m = *mask++;

+	    if (m == 0xff)

+	    {

+		if (srca == 0xff)

+		    *dst = src;

+		else

+		    *dst = fbOver24 (src, *dst);

+	    }

+	    else if (m)

+	    {

+		d = fbIn (src, m);

+		*dst = fbOver24 (d, *dst);

+	    }

+	    dst++;

+	}

+    }

+}

+

+static void

+_XftSmoothGlyphGray565 (XImage		    *image,

+			_Xconst XftGlyph    *xftg,

+			int		    x,

+			int		    y,

+			_Xconst XftColor    *color)

+{

+    CARD32	src, srca;

+    CARD32	r, g, b;

+    CARD32	d;

+    CARD16	*dstLine, *dst;

+    CARD8	*maskLine, *mask, m;

+    int		dstStride, maskStride;

+    int		width, height;

+    int		w;

+

+    srca = color->color.alpha >> 8;

+    

+    /* This handles only RGB and BGR */

+    g = (color->color.green & 0xff00);

+    if (image->red_mask == 0xf800)

+    {

+	r = (color->color.red & 0xff00) << 8;

+	b = color->color.blue >> 8;

+    }

+    else

+    {

+	r = color->color.red >> 8;

+	b = (color->color.blue & 0xff00) << 8;

+    }

+    src = (srca << 24) | r | g | b;

+    

+    width = xftg->metrics.width;

+    height = xftg->metrics.height;

+    

+    x -= xftg->metrics.x;

+    y -= xftg->metrics.y;

+

+    dstLine = (CARD16 *) (image->data + image->bytes_per_line * y + (x << 1));

+    dstStride = image->bytes_per_line >> 1;

+    maskLine = (unsigned char *) xftg->bitmap;

+    maskStride = (width + 3) & ~3;

+    

+    while (height--)

+    {

+	dst = dstLine;

+	dstLine += dstStride;

+	mask = maskLine;

+	maskLine += maskStride;

+	w = width;

+

+	while (w--)

+	{

+	    m = *mask++;

+	    if (m == 0xff)

+	    {

+		if (srca == 0xff)

+		    d = src;

+		else

+		{

+		    d = *dst;

+		    d = fbOver24 (src, cvt0565to8888(d));

+		}

+		*dst = cvt8888to0565(d);

+	    }

+	    else if (m)

+	    {

+		d = *dst;

+		d = fbOver24 (fbIn(src,m), cvt0565to8888(d));

+		*dst = cvt8888to0565(d);

+	    }

+	    dst++;

+	}

+    }

+}

+

+static void

+_XftSmoothGlyphGray555 (XImage		    *image,

+			_Xconst XftGlyph    *xftg,

+			int		    x,

+			int		    y,

+			_Xconst XftColor    *color)

+{

+    CARD32	src, srca;

+    CARD32	r, g, b;

+    CARD32	d;

+    CARD16	*dstLine, *dst;

+    CARD8	*maskLine, *mask, m;

+    int		dstStride, maskStride;

+    int		width, height;

+    int		w;

+

+    srca = color->color.alpha >> 8;

+    

+    /* This handles only RGB and BGR */

+    g = (color->color.green & 0xff00);

+    if (image->red_mask == 0xf800)

+    {

+	r = (color->color.red & 0xff00) << 8;

+	b = color->color.blue >> 8;

+    }

+    else

+    {

+	r = color->color.red >> 8;

+	b = (color->color.blue & 0xff00) << 8;

+    }

+    src = (srca << 24) | r | g | b;

+    

+    width = xftg->metrics.width;

+    height = xftg->metrics.height;

+    

+    x -= xftg->metrics.x;

+    y -= xftg->metrics.y;

+

+    dstLine = (CARD16 *) (image->data + image->bytes_per_line * y + (x << 1));

+    dstStride = image->bytes_per_line >> 1;

+    maskLine = (unsigned char *) xftg->bitmap;

+    maskStride = (width + 3) & ~3;

+    

+    while (height--)

+    {

+	dst = dstLine;

+	dstLine += dstStride;

+	mask = maskLine;

+	maskLine += maskStride;

+	w = width;

+

+	while (w--)

+	{

+	    m = *mask++;

+	    if (m == 0xff)

+	    {

+		if (srca == 0xff)

+		    d = src;

+		else

+		{

+		    d = *dst;

+		    d = fbOver24 (src, cvt0555to8888(d));

+		}

+		*dst = cvt8888to0555(d);

+	    }

+	    else if (m)

+	    {

+		d = *dst;

+		d = fbOver24 (fbIn(src,m), cvt0555to8888(d));

+		*dst = cvt8888to0555(d);

+	    }

+	    dst++;

+	}

+    }

+}

+

+static void

+_XftSmoothGlyphGray (XImage		*image,

+		     _Xconst XftGlyph	*xftg,

+		     int		x,

+		     int		y,

+		     _Xconst XftColor   *color)

+{

+    CARD32	    src, srca;

+    int		    r_shift, r_len;

+    int		    g_shift, g_len;

+    int		    b_shift, b_len;

+    CARD8	    *maskLine, *mask, m;

+    int		    maskStride;

+    CARD32	    d;

+    unsigned long   pixel;

+    int		    width, height;

+    int		    w, tx;

+    

+    srca = color->color.alpha >> 8;

+    src = (srca << 24 |

+	   (color->color.red & 0xff00) << 8 |

+	   (color->color.green & 0xff00) |

+	   (color->color.blue) >> 8);

+    x -= xftg->metrics.x;

+    y -= xftg->metrics.y;

+    width = xftg->metrics.width;

+    height = xftg->metrics.height;

+    

+    maskLine = (unsigned char *) xftg->bitmap;

+    maskStride = (width + 3) & ~3;

+

+    _XftExamineBitfield (image->red_mask, &r_shift, &r_len);

+    _XftExamineBitfield (image->green_mask, &g_shift, &g_len);

+    _XftExamineBitfield (image->blue_mask, &b_shift, &b_len);

+    while (height--)

+    {

+	mask = maskLine;

+	maskLine += maskStride;

+	w = width;

+	tx = x;

+	

+	while (w--)

+	{

+	    m = *mask++;

+	    if (m == 0xff)

+	    {

+		if (srca == 0xff)

+		    d = src;

+		else

+		{

+		    pixel = XGetPixel (image, tx, y);

+		    d = (_XftGetField (pixel, r_shift, r_len) << 16 |

+			 _XftGetField (pixel, g_shift, g_len) << 8 |

+			 _XftGetField (pixel, b_shift, b_len));

+		    d = fbOver24 (src, d);

+		}

+		pixel = (_XftPutField ((d >> 16) & 0xff, r_shift, r_len) |

+			 _XftPutField ((d >>  8) & 0xff, g_shift, g_len) |

+			 _XftPutField ((d      ) & 0xff, b_shift, b_len));

+		XPutPixel (image, tx, y, pixel);

+	    }

+	    else if (m)

+	    {

+		pixel = XGetPixel (image, tx, y);

+		d = (_XftGetField (pixel, r_shift, r_len) << 16 |

+		     _XftGetField (pixel, g_shift, g_len) << 8 |

+		     _XftGetField (pixel, b_shift, b_len));

+		d = fbOver24 (fbIn(src,m), d);

+		pixel = (_XftPutField ((d >> 16) & 0xff, r_shift, r_len) |

+			 _XftPutField ((d >>  8) & 0xff, g_shift, g_len) |

+			 _XftPutField ((d      ) & 0xff, b_shift, b_len));

+		XPutPixel (image, tx, y, pixel);

+	    }

+	    tx++;

+	}

+	y++;

+    }

+}

+

+static void

+_XftSmoothGlyphRgba (XImage		*image,

+		     _Xconst XftGlyph	*xftg,

+		     int		x,

+		     int		y,

+		     _Xconst XftColor   *color)

+{

+    CARD32	    src, srca;

+    int		    r_shift, r_len;

+    int		    g_shift, g_len;

+    int		    b_shift, b_len;

+    CARD32	    *mask, ma;

+    CARD32	    d;

+    unsigned long   pixel;

+    int		    width, height;

+    int		    w, tx;

+    

+    srca = color->color.alpha >> 8;

+    src = (srca << 24 |

+	   (color->color.red & 0xff00) << 8 |

+	   (color->color.green & 0xff00) |

+	   (color->color.blue) >> 8);

+    x -= xftg->metrics.x;

+    y -= xftg->metrics.y;

+    width = xftg->metrics.width;

+    height = xftg->metrics.height;

+    

+    mask = (CARD32 *) xftg->bitmap;

+

+    _XftExamineBitfield (image->red_mask, &r_shift, &r_len);

+    _XftExamineBitfield (image->green_mask, &g_shift, &g_len);

+    _XftExamineBitfield (image->blue_mask, &b_shift, &b_len);

+    while (height--)

+    {

+	w = width;

+	tx = x;

+	

+	while (w--)

+	{

+	    ma = *mask++;

+	    if (ma == 0xffffffff)

+	    {

+		if (srca == 0xff)

+		    d = src;

+		else

+		{

+		    pixel = XGetPixel (image, tx, y);

+		    d = (_XftGetField (pixel, r_shift, r_len) << 16 |

+			 _XftGetField (pixel, g_shift, g_len) << 8 |

+			 _XftGetField (pixel, b_shift, b_len));

+		    d = fbOver24 (src, d);

+		}

+		pixel = (_XftPutField ((d >> 16) & 0xff, r_shift, r_len) |

+			 _XftPutField ((d >>  8) & 0xff, g_shift, g_len) |

+			 _XftPutField ((d      ) & 0xff, b_shift, b_len));

+		XPutPixel (image, tx, y, pixel);

+	    }

+	    else if (ma)

+	    {

+		CARD32	m,n,o;

+		pixel = XGetPixel (image, tx, y);

+		d = (_XftGetField (pixel, r_shift, r_len) << 16 |

+		     _XftGetField (pixel, g_shift, g_len) << 8 |

+		     _XftGetField (pixel, b_shift, b_len));

+#define XftInOverC(src,srca,msk,dst,i,result) { \

+    CARD16  __a = XftGet8(msk,i); \

+    CARD32  __t, __ta; \

+    CARD32  __i; \

+    __t = XftIntMult (XftGet8(src,i), __a,__i); \

+    __ta = (CARD8) ~XftIntMult (srca, __a,__i); \

+    __t = __t + XftIntMult(XftGet8(dst,i),__ta,__i); \

+    __t = (CARD32) (CARD8) (__t | (-(__t >> 8))); \

+    result = __t << (i); \

+}

+		XftInOverC(src,srca,ma,d,0,m);

+		XftInOverC(src,srca,ma,d,8,n);

+		XftInOverC(src,srca,ma,d,16,o);

+		d = m | n | o;

+		pixel = (_XftPutField ((d >> 16) & 0xff, r_shift, r_len) |

+			 _XftPutField ((d >>  8) & 0xff, g_shift, g_len) |

+			 _XftPutField ((d      ) & 0xff, b_shift, b_len));

+		XPutPixel (image, tx, y, pixel);

+	    }

+	    tx++;

+	}

+	y++;

+    }

+}

+

+static FcBool

+_XftSmoothGlyphPossible (XftDraw *draw)

+{

+    if (!draw->visual)

+	return FcFalse;

+    if (draw->visual->class != TrueColor)

+	return FcFalse;

+    return FcTrue;

+}

+

+typedef	void (*XftSmoothGlyph) (XImage		    *image, 

+				_Xconst XftGlyph    *xftg,

+				int		    x,

+				int		    y,

+				_Xconst XftColor    *color);

+

+static XftSmoothGlyph

+_XftSmoothGlyphFind (XftDraw *draw, XftFont *public)

+{

+    XftFontInt *font = (XftFontInt *) public;

+

+    if (!font->info.antialias)

+	return _XftSmoothGlyphMono;

+    else switch (font->info.rgba) {

+    case FC_RGBA_RGB:

+    case FC_RGBA_BGR:

+    case FC_RGBA_VRGB:

+    case FC_RGBA_VBGR:

+	return _XftSmoothGlyphRgba;

+    default:

+	switch (XftDrawBitsPerPixel (draw)) {

+	case 32:

+	    if ((draw->visual->red_mask   == 0xff0000 &&

+		 draw->visual->green_mask == 0x00ff00 &&

+		 draw->visual->blue_mask  == 0x0000ff) ||

+		(draw->visual->red_mask   == 0x0000ff &&

+		 draw->visual->green_mask == 0x00ff00 &&

+		 draw->visual->blue_mask  == 0xff0000))

+	    {

+		return _XftSmoothGlyphGray8888;

+	    }

+	    break;

+	case 16:

+	    if ((draw->visual->red_mask   == 0xf800 &&

+		 draw->visual->green_mask == 0x07e0 &&

+		 draw->visual->blue_mask  == 0x001f) ||

+		(draw->visual->red_mask   == 0x001f &&

+		 draw->visual->green_mask == 0x07e0 &&

+		 draw->visual->blue_mask  == 0xf800))

+	    {

+		return _XftSmoothGlyphGray565;

+	    }

+	    if ((draw->visual->red_mask   == 0x7c00 &&

+		 draw->visual->green_mask == 0x03e0 &&

+		 draw->visual->blue_mask  == 0x001f) ||

+		(draw->visual->red_mask   == 0x001f &&

+		 draw->visual->green_mask == 0x03e0 &&

+		 draw->visual->blue_mask  == 0x7c00))

+	    {

+		return _XftSmoothGlyphGray555;

+	    }

+	    break;

+	default:

+	    break;

+	}

+	return _XftSmoothGlyphGray;

+    }

+}

+

+static XftGlyph *

+_XftGlyphDefault (Display *dpy, XftFont   *public)

+{

+    XftFontInt	    *font = (XftFontInt *) public;

+    FT_UInt	    missing[XFT_NMISSING];

+    int		    nmissing;

+    FcBool	    glyphs_loaded = FcFalse;

+

+    if (XftFontCheckGlyph (dpy, public, FcTrue, 0, missing, &nmissing))

+	glyphs_loaded = FcTrue;

+    if (nmissing)

+	XftFontLoadGlyphs (dpy, public, glyphs_loaded, missing, nmissing);

+    return font->glyphs[0];

+}

+

+static int XftGetImageErrorHandler (Display *dpy, XErrorEvent *error_event)

+{

+    return 0;

+}

+

+_X_HIDDEN void

+XftGlyphCore (XftDraw		*draw,

+	      _Xconst XftColor	*color,

+	      XftFont		*public,

+	      int		x,

+	      int		y,

+	      _Xconst FT_UInt	*glyphs,

+	      int		nglyphs)

+{

+    Display	    *dpy = draw->dpy;

+    XftFontInt	    *font = (XftFontInt *) public;

+    XftGlyph	    *xftg;

+    FT_UInt	    glyph;

+    _Xconst FT_UInt *g;

+    FT_UInt	    missing[XFT_NMISSING];

+    FcBool	    glyphs_loaded;

+    int		    nmissing;

+    int		    n;

+    XErrorHandler   prev_error;

+

+    /*

+     * Load missing glyphs

+     */

+    g = glyphs;

+    n = nglyphs;

+    nmissing = 0;

+    glyphs_loaded = FcFalse;

+    while (n--)

+	if (XftFontCheckGlyph (dpy, public, FcTrue, *g++, missing, &nmissing))

+	    glyphs_loaded = FcTrue;

+    if (nmissing)

+	XftFontLoadGlyphs (dpy, public, FcTrue, missing, nmissing);

+    

+    g = glyphs;

+    n = nglyphs;

+    if ((font->info.antialias || color->color.alpha != 0xffff) &&

+	_XftSmoothGlyphPossible (draw))

+    {

+	XGlyphInfo	gi;

+	XImage		*image;

+        unsigned int    depth;

+	int		ox, oy;

+	XftSmoothGlyph	smooth = _XftSmoothGlyphFind (draw, public);

+	

+	XftGlyphExtents (dpy, public, glyphs, nglyphs, &gi);

+	if (!gi.width || !gi.height)

+	    goto bail1;

+	ox = x - gi.x;

+	oy = y - gi.y;

+	/*

+	 * Try to get bits directly from the drawable; if that fails,

+	 * use a temporary pixmap.  When it does fail, assume it

+	 * will probably fail for a while and keep using temporary

+	 * pixmaps for a while to avoid double round trips.

+	 */

+	if (draw->core.use_pixmap == 0)

+	{

+	    prev_error = XSetErrorHandler (XftGetImageErrorHandler);

+	    image = XGetImage (dpy, draw->drawable,

+			       ox, oy,

+			       gi.width, gi.height, AllPlanes,

+			       ZPixmap);

+	    XSetErrorHandler (prev_error);

+	    if (!image)

+		draw->core.use_pixmap = XFT_ASSUME_PIXMAP;

+	}

+	else

+	{

+	    draw->core.use_pixmap--;

+	    image = NULL;

+	}

+	if (!image && (depth = XftDrawDepth (draw)))

+	{

+	    Pixmap	pix;

+	    GC		gc;

+	    XGCValues	gcv;

+

+	    pix = XCreatePixmap (dpy, draw->drawable,

+				 gi.width, gi.height, depth);

+	    gcv.graphics_exposures = False;

+	    gc = XCreateGC (dpy, pix, GCGraphicsExposures, &gcv);

+	    XCopyArea (dpy, draw->drawable, pix, gc, ox, oy,

+		       gi.width, gi.height, 0, 0);

+	    XFreeGC (dpy, gc);

+	    image = XGetImage (dpy, pix, 0, 0, gi.width, gi.height, AllPlanes,

+			       ZPixmap);

+	    XFreePixmap (dpy, pix);

+	}

+	if (!image)

+	    goto bail1;

+	image->red_mask = draw->visual->red_mask;

+	image->green_mask = draw->visual->green_mask;

+	image->blue_mask = draw->visual->blue_mask;

+	if (image->byte_order != XftNativeByteOrder ())

+	    XftSwapImage (image);

+	while (n--)

+	{

+	    glyph = *g++;

+	    if (glyph >= font->num_glyphs || !(xftg = font->glyphs[glyph]))

+		xftg = _XftGlyphDefault (dpy, public);

+	    if (xftg)

+	    {

+		(*smooth) (image, xftg, x - ox, y - oy, color);

+		x += xftg->metrics.xOff;

+		y += xftg->metrics.yOff;

+	    }

+	}

+	if (image->byte_order != XftNativeByteOrder ())

+	    XftSwapImage (image);

+	XPutImage (dpy, draw->drawable, draw->core.gc, image, 0, 0, ox, oy,

+		   gi.width, gi.height);

+	XDestroyImage (image);

+    }

+    else

+    {

+	XftSharpGlyph	sharp = _XftSharpGlyphFind (draw, public);

+	while (n--)

+	{

+	    glyph = *g++;

+	    if (glyph >= font->num_glyphs || !(xftg = font->glyphs[glyph]))

+		xftg = _XftGlyphDefault (dpy, public);

+	    if (xftg)

+	    {

+		(*sharp) (draw, xftg, x, y);

+		x += xftg->metrics.xOff;

+		y += xftg->metrics.yOff;

+	    }

+	}

+    }

+bail1:

+    if (glyphs_loaded)

+	_XftFontManageMemory (dpy, public);

+}

+

+#define NUM_LOCAL   1024

+

+_X_HIDDEN void

+XftGlyphSpecCore (XftDraw		*draw,

+		  _Xconst XftColor	*color,

+		  XftFont		*public,

+		  _Xconst XftGlyphSpec	*glyphs,

+		  int			nglyphs)

+{

+    Display	    *dpy = draw->dpy;

+    XftFontInt	    *font = (XftFontInt *) public;

+    XftGlyph	    *xftg;

+    FT_UInt	    missing[XFT_NMISSING];

+    FcBool	    glyphs_loaded;

+    int		    nmissing;

+    int		    i;

+    XErrorHandler   prev_error;

+    int		    x1, y1, x2, y2;

+

+    /*

+     * Load missing glyphs

+     */

+    glyphs_loaded = FcFalse;

+    x1 = y1 = x2 = y2 = 0;

+    for (i = 0; i < nglyphs; i++)

+    {

+	XGlyphInfo	gi;

+	int		g_x1, g_x2, g_y1, g_y2;

+	

+	nmissing = 0;

+	if (XftFontCheckGlyph (dpy, public, FcTrue, glyphs[i].glyph, missing, &nmissing))

+	    glyphs_loaded = FcTrue;

+	if (nmissing)

+	    XftFontLoadGlyphs (dpy, public, FcTrue, missing, nmissing);

+

+	XftGlyphExtents (dpy, public, &glyphs[i].glyph, 1, &gi);

+	g_x1 = glyphs[i].x - gi.x;

+	g_y1 = glyphs[i].y - gi.y;

+	g_x2 = g_x1 + gi.width;

+	g_y2 = g_y1 + gi.height;

+	if (i)

+	{

+	    if (g_x1 < x1)

+		x1 = g_x1;

+	    if (g_y1 < y1)

+		y1 = g_y1;

+	    if (g_x2 > x2)

+		x2 = g_x2;

+	    if (g_y2 > y2)

+		y2 = g_y2;

+	}

+	else

+	{

+	    x1 = g_x1;

+	    y1 = g_y1;

+	    x2 = g_x2;

+	    y2 = g_y2;

+	}

+    }

+    

+    if (x1 == x2 || y1 == y2)

+	goto bail1;

+

+    if ((font->info.antialias || color->color.alpha != 0xffff) &&

+	_XftSmoothGlyphPossible (draw))

+    {

+	XImage		*image;

+        unsigned int    depth;

+	int		width = x2 - x1, height = y2 - y1;

+	XftSmoothGlyph	smooth = _XftSmoothGlyphFind (draw, public);

+

+	/*

+	 * Try to get bits directly from the drawable; if that fails,

+	 * use a temporary pixmap.  When it does fail, assume it

+	 * will probably fail for a while and keep using temporary

+	 * pixmaps for a while to avoid double round trips.

+	 */

+	if (draw->core.use_pixmap == 0)

+	{

+	    prev_error = XSetErrorHandler (XftGetImageErrorHandler);

+	    image = XGetImage (dpy, draw->drawable,

+			       x1, y1,

+			       width, height, AllPlanes,

+			       ZPixmap);

+	    XSetErrorHandler (prev_error);

+	    if (!image)

+		draw->core.use_pixmap = XFT_ASSUME_PIXMAP;

+	}

+	else

+	{

+	    draw->core.use_pixmap--;

+	    image = NULL;

+	}

+	if (!image && (depth = XftDrawDepth (draw)))

+	{

+	    Pixmap	pix;

+	    GC		gc;

+	    XGCValues	gcv;

+

+	    pix = XCreatePixmap (dpy, draw->drawable,

+				 width, height, depth);

+	    gcv.graphics_exposures = False;

+	    gc = XCreateGC (dpy, pix, GCGraphicsExposures, &gcv);

+	    XCopyArea (dpy, draw->drawable, pix, gc, x1, y1,

+		       width, height, 0, 0);

+	    XFreeGC (dpy, gc);

+	    image = XGetImage (dpy, pix, 0, 0, width, height, AllPlanes,

+			       ZPixmap);

+	    XFreePixmap (dpy, pix);

+	}

+	if (!image)

+	    goto bail1;

+	image->red_mask = draw->visual->red_mask;

+	image->green_mask = draw->visual->green_mask;

+	image->blue_mask = draw->visual->blue_mask;

+	if (image->byte_order != XftNativeByteOrder ())

+	    XftSwapImage (image);

+	for (i = 0; i < nglyphs; i++)

+	{

+	    FT_UInt glyph = glyphs[i].glyph;

+	    if (glyph >= font->num_glyphs || !(xftg = font->glyphs[glyph]))

+		xftg = _XftGlyphDefault (dpy, public);

+	    if (xftg)

+	    {

+		(*smooth) (image, xftg, glyphs[i].x - x1, 

+			   glyphs[i].y - y1, color);

+	    }

+	}

+	if (image->byte_order != XftNativeByteOrder ())

+	    XftSwapImage (image);

+	XPutImage (dpy, draw->drawable, draw->core.gc, image, 0, 0, x1, y1,

+		   width, height);

+	XDestroyImage (image);

+    }

+    else

+    {

+	XftSharpGlyph	sharp = _XftSharpGlyphFind (draw, public);

+	for (i = 0; i < nglyphs; i++)

+	{

+	    FT_UInt glyph = glyphs[i].glyph;

+	    if (glyph >= font->num_glyphs || !(xftg = font->glyphs[glyph]))

+		xftg = _XftGlyphDefault (dpy, public);

+	    if (xftg)

+		(*sharp) (draw, xftg, glyphs[i].x, glyphs[i].y);

+	}

+    }

+bail1:

+    if (glyphs_loaded)

+	_XftFontManageMemory (dpy, public);

+}

+

+_X_HIDDEN void

+XftGlyphFontSpecCore (XftDraw			*draw,

+		      _Xconst XftColor		*color,

+		      _Xconst XftGlyphFontSpec	*glyphs,

+		      int			nglyphs)

+{

+    Display	    *dpy = draw->dpy;

+    XftGlyph	    *xftg;

+    FT_UInt	    missing[XFT_NMISSING];

+    FcBool	    glyphs_loaded;

+    int		    nmissing;

+    int		    i;

+    XErrorHandler   prev_error;

+    int		    x1, y1, x2, y2;

+

+    /*

+     * Load missing glyphs

+     */

+    glyphs_loaded = FcFalse;

+    x1 = y1 = x2 = y2 = 0;

+    for (i = 0; i < nglyphs; i++)

+    {

+	XftFont		*public = glyphs[i].font;

+	XGlyphInfo	gi;

+	int		g_x1, g_x2, g_y1, g_y2;

+	

+	nmissing = 0;

+	if (XftFontCheckGlyph (dpy, public, FcTrue, glyphs[i].glyph, missing, &nmissing))

+	    glyphs_loaded = FcTrue;

+	if (nmissing)

+	    XftFontLoadGlyphs (dpy, public, FcTrue, missing, nmissing);

+	

+	XftGlyphExtents (dpy, public, &glyphs[i].glyph, 1, &gi);

+	g_x1 = glyphs[i].x - gi.x;

+	g_y1 = glyphs[i].y - gi.y;

+	g_x2 = g_x1 + gi.width;

+	g_y2 = g_y1 + gi.height;

+	if (i)

+	{

+	    if (g_x1 < x1)

+	    {

+		if (g_x1 < 0)

+		{

+		    /* do nothing if the given glyphs are out of range */

+		    short t = glyphs[i-1].font->max_advance_width

+			+ glyphs[i-1].x;

+		    if (t < 0 && glyphs[i-1].x > 0)

+			goto bail1;

+		}

+		x1 = g_x1;

+	    }

+	    if (g_y1 < y1)

+		y1 = g_y1;

+	    if (g_x2 > x2)

+		x2 = g_x2;

+	    if (g_y2 > y2)

+		y2 = g_y2;

+	}

+	else

+	{

+	    x1 = g_x1;

+	    y1 = g_y1;

+	    x2 = g_x2;

+	    y2 = g_y2;

+	}

+    }

+    

+    if (x1 == x2 || y1 == y2)

+	goto bail1;

+

+    for (i = 0; i < nglyphs; i++)

+	if (((XftFontInt *) glyphs[i].font)->info.antialias)

+	    break;

+    

+    if ((i != nglyphs || color->color.alpha != 0xffff) &&

+	_XftSmoothGlyphPossible (draw))

+    {

+	XImage		*image;

+        unsigned int    depth;

+	int		width = x2 - x1, height = y2 - y1;

+

+	/*

+	 * Try to get bits directly from the drawable; if that fails,

+	 * use a temporary pixmap.  When it does fail, assume it

+	 * will probably fail for a while and keep using temporary

+	 * pixmaps for a while to avoid double round trips.

+	 */

+	if (draw->core.use_pixmap == 0)

+	{

+	    prev_error = XSetErrorHandler (XftGetImageErrorHandler);

+	    image = XGetImage (dpy, draw->drawable,

+			       x1, y1,

+			       width, height, AllPlanes,

+			       ZPixmap);

+	    XSetErrorHandler (prev_error);

+	    if (!image)

+		draw->core.use_pixmap = XFT_ASSUME_PIXMAP;

+	}

+	else

+	{

+	    draw->core.use_pixmap--;

+	    image = NULL;

+	}

+	if (!image && (depth = XftDrawDepth (draw)))

+	{

+	    Pixmap	pix;

+	    GC		gc;

+	    XGCValues	gcv;

+

+	    pix = XCreatePixmap (dpy, draw->drawable,

+				 width, height, depth);

+	    gcv.graphics_exposures = False;

+	    gc = XCreateGC (dpy, pix, GCGraphicsExposures, &gcv);

+	    XCopyArea (dpy, draw->drawable, pix, gc, x1, y1,

+		       width, height, 0, 0);

+	    XFreeGC (dpy, gc);

+	    image = XGetImage (dpy, pix, 0, 0, width, height, AllPlanes,

+			       ZPixmap);

+	    XFreePixmap (dpy, pix);

+	}

+	if (!image)

+	    goto bail1;

+	image->red_mask = draw->visual->red_mask;

+	image->green_mask = draw->visual->green_mask;

+	image->blue_mask = draw->visual->blue_mask;

+	if (image->byte_order != XftNativeByteOrder ())

+	    XftSwapImage (image);

+	for (i = 0; i < nglyphs; i++)

+	{

+	    XftFont	    *public = glyphs[i].font;

+	    XftFontInt	    *font = (XftFontInt *) public;

+	    XftSmoothGlyph  smooth = _XftSmoothGlyphFind (draw, public);

+	    FT_UInt	    glyph = glyphs[i].glyph;

+	    

+	    if (glyph >= font->num_glyphs || !(xftg = font->glyphs[glyph]))

+		xftg = _XftGlyphDefault (dpy, public);

+	    if (xftg)

+	    {

+		(*smooth) (image, xftg, glyphs[i].x - x1, 

+			   glyphs[i].y - y1, color);

+	    }

+	}

+	if (image->byte_order != XftNativeByteOrder ())

+	    XftSwapImage (image);

+	XPutImage (dpy, draw->drawable, draw->core.gc, image, 0, 0, x1, y1,

+		   width, height);

+	XDestroyImage (image);

+    }

+    else

+    {

+	for (i = 0; i < nglyphs; i++)

+	{

+	    XftFont		*public = glyphs[i].font;

+	    XftFontInt		*font = (XftFontInt *) public;

+	    XftSharpGlyph	sharp = _XftSharpGlyphFind (draw, public);

+	    FT_UInt		glyph = glyphs[i].glyph;

+	    

+	    if (glyph >= font->num_glyphs || !(xftg = font->glyphs[glyph]))

+		xftg = _XftGlyphDefault (dpy, public);

+	    if (xftg)

+		(*sharp) (draw, xftg, glyphs[i].x, glyphs[i].y);

+	}

+    }

+bail1:

+    if (glyphs_loaded)

+	for (i = 0; i < nglyphs; i++)

+	    _XftFontManageMemory (dpy, glyphs[i].font);

+}

diff --git a/libXft/src/xftdpy.c b/libXft/src/xftdpy.c
index cd50358d2..862c7e8ab 100644
--- a/libXft/src/xftdpy.c
+++ b/libXft/src/xftdpy.c
@@ -1,552 +1,552 @@
-/*
- * Copyright © 2000 Keith Packard
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
- * representations about the suitability of this software for any purpose.  It
- * is provided "as is" without express or implied warranty.
- *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include "xftint.h"
-
-_X_HIDDEN XftDisplayInfo	*_XftDisplayInfo;
-
-static int
-_XftCloseDisplay (Display *dpy, XExtCodes *codes)
-{
-    XftDisplayInfo  *info, **prev;
-
-    info = _XftDisplayInfoGet (dpy, FcFalse);
-    if (!info)
-	return 0;
-    
-    /*
-     * Get rid of any dangling unreferenced fonts
-     */
-    info->max_unref_fonts = 0;
-    XftFontManageMemory (dpy);
-    
-    /*
-     * Clean up the default values
-     */
-    if (info->defaults)
-	FcPatternDestroy (info->defaults);
-    
-    /*
-     * Unhook from the global list
-     */
-    for (prev = &_XftDisplayInfo; (info = *prev); prev = &(*prev)->next)
-	if (info->display == dpy)
-	    break;
-    *prev = info->next;
-    
-    free (info);
-    return 0;
-}
-
-
-_X_HIDDEN XftDisplayInfo *
-_XftDisplayInfoGet (Display *dpy, FcBool createIfNecessary)
-{
-    XftDisplayInfo	*info, **prev;
-    XRenderPictFormat	pf;
-    int			i;
-    int			event_base, error_base;
-
-    for (prev = &_XftDisplayInfo; (info = *prev); prev = &(*prev)->next)
-    {
-	if (info->display == dpy)
-	{
-	    /*
-	     * MRU the list
-	     */
-	    if (prev != &_XftDisplayInfo)
-	    {
-		*prev = info->next;
-		info->next = _XftDisplayInfo;
-		_XftDisplayInfo = info;
-	    }
-	    return info;
-	}
-    }
-    if (!createIfNecessary)
-	return NULL;
-
-    info = (XftDisplayInfo *) malloc (sizeof (XftDisplayInfo));
-    if (!info)
-	goto bail0;
-    info->codes = XAddExtension (dpy);
-    if (!info->codes)
-	goto bail1;
-    (void) XESetCloseDisplay (dpy, info->codes->extension, _XftCloseDisplay);
-
-    info->display = dpy;
-    info->defaults = NULL;
-    info->solidFormat = NULL;
-    info->hasRender = (XRenderQueryExtension (dpy, &event_base, &error_base) &&
-		       (XRenderFindVisualFormat (dpy, DefaultVisual (dpy, DefaultScreen (dpy))) != NULL));
-    info->use_free_glyphs = FcTrue;
-    if (info->hasRender)
-    {
-	int major, minor;
-	XRenderQueryVersion (dpy, &major, &minor);
-	if (major < 0 || (major == 0 && minor <= 2))
-	    info->use_free_glyphs = FcFalse;
-
-	pf.type = PictTypeDirect;
-	pf.depth = 32;
-	pf.direct.redMask = 0xff;
-	pf.direct.greenMask = 0xff;
-	pf.direct.blueMask = 0xff;
-	pf.direct.alphaMask = 0xff;
-	info->solidFormat = XRenderFindFormat (dpy,
-					       (PictFormatType|
-						PictFormatDepth|
-						PictFormatRedMask|
-						PictFormatGreenMask|
-						PictFormatBlueMask|
-						PictFormatAlphaMask),
-					       &pf,
-					       0);
-    }
-    if (XftDebug () & XFT_DBG_RENDER)
-    {
-	Visual		    *visual = DefaultVisual (dpy, DefaultScreen (dpy));
-	XRenderPictFormat   *format = XRenderFindVisualFormat (dpy, visual);
-	
-	printf ("XftDisplayInfoGet Default visual 0x%x ", 
-		(int) visual->visualid);
-	if (format)
-	{
-	    if (format->type == PictTypeDirect)
-	    {
-		printf ("format %d,%d,%d,%d\n",
-			format->direct.alpha,
-			format->direct.red,
-			format->direct.green,
-			format->direct.blue);
-	    }
-	    else
-	    {
-		printf ("format indexed\n");
-	    }
-	}
-	else
-	    printf ("No Render format for default visual\n");
-	
-	printf ("XftDisplayInfoGet initialized, hasRender set to \"%s\"\n",
-		info->hasRender ? "True" : "False");
-    }
-    for (i = 0; i < XFT_NUM_SOLID_COLOR; i++)
-    {
-	info->colors[i].screen = -1;
-	info->colors[i].pict = 0;
-    }
-    info->fonts = NULL;
-    
-    info->next = _XftDisplayInfo;
-    _XftDisplayInfo = info;
-
-    info->glyph_memory = 0;
-    info->max_glyph_memory = XftDefaultGetInteger (dpy,
-						   XFT_MAX_GLYPH_MEMORY, 0,
-						   XFT_DPY_MAX_GLYPH_MEMORY);
-    if (XftDebug () & XFT_DBG_CACHE)
-	printf ("global max cache memory %ld\n", info->max_glyph_memory);
-
-    
-    info->num_unref_fonts = 0;
-    info->max_unref_fonts = XftDefaultGetInteger (dpy,
-						  XFT_MAX_UNREF_FONTS, 0,
-						  XFT_DPY_MAX_UNREF_FONTS);
-    if (XftDebug() & XFT_DBG_CACHE)
-	printf ("global max unref fonts %d\n", info->max_unref_fonts);
-
-    memset (info->fontHash, '\0', sizeof (XftFont *) * XFT_NUM_FONT_HASH);
-    return info;
-    
-bail1:
-    free (info);
-bail0:
-    if (XftDebug () & XFT_DBG_RENDER)
-    {
-	printf ("XftDisplayInfoGet failed to initialize, Xft unhappy\n");
-    }
-    return NULL;
-}
-
-/*
- * Reduce memory usage in X server
- */
-
-static void
-_XftDisplayValidateMemory (XftDisplayInfo *info)
-{
-    XftFont	    *public;
-    XftFontInt	    *font;
-    unsigned long   glyph_memory;
-
-    glyph_memory = 0;
-    for (public = info->fonts; public; public = font->next)
-    {
-	font = (XftFontInt *) public;
-	glyph_memory += font->glyph_memory;
-    }
-    if (glyph_memory != info->glyph_memory)
-	printf ("Display glyph cache incorrect has %ld bytes, should have %ld\n",
-		info->glyph_memory, glyph_memory);
-}
-
-_X_HIDDEN void
-_XftDisplayManageMemory (Display *dpy)
-{
-    XftDisplayInfo  *info = _XftDisplayInfoGet (dpy, False);
-    unsigned long   glyph_memory;
-    XftFont	    *public;
-    XftFontInt	    *font;
-
-    if (!info || !info->max_glyph_memory)
-	return;
-    if (XftDebug () & XFT_DBG_CACHE)
-    {
-	if (info->glyph_memory > info->max_glyph_memory)
-	    printf ("Reduce global memory from %ld to %ld\n",
-		    info->glyph_memory, info->max_glyph_memory);
-	_XftDisplayValidateMemory (info);
-    }
-    while (info->glyph_memory > info->max_glyph_memory)
-    {
-	glyph_memory = rand () % info->glyph_memory;
-	public = info->fonts;
-	while (public)
-	{
-	    font = (XftFontInt *) public;
-
-	    if (font->glyph_memory > glyph_memory)
-	    {
-		_XftFontUncacheGlyph (dpy, public);
-		break;
-	    }
-	    public = font->next;
-	    glyph_memory -= font->glyph_memory;
-	}
-    }
-    if (XftDebug () & XFT_DBG_CACHE)
-	_XftDisplayValidateMemory (info);
-}
-
-_X_EXPORT Bool
-XftDefaultHasRender (Display *dpy)
-{
-    XftDisplayInfo  *info = _XftDisplayInfoGet (dpy, True);
-
-    if (!info)
-	return False;
-    return info->hasRender;
-}
-
-_X_EXPORT Bool
-XftDefaultSet (Display *dpy, FcPattern *defaults)
-{
-    XftDisplayInfo  *info = _XftDisplayInfoGet (dpy, True);
-
-    if (!info)
-	return False;
-    if (info->defaults)
-	FcPatternDestroy (info->defaults);
-    info->defaults = defaults;
-    if (!info->max_glyph_memory)
-	info->max_glyph_memory = XFT_DPY_MAX_GLYPH_MEMORY;
-    info->max_glyph_memory = XftDefaultGetInteger (dpy,
-						   XFT_MAX_GLYPH_MEMORY, 0,
-						   info->max_glyph_memory);
-    if (!info->max_unref_fonts)
-	info->max_unref_fonts = XFT_DPY_MAX_UNREF_FONTS;
-    info->max_unref_fonts = XftDefaultGetInteger (dpy,
-						  XFT_MAX_UNREF_FONTS, 0,
-						  info->max_unref_fonts);
-    return True;
-}
-
-_X_HIDDEN int
-XftDefaultParseBool (char *v)
-{
-    char    c0, c1;
-
-    c0 = *v;
-    if (isupper ((int)c0))
-	c0 = tolower (c0);
-    if (c0 == 't' || c0 == 'y' || c0 == '1')
-	return 1;
-    if (c0 == 'f' || c0 == 'n' || c0 == '0')
-	return 0;
-    if (c0 == 'o')
-    {
-	c1 = v[1];
-	if (isupper ((int)c1))
-	    c1 = tolower (c1);
-	if (c1 == 'n')
-	    return 1;
-	if (c1 == 'f')
-	    return 0;
-    }
-    return -1;
-}
-
-static Bool
-_XftDefaultInitBool (Display *dpy, FcPattern *pat, char *option)
-{
-    char    *v;
-    int	    i;
-
-    v = XGetDefault (dpy, "Xft", option);
-    if (v && (i = XftDefaultParseBool (v)) >= 0)
-	return FcPatternAddBool (pat, option, i != 0);
-    return True;
-}
-
-static Bool
-_XftDefaultInitDouble (Display *dpy, FcPattern *pat, char *option)
-{
-    char    *v, *e;
-    double  d;
-
-    v = XGetDefault (dpy, "Xft", option);
-    if (v)
-    {
-	d = strtod (v, &e);
-	if (e != v)
-	    return FcPatternAddDouble (pat, option, d);
-    }
-    return True;
-}
-
-static Bool
-_XftDefaultInitInteger (Display *dpy, FcPattern *pat, char *option)
-{
-    char    *v, *e;
-    int	    i;
-
-    v = XGetDefault (dpy, "Xft", option);
-    if (v)
-    {
-	if (FcNameConstant ((FcChar8 *) v, &i))
-	    return FcPatternAddInteger (pat, option, i);
-	i = strtol (v, &e, 0);
-	if (e != v)
-	    return FcPatternAddInteger (pat, option, i);
-    }
-    return True;
-}
-
-static FcPattern *
-_XftDefaultInit (Display *dpy)
-{
-    FcPattern	*pat;
-
-    pat = FcPatternCreate ();
-    if (!pat)
-	goto bail0;
-
-    if (!_XftDefaultInitDouble (dpy, pat, FC_SCALE))
-	goto bail1;
-    if (!_XftDefaultInitDouble (dpy, pat, FC_DPI))
-	goto bail1;
-    if (!_XftDefaultInitBool (dpy, pat, XFT_RENDER))
-	goto bail1;
-    if (!_XftDefaultInitInteger (dpy, pat, FC_RGBA))
-	goto bail1;
-    if (!_XftDefaultInitBool (dpy, pat, FC_ANTIALIAS))
-	goto bail1;
-#ifdef FC_EMBOLDEN
-    if (!_XftDefaultInitBool (dpy, pat, FC_EMBOLDEN))
-	goto bail1;
-#endif
-    if (!_XftDefaultInitBool (dpy, pat, FC_AUTOHINT))
-	goto bail1;
-#ifdef FC_HINT_STYLE
-    if (!_XftDefaultInitInteger (dpy, pat, FC_HINT_STYLE))
-	goto bail1;
-#endif
-    if (!_XftDefaultInitBool (dpy, pat, FC_HINTING))
-	goto bail1;
-    if (!_XftDefaultInitBool (dpy, pat, FC_MINSPACE))
-	goto bail1;
-    if (!_XftDefaultInitInteger (dpy, pat, XFT_MAX_GLYPH_MEMORY))
-	goto bail1;
-    
-    return pat;
-    
-bail1:
-    FcPatternDestroy (pat);
-bail0:
-    return NULL;
-}
-
-static FcResult
-_XftDefaultGet (Display *dpy, const char *object, int screen, FcValue *v)
-{
-    XftDisplayInfo  *info = _XftDisplayInfoGet (dpy, True);
-    FcResult	    r;
-
-    if (!info)
-	return FcResultNoMatch;
-    
-    if (!info->defaults)
-    {
-	info->defaults = _XftDefaultInit (dpy);
-	if (!info->defaults)
-	    return FcResultNoMatch;
-    }
-    r = FcPatternGet (info->defaults, object, screen, v);
-    if (r == FcResultNoId && screen > 0)
-	r = FcPatternGet (info->defaults, object, 0, v);
-    return r;
-}
-
-_X_HIDDEN Bool
-XftDefaultGetBool (Display *dpy, const char *object, int screen, Bool def)
-{
-    FcResult	    r;
-    FcValue	    v;
-
-    r = _XftDefaultGet (dpy, object, screen, &v);
-    if (r != FcResultMatch || v.type != FcTypeBool)
-	return def;
-    return v.u.b;
-}
-
-_X_HIDDEN int
-XftDefaultGetInteger (Display *dpy, const char *object, int screen, int def)
-{
-    FcResult	    r;
-    FcValue	    v;
-
-    r = _XftDefaultGet (dpy, object, screen, &v);
-    if (r != FcResultMatch || v.type != FcTypeInteger)
-	return def;
-    return v.u.i;
-}
-
-_X_HIDDEN double
-XftDefaultGetDouble (Display *dpy, const char *object, int screen, double def)
-{
-    FcResult	    r;
-    FcValue	    v;
-
-    r = _XftDefaultGet (dpy, object, screen, &v);
-    if (r != FcResultMatch || v.type != FcTypeDouble)
-	return def;
-    return v.u.d;
-}
-
-_X_EXPORT void
-XftDefaultSubstitute (Display *dpy, int screen, FcPattern *pattern)
-{
-    FcValue	v;
-    double	dpi;
-
-    if (FcPatternGet (pattern, XFT_RENDER, 0, &v) == FcResultNoMatch)
-    {
-	FcPatternAddBool (pattern, XFT_RENDER,
-			   XftDefaultGetBool (dpy, XFT_RENDER, screen, 
-					      XftDefaultHasRender (dpy)));
-    }
-    if (FcPatternGet (pattern, FC_ANTIALIAS, 0, &v) == FcResultNoMatch)
-    {
-	FcPatternAddBool (pattern, FC_ANTIALIAS,
-			   XftDefaultGetBool (dpy, FC_ANTIALIAS, screen,
-					      True));
-    }
-#ifdef FC_EMBOLDEN
-    if (FcPatternGet (pattern, FC_EMBOLDEN, 0, &v) == FcResultNoMatch)
-    {
-	FcPatternAddBool (pattern, FC_EMBOLDEN,
-			   XftDefaultGetBool (dpy, FC_EMBOLDEN, screen,
-					      False));
-    }
-#endif
-    if (FcPatternGet (pattern, FC_HINTING, 0, &v) == FcResultNoMatch)
-    {
-	FcPatternAddBool (pattern, FC_HINTING,
-			  XftDefaultGetBool (dpy, FC_HINTING, screen,
-					     True));
-    }
-#ifdef FC_HINT_STYLE
-    if (FcPatternGet (pattern, FC_HINT_STYLE, 0, &v) == FcResultNoMatch)
-    {
-	FcPatternAddInteger (pattern, FC_HINT_STYLE,
-			     XftDefaultGetInteger (dpy, FC_HINT_STYLE, screen,
-						   FC_HINT_FULL));
-    }
-#endif
-    if (FcPatternGet (pattern, FC_AUTOHINT, 0, &v) == FcResultNoMatch)
-    {
-	FcPatternAddBool (pattern, FC_AUTOHINT,
-			  XftDefaultGetBool (dpy, FC_AUTOHINT, screen,
-					     False));
-    }
-    if (FcPatternGet (pattern, FC_RGBA, 0, &v) == FcResultNoMatch)
-    {
-	int	subpixel = FC_RGBA_UNKNOWN;
-#if RENDER_MAJOR > 0 || RENDER_MINOR >= 6
-	if (XftDefaultHasRender (dpy))
-	{
-	    int render_order = XRenderQuerySubpixelOrder (dpy, screen);
-	    switch (render_order) {
-	    default:
-	    case SubPixelUnknown:	subpixel = FC_RGBA_UNKNOWN; break;
-	    case SubPixelHorizontalRGB:	subpixel = FC_RGBA_RGB; break;
-	    case SubPixelHorizontalBGR:	subpixel = FC_RGBA_BGR; break;
-	    case SubPixelVerticalRGB:	subpixel = FC_RGBA_VRGB; break;
-	    case SubPixelVerticalBGR:	subpixel = FC_RGBA_VBGR; break;
-	    case SubPixelNone:		subpixel = FC_RGBA_NONE; break;
-	    }
-	}
-#endif
-	FcPatternAddInteger (pattern, FC_RGBA,
-			      XftDefaultGetInteger (dpy, FC_RGBA, screen, 
-						    subpixel));
-    }
-    if (FcPatternGet (pattern, FC_MINSPACE, 0, &v) == FcResultNoMatch)
-    {
-	FcPatternAddBool (pattern, FC_MINSPACE,
-			   XftDefaultGetBool (dpy, FC_MINSPACE, screen,
-					      False));
-    }
-    if (FcPatternGet (pattern, FC_DPI, 0, &v) == FcResultNoMatch)
-    {
-	dpi = (((double) DisplayHeight (dpy, screen) * 25.4) / 
-	       (double) DisplayHeightMM (dpy, screen));
-	FcPatternAddDouble (pattern, FC_DPI, 
-			    XftDefaultGetDouble (dpy, FC_DPI, screen, 
-						 dpi));
-    }
-    if (FcPatternGet (pattern, FC_SCALE, 0, &v) == FcResultNoMatch)
-    {
-	FcPatternAddDouble (pattern, FC_SCALE,
-			    XftDefaultGetDouble (dpy, FC_SCALE, screen, 1.0));
-    }
-    if (FcPatternGet (pattern, XFT_MAX_GLYPH_MEMORY, 0, &v) == FcResultNoMatch)
-    {
-	FcPatternAddInteger (pattern, XFT_MAX_GLYPH_MEMORY,
-			     XftDefaultGetInteger (dpy, XFT_MAX_GLYPH_MEMORY,
-						   screen,
-						   XFT_FONT_MAX_GLYPH_MEMORY));
-    }
-    FcDefaultSubstitute (pattern);
-}
-
+/*

+ * Copyright © 2000 Keith Packard

+ *

+ * Permission to use, copy, modify, distribute, and sell this software and its

+ * documentation for any purpose is hereby granted without fee, provided that

+ * the above copyright notice appear in all copies and that both that

+ * copyright notice and this permission notice appear in supporting

+ * documentation, and that the name of Keith Packard not be used in

+ * advertising or publicity pertaining to distribution of the software without

+ * specific, written prior permission.  Keith Packard makes no

+ * representations about the suitability of this software for any purpose.  It

+ * is provided "as is" without express or implied warranty.

+ *

+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR

+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,

+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

+ * PERFORMANCE OF THIS SOFTWARE.

+ */

+

+#include "xftint.h"

+

+_X_HIDDEN XftDisplayInfo	*_XftDisplayInfo;

+

+static int

+_XftCloseDisplay (Display *dpy, XExtCodes *codes)

+{

+    XftDisplayInfo  *info, **prev;

+

+    info = _XftDisplayInfoGet (dpy, FcFalse);

+    if (!info)

+	return 0;

+    

+    /*

+     * Get rid of any dangling unreferenced fonts

+     */

+    info->max_unref_fonts = 0;

+    XftFontManageMemory (dpy);

+    

+    /*

+     * Clean up the default values

+     */

+    if (info->defaults)

+	FcPatternDestroy (info->defaults);

+    

+    /*

+     * Unhook from the global list

+     */

+    for (prev = &_XftDisplayInfo; (info = *prev); prev = &(*prev)->next)

+	if (info->display == dpy)

+	    break;

+    *prev = info->next;

+    

+    free (info);

+    return 0;

+}

+

+

+_X_HIDDEN XftDisplayInfo *

+_XftDisplayInfoGet (Display *dpy, FcBool createIfNecessary)

+{

+    XftDisplayInfo	*info, **prev;

+    XRenderPictFormat	pf;

+    int			i;

+    int			event_base, error_base;

+

+    for (prev = &_XftDisplayInfo; (info = *prev); prev = &(*prev)->next)

+    {

+	if (info->display == dpy)

+	{

+	    /*

+	     * MRU the list

+	     */

+	    if (prev != &_XftDisplayInfo)

+	    {

+		*prev = info->next;

+		info->next = _XftDisplayInfo;

+		_XftDisplayInfo = info;

+	    }

+	    return info;

+	}

+    }

+    if (!createIfNecessary)

+	return NULL;

+

+    info = (XftDisplayInfo *) malloc (sizeof (XftDisplayInfo));

+    if (!info)

+	goto bail0;

+    info->codes = XAddExtension (dpy);

+    if (!info->codes)

+	goto bail1;

+    (void) XESetCloseDisplay (dpy, info->codes->extension, _XftCloseDisplay);

+

+    info->display = dpy;

+    info->defaults = NULL;

+    info->solidFormat = NULL;

+    info->hasRender = (XRenderQueryExtension (dpy, &event_base, &error_base) &&

+		       (XRenderFindVisualFormat (dpy, DefaultVisual (dpy, DefaultScreen (dpy))) != NULL));

+    info->use_free_glyphs = FcTrue;

+    if (info->hasRender)

+    {

+	int major, minor;

+	XRenderQueryVersion (dpy, &major, &minor);

+	if (major < 0 || (major == 0 && minor <= 2))

+	    info->use_free_glyphs = FcFalse;

+

+	pf.type = PictTypeDirect;

+	pf.depth = 32;

+	pf.direct.redMask = 0xff;

+	pf.direct.greenMask = 0xff;

+	pf.direct.blueMask = 0xff;

+	pf.direct.alphaMask = 0xff;

+	info->solidFormat = XRenderFindFormat (dpy,

+					       (PictFormatType|

+						PictFormatDepth|

+						PictFormatRedMask|

+						PictFormatGreenMask|

+						PictFormatBlueMask|

+						PictFormatAlphaMask),

+					       &pf,

+					       0);

+    }

+    if (XftDebug () & XFT_DBG_RENDER)

+    {

+	Visual		    *visual = DefaultVisual (dpy, DefaultScreen (dpy));

+	XRenderPictFormat   *format = XRenderFindVisualFormat (dpy, visual);

+	

+	printf ("XftDisplayInfoGet Default visual 0x%x ", 

+		(int) visual->visualid);

+	if (format)

+	{

+	    if (format->type == PictTypeDirect)

+	    {

+		printf ("format %d,%d,%d,%d\n",

+			format->direct.alpha,

+			format->direct.red,

+			format->direct.green,

+			format->direct.blue);

+	    }

+	    else

+	    {

+		printf ("format indexed\n");

+	    }

+	}

+	else

+	    printf ("No Render format for default visual\n");

+	

+	printf ("XftDisplayInfoGet initialized, hasRender set to \"%s\"\n",

+		info->hasRender ? "True" : "False");

+    }

+    for (i = 0; i < XFT_NUM_SOLID_COLOR; i++)

+    {

+	info->colors[i].screen = -1;

+	info->colors[i].pict = 0;

+    }

+    info->fonts = NULL;

+    

+    info->next = _XftDisplayInfo;

+    _XftDisplayInfo = info;

+

+    info->glyph_memory = 0;

+    info->max_glyph_memory = XftDefaultGetInteger (dpy,

+						   XFT_MAX_GLYPH_MEMORY, 0,

+						   XFT_DPY_MAX_GLYPH_MEMORY);

+    if (XftDebug () & XFT_DBG_CACHE)

+	printf ("global max cache memory %ld\n", info->max_glyph_memory);

+

+    

+    info->num_unref_fonts = 0;

+    info->max_unref_fonts = XftDefaultGetInteger (dpy,

+						  XFT_MAX_UNREF_FONTS, 0,

+						  XFT_DPY_MAX_UNREF_FONTS);

+    if (XftDebug() & XFT_DBG_CACHE)

+	printf ("global max unref fonts %d\n", info->max_unref_fonts);

+

+    memset (info->fontHash, '\0', sizeof (XftFont *) * XFT_NUM_FONT_HASH);

+    return info;

+    

+bail1:

+    free (info);

+bail0:

+    if (XftDebug () & XFT_DBG_RENDER)

+    {

+	printf ("XftDisplayInfoGet failed to initialize, Xft unhappy\n");

+    }

+    return NULL;

+}

+

+/*

+ * Reduce memory usage in X server

+ */

+

+static void

+_XftDisplayValidateMemory (XftDisplayInfo *info)

+{

+    XftFont	    *public;

+    XftFontInt	    *font;

+    unsigned long   glyph_memory;

+

+    glyph_memory = 0;

+    for (public = info->fonts; public; public = font->next)

+    {

+	font = (XftFontInt *) public;

+	glyph_memory += font->glyph_memory;

+    }

+    if (glyph_memory != info->glyph_memory)

+	printf ("Display glyph cache incorrect has %ld bytes, should have %ld\n",

+		info->glyph_memory, glyph_memory);

+}

+

+_X_HIDDEN void

+_XftDisplayManageMemory (Display *dpy)

+{

+    XftDisplayInfo  *info = _XftDisplayInfoGet (dpy, False);

+    unsigned long   glyph_memory;

+    XftFont	    *public;

+    XftFontInt	    *font;

+

+    if (!info || !info->max_glyph_memory)

+	return;

+    if (XftDebug () & XFT_DBG_CACHE)

+    {

+	if (info->glyph_memory > info->max_glyph_memory)

+	    printf ("Reduce global memory from %ld to %ld\n",

+		    info->glyph_memory, info->max_glyph_memory);

+	_XftDisplayValidateMemory (info);

+    }

+    while (info->glyph_memory > info->max_glyph_memory)

+    {

+	glyph_memory = rand () % info->glyph_memory;

+	public = info->fonts;

+	while (public)

+	{

+	    font = (XftFontInt *) public;

+

+	    if (font->glyph_memory > glyph_memory)

+	    {

+		_XftFontUncacheGlyph (dpy, public);

+		break;

+	    }

+	    public = font->next;

+	    glyph_memory -= font->glyph_memory;

+	}

+    }

+    if (XftDebug () & XFT_DBG_CACHE)

+	_XftDisplayValidateMemory (info);

+}

+

+_X_EXPORT Bool

+XftDefaultHasRender (Display *dpy)

+{

+    XftDisplayInfo  *info = _XftDisplayInfoGet (dpy, True);

+

+    if (!info)

+	return False;

+    return info->hasRender;

+}

+

+_X_EXPORT Bool

+XftDefaultSet (Display *dpy, FcPattern *defaults)

+{

+    XftDisplayInfo  *info = _XftDisplayInfoGet (dpy, True);

+

+    if (!info)

+	return False;

+    if (info->defaults)

+	FcPatternDestroy (info->defaults);

+    info->defaults = defaults;

+    if (!info->max_glyph_memory)

+	info->max_glyph_memory = XFT_DPY_MAX_GLYPH_MEMORY;

+    info->max_glyph_memory = XftDefaultGetInteger (dpy,

+						   XFT_MAX_GLYPH_MEMORY, 0,

+						   info->max_glyph_memory);

+    if (!info->max_unref_fonts)

+	info->max_unref_fonts = XFT_DPY_MAX_UNREF_FONTS;

+    info->max_unref_fonts = XftDefaultGetInteger (dpy,

+						  XFT_MAX_UNREF_FONTS, 0,

+						  info->max_unref_fonts);

+    return True;

+}

+

+_X_HIDDEN int

+XftDefaultParseBool (char *v)

+{

+    char    c0, c1;

+

+    c0 = *v;

+    if (isupper ((int)c0))

+	c0 = tolower (c0);

+    if (c0 == 't' || c0 == 'y' || c0 == '1')

+	return 1;

+    if (c0 == 'f' || c0 == 'n' || c0 == '0')

+	return 0;

+    if (c0 == 'o')

+    {

+	c1 = v[1];

+	if (isupper ((int)c1))

+	    c1 = tolower (c1);

+	if (c1 == 'n')

+	    return 1;

+	if (c1 == 'f')

+	    return 0;

+    }

+    return -1;

+}

+

+static Bool

+_XftDefaultInitBool (Display *dpy, FcPattern *pat, char *option)

+{

+    char    *v;

+    int	    i;

+

+    v = XGetDefault (dpy, "Xft", option);

+    if (v && (i = XftDefaultParseBool (v)) >= 0)

+	return FcPatternAddBool (pat, option, i != 0);

+    return True;

+}

+

+static Bool

+_XftDefaultInitDouble (Display *dpy, FcPattern *pat, char *option)

+{

+    char    *v, *e;

+    double  d;

+

+    v = XGetDefault (dpy, "Xft", option);

+    if (v)

+    {

+	d = strtod (v, &e);

+	if (e != v)

+	    return FcPatternAddDouble (pat, option, d);

+    }

+    return True;

+}

+

+static Bool

+_XftDefaultInitInteger (Display *dpy, FcPattern *pat, char *option)

+{

+    char    *v, *e;

+    int	    i;

+

+    v = XGetDefault (dpy, "Xft", option);

+    if (v)

+    {

+	if (FcNameConstant ((FcChar8 *) v, &i))

+	    return FcPatternAddInteger (pat, option, i);

+	i = strtol (v, &e, 0);

+	if (e != v)

+	    return FcPatternAddInteger (pat, option, i);

+    }

+    return True;

+}

+

+static FcPattern *

+_XftDefaultInit (Display *dpy)

+{

+    FcPattern	*pat;

+

+    pat = FcPatternCreate ();

+    if (!pat)

+	goto bail0;

+

+    if (!_XftDefaultInitDouble (dpy, pat, FC_SCALE))

+	goto bail1;

+    if (!_XftDefaultInitDouble (dpy, pat, FC_DPI))

+	goto bail1;

+    if (!_XftDefaultInitBool (dpy, pat, XFT_RENDER))

+	goto bail1;

+    if (!_XftDefaultInitInteger (dpy, pat, FC_RGBA))

+	goto bail1;

+    if (!_XftDefaultInitBool (dpy, pat, FC_ANTIALIAS))

+	goto bail1;

+#ifdef FC_EMBOLDEN

+    if (!_XftDefaultInitBool (dpy, pat, FC_EMBOLDEN))

+	goto bail1;

+#endif

+    if (!_XftDefaultInitBool (dpy, pat, FC_AUTOHINT))

+	goto bail1;

+#ifdef FC_HINT_STYLE

+    if (!_XftDefaultInitInteger (dpy, pat, FC_HINT_STYLE))

+	goto bail1;

+#endif

+    if (!_XftDefaultInitBool (dpy, pat, FC_HINTING))

+	goto bail1;

+    if (!_XftDefaultInitBool (dpy, pat, FC_MINSPACE))

+	goto bail1;

+    if (!_XftDefaultInitInteger (dpy, pat, XFT_MAX_GLYPH_MEMORY))

+	goto bail1;

+    

+    return pat;

+    

+bail1:

+    FcPatternDestroy (pat);

+bail0:

+    return NULL;

+}

+

+static FcResult

+_XftDefaultGet (Display *dpy, const char *object, int screen, FcValue *v)

+{

+    XftDisplayInfo  *info = _XftDisplayInfoGet (dpy, True);

+    FcResult	    r;

+

+    if (!info)

+	return FcResultNoMatch;

+    

+    if (!info->defaults)

+    {

+	info->defaults = _XftDefaultInit (dpy);

+	if (!info->defaults)

+	    return FcResultNoMatch;

+    }

+    r = FcPatternGet (info->defaults, object, screen, v);

+    if (r == FcResultNoId && screen > 0)

+	r = FcPatternGet (info->defaults, object, 0, v);

+    return r;

+}

+

+_X_HIDDEN Bool

+XftDefaultGetBool (Display *dpy, const char *object, int screen, Bool def)

+{

+    FcResult	    r;

+    FcValue	    v;

+

+    r = _XftDefaultGet (dpy, object, screen, &v);

+    if (r != FcResultMatch || v.type != FcTypeBool)

+	return def;

+    return v.u.b;

+}

+

+_X_HIDDEN int

+XftDefaultGetInteger (Display *dpy, const char *object, int screen, int def)

+{

+    FcResult	    r;

+    FcValue	    v;

+

+    r = _XftDefaultGet (dpy, object, screen, &v);

+    if (r != FcResultMatch || v.type != FcTypeInteger)

+	return def;

+    return v.u.i;

+}

+

+_X_HIDDEN double

+XftDefaultGetDouble (Display *dpy, const char *object, int screen, double def)

+{

+    FcResult	    r;

+    FcValue	    v;

+

+    r = _XftDefaultGet (dpy, object, screen, &v);

+    if (r != FcResultMatch || v.type != FcTypeDouble)

+	return def;

+    return v.u.d;

+}

+

+_X_EXPORT void

+XftDefaultSubstitute (Display *dpy, int screen, FcPattern *pattern)

+{

+    FcValue	v;

+    double	dpi;

+

+    if (FcPatternGet (pattern, XFT_RENDER, 0, &v) == FcResultNoMatch)

+    {

+	FcPatternAddBool (pattern, XFT_RENDER,

+			   XftDefaultGetBool (dpy, XFT_RENDER, screen, 

+					      XftDefaultHasRender (dpy)));

+    }

+    if (FcPatternGet (pattern, FC_ANTIALIAS, 0, &v) == FcResultNoMatch)

+    {

+	FcPatternAddBool (pattern, FC_ANTIALIAS,

+			   XftDefaultGetBool (dpy, FC_ANTIALIAS, screen,

+					      True));

+    }

+#ifdef FC_EMBOLDEN

+    if (FcPatternGet (pattern, FC_EMBOLDEN, 0, &v) == FcResultNoMatch)

+    {

+	FcPatternAddBool (pattern, FC_EMBOLDEN,

+			   XftDefaultGetBool (dpy, FC_EMBOLDEN, screen,

+					      False));

+    }

+#endif

+    if (FcPatternGet (pattern, FC_HINTING, 0, &v) == FcResultNoMatch)

+    {

+	FcPatternAddBool (pattern, FC_HINTING,

+			  XftDefaultGetBool (dpy, FC_HINTING, screen,

+					     True));

+    }

+#ifdef FC_HINT_STYLE

+    if (FcPatternGet (pattern, FC_HINT_STYLE, 0, &v) == FcResultNoMatch)

+    {

+	FcPatternAddInteger (pattern, FC_HINT_STYLE,

+			     XftDefaultGetInteger (dpy, FC_HINT_STYLE, screen,

+						   FC_HINT_FULL));

+    }

+#endif

+    if (FcPatternGet (pattern, FC_AUTOHINT, 0, &v) == FcResultNoMatch)

+    {

+	FcPatternAddBool (pattern, FC_AUTOHINT,

+			  XftDefaultGetBool (dpy, FC_AUTOHINT, screen,

+					     False));

+    }

+    if (FcPatternGet (pattern, FC_RGBA, 0, &v) == FcResultNoMatch)

+    {

+	int	subpixel = FC_RGBA_UNKNOWN;

+#if RENDER_MAJOR > 0 || RENDER_MINOR >= 6

+	if (XftDefaultHasRender (dpy))

+	{

+	    int render_order = XRenderQuerySubpixelOrder (dpy, screen);

+	    switch (render_order) {

+	    default:

+	    case SubPixelUnknown:	subpixel = FC_RGBA_UNKNOWN; break;

+	    case SubPixelHorizontalRGB:	subpixel = FC_RGBA_RGB; break;

+	    case SubPixelHorizontalBGR:	subpixel = FC_RGBA_BGR; break;

+	    case SubPixelVerticalRGB:	subpixel = FC_RGBA_VRGB; break;

+	    case SubPixelVerticalBGR:	subpixel = FC_RGBA_VBGR; break;

+	    case SubPixelNone:		subpixel = FC_RGBA_NONE; break;

+	    }

+	}

+#endif

+	FcPatternAddInteger (pattern, FC_RGBA,

+			      XftDefaultGetInteger (dpy, FC_RGBA, screen, 

+						    subpixel));

+    }

+    if (FcPatternGet (pattern, FC_MINSPACE, 0, &v) == FcResultNoMatch)

+    {

+	FcPatternAddBool (pattern, FC_MINSPACE,

+			   XftDefaultGetBool (dpy, FC_MINSPACE, screen,

+					      False));

+    }

+    if (FcPatternGet (pattern, FC_DPI, 0, &v) == FcResultNoMatch)

+    {

+	dpi = (((double) DisplayHeight (dpy, screen) * 25.4) / 

+	       (double) DisplayHeightMM (dpy, screen));

+	FcPatternAddDouble (pattern, FC_DPI, 

+			    XftDefaultGetDouble (dpy, FC_DPI, screen, 

+						 dpi));

+    }

+    if (FcPatternGet (pattern, FC_SCALE, 0, &v) == FcResultNoMatch)

+    {

+	FcPatternAddDouble (pattern, FC_SCALE,

+			    XftDefaultGetDouble (dpy, FC_SCALE, screen, 1.0));

+    }

+    if (FcPatternGet (pattern, XFT_MAX_GLYPH_MEMORY, 0, &v) == FcResultNoMatch)

+    {

+	FcPatternAddInteger (pattern, XFT_MAX_GLYPH_MEMORY,

+			     XftDefaultGetInteger (dpy, XFT_MAX_GLYPH_MEMORY,

+						   screen,

+						   XFT_FONT_MAX_GLYPH_MEMORY));

+    }

+    FcDefaultSubstitute (pattern);

+}

+

diff --git a/libXft/src/xftdraw.c b/libXft/src/xftdraw.c
index 21f8538a3..7b8f84dd5 100644
--- a/libXft/src/xftdraw.c
+++ b/libXft/src/xftdraw.c
@@ -1,994 +1,994 @@
-/*
- * Copyright © 2000 Keith Packard
- *
- * Permission to use, copy, modify, distribute, and sell this software and its
- * documentation for any purpose is hereby granted without fee, provided that
- * the above copyright notice appear in all copies and that both that
- * copyright notice and this permission notice appear in supporting
- * documentation, and that the name of Keith Packard not be used in
- * advertising or publicity pertaining to distribution of the software without
- * specific, written prior permission.  Keith Packard makes no
- * representations about the suitability of this software for any purpose.  It
- * is provided "as is" without express or implied warranty.
- *
- * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
- * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
- * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include "xftint.h"
-
-/*
- * Ok, this is a pain.  To share source pictures across multiple destinations,
- * the screen for each drawable must be discovered.
- */
-
-static int
-_XftDrawScreen (Display *dpy, Drawable drawable, Visual *visual)
-{
-    int		    s;
-    Window	    root;
-    int		    x, y;
-    unsigned int    width, height, borderWidth, depth;
-    /* Special case the most common environment */
-    if (ScreenCount (dpy) == 1)
-	return 0;
-    /*
-     * If we've got a visual, look for the screen that points at it.
-     * This requires no round trip.
-     */
-    if (visual)
-    {
-	for (s = 0; s < ScreenCount (dpy); s++)
-	{
-	    XVisualInfo	template, *ret;
-	    int		nret;
-
-	    template.visualid = visual->visualid;
-	    template.screen = s;
-	    ret = XGetVisualInfo (dpy, VisualIDMask|VisualScreenMask,
-				  &template, &nret);
-	    if (ret)
-	    {
-		XFree (ret);
-		return s;
-	    }
-	}
-    }
-    /*
-     * Otherwise, as the server for the drawable geometry and find
-     * the screen from the root window.
-     * This takes a round trip.
-     */
-    if (XGetGeometry (dpy, drawable, &root, &x, &y, &width, &height,
-		      &borderWidth, &depth))
-    {
-	for (s = 0; s < ScreenCount (dpy); s++)
-	{
-	    if (RootWindow (dpy, s) == root)
-		return s;
-	}
-    }
-    /*
-     * Make a guess -- it's probably wrong, but then the app probably
-     * handed us a bogus drawable in this case
-     */
-    return 0;
-}
-
-_X_HIDDEN unsigned int
-XftDrawDepth (XftDraw *draw)
-{
-    if (!draw->depth)
-    {
-	Window		    root;
-	int		    x, y;
-	unsigned int	    width, height, borderWidth, depth;
-	if (XGetGeometry (draw->dpy, draw->drawable, 
-			  &root, &x, &y, &width, &height,
-			  &borderWidth, &depth))
-	    draw->depth = depth;
-    }
-    return draw->depth;
-}
-
-_X_HIDDEN unsigned int
-XftDrawBitsPerPixel (XftDraw	*draw)
-{
-    if (!draw->bits_per_pixel)
-    {
-	XPixmapFormatValues *formats;
-	int		    nformats;
-	unsigned int	    depth;
-	
-	if ((depth = XftDrawDepth (draw)) &&
-	    (formats = XListPixmapFormats (draw->dpy, &nformats)))
-	{
-	    int	i;
-
-	    for (i = 0; i < nformats; i++)
-	    {
-		if (formats[i].depth == depth)
-		{
-		    draw->bits_per_pixel = formats[i].bits_per_pixel;
-		    break;
-		}
-	    }
-	    XFree (formats);
-	}
-    }
-    return draw->bits_per_pixel;
-}
-
-_X_EXPORT XftDraw *
-XftDrawCreate (Display   *dpy,
-	       Drawable  drawable,
-	       Visual    *visual,
-	       Colormap  colormap)
-{
-    XftDraw	*draw;
-
-    draw = (XftDraw *) malloc (sizeof (XftDraw));
-    if (!draw)
-	return NULL;
-    
-    draw->dpy = dpy;
-    draw->drawable = drawable;
-    draw->screen = _XftDrawScreen (dpy, drawable, visual);
-    draw->depth = 0;		/* don't find out unless we need to know */
-    draw->bits_per_pixel = 0;	/* don't find out unless we need to know */
-    draw->visual = visual;
-    draw->colormap = colormap;
-    draw->render.pict = 0;
-    draw->core.gc = NULL;
-    draw->core.use_pixmap = 0;
-    draw->clip_type = XftClipTypeNone;
-    draw->subwindow_mode = ClipByChildren;
-    XftMemAlloc (XFT_MEM_DRAW, sizeof (XftDraw));
-    return draw;
-}
-
-_X_EXPORT XftDraw *
-XftDrawCreateBitmap (Display	*dpy,
-		     Pixmap	bitmap)
-{
-    XftDraw	*draw;
-
-    draw = (XftDraw *) malloc (sizeof (XftDraw));
-    if (!draw)
-	return NULL;
-    draw->dpy = dpy;
-    draw->drawable = (Drawable) bitmap;
-    draw->screen = _XftDrawScreen (dpy, bitmap, NULL);
-    draw->depth = 1;
-    draw->bits_per_pixel = 1;
-    draw->visual = NULL;
-    draw->colormap = 0;
-    draw->render.pict = 0;
-    draw->core.gc = NULL;
-    draw->core.use_pixmap = 0;
-    draw->clip_type = XftClipTypeNone;
-    draw->subwindow_mode = ClipByChildren;
-    XftMemAlloc (XFT_MEM_DRAW, sizeof (XftDraw));
-    return draw;
-}
-
-_X_EXPORT XftDraw *
-XftDrawCreateAlpha (Display *dpy,
-		    Pixmap  pixmap,
-		    int	    depth)
-{
-    XftDraw	*draw;
-
-    draw = (XftDraw *) malloc (sizeof (XftDraw));
-    if (!draw)
-	return NULL;
-    draw->dpy = dpy;
-    draw->drawable = (Drawable) pixmap;
-    draw->screen = _XftDrawScreen (dpy, pixmap, NULL);
-    draw->depth = depth;
-    draw->bits_per_pixel = 0;	/* don't find out until we need it */
-    draw->visual = NULL;
-    draw->colormap = 0;
-    draw->render.pict = 0;
-    draw->core.gc = NULL;
-    draw->core.use_pixmap = 0;
-    draw->clip_type = XftClipTypeNone;
-    draw->subwindow_mode = ClipByChildren;
-    XftMemAlloc (XFT_MEM_DRAW, sizeof (XftDraw));
-    return draw;
-}
-
-static XRenderPictFormat *
-_XftDrawFormat (XftDraw	*draw)
-{
-    XftDisplayInfo  *info = _XftDisplayInfoGet (draw->dpy, True);
-
-    if (!info || !info->hasRender)
-	return NULL;
-
-    if (draw->visual == NULL)
-    {
-	XRenderPictFormat   pf;
-
-	pf.type = PictTypeDirect;
-	pf.depth = XftDrawDepth (draw);
-	pf.direct.alpha = 0;
-	pf.direct.alphaMask = (1 << pf.depth) - 1;
-	return XRenderFindFormat (draw->dpy,
-				  (PictFormatType|
-				   PictFormatDepth|
-				   PictFormatAlpha|
-				   PictFormatAlphaMask),
-				  &pf,
-				  0);
-    }
-    else
-	return XRenderFindVisualFormat (draw->dpy, draw->visual);
-}
-
-_X_EXPORT void
-XftDrawChange (XftDraw	*draw,
-	       Drawable	drawable)
-{
-    draw->drawable = drawable;
-    if (draw->render.pict)
-    {
-	XRenderFreePicture (draw->dpy, draw->render.pict);
-	draw->render.pict = 0;
-    }
-    if (draw->core.gc)
-    {
-	XFreeGC (draw->dpy, draw->core.gc);
-	draw->core.gc = NULL;
-    }
-}
-
-_X_EXPORT Display *
-XftDrawDisplay (XftDraw *draw)
-{
-    return draw->dpy;
-}
-
-_X_EXPORT Drawable
-XftDrawDrawable (XftDraw *draw)
-{
-    return draw->drawable;
-}
-
-_X_EXPORT Colormap
-XftDrawColormap (XftDraw *draw)
-{
-    return draw->colormap;
-}
-
-_X_EXPORT Visual *
-XftDrawVisual (XftDraw *draw)
-{
-    return draw->visual;
-}
-
-_X_EXPORT void
-XftDrawDestroy (XftDraw	*draw)
-{
-    if (draw->render.pict)
-	XRenderFreePicture (draw->dpy, draw->render.pict);
-    if (draw->core.gc)
-	XFreeGC (draw->dpy, draw->core.gc);
-    switch (draw->clip_type) {
-    case XftClipTypeRegion:
-	XDestroyRegion (draw->clip.region);
-	break;
-    case XftClipTypeRectangles:
-	free (draw->clip.rect);
-	break;
-    case XftClipTypeNone:
-	break;
-    }
-    XftMemFree (XFT_MEM_DRAW, sizeof (XftDraw));
-    free (draw);
-}
-
-_X_EXPORT Picture
-XftDrawSrcPicture (XftDraw *draw, _Xconst XftColor *color)
-{
-    Display	    *dpy = draw->dpy;
-    XftDisplayInfo  *info = _XftDisplayInfoGet (dpy, True);
-    int		    i;
-    XftColor	    bitmapColor;
-
-    if (!info || !info->solidFormat)
-	return 0;
-    
-    /*
-     * Monochrome targets require special handling; the PictOp controls
-     * the color, and the color must be opaque
-     */
-    if (!draw->visual && draw->depth == 1)
-    {
-	bitmapColor.color.alpha = 0xffff;
-	bitmapColor.color.red   = 0xffff;
-	bitmapColor.color.green = 0xffff;
-	bitmapColor.color.blue  = 0xffff;
-	color = &bitmapColor;
-    }
-
-    /*
-     * See if there's one already available
-     */
-    for (i = 0; i < XFT_NUM_SOLID_COLOR; i++)
-    {
-	if (info->colors[i].pict && 
-	    info->colors[i].screen == draw->screen &&
-	    !memcmp ((void *) &color->color, 
-		     (void *) &info->colors[i].color,
-		     sizeof (XRenderColor)))
-	    return info->colors[i].pict;
-    }
-    /*
-     * Pick one to replace at random
-     */
-    i = (unsigned int) rand () % XFT_NUM_SOLID_COLOR;
-    /*
-     * Recreate if it was for the wrong screen
-     */
-    if (info->colors[i].screen != draw->screen && info->colors[i].pict)
-    {
-	XRenderFreePicture (dpy, info->colors[i].pict);
-	info->colors[i].pict = 0;
-    }
-    /*
-     * Create picture if necessary
-     */
-    if (!info->colors[i].pict)
-    {
-	Pixmap			    pix;
-        XRenderPictureAttributes    pa;
-	
-	pix = XCreatePixmap (dpy, RootWindow (dpy, draw->screen), 1, 1,
-			     info->solidFormat->depth);
-	pa.repeat = True;
-	info->colors[i].pict = XRenderCreatePicture (draw->dpy,
-						     pix,
-						     info->solidFormat,
-						     CPRepeat, &pa);
-	XFreePixmap (dpy, pix);
-    }
-    /*
-     * Set to the new color
-     */
-    info->colors[i].color = color->color;
-    info->colors[i].screen = draw->screen;
-    XRenderFillRectangle (dpy, PictOpSrc,
-			  info->colors[i].pict,
-			  &color->color, 0, 0, 1, 1);
-    return info->colors[i].pict;
-}
-
-static int
-_XftDrawOp (_Xconst XftDraw *draw, _Xconst XftColor *color)
-{
-    if (draw->visual || draw->depth != 1)
-	return PictOpOver;
-    if (color->color.alpha >= 0x8000)
-	return PictOpOver;
-    return PictOpOutReverse;
-}
-
-static FcBool
-_XftDrawRenderPrepare (XftDraw	*draw)
-{
-    if (!draw->render.pict)
-    {
-	XRenderPictFormat	    *format;
-	XRenderPictureAttributes    pa;
-	unsigned long		    mask = 0;
-
-	format = _XftDrawFormat (draw);
-	if (!format)
-	    return FcFalse;
-	
-	if (draw->subwindow_mode == IncludeInferiors)
-	{
-	    pa.subwindow_mode = IncludeInferiors;
-	    mask |= CPSubwindowMode;
-	}
-	draw->render.pict = XRenderCreatePicture (draw->dpy, draw->drawable,
-						  format, mask, &pa);
-	if (!draw->render.pict)
-	    return FcFalse;
-	switch (draw->clip_type) {
-	case XftClipTypeRegion:
-	    XRenderSetPictureClipRegion (draw->dpy, draw->render.pict,
-					 draw->clip.region);
-	    break;
-	case XftClipTypeRectangles:
-	    XRenderSetPictureClipRectangles (draw->dpy, draw->render.pict,
-					     draw->clip.rect->xOrigin,
-					     draw->clip.rect->yOrigin,
-					     XftClipRects(draw->clip.rect),
-					     draw->clip.rect->n);
-	    break;
-	case XftClipTypeNone:
-	    break;
-	}
-    }
-    return FcTrue;
-}
-
-static FcBool
-_XftDrawCorePrepare (XftDraw *draw, _Xconst XftColor *color)
-{
-    if (!draw->core.gc)
-    {
-	XGCValues	gcv;
-	unsigned long	mask = 0;
-	if (draw->subwindow_mode == IncludeInferiors)
-	{
-	    gcv.subwindow_mode = IncludeInferiors;
-	    mask |= GCSubwindowMode;
-	}
-	draw->core.gc = XCreateGC (draw->dpy, draw->drawable, mask, &gcv);
-	if (!draw->core.gc)
-	    return FcFalse;
-	switch (draw->clip_type) {
-	case XftClipTypeRegion:
-	    XSetRegion (draw->dpy, draw->core.gc, draw->clip.region);
-	    break;
-	case XftClipTypeRectangles:
-	    XSetClipRectangles (draw->dpy, draw->core.gc,
-				draw->clip.rect->xOrigin,
-				draw->clip.rect->yOrigin,
-				XftClipRects (draw->clip.rect),
-				draw->clip.rect->n,
-				Unsorted);
-	    break;
-	case XftClipTypeNone:
-	    break;
-	}
-    }
-    XSetForeground (draw->dpy, draw->core.gc, color->pixel);
-    return FcTrue;
-}
-			
-_X_EXPORT Picture
-XftDrawPicture (XftDraw *draw)
-{
-    if (!_XftDrawRenderPrepare (draw))
-	return 0;
-    return draw->render.pict;
-}
-
-#define NUM_LOCAL   1024
-
-_X_EXPORT void
-XftDrawGlyphs (XftDraw		*draw,
-	       _Xconst XftColor	*color,
-	       XftFont		*pub,
-	       int		x,
-	       int		y,
-	       _Xconst FT_UInt	*glyphs,
-	       int		nglyphs)
-{
-    XftFontInt	*font = (XftFontInt *) pub;
-
-    if (font->format)
-    {
-	Picture	    src;
-	
-	if (_XftDrawRenderPrepare (draw) &&
-	    (src = XftDrawSrcPicture (draw, color)))
-	    XftGlyphRender (draw->dpy, _XftDrawOp (draw, color),
-			     src, pub, draw->render.pict,
-			     0, 0, x, y, glyphs, nglyphs);
-    }
-    else
-    {
-	if (_XftDrawCorePrepare (draw, color))
-	    XftGlyphCore (draw, color, pub, x, y, glyphs, nglyphs);
-    }
-}
-
-_X_EXPORT void
-XftDrawString8 (XftDraw		    *draw,
-		_Xconst XftColor    *color,
-		XftFont		    *pub,
-		int		    x, 
-		int		    y,
-		_Xconst FcChar8	    *string,
-		int		    len)
-{
-    FT_UInt	    *glyphs, glyphs_local[NUM_LOCAL];
-    int		    i;
-
-    if (XftDebug () & XFT_DBG_DRAW)
-	printf ("DrawString \"%*.*s\"\n", len, len, string);
-    
-    if (len <= NUM_LOCAL)
-	glyphs = glyphs_local;
-    else
-    {
-	glyphs = malloc (len * sizeof (FT_UInt));
-	if (!glyphs)
-	    return;
-    }
-    for (i = 0; i < len; i++)
-	glyphs[i] = XftCharIndex (draw->dpy, pub, string[i]);
-    XftDrawGlyphs (draw, color, pub, x, y, glyphs, len);
-    if (glyphs != glyphs_local)
-	free (glyphs);
-}
-
-_X_EXPORT void
-XftDrawString16 (XftDraw	    *draw,
-		 _Xconst XftColor   *color,
-		 XftFont	    *pub,
-		 int		    x,
-		 int		    y,
-		 _Xconst FcChar16   *string,
-		 int		    len)
-{
-    FT_UInt	    *glyphs, glyphs_local[NUM_LOCAL];
-    int		    i;
-
-    if (len <= NUM_LOCAL)
-	glyphs = glyphs_local;
-    else
-    {
-	glyphs = malloc (len * sizeof (FT_UInt));
-	if (!glyphs)
-	    return;
-    }
-    for (i = 0; i < len; i++)
-	glyphs[i] = XftCharIndex (draw->dpy, pub, string[i]);
-    
-    XftDrawGlyphs (draw, color, pub, x, y, glyphs, len);
-    if (glyphs != glyphs_local)
-	free (glyphs);
-}
-
-_X_EXPORT void
-XftDrawString32 (XftDraw	    *draw,
-		 _Xconst XftColor   *color,
-		 XftFont	    *pub,
-		 int		    x,
-		 int		    y,
-		 _Xconst FcChar32   *string,
-		 int		    len)
-{
-    FT_UInt	    *glyphs, glyphs_local[NUM_LOCAL];
-    int		    i;
-
-    if (len <= NUM_LOCAL)
-	glyphs = glyphs_local;
-    else
-    {
-	glyphs = malloc (len * sizeof (FT_UInt));
-	if (!glyphs)
-	    return;
-    }
-    for (i = 0; i < len; i++)
-	glyphs[i] = XftCharIndex (draw->dpy, pub, string[i]);
-    
-    XftDrawGlyphs (draw, color, pub, x, y, glyphs, len);
-    if (glyphs != glyphs_local)
-	free (glyphs);
-}
-
-_X_EXPORT void
-XftDrawStringUtf8 (XftDraw	    *draw,
-		   _Xconst XftColor *color,
-		   XftFont	    *pub,
-		   int		    x, 
-		   int		    y,
-		   _Xconst FcChar8  *string,
-		   int		    len)
-{
-    FT_UInt	    *glyphs, *glyphs_new, glyphs_local[NUM_LOCAL];
-    FcChar32	    ucs4;
-    int		    i;
-    int		    l;
-    int		    size;
-
-    i = 0;
-    glyphs = glyphs_local;
-    size = NUM_LOCAL;
-    while (len && (l = FcUtf8ToUcs4 (string, &ucs4, len)) > 0)
-    {
-	if (i == size)
-	{
-	    glyphs_new = malloc (size * 2 * sizeof (FT_UInt));
-	    if (!glyphs_new)
-	    {
-		if (glyphs != glyphs_local)
-		    free (glyphs);
-		return;
-	    }
-	    memcpy (glyphs_new, glyphs, size * sizeof (FT_UInt));
-	    size *= 2;
-	    if (glyphs != glyphs_local)
-		free (glyphs);
-	    glyphs = glyphs_new;
-	}
-	glyphs[i++] = XftCharIndex (draw->dpy, pub, ucs4);
-	string += l;
-	len -= l;
-    }
-    XftDrawGlyphs (draw, color, pub, x, y, glyphs, i);
-    if (glyphs != glyphs_local)
-	free (glyphs);
-}
-
-_X_EXPORT void
-XftDrawStringUtf16 (XftDraw		*draw,
-		    _Xconst XftColor	*color,
-		    XftFont		*pub,
-		    int			x,
-		    int			y,
-		    _Xconst FcChar8	*string,
-		    FcEndian		endian,
-		    int			len)
-{
-    FT_UInt	    *glyphs, *glyphs_new, glyphs_local[NUM_LOCAL];
-    FcChar32	    ucs4;
-    int		    i;
-    int		    l;
-    int		    size;
-
-    i = 0;
-    glyphs = glyphs_local;
-    size = NUM_LOCAL;
-    while (len && (l = FcUtf16ToUcs4 (string, endian, &ucs4, len)) > 0)
-    {
-	if (i == size)
-	{
-	    glyphs_new = malloc (size * 2 * sizeof (FT_UInt));
-	    if (!glyphs_new)
-	    {
-		if (glyphs != glyphs_local)
-		    free (glyphs);
-		return;
-	    }
-	    memcpy (glyphs_new, glyphs, size * sizeof (FT_UInt));
-	    size *= 2;
-	    if (glyphs != glyphs_local)
-		free (glyphs);
-	    glyphs = glyphs_new;
-	}
-	glyphs[i++] = XftCharIndex (draw->dpy, pub, ucs4);
-	string += l;
-	len -= l;
-    }
-    XftDrawGlyphs (draw, color, pub, x, y, glyphs, i);
-    if (glyphs != glyphs_local)
-	free (glyphs);
-}
-
-_X_EXPORT void
-XftDrawGlyphSpec (XftDraw		*draw,
-		  _Xconst XftColor	*color,
-		  XftFont		*pub,
-		  _Xconst XftGlyphSpec	*glyphs,
-		  int			len)
-{
-    XftFontInt	*font = (XftFontInt *) pub;
-
-    if (font->format)
-    {
-	Picture	src;
-
-	if (_XftDrawRenderPrepare (draw) &&
-	    (src = XftDrawSrcPicture (draw, color)))
-	{
-	    XftGlyphSpecRender (draw->dpy, _XftDrawOp (draw, color),
-				src, pub, draw->render.pict,
-				0, 0, glyphs, len);
-	}
-    }
-    else
-    {
-	if (_XftDrawCorePrepare (draw, color))
-	    XftGlyphSpecCore (draw, color, pub, glyphs, len);
-    }
-}
-
-_X_EXPORT void
-XftDrawGlyphFontSpec (XftDraw			*draw,
-		      _Xconst XftColor		*color,
-		      _Xconst XftGlyphFontSpec	*glyphs,
-		      int			len)
-{
-    int		i;
-    int		start;
-
-    i = 0;
-    while (i < len)
-    {
-	start = i;
-	if (((XftFontInt *) glyphs[i].font)->format)
-	{
-	    Picture	src;
-	    while (i < len && ((XftFontInt *) glyphs[i].font)->format)
-		i++;
-	    if (_XftDrawRenderPrepare (draw) &&
-		(src = XftDrawSrcPicture (draw, color)))
-	    {
-		XftGlyphFontSpecRender (draw->dpy, _XftDrawOp (draw, color),
-					src, draw->render.pict,
-					0, 0, glyphs + start , i - start);
-	    }
-	}
-	else
-	{
-	    while (i < len && !((XftFontInt *) glyphs[i].font)->format)
-		i++;
-	    if (_XftDrawCorePrepare (draw, color))
-		XftGlyphFontSpecCore (draw, color, glyphs + start, i - start);
-	}
-    }
-}
-
-_X_EXPORT void
-XftDrawCharSpec (XftDraw		*draw,
-		 _Xconst XftColor	*color,
-		 XftFont		*pub,
-		 _Xconst XftCharSpec	*chars,
-		 int			len)
-{
-    XftGlyphSpec    *glyphs, glyphs_local[NUM_LOCAL];
-    int		    i;
-
-    if (len <= NUM_LOCAL)
-	glyphs = glyphs_local;
-    else
-    {
-	glyphs = malloc (len * sizeof (XftGlyphSpec));
-	if (!glyphs)
-	    return;
-    }
-    for (i = 0; i < len; i++)
-    {
-	glyphs[i].glyph = XftCharIndex(draw->dpy, pub, chars[i].ucs4);
-	glyphs[i].x = chars[i].x;
-	glyphs[i].y = chars[i].y;
-    }
-
-    XftDrawGlyphSpec (draw, color, pub, glyphs, len);
-    if (glyphs != glyphs_local)
-	free (glyphs);
-}
-
-_X_EXPORT void
-XftDrawCharFontSpec (XftDraw			*draw,
-		     _Xconst XftColor		*color,
-		     _Xconst XftCharFontSpec	*chars,
-		     int			len)
-{
-    XftGlyphFontSpec	*glyphs, glyphs_local[NUM_LOCAL];
-    int			i;
-
-    if (len <= NUM_LOCAL)
-	glyphs = glyphs_local;
-    else
-    {
-	glyphs = malloc (len * sizeof (XftGlyphFontSpec));
-	if (!glyphs)
-	    return;
-    }
-    for (i = 0; i < len; i++)
-    {
-	glyphs[i].font = chars[i].font;
-	glyphs[i].glyph = XftCharIndex(draw->dpy, glyphs[i].font, chars[i].ucs4);
-	glyphs[i].x = chars[i].x;
-	glyphs[i].y = chars[i].y;
-    }
-
-    XftDrawGlyphFontSpec (draw, color, glyphs, len);
-    if (glyphs != glyphs_local)
-	free (glyphs);
-}
-
-_X_EXPORT void
-XftDrawRect (XftDraw		*draw,
-	     _Xconst XftColor	*color,
-	     int		x, 
-	     int		y,
-	     unsigned int	width,
-	     unsigned int	height)
-{
-    if (_XftDrawRenderPrepare (draw))
-    {
-	XRenderFillRectangle (draw->dpy, PictOpSrc, draw->render.pict,
-			      &color->color, x, y, width, height);
-    }
-    else if (_XftDrawCorePrepare (draw, color))
-    {
-	/* note: not XftRectCore() */
-	XSetForeground (draw->dpy, draw->core.gc, color->pixel);
-	XFillRectangle (draw->dpy, draw->drawable, draw->core.gc,
-			x, y, width, height);
-    }
-}
-
-_X_EXPORT Bool
-XftDrawSetClip (XftDraw	*draw,
-		Region	r)
-{
-    Region			n = NULL;
-
-    /*
-     * Check for quick exits
-     */
-    if (!r && draw->clip_type == XftClipTypeNone)
-	return True;
-    
-    if (r && 
-	draw->clip_type == XftClipTypeRegion && 
-	XEqualRegion (r, draw->clip.region))
-    {
-	return True;
-    }
-
-    /*
-     * Duplicate the region so future changes can be short circuited
-     */
-    if (r)
-    {
-	n = XCreateRegion ();
-	if (n)
-	{
-	    if (!XUnionRegion (n, r, n))
-	    {
-		XDestroyRegion (n);
-		return False;
-	    }
-	}
-    }
-
-    /*
-     * Destroy existing clip
-     */
-    switch (draw->clip_type) {
-    case XftClipTypeRegion:
-	XDestroyRegion (draw->clip.region);
-	break;
-    case XftClipTypeRectangles:
-	free (draw->clip.rect);
-	break;
-    case XftClipTypeNone:
-	break;
-    }
-    
-    /*
-     * Set the clip
-     */
-    if (n)
-    {
-	draw->clip_type = XftClipTypeRegion;
-	draw->clip.region = n;
-    }
-    else
-    {
-	draw->clip_type = XftClipTypeNone;
-    }
-    /*
-     * Apply new clip to existing objects
-     */
-    if (draw->render.pict)
-    {
-	if (n)
-	    XRenderSetPictureClipRegion (draw->dpy, draw->render.pict, n);
-	else
-	{
-	    XRenderPictureAttributes	pa;
-	    pa.clip_mask = None;
-	    XRenderChangePicture (draw->dpy, draw->render.pict,
-				  CPClipMask, &pa);
-	}
-    }
-    if (draw->core.gc)
-    {
-	if (n)
-	    XSetRegion (draw->dpy, draw->core.gc, draw->clip.region);
-	else
-	    XSetClipMask (draw->dpy, draw->core.gc, None);
-    }
-    return True;
-}
-
-_X_EXPORT Bool
-XftDrawSetClipRectangles (XftDraw		*draw,
-			  int			xOrigin,
-			  int			yOrigin,
-			  _Xconst XRectangle	*rects,
-			  int			n)
-{
-    XftClipRect	*new = NULL;
-
-    /*
-     * Check for quick exit
-     */
-    if (draw->clip_type == XftClipTypeRectangles &&
-	draw->clip.rect->n == n &&
-	(n == 0 || (draw->clip.rect->xOrigin == xOrigin &&
-		    draw->clip.rect->yOrigin == yOrigin)) &&
-	!memcmp (XftClipRects (draw->clip.rect), rects, n * sizeof (XRectangle)))
-    {
-	return True;
-    }
-
-    /*
-     * Duplicate the region so future changes can be short circuited
-     */
-    new = malloc (sizeof (XftClipRect) + n * sizeof (XRectangle));
-    if (!new)
-	return False;
-
-    new->n = n;
-    new->xOrigin = xOrigin;
-    new->yOrigin = yOrigin;
-    memcpy (XftClipRects (new), rects, n * sizeof (XRectangle));
-
-    /*
-     * Destroy existing clip
-     */
-    switch (draw->clip_type) {
-    case XftClipTypeRegion:
-	XDestroyRegion (draw->clip.region);
-	break;
-    case XftClipTypeRectangles:
-	free (draw->clip.rect);
-	break;
-    case XftClipTypeNone:
-	break;
-    }
-    
-    /*
-     * Set the clip
-     */
-    draw->clip_type = XftClipTypeRectangles;
-    draw->clip.rect = new;
-    /*
-     * Apply new clip to existing objects
-     */
-    if (draw->render.pict)
-    {
-	XRenderSetPictureClipRectangles (draw->dpy, draw->render.pict,
-					 new->xOrigin,
-					 new->yOrigin,
-					 XftClipRects(new),
-					 new->n);
-    }
-    if (draw->core.gc)
-    {
-	XSetClipRectangles (draw->dpy, draw->core.gc,
-			    new->xOrigin,
-			    new->yOrigin,
-			    XftClipRects (new),
-			    new->n,
-			    Unsorted);
-    }
-    return True;
-}
-
-_X_EXPORT void
-XftDrawSetSubwindowMode (XftDraw *draw, int mode)
-{
-    if (mode == draw->subwindow_mode)
-	return;
-    draw->subwindow_mode = mode;
-    if (draw->render.pict)
-    {
-	XRenderPictureAttributes    pa;
-
-	pa.subwindow_mode = mode;
-	XRenderChangePicture (draw->dpy, draw->render.pict, 
-			      CPSubwindowMode, &pa);
-    }
-    if (draw->core.gc)
-	XSetSubwindowMode (draw->dpy, draw->core.gc, mode);
-}
+/*

+ * Copyright © 2000 Keith Packard

+ *

+ * Permission to use, copy, modify, distribute, and sell this software and its

+ * documentation for any purpose is hereby granted without fee, provided that

+ * the above copyright notice appear in all copies and that both that

+ * copyright notice and this permission notice appear in supporting

+ * documentation, and that the name of Keith Packard not be used in

+ * advertising or publicity pertaining to distribution of the software without

+ * specific, written prior permission.  Keith Packard makes no

+ * representations about the suitability of this software for any purpose.  It

+ * is provided "as is" without express or implied warranty.

+ *

+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR

+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,

+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

+ * PERFORMANCE OF THIS SOFTWARE.

+ */

+

+#include "xftint.h"

+

+/*

+ * Ok, this is a pain.  To share source pictures across multiple destinations,

+ * the screen for each drawable must be discovered.

+ */

+

+static int

+_XftDrawScreen (Display *dpy, Drawable drawable, Visual *visual)

+{

+    int		    s;

+    Window	    root;

+    int		    x, y;

+    unsigned int    width, height, borderWidth, depth;

+    /* Special case the most common environment */

+    if (ScreenCount (dpy) == 1)

+	return 0;

+    /*

+     * If we've got a visual, look for the screen that points at it.

+     * This requires no round trip.

+     */

+    if (visual)

+    {

+	for (s = 0; s < ScreenCount (dpy); s++)

+	{

+	    XVisualInfo	template, *ret;

+	    int		nret;

+

+	    template.visualid = visual->visualid;

+	    template.screen = s;

+	    ret = XGetVisualInfo (dpy, VisualIDMask|VisualScreenMask,

+				  &template, &nret);

+	    if (ret)

+	    {

+		XFree (ret);

+		return s;

+	    }

+	}

+    }

+    /*

+     * Otherwise, as the server for the drawable geometry and find

+     * the screen from the root window.

+     * This takes a round trip.

+     */

+    if (XGetGeometry (dpy, drawable, &root, &x, &y, &width, &height,

+		      &borderWidth, &depth))

+    {

+	for (s = 0; s < ScreenCount (dpy); s++)

+	{

+	    if (RootWindow (dpy, s) == root)

+		return s;

+	}

+    }

+    /*

+     * Make a guess -- it's probably wrong, but then the app probably

+     * handed us a bogus drawable in this case

+     */

+    return 0;

+}

+

+_X_HIDDEN unsigned int

+XftDrawDepth (XftDraw *draw)

+{

+    if (!draw->depth)

+    {

+	Window		    root;

+	int		    x, y;

+	unsigned int	    width, height, borderWidth, depth;

+	if (XGetGeometry (draw->dpy, draw->drawable, 

+			  &root, &x, &y, &width, &height,

+			  &borderWidth, &depth))

+	    draw->depth = depth;

+    }

+    return draw->depth;

+}

+

+_X_HIDDEN unsigned int

+XftDrawBitsPerPixel (XftDraw	*draw)

+{

+    if (!draw->bits_per_pixel)

+    {

+	XPixmapFormatValues *formats;

+	int		    nformats;

+	unsigned int	    depth;

+	

+	if ((depth = XftDrawDepth (draw)) &&

+	    (formats = XListPixmapFormats (draw->dpy, &nformats)))

+	{

+	    int	i;

+

+	    for (i = 0; i < nformats; i++)

+	    {

+		if (formats[i].depth == depth)

+		{

+		    draw->bits_per_pixel = formats[i].bits_per_pixel;

+		    break;

+		}

+	    }

+	    XFree (formats);

+	}

+    }

+    return draw->bits_per_pixel;

+}

+

+_X_EXPORT XftDraw *

+XftDrawCreate (Display   *dpy,

+	       Drawable  drawable,

+	       Visual    *visual,

+	       Colormap  colormap)

+{

+    XftDraw	*draw;

+

+    draw = (XftDraw *) malloc (sizeof (XftDraw));

+    if (!draw)

+	return NULL;

+    

+    draw->dpy = dpy;

+    draw->drawable = drawable;

+    draw->screen = _XftDrawScreen (dpy, drawable, visual);

+    draw->depth = 0;		/* don't find out unless we need to know */

+    draw->bits_per_pixel = 0;	/* don't find out unless we need to know */

+    draw->visual = visual;

+    draw->colormap = colormap;

+    draw->render.pict = 0;

+    draw->core.gc = NULL;

+    draw->core.use_pixmap = 0;

+    draw->clip_type = XftClipTypeNone;

+    draw->subwindow_mode = ClipByChildren;

+    XftMemAlloc (XFT_MEM_DRAW, sizeof (XftDraw));

+    return draw;

+}

+

+_X_EXPORT XftDraw *

+XftDrawCreateBitmap (Display	*dpy,

+		     Pixmap	bitmap)

+{

+    XftDraw	*draw;

+

+    draw = (XftDraw *) malloc (sizeof (XftDraw));

+    if (!draw)

+	return NULL;

+    draw->dpy = dpy;

+    draw->drawable = (Drawable) bitmap;

+    draw->screen = _XftDrawScreen (dpy, bitmap, NULL);

+    draw->depth = 1;

+    draw->bits_per_pixel = 1;

+    draw->visual = NULL;

+    draw->colormap = 0;

+    draw->render.pict = 0;

+    draw->core.gc = NULL;

+    draw->core.use_pixmap = 0;

+    draw->clip_type = XftClipTypeNone;

+    draw->subwindow_mode = ClipByChildren;

+    XftMemAlloc (XFT_MEM_DRAW, sizeof (XftDraw));

+    return draw;

+}

+

+_X_EXPORT XftDraw *

+XftDrawCreateAlpha (Display *dpy,

+		    Pixmap  pixmap,

+		    int	    depth)

+{

+    XftDraw	*draw;

+

+    draw = (XftDraw *) malloc (sizeof (XftDraw));

+    if (!draw)

+	return NULL;

+    draw->dpy = dpy;

+    draw->drawable = (Drawable) pixmap;

+    draw->screen = _XftDrawScreen (dpy, pixmap, NULL);

+    draw->depth = depth;

+    draw->bits_per_pixel = 0;	/* don't find out until we need it */

+    draw->visual = NULL;

+    draw->colormap = 0;

+    draw->render.pict = 0;

+    draw->core.gc = NULL;

+    draw->core.use_pixmap = 0;

+    draw->clip_type = XftClipTypeNone;

+    draw->subwindow_mode = ClipByChildren;

+    XftMemAlloc (XFT_MEM_DRAW, sizeof (XftDraw));

+    return draw;

+}

+

+static XRenderPictFormat *

+_XftDrawFormat (XftDraw	*draw)

+{

+    XftDisplayInfo  *info = _XftDisplayInfoGet (draw->dpy, True);

+

+    if (!info || !info->hasRender)

+	return NULL;

+

+    if (draw->visual == NULL)

+    {

+	XRenderPictFormat   pf;

+

+	pf.type = PictTypeDirect;

+	pf.depth = XftDrawDepth (draw);

+	pf.direct.alpha = 0;

+	pf.direct.alphaMask = (1 << pf.depth) - 1;

+	return XRenderFindFormat (draw->dpy,

+				  (PictFormatType|

+				   PictFormatDepth|

+				   PictFormatAlpha|

+				   PictFormatAlphaMask),

+				  &pf,

+				  0);

+    }

+    else

+	return XRenderFindVisualFormat (draw->dpy, draw->visual);

+}

+

+_X_EXPORT void

+XftDrawChange (XftDraw	*draw,

+	       Drawable	drawable)

+{

+    draw->drawable = drawable;

+    if (draw->render.pict)

+    {

+	XRenderFreePicture (draw->dpy, draw->render.pict);

+	draw->render.pict = 0;

+    }

+    if (draw->core.gc)

+    {

+	XFreeGC (draw->dpy, draw->core.gc);

+	draw->core.gc = NULL;

+    }

+}

+

+_X_EXPORT Display *

+XftDrawDisplay (XftDraw *draw)

+{

+    return draw->dpy;

+}

+

+_X_EXPORT Drawable

+XftDrawDrawable (XftDraw *draw)

+{

+    return draw->drawable;

+}

+

+_X_EXPORT Colormap

+XftDrawColormap (XftDraw *draw)

+{

+    return draw->colormap;

+}

+

+_X_EXPORT Visual *

+XftDrawVisual (XftDraw *draw)

+{

+    return draw->visual;

+}

+

+_X_EXPORT void

+XftDrawDestroy (XftDraw	*draw)

+{

+    if (draw->render.pict)

+	XRenderFreePicture (draw->dpy, draw->render.pict);

+    if (draw->core.gc)

+	XFreeGC (draw->dpy, draw->core.gc);

+    switch (draw->clip_type) {

+    case XftClipTypeRegion:

+	XDestroyRegion (draw->clip.region);

+	break;

+    case XftClipTypeRectangles:

+	free (draw->clip.rect);

+	break;

+    case XftClipTypeNone:

+	break;

+    }

+    XftMemFree (XFT_MEM_DRAW, sizeof (XftDraw));

+    free (draw);

+}

+

+_X_EXPORT Picture

+XftDrawSrcPicture (XftDraw *draw, _Xconst XftColor *color)

+{

+    Display	    *dpy = draw->dpy;

+    XftDisplayInfo  *info = _XftDisplayInfoGet (dpy, True);

+    int		    i;

+    XftColor	    bitmapColor;

+

+    if (!info || !info->solidFormat)

+	return 0;

+    

+    /*

+     * Monochrome targets require special handling; the PictOp controls

+     * the color, and the color must be opaque

+     */

+    if (!draw->visual && draw->depth == 1)

+    {

+	bitmapColor.color.alpha = 0xffff;

+	bitmapColor.color.red   = 0xffff;

+	bitmapColor.color.green = 0xffff;

+	bitmapColor.color.blue  = 0xffff;

+	color = &bitmapColor;

+    }

+

+    /*

+     * See if there's one already available

+     */

+    for (i = 0; i < XFT_NUM_SOLID_COLOR; i++)

+    {

+	if (info->colors[i].pict && 

+	    info->colors[i].screen == draw->screen &&

+	    !memcmp ((void *) &color->color, 

+		     (void *) &info->colors[i].color,

+		     sizeof (XRenderColor)))

+	    return info->colors[i].pict;

+    }

+    /*

+     * Pick one to replace at random

+     */

+    i = (unsigned int) rand () % XFT_NUM_SOLID_COLOR;

+    /*

+     * Recreate if it was for the wrong screen

+     */

+    if (info->colors[i].screen != draw->screen && info->colors[i].pict)

+    {

+	XRenderFreePicture (dpy, info->colors[i].pict);

+	info->colors[i].pict = 0;

+    }

+    /*

+     * Create picture if necessary

+     */

+    if (!info->colors[i].pict)

+    {

+	Pixmap			    pix;

+        XRenderPictureAttributes    pa;

+	

+	pix = XCreatePixmap (dpy, RootWindow (dpy, draw->screen), 1, 1,

+			     info->solidFormat->depth);

+	pa.repeat = True;

+	info->colors[i].pict = XRenderCreatePicture (draw->dpy,

+						     pix,

+						     info->solidFormat,

+						     CPRepeat, &pa);

+	XFreePixmap (dpy, pix);

+    }

+    /*

+     * Set to the new color

+     */

+    info->colors[i].color = color->color;

+    info->colors[i].screen = draw->screen;

+    XRenderFillRectangle (dpy, PictOpSrc,

+			  info->colors[i].pict,

+			  &color->color, 0, 0, 1, 1);

+    return info->colors[i].pict;

+}

+

+static int

+_XftDrawOp (_Xconst XftDraw *draw, _Xconst XftColor *color)

+{

+    if (draw->visual || draw->depth != 1)

+	return PictOpOver;

+    if (color->color.alpha >= 0x8000)

+	return PictOpOver;

+    return PictOpOutReverse;

+}

+

+static FcBool

+_XftDrawRenderPrepare (XftDraw	*draw)

+{

+    if (!draw->render.pict)

+    {

+	XRenderPictFormat	    *format;

+	XRenderPictureAttributes    pa;

+	unsigned long		    mask = 0;

+

+	format = _XftDrawFormat (draw);

+	if (!format)

+	    return FcFalse;

+	

+	if (draw->subwindow_mode == IncludeInferiors)

+	{

+	    pa.subwindow_mode = IncludeInferiors;

+	    mask |= CPSubwindowMode;

+	}

+	draw->render.pict = XRenderCreatePicture (draw->dpy, draw->drawable,

+						  format, mask, &pa);

+	if (!draw->render.pict)

+	    return FcFalse;

+	switch (draw->clip_type) {

+	case XftClipTypeRegion:

+	    XRenderSetPictureClipRegion (draw->dpy, draw->render.pict,

+					 draw->clip.region);

+	    break;

+	case XftClipTypeRectangles:

+	    XRenderSetPictureClipRectangles (draw->dpy, draw->render.pict,

+					     draw->clip.rect->xOrigin,

+					     draw->clip.rect->yOrigin,

+					     XftClipRects(draw->clip.rect),

+					     draw->clip.rect->n);

+	    break;

+	case XftClipTypeNone:

+	    break;

+	}

+    }

+    return FcTrue;

+}

+

+static FcBool

+_XftDrawCorePrepare (XftDraw *draw, _Xconst XftColor *color)

+{

+    if (!draw->core.gc)

+    {

+	XGCValues	gcv;

+	unsigned long	mask = 0;

+	if (draw->subwindow_mode == IncludeInferiors)

+	{

+	    gcv.subwindow_mode = IncludeInferiors;

+	    mask |= GCSubwindowMode;

+	}

+	draw->core.gc = XCreateGC (draw->dpy, draw->drawable, mask, &gcv);

+	if (!draw->core.gc)

+	    return FcFalse;

+	switch (draw->clip_type) {

+	case XftClipTypeRegion:

+	    XSetRegion (draw->dpy, draw->core.gc, draw->clip.region);

+	    break;

+	case XftClipTypeRectangles:

+	    XSetClipRectangles (draw->dpy, draw->core.gc,

+				draw->clip.rect->xOrigin,

+				draw->clip.rect->yOrigin,

+				XftClipRects (draw->clip.rect),

+				draw->clip.rect->n,

+				Unsorted);

+	    break;

+	case XftClipTypeNone:

+	    break;

+	}

+    }

+    XSetForeground (draw->dpy, draw->core.gc, color->pixel);

+    return FcTrue;

+}

+			

+_X_EXPORT Picture

+XftDrawPicture (XftDraw *draw)

+{

+    if (!_XftDrawRenderPrepare (draw))

+	return 0;

+    return draw->render.pict;

+}

+

+#define NUM_LOCAL   1024

+

+_X_EXPORT void

+XftDrawGlyphs (XftDraw		*draw,

+	       _Xconst XftColor	*color,

+	       XftFont		*pub,

+	       int		x,

+	       int		y,

+	       _Xconst FT_UInt	*glyphs,

+	       int		nglyphs)

+{

+    XftFontInt	*font = (XftFontInt *) pub;

+

+    if (font->format)

+    {

+	Picture	    src;

+	

+	if (_XftDrawRenderPrepare (draw) &&

+	    (src = XftDrawSrcPicture (draw, color)))

+	    XftGlyphRender (draw->dpy, _XftDrawOp (draw, color),

+			     src, pub, draw->render.pict,

+			     0, 0, x, y, glyphs, nglyphs);

+    }

+    else

+    {

+	if (_XftDrawCorePrepare (draw, color))

+	    XftGlyphCore (draw, color, pub, x, y, glyphs, nglyphs);

+    }

+}

+

+_X_EXPORT void

+XftDrawString8 (XftDraw		    *draw,

+		_Xconst XftColor    *color,

+		XftFont		    *pub,

+		int		    x, 

+		int		    y,

+		_Xconst FcChar8	    *string,

+		int		    len)

+{

+    FT_UInt	    *glyphs, glyphs_local[NUM_LOCAL];

+    int		    i;

+

+    if (XftDebug () & XFT_DBG_DRAW)

+	printf ("DrawString \"%*.*s\"\n", len, len, string);

+    

+    if (len <= NUM_LOCAL)

+	glyphs = glyphs_local;

+    else

+    {

+	glyphs = malloc (len * sizeof (FT_UInt));

+	if (!glyphs)

+	    return;

+    }

+    for (i = 0; i < len; i++)

+	glyphs[i] = XftCharIndex (draw->dpy, pub, string[i]);

+    XftDrawGlyphs (draw, color, pub, x, y, glyphs, len);

+    if (glyphs != glyphs_local)

+	free (glyphs);

+}

+

+_X_EXPORT void

+XftDrawString16 (XftDraw	    *draw,

+		 _Xconst XftColor   *color,

+		 XftFont	    *pub,

+		 int		    x,

+		 int		    y,

+		 _Xconst FcChar16   *string,

+		 int		    len)

+{

+    FT_UInt	    *glyphs, glyphs_local[NUM_LOCAL];

+    int		    i;

+

+    if (len <= NUM_LOCAL)

+	glyphs = glyphs_local;

+    else

+    {

+	glyphs = malloc (len * sizeof (FT_UInt));

+	if (!glyphs)

+	    return;

+    }

+    for (i = 0; i < len; i++)

+	glyphs[i] = XftCharIndex (draw->dpy, pub, string[i]);

+    

+    XftDrawGlyphs (draw, color, pub, x, y, glyphs, len);

+    if (glyphs != glyphs_local)

+	free (glyphs);

+}

+

+_X_EXPORT void

+XftDrawString32 (XftDraw	    *draw,

+		 _Xconst XftColor   *color,

+		 XftFont	    *pub,

+		 int		    x,

+		 int		    y,

+		 _Xconst FcChar32   *string,

+		 int		    len)

+{

+    FT_UInt	    *glyphs, glyphs_local[NUM_LOCAL];

+    int		    i;

+

+    if (len <= NUM_LOCAL)

+	glyphs = glyphs_local;

+    else

+    {

+	glyphs = malloc (len * sizeof (FT_UInt));

+	if (!glyphs)

+	    return;

+    }

+    for (i = 0; i < len; i++)

+	glyphs[i] = XftCharIndex (draw->dpy, pub, string[i]);

+    

+    XftDrawGlyphs (draw, color, pub, x, y, glyphs, len);

+    if (glyphs != glyphs_local)

+	free (glyphs);

+}

+

+_X_EXPORT void

+XftDrawStringUtf8 (XftDraw	    *draw,

+		   _Xconst XftColor *color,

+		   XftFont	    *pub,

+		   int		    x, 

+		   int		    y,

+		   _Xconst FcChar8  *string,

+		   int		    len)

+{

+    FT_UInt	    *glyphs, *glyphs_new, glyphs_local[NUM_LOCAL];

+    FcChar32	    ucs4;

+    int		    i;

+    int		    l;

+    int		    size;

+

+    i = 0;

+    glyphs = glyphs_local;

+    size = NUM_LOCAL;

+    while (len && (l = FcUtf8ToUcs4 (string, &ucs4, len)) > 0)

+    {

+	if (i == size)

+	{

+	    glyphs_new = malloc (size * 2 * sizeof (FT_UInt));

+	    if (!glyphs_new)

+	    {

+		if (glyphs != glyphs_local)

+		    free (glyphs);

+		return;

+	    }

+	    memcpy (glyphs_new, glyphs, size * sizeof (FT_UInt));

+	    size *= 2;

+	    if (glyphs != glyphs_local)

+		free (glyphs);

+	    glyphs = glyphs_new;

+	}

+	glyphs[i++] = XftCharIndex (draw->dpy, pub, ucs4);

+	string += l;

+	len -= l;

+    }

+    XftDrawGlyphs (draw, color, pub, x, y, glyphs, i);

+    if (glyphs != glyphs_local)

+	free (glyphs);

+}

+

+_X_EXPORT void

+XftDrawStringUtf16 (XftDraw		*draw,

+		    _Xconst XftColor	*color,

+		    XftFont		*pub,

+		    int			x,

+		    int			y,

+		    _Xconst FcChar8	*string,

+		    FcEndian		endian,

+		    int			len)

+{

+    FT_UInt	    *glyphs, *glyphs_new, glyphs_local[NUM_LOCAL];

+    FcChar32	    ucs4;

+    int		    i;

+    int		    l;

+    int		    size;

+

+    i = 0;

+    glyphs = glyphs_local;

+    size = NUM_LOCAL;

+    while (len && (l = FcUtf16ToUcs4 (string, endian, &ucs4, len)) > 0)

+    {

+	if (i == size)

+	{

+	    glyphs_new = malloc (size * 2 * sizeof (FT_UInt));

+	    if (!glyphs_new)

+	    {

+		if (glyphs != glyphs_local)

+		    free (glyphs);

+		return;

+	    }

+	    memcpy (glyphs_new, glyphs, size * sizeof (FT_UInt));

+	    size *= 2;

+	    if (glyphs != glyphs_local)

+		free (glyphs);

+	    glyphs = glyphs_new;

+	}

+	glyphs[i++] = XftCharIndex (draw->dpy, pub, ucs4);

+	string += l;

+	len -= l;

+    }

+    XftDrawGlyphs (draw, color, pub, x, y, glyphs, i);

+    if (glyphs != glyphs_local)

+	free (glyphs);

+}

+

+_X_EXPORT void

+XftDrawGlyphSpec (XftDraw		*draw,

+		  _Xconst XftColor	*color,

+		  XftFont		*pub,

+		  _Xconst XftGlyphSpec	*glyphs,

+		  int			len)

+{

+    XftFontInt	*font = (XftFontInt *) pub;

+

+    if (font->format)

+    {

+	Picture	src;

+

+	if (_XftDrawRenderPrepare (draw) &&

+	    (src = XftDrawSrcPicture (draw, color)))

+	{

+	    XftGlyphSpecRender (draw->dpy, _XftDrawOp (draw, color),

+				src, pub, draw->render.pict,

+				0, 0, glyphs, len);

+	}

+    }

+    else

+    {

+	if (_XftDrawCorePrepare (draw, color))

+	    XftGlyphSpecCore (draw, color, pub, glyphs, len);

+    }

+}

+

+_X_EXPORT void

+XftDrawGlyphFontSpec (XftDraw			*draw,

+		      _Xconst XftColor		*color,

+		      _Xconst XftGlyphFontSpec	*glyphs,

+		      int			len)

+{

+    int		i;

+    int		start;

+

+    i = 0;

+    while (i < len)

+    {

+	start = i;

+	if (((XftFontInt *) glyphs[i].font)->format)

+	{

+	    Picture	src;

+	    while (i < len && ((XftFontInt *) glyphs[i].font)->format)

+		i++;

+	    if (_XftDrawRenderPrepare (draw) &&

+		(src = XftDrawSrcPicture (draw, color)))

+	    {

+		XftGlyphFontSpecRender (draw->dpy, _XftDrawOp (draw, color),

+					src, draw->render.pict,

+					0, 0, glyphs + start , i - start);

+	    }

+	}

+	else

+	{

+	    while (i < len && !((XftFontInt *) glyphs[i].font)->format)

+		i++;

+	    if (_XftDrawCorePrepare (draw, color))

+		XftGlyphFontSpecCore (draw, color, glyphs + start, i - start);

+	}

+    }

+}

+

+_X_EXPORT void

+XftDrawCharSpec (XftDraw		*draw,

+		 _Xconst XftColor	*color,

+		 XftFont		*pub,

+		 _Xconst XftCharSpec	*chars,

+		 int			len)

+{

+    XftGlyphSpec    *glyphs, glyphs_local[NUM_LOCAL];

+    int		    i;

+

+    if (len <= NUM_LOCAL)

+	glyphs = glyphs_local;

+    else

+    {

+	glyphs = malloc (len * sizeof (XftGlyphSpec));

+	if (!glyphs)

+	    return;

+    }

+    for (i = 0; i < len; i++)

+    {

+	glyphs[i].glyph = XftCharIndex(draw->dpy, pub, chars[i].ucs4);

+	glyphs[i].x = chars[i].x;

+	glyphs[i].y = chars[i].y;

+    }

+

+    XftDrawGlyphSpec (draw, color, pub, glyphs, len);

+    if (glyphs != glyphs_local)

+	free (glyphs);

+}

+

+_X_EXPORT void

+XftDrawCharFontSpec (XftDraw			*draw,

+		     _Xconst XftColor		*color,

+		     _Xconst XftCharFontSpec	*chars,

+		     int			len)

+{

+    XftGlyphFontSpec	*glyphs, glyphs_local[NUM_LOCAL];

+    int			i;

+

+    if (len <= NUM_LOCAL)

+	glyphs = glyphs_local;

+    else

+    {

+	glyphs = malloc (len * sizeof (XftGlyphFontSpec));

+	if (!glyphs)

+	    return;

+    }

+    for (i = 0; i < len; i++)

+    {

+	glyphs[i].font = chars[i].font;

+	glyphs[i].glyph = XftCharIndex(draw->dpy, glyphs[i].font, chars[i].ucs4);

+	glyphs[i].x = chars[i].x;

+	glyphs[i].y = chars[i].y;

+    }

+

+    XftDrawGlyphFontSpec (draw, color, glyphs, len);

+    if (glyphs != glyphs_local)

+	free (glyphs);

+}

+

+_X_EXPORT void

+XftDrawRect (XftDraw		*draw,

+	     _Xconst XftColor	*color,

+	     int		x, 

+	     int		y,

+	     unsigned int	width,

+	     unsigned int	height)

+{

+    if (_XftDrawRenderPrepare (draw))

+    {

+	XRenderFillRectangle (draw->dpy, PictOpSrc, draw->render.pict,

+			      &color->color, x, y, width, height);

+    }

+    else if (_XftDrawCorePrepare (draw, color))

+    {

+	/* note: not XftRectCore() */

+	XSetForeground (draw->dpy, draw->core.gc, color->pixel);

+	XFillRectangle (draw->dpy, draw->drawable, draw->core.gc,

+			x, y, width, height);

+    }

+}

+

+_X_EXPORT Bool

+XftDrawSetClip (XftDraw	*draw,

+		Region	r)

+{

+    Region			n = NULL;

+

+    /*

+     * Check for quick exits

+     */

+    if (!r && draw->clip_type == XftClipTypeNone)

+	return True;

+    

+    if (r && 

+	draw->clip_type == XftClipTypeRegion && 

+	XEqualRegion (r, draw->clip.region))

+    {

+	return True;

+    }

+

+    /*

+     * Duplicate the region so future changes can be short circuited

+     */

+    if (r)

+    {

+	n = XCreateRegion ();

+	if (n)

+	{

+	    if (!XUnionRegion (n, r, n))

+	    {

+		XDestroyRegion (n);

+		return False;

+	    }

+	}

+    }

+

+    /*

+     * Destroy existing clip

+     */

+    switch (draw->clip_type) {

+    case XftClipTypeRegion:

+	XDestroyRegion (draw->clip.region);

+	break;

+    case XftClipTypeRectangles:

+	free (draw->clip.rect);

+	break;

+    case XftClipTypeNone:

+	break;

+    }

+    

+    /*

+     * Set the clip

+     */

+    if (n)

+    {

+	draw->clip_type = XftClipTypeRegion;

+	draw->clip.region = n;

+    }

+    else

+    {

+	draw->clip_type = XftClipTypeNone;

+    }

+    /*

+     * Apply new clip to existing objects

+     */

+    if (draw->render.pict)

+    {

+	if (n)

+	    XRenderSetPictureClipRegion (draw->dpy, draw->render.pict, n);

+	else

+	{

+	    XRenderPictureAttributes	pa;

+	    pa.clip_mask = None;

+	    XRenderChangePicture (draw->dpy, draw->render.pict,

+				  CPClipMask, &pa);

+	}

+    }

+    if (draw->core.gc)

+    {

+	if (n)

+	    XSetRegion (draw->dpy, draw->core.gc, draw->clip.region);

+	else

+	    XSetClipMask (draw->dpy, draw->core.gc, None);

+    }

+    return True;

+}

+

+_X_EXPORT Bool

+XftDrawSetClipRectangles (XftDraw		*draw,

+			  int			xOrigin,

+			  int			yOrigin,

+			  _Xconst XRectangle	*rects,

+			  int			n)

+{

+    XftClipRect	*new = NULL;

+

+    /*

+     * Check for quick exit

+     */

+    if (draw->clip_type == XftClipTypeRectangles &&

+	draw->clip.rect->n == n &&

+	(n == 0 || (draw->clip.rect->xOrigin == xOrigin &&

+		    draw->clip.rect->yOrigin == yOrigin)) &&

+	!memcmp (XftClipRects (draw->clip.rect), rects, n * sizeof (XRectangle)))

+    {

+	return True;

+    }

+

+    /*

+     * Duplicate the region so future changes can be short circuited

+     */

+    new = malloc (sizeof (XftClipRect) + n * sizeof (XRectangle));

+    if (!new)

+	return False;

+

+    new->n = n;

+    new->xOrigin = xOrigin;

+    new->yOrigin = yOrigin;

+    memcpy (XftClipRects (new), rects, n * sizeof (XRectangle));

+

+    /*

+     * Destroy existing clip

+     */

+    switch (draw->clip_type) {

+    case XftClipTypeRegion:

+	XDestroyRegion (draw->clip.region);

+	break;

+    case XftClipTypeRectangles:

+	free (draw->clip.rect);

+	break;

+    case XftClipTypeNone:

+	break;

+    }

+    

+    /*

+     * Set the clip

+     */

+    draw->clip_type = XftClipTypeRectangles;

+    draw->clip.rect = new;

+    /*

+     * Apply new clip to existing objects

+     */

+    if (draw->render.pict)

+    {

+	XRenderSetPictureClipRectangles (draw->dpy, draw->render.pict,

+					 new->xOrigin,

+					 new->yOrigin,

+					 XftClipRects(new),

+					 new->n);

+    }

+    if (draw->core.gc)

+    {

+	XSetClipRectangles (draw->dpy, draw->core.gc,

+			    new->xOrigin,

+			    new->yOrigin,

+			    XftClipRects (new),

+			    new->n,

+			    Unsorted);

+    }

+    return True;

+}

+

+_X_EXPORT void

+XftDrawSetSubwindowMode (XftDraw *draw, int mode)

+{

+    if (mode == draw->subwindow_mode)

+	return;

+    draw->subwindow_mode = mode;

+    if (draw->render.pict)

+    {

+	XRenderPictureAttributes    pa;

+

+	pa.subwindow_mode = mode;

+	XRenderChangePicture (draw->dpy, draw->render.pict, 

+			      CPSubwindowMode, &pa);

+    }

+    if (draw->core.gc)

+	XSetSubwindowMode (draw->dpy, draw->core.gc, mode);

+}