Added libXft-2.2.0 fontconfig-2.8.0 libXrender-0.9.6

18 files changed, 7668 insertions, 0 deletions

diff --git a/libXft/src/Makefile.am b/libXft/src/Makefile.am
new file mode 100644
index 000000000..d9604a02c
--- /dev/null
+++ b/libXft/src/Makefile.am
@@ -0,0 +1,32 @@
+AM_CFLAGS = $(FONTCONFIG_CFLAGS) $(FREETYPE_CFLAGS) $(XRENDER_CFLAGS) \
+            $(CWARNFLAGS) -I$(top_builddir)/include/X11/Xft
+
+lib_LTLIBRARIES = libXft.la
+
+libXft_la_SOURCES = xftint.h \
+                    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
+
+libXft_la_LIBADD = @FONTCONFIG_LIBS@ @FREETYPE_LIBS@ @XRENDER_LIBS@
+
+# -version-number requires libtool >= 1.5
+libXft_la_LDFLAGS = -version-number $(XFT_LT_VERSION) -no-undefined
+
+libXftincludedir = $(includedir)/X11/Xft
+libXftinclude_HEADERS = \
+	$(top_builddir)/include/X11/Xft/Xft.h		\
+	$(top_srcdir)/include/X11/Xft/XftCompat.h
diff --git a/libXft/src/xftcolor.c b/libXft/src/xftcolor.c
new file mode 100644
index 000000000..77872efa4
--- /dev/null
+++ b/libXft/src/xftcolor.c
@@ -0,0 +1,123 @@
+/*
+ * 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_EXPORT Bool
+XftColorAllocName (Display  *dpy,
+		   _Xconst Visual   *visual,
+		   Colormap cmap,
+		   _Xconst char	    *name,
+		   XftColor *result)
+{
+    XColor  screen, exact;
+    
+    if (!XAllocNamedColor (dpy, cmap, name, &screen, &exact))
+    {
+	/* XXX stick standard colormap stuff here */
+	return False;
+    }
+
+    result->pixel = screen.pixel;
+    result->color.red = exact.red;
+    result->color.green = exact.green;
+    result->color.blue = exact.blue;
+    result->color.alpha = 0xffff;
+    return True;
+}
+
+static short
+maskbase (unsigned long m)
+{
+    short        i;
+
+    if (!m)
+	return 0;
+    i = 0;
+    while (!(m&1))
+    {
+	m>>=1;
+	i++;
+    }
+    return i;
+}
+
+static short
+masklen (unsigned long m)
+{
+    unsigned long y;
+
+    y = (m >> 1) &033333333333;
+    y = m - y - ((y >>1) & 033333333333);
+    return (short) (((y + (y >> 3)) & 030707070707) % 077);
+}
+
+_X_EXPORT Bool
+XftColorAllocValue (Display	    *dpy,
+		    Visual	    *visual,
+		    Colormap	    cmap,
+		    _Xconst XRenderColor    *color,
+		    XftColor	    *result)
+{
+    if (visual->class == TrueColor)
+    {
+	int	    red_shift, red_len;
+	int	    green_shift, green_len;
+	int	    blue_shift, blue_len;
+
+	red_shift = maskbase (visual->red_mask);
+	red_len = masklen (visual->red_mask);
+	green_shift = maskbase (visual->green_mask);
+	green_len = masklen (visual->green_mask);
+	blue_shift = maskbase (visual->blue_mask);
+	blue_len = masklen (visual->blue_mask);
+	result->pixel = (((color->red >> (16 - red_len)) << red_shift) |
+			 ((color->green >> (16 - green_len)) << green_shift) |
+			 ((color->blue >> (16 - blue_len)) << blue_shift));
+    }
+    else
+    {
+	XColor  xcolor;
+	    
+	xcolor.red = color->red;
+	xcolor.green = color->green;
+	xcolor.blue = color->blue;
+	if (!XAllocColor (dpy, cmap, &xcolor))
+	    return False;
+	result->pixel = xcolor.pixel;
+    }
+    result->color.red = color->red;
+    result->color.green = color->green;
+    result->color.blue = color->blue;
+    result->color.alpha = color->alpha;
+    return True;
+}
+
+_X_EXPORT void 
+XftColorFree (Display	*dpy,
+	      Visual	*visual,
+	      Colormap	cmap,
+	      XftColor	*color)
+{
+    if (visual->class != TrueColor)
+	XFreeColors (dpy, cmap, &color->pixel, 1, 0);
+}
diff --git a/libXft/src/xftcore.c b/libXft/src/xftcore.c
new file mode 100644
index 000000000..3f8710929
--- /dev/null
+++ b/libXft/src/xftcore.c
@@ -0,0 +1,1373 @@
+/*
+ * 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)
+		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/xftdbg.c b/libXft/src/xftdbg.c
new file mode 100644
index 000000000..4c4b078d0
--- /dev/null
+++ b/libXft/src/xftdbg.c
@@ -0,0 +1,46 @@
+/*
+ * 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 int
+XftDebug (void)
+{
+    static int  initialized;
+    static int  debug;
+
+    if (!initialized)
+    {
+	char    *e;
+
+	initialized = 1;
+        e = getenv ("XFT_DEBUG");
+	if (e)
+	{
+	    printf ("XFT_DEBUG=%s\n", e);
+	    debug = atoi (e);
+	    if (debug <= 0)
+		debug = 1;
+	}
+    }
+    return debug;
+}
diff --git a/libXft/src/xftdpy.c b/libXft/src/xftdpy.c
new file mode 100644
index 000000000..055351586
--- /dev/null
+++ b/libXft/src/xftdpy.c
@@ -0,0 +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 = NULL;
+    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
new file mode 100644
index 000000000..ab5174973
--- /dev/null
+++ b/libXft/src/xftdraw.c
@@ -0,0 +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)
+	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);
+}
diff --git a/libXft/src/xftextent.c b/libXft/src/xftextent.c
new file mode 100644
index 000000000..71f5c1c13
--- /dev/null
+++ b/libXft/src/xftextent.c
@@ -0,0 +1,285 @@
+/*
+ * 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_EXPORT void
+XftGlyphExtents (Display	    *dpy,
+		 XftFont	    *pub,
+		 _Xconst FT_UInt    *glyphs,
+		 int		    nglyphs,
+		 XGlyphInfo	    *extents)
+{
+    XftFontInt		*font = (XftFontInt *) pub;
+    FT_UInt		missing[XFT_NMISSING];
+    int			nmissing;
+    int			n;
+    _Xconst FT_UInt	*g;
+    FT_UInt		glyph;
+    XftGlyph		*xftg;
+    FcBool		glyphs_loaded;
+    int			x, y;
+    int			left, right, top, bottom;
+    int			overall_left, overall_right;
+    int			overall_top, overall_bottom;
+    
+    g = glyphs;
+    n = nglyphs;
+    nmissing = 0;
+    glyphs_loaded = FcFalse;
+    while (n--)
+	if (XftFontCheckGlyph (dpy, pub, FcFalse, *g++, missing, &nmissing))
+	    glyphs_loaded = FcTrue;
+    if (nmissing)
+	XftFontLoadGlyphs (dpy, pub, FcFalse, missing, nmissing);
+    g = glyphs;
+    n = nglyphs;
+    xftg = NULL;
+    while (n)
+    {
+	glyph = *g++;
+	n--;
+	if (glyph < font->num_glyphs &&
+	    (xftg = font->glyphs[glyph]))
+	    break;
+    }
+    if (n == 0)
+    {
+	if (xftg)
+	    *extents = xftg->metrics;
+	else
+	    memset (extents, '\0', sizeof (*extents));
+    }
+    else
+    {
+	x = 0;
+	y = 0;
+	overall_left = x - xftg->metrics.x;
+	overall_top = y - xftg->metrics.y;
+	overall_right = overall_left + (int) xftg->metrics.width;
+	overall_bottom = overall_top + (int) xftg->metrics.height;
+	x += xftg->metrics.xOff;
+	y += xftg->metrics.yOff;
+	while (n--)
+	{
+	    glyph = *g++;
+	    if (glyph < font->num_glyphs && (xftg = font->glyphs[glyph]))
+	    {
+		left = x - xftg->metrics.x;
+		top = y - xftg->metrics.y;
+		right = left + (int) xftg->metrics.width;
+		bottom = top + (int) xftg->metrics.height;
+		if (left < overall_left)
+		    overall_left = left;
+		if (top < overall_top)
+		    overall_top = top;
+		if (right > overall_right)
+		    overall_right = right;
+		if (bottom > overall_bottom)
+		    overall_bottom = bottom;
+		x += xftg->metrics.xOff;
+		y += xftg->metrics.yOff;
+	    }
+	}
+	extents->x = -overall_left;
+	extents->y = -overall_top;
+	extents->width = overall_right - overall_left;
+	extents->height = overall_bottom - overall_top;
+	extents->xOff = x;
+	extents->yOff = y;
+    }
+    if (glyphs_loaded)
+	_XftFontManageMemory (dpy, pub);
+}
+
+#define NUM_LOCAL   1024
+
+_X_EXPORT void
+XftTextExtents8 (Display	    *dpy,
+		 XftFont	    *pub,
+		 _Xconst FcChar8    *string, 
+		 int		    len,
+		 XGlyphInfo	    *extents)
+{
+    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)
+	{
+	    memset (extents, '\0', sizeof (XGlyphInfo));
+	    return;
+	}
+    }
+    for (i = 0; i < len; i++)
+	glyphs[i] = XftCharIndex (dpy, pub, string[i]);
+    XftGlyphExtents (dpy, pub, glyphs, len, extents);
+    if (glyphs != glyphs_local)
+	free (glyphs);
+}
+
+_X_EXPORT void
+XftTextExtents16 (Display	    *dpy,
+		  XftFont	    *pub,
+		  _Xconst FcChar16  *string, 
+		  int		    len,
+		  XGlyphInfo	    *extents)
+{
+    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)
+	{
+	    memset (extents, '\0', sizeof (XGlyphInfo));
+	    return;
+	}
+    }
+    for (i = 0; i < len; i++)
+	glyphs[i] = XftCharIndex (dpy, pub, string[i]);
+    XftGlyphExtents (dpy, pub, glyphs, len, extents);
+    if (glyphs != glyphs_local)
+	free (glyphs);
+}
+
+_X_EXPORT void
+XftTextExtents32 (Display	    *dpy,
+		  XftFont	    *pub,
+		  _Xconst FcChar32  *string, 
+		  int		    len,
+		  XGlyphInfo	    *extents)
+{
+    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)
+	{
+	    memset (extents, '\0', sizeof (XGlyphInfo));
+	    return;
+	}
+    }
+    for (i = 0; i < len; i++)
+	glyphs[i] = XftCharIndex (dpy, pub, string[i]);
+    XftGlyphExtents (dpy, pub, glyphs, len, extents);
+    if (glyphs != glyphs_local)
+	free (glyphs);
+}
+
+_X_EXPORT void
+XftTextExtentsUtf8 (Display	    *dpy,
+		    XftFont	    *pub,
+		    _Xconst FcChar8 *string, 
+		    int		    len,
+		    XGlyphInfo	    *extents)
+{
+    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);
+		memset (extents, '\0', sizeof (XGlyphInfo));
+		return;
+	    }
+	    memcpy (glyphs_new, glyphs, size * sizeof (FT_UInt));
+	    size *= 2;
+	    if (glyphs != glyphs_local)
+		free (glyphs);
+	    glyphs = glyphs_new;
+	}
+	glyphs[i++] = XftCharIndex (dpy, pub, ucs4);
+	string += l;
+	len -= l;
+    }
+    XftGlyphExtents (dpy, pub, glyphs, i, extents);
+    if (glyphs != glyphs_local)
+	free (glyphs);
+}
+
+_X_EXPORT void
+XftTextExtentsUtf16 (Display		*dpy,
+		     XftFont		*pub,
+		     _Xconst FcChar8	*string, 
+		     FcEndian		endian,
+		     int		len,
+		     XGlyphInfo		*extents)
+{
+    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);
+		memset (extents, '\0', sizeof (XGlyphInfo));
+		return;
+	    }
+	    memcpy (glyphs_new, glyphs, size * sizeof (FT_UInt));
+	    size *= 2;
+	    if (glyphs != glyphs_local)
+		free (glyphs);
+	    glyphs = glyphs_new;
+	}
+	glyphs[i++] = XftCharIndex (dpy, pub, ucs4);
+	string += l;
+	len -= l;
+    }
+    XftGlyphExtents (dpy, pub, glyphs, i, extents);
+    if (glyphs != glyphs_local)
+	free (glyphs);
+}
diff --git a/libXft/src/xftfont.c b/libXft/src/xftfont.c
new file mode 100644
index 000000000..70ab5d8bb
--- /dev/null
+++ b/libXft/src/xftfont.c
@@ -0,0 +1,206 @@
+/*
+ * 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_EXPORT FcPattern *
+XftFontMatch (Display		*dpy,
+	      int		screen,
+	      _Xconst FcPattern *pattern,
+	      FcResult		*result)
+{
+    FcPattern	*new;
+    FcPattern	*match;
+
+    if (!XftInit (NULL))
+	return NULL;
+    
+    new = FcPatternDuplicate (pattern);
+    if (!new)
+	return NULL;
+
+    if (XftDebug () & XFT_DBG_OPENV)
+    {
+	printf ("XftFontMatch pattern ");
+	FcPatternPrint (new);
+    }
+    FcConfigSubstitute (NULL, new, FcMatchPattern);
+    if (XftDebug () & XFT_DBG_OPENV)
+    {
+	printf ("XftFontMatch after FcConfig substitutions ");
+	FcPatternPrint (new);
+    }
+    XftDefaultSubstitute (dpy, screen, new);
+    if (XftDebug () & XFT_DBG_OPENV)
+    {
+	printf ("XftFontMatch after X resource substitutions ");
+	FcPatternPrint (new);
+    }
+
+    match = FcFontMatch (NULL, new, result);
+    if (XftDebug () & XFT_DBG_OPENV)
+    {
+	printf ("XftFontMatch result ");
+	FcPatternPrint (match);
+    }
+    FcPatternDestroy (new);
+    return match;
+}
+
+_X_EXPORT XftFont *
+XftFontOpen (Display *dpy, int screen, ...)
+{
+    va_list	    va;
+    FcPattern	    *pat;
+    FcPattern	    *match;
+    FcResult	    result;
+    XftFont	    *font;
+
+    va_start (va, screen);
+    pat = FcPatternVaBuild (NULL, va);
+    va_end (va);
+    if (!pat)
+    {
+	if (XftDebug () & XFT_DBG_OPEN)
+	    printf ("XftFontOpen: Invalid pattern argument\n");
+	return NULL;
+    }
+    match = XftFontMatch (dpy, screen, pat, &result);
+    if (XftDebug () & XFT_DBG_OPEN)
+    {
+	printf ("Pattern ");
+	FcPatternPrint (pat);
+	if (match)
+	{
+	    printf ("Match ");
+	    FcPatternPrint (match);
+	}
+	else
+	    printf ("No Match\n");
+    }
+    FcPatternDestroy (pat);
+    if (!match)
+	return NULL;
+    
+    font = XftFontOpenPattern (dpy, match);
+    if (!font)
+    {
+	if (XftDebug () & XFT_DBG_OPEN)
+	    printf ("No Font\n");
+	FcPatternDestroy (match);
+    }
+
+    return font;
+}
+
+_X_EXPORT XftFont *
+XftFontOpenName (Display *dpy, int screen, const char *name)
+{
+    FcPattern	    *pat;
+    FcPattern	    *match;
+    FcResult	    result;
+    XftFont	    *font;
+
+    pat = FcNameParse ((FcChar8 *) name);
+    if (XftDebug () & XFT_DBG_OPEN)
+    {
+	printf ("XftFontOpenName \"%s\": ", name);
+	if (pat)
+	    FcPatternPrint (pat);
+	else
+	    printf ("Invalid name\n");
+    }
+			     
+    if (!pat)
+	return NULL;
+    match = XftFontMatch (dpy, screen, pat, &result);
+    if (XftDebug () & XFT_DBG_OPEN)
+    {
+	if (match)
+	{
+	    printf ("Match ");
+	    FcPatternPrint (match);
+	}
+	else
+	    printf ("No Match\n");
+    }
+    FcPatternDestroy (pat);
+    if (!match)
+	return NULL;
+    
+    font = XftFontOpenPattern (dpy, match);
+    if (!font)
+    {
+	if (XftDebug () & XFT_DBG_OPEN)
+	    printf ("No Font\n");
+	FcPatternDestroy (match);
+    }
+    
+    return font;
+}
+
+_X_EXPORT XftFont *
+XftFontOpenXlfd (Display *dpy, int screen, const char *xlfd)
+{
+    FcPattern	    *pat;
+    FcPattern	    *match;
+    FcResult	    result;
+    XftFont	    *font;
+
+    pat = XftXlfdParse (xlfd, FcFalse, FcFalse);
+    if (XftDebug () & XFT_DBG_OPEN)
+    {
+	printf ("XftFontOpenXlfd \"%s\": ", xlfd);
+	if (pat)
+	    printf ("Invalid xlfd\n");
+	else
+	    FcPatternPrint (pat);
+    }
+			     
+    if (!pat)
+	return NULL;
+    match = XftFontMatch (dpy, screen, pat, &result);
+    if (XftDebug () & XFT_DBG_OPEN)
+    {
+	if (match)
+	{
+	    printf ("Match ");
+	    FcPatternPrint (match);
+	}
+	else
+	    printf ("No Match\n");
+    }
+    FcPatternDestroy (pat);
+    if (!match)
+	return NULL;
+    
+    font = XftFontOpenPattern (dpy, match);
+    if (!font)
+    {
+	if (XftDebug () & XFT_DBG_OPEN)
+	    printf ("No Font\n");
+	FcPatternDestroy (match);
+    }
+    
+    return font;
+}
+
diff --git a/libXft/src/xftfreetype.c b/libXft/src/xftfreetype.c
new file mode 100644
index 000000000..7238b8259
--- /dev/null
+++ b/libXft/src/xftfreetype.c
@@ -0,0 +1,1174 @@
+/*
+ * 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 FT_Library  _XftFTlibrary;
+
+#define FT_Matrix_Equal(a,b)	((a)->xx == (b)->xx && \
+				 (a)->yy == (b)->yy && \
+				 (a)->xy == (b)->xy && \
+				 (a)->yx == (b)->yx)
+/*
+ * List of all open files (each face in a file is managed separately)
+ */
+
+static XftFtFile *_XftFtFiles;
+static int XftMaxFreeTypeFiles = 5;
+
+static XftFtFile *
+_XftGetFile (const FcChar8 *file, int id)
+{
+    XftFtFile	*f;
+
+    if (!XftInitFtLibrary ())
+	return NULL;
+
+    for (f = _XftFtFiles; f; f = f->next)
+    {
+	if (!strcmp (f->file, (char *) file) && f->id == id)
+	{
+	    ++f->ref;
+	    if (XftDebug () & XFT_DBG_REF)
+		printf ("FontFile %s/%d matches existing (%d)\n",
+			file, id, f->ref);
+	    return f;
+	}
+    }
+    f = malloc (sizeof (XftFtFile) + strlen ((char *) file) + 1);
+    if (!f)
+	return NULL;
+    
+    XftMemAlloc (XFT_MEM_FILE, sizeof (XftFtFile) + strlen ((char *) file) + 1);
+    if (XftDebug () & XFT_DBG_REF)
+    	printf ("FontFile %s/%d matches new\n",
+		file, id);
+    f->next = _XftFtFiles;
+    _XftFtFiles = f;
+    
+    f->ref = 1;
+    
+    f->file = (char *) (f+1);
+    strcpy (f->file, (char *) file);
+    f->id = id;
+    
+    f->lock = 0;
+    f->face = NULL;
+    f->xsize = 0;
+    f->ysize = 0;
+    f->matrix.xx = f->matrix.xy = f->matrix.yx = f->matrix.yy = 0;
+    return f;
+}
+
+static XftFtFile *
+_XftGetFaceFile (FT_Face face)
+{
+    XftFtFile	*f;
+
+    f = malloc (sizeof (XftFtFile));
+    if (!f)
+	return NULL;
+    XftMemAlloc (XFT_MEM_FILE, sizeof(XftFtFile));
+    f->next = NULL;
+    
+    f->ref = 1;
+
+    f->file = NULL;
+    f->id = 0;
+    f->lock = 0;
+    f->face = face;
+    f->xsize = 0;
+    f->ysize = 0;
+    f->matrix.xx = f->matrix.xy = f->matrix.yx = f->matrix.yy = 0;
+    return f;
+}
+
+static int
+_XftNumFiles (void)
+{
+    XftFtFile	*f;
+    int		count = 0;
+    for (f = _XftFtFiles; f; f = f->next)
+	if (f->face && !f->lock)
+	    ++count;
+    return count;
+}
+
+static XftFtFile *
+_XftNthFile (int n)
+{
+    XftFtFile	*f;
+    int		count = 0;
+    for (f = _XftFtFiles; f; f = f->next)
+	if (f->face && !f->lock)
+	    if (count++ == n)
+		break;
+    return f;
+}
+
+static void
+_XftUncacheFiles (void)
+{
+    int		n;
+    XftFtFile	*f;
+    while ((n = _XftNumFiles ()) > XftMaxFreeTypeFiles)
+    {
+	f = _XftNthFile (rand () % n);
+	if (f)
+	{
+	    if (XftDebug() & XFT_DBG_REF)
+		printf ("Discard file %s/%d from cache\n",
+			f->file, f->id);
+	    FT_Done_Face (f->face);
+	    f->face = NULL;
+	}
+    }
+}
+
+static FT_Face
+_XftLockFile (XftFtFile *f)
+{
+    ++f->lock;
+    if (!f->face)
+    {
+	if (XftDebug() & XFT_DBG_REF)
+	    printf ("Loading file %s/%d\n", f->file, f->id);
+	if (FT_New_Face (_XftFTlibrary, f->file, f->id, &f->face))
+	    --f->lock;
+	    
+	f->xsize = 0;
+	f->ysize = 0;
+	f->matrix.xx = f->matrix.xy = f->matrix.yx = f->matrix.yy = 0;
+	_XftUncacheFiles ();
+    }
+    return f->face;
+}
+
+static void
+_XftLockError (char *reason)
+{
+    fprintf (stderr, "Xft: locking error %s\n", reason);
+}
+
+static void
+_XftUnlockFile (XftFtFile *f)
+{
+    if (--f->lock < 0)
+	_XftLockError ("too many file unlocks");
+}
+
+#if HAVE_FT_BITMAP_SIZE_Y_PPEM
+#define X_SIZE(face,i) ((face)->available_sizes[i].x_ppem)
+#define Y_SIZE(face,i) ((face)->available_sizes[i].y_ppem)
+#else
+#define X_SIZE(face,i) ((face)->available_sizes[i].width << 6)
+#define Y_SIZE(face,i) ((face)->available_sizes[i].height << 6)
+#endif
+
+_X_HIDDEN FcBool
+_XftSetFace (XftFtFile *f, FT_F26Dot6 xsize, FT_F26Dot6 ysize, FT_Matrix *matrix)
+{
+    FT_Face face = f->face;
+    
+    if (f->xsize != xsize || f->ysize != ysize)
+    {
+	if (XftDebug() & XFT_DBG_GLYPH)
+	    printf ("Set face size to %dx%d (%dx%d)\n", 
+		    (int) (xsize >> 6), (int) (ysize >> 6), (int) xsize, (int) ysize);
+	/*
+	 * Bitmap only faces must match exactly, so find the closest
+	 * one (height dominant search)
+	 */
+	if (!(face->face_flags & FT_FACE_FLAG_SCALABLE))
+	{
+	    int		i, best = 0;
+
+#define xft_abs(a)	((a) < 0 ? -(a) : (a))
+#define dist(a,b)	(xft_abs((a)-(b)))
+
+	    for (i = 1; i < face->num_fixed_sizes; i++)
+	    {
+		if (dist (ysize, Y_SIZE(face,i)) <
+		    dist (ysize, Y_SIZE(face, best)) ||
+		    (dist (ysize, Y_SIZE(face, i)) ==
+		     dist (ysize, Y_SIZE(face, best)) &&
+		     dist (xsize, X_SIZE(face, i)) <
+		     dist (xsize, X_SIZE(face, best))))
+		{
+		    best = i;
+		}
+	    }
+	    /* 
+	     * Freetype 2.1.7 and earlier used width/height
+	     * for matching sizes in the BDF and PCF loaders.
+	     * This has been fixed for 2.1.8.  Because BDF and PCF
+	     * files have but a single strike per file, we can
+	     * simply try both sizes.
+	     */
+	    if (
+#if HAVE_FT_BITMAP_SIZE_Y_PPEM
+		FT_Set_Char_Size (face, face->available_sizes[best].x_ppem,
+				  face->available_sizes[best].y_ppem, 0, 0) != 0
+		&&
+#endif
+		FT_Set_Char_Size (face, face->available_sizes[best].width << 6,
+				  face->available_sizes[best].height << 6,
+				  0, 0) != 0)
+	    {
+		return False;
+	    }
+	}
+	else
+    	{
+	    if (FT_Set_Char_Size (face, xsize, ysize, 0, 0))
+	    {
+		return False;
+	    }
+	}
+	f->xsize = xsize;
+	f->ysize = ysize;
+    }
+    if (!FT_Matrix_Equal (&f->matrix, matrix))
+    {
+	if (XftDebug() & XFT_DBG_GLYPH)
+	    printf ("Set face matrix to (%g,%g,%g,%g)\n",
+		    (double) matrix->xx / 0x10000,
+		    (double) matrix->xy / 0x10000,
+		    (double) matrix->yx / 0x10000,
+		    (double) matrix->yy / 0x10000);
+	FT_Set_Transform (face, matrix, NULL);
+	f->matrix = *matrix;
+    }
+    return True;
+}
+
+static void
+_XftReleaseFile (XftFtFile *f)
+{
+    XftFtFile	**prev;
+    
+    if (--f->ref != 0)
+        return;
+    if (f->lock)
+	_XftLockError ("Attempt to close locked file");
+    if (f->file)
+    {
+	for (prev = &_XftFtFiles; *prev; prev = &(*prev)->next)
+	{
+	    if (*prev == f)
+	    {
+		*prev = f->next;
+		break;
+	    }
+	}
+	if (f->face)
+	    FT_Done_Face (f->face);
+    }
+    XftMemFree (XFT_MEM_FILE, 
+		sizeof (XftFtFile) + (f->file ? strlen (f->file) + 1 : 0));
+    free (f);
+}
+
+/*
+ * Find a prime larger than the minimum reasonable hash size
+ */
+
+static FcChar32
+_XftSqrt (FcChar32 a)
+{
+    FcChar32	    l, h, m;
+
+    l = 2;
+    h = a/2;
+    while ((h-l) > 1)
+    {
+	m = (h+l) >> 1;
+	if (m * m < a)
+	    l = m;
+	else
+	    h = m;
+    }
+    return h;
+}
+
+static FcBool
+_XftIsPrime (FcChar32 i)
+{
+    FcChar32	l, t;
+
+    if (i < 2)
+	return FcFalse;
+    if ((i & 1) == 0)
+    {
+	if (i == 2)
+	    return FcTrue;
+	return FcFalse;
+    }
+    l = _XftSqrt (i) + 1;
+    for (t = 3; t <= l; t += 2)
+	if (i % t == 0)
+	    return FcFalse;
+    return FcTrue;
+}
+
+static FcChar32
+_XftHashSize (FcChar32 num_unicode)
+{
+    /* at least 31.25 % extra space */
+    FcChar32	hash = num_unicode + (num_unicode >> 2) + (num_unicode >> 4);
+
+    if ((hash & 1) == 0)
+	hash++;
+    while (!_XftIsPrime (hash))
+	hash += 2;
+    return hash;
+}
+
+_X_EXPORT FT_Face
+XftLockFace (XftFont *public)
+{
+    XftFontInt	*font = (XftFontInt *) public;
+    XftFontInfo	*fi = &font->info;
+    FT_Face	face;
+    
+    face = _XftLockFile (fi->file);
+    /*
+     * Make sure the face is usable at the requested size
+     */
+    if (face && !_XftSetFace (fi->file, fi->xsize, fi->ysize, &fi->matrix))
+    {
+	_XftUnlockFile (fi->file);
+	face = NULL;
+    }
+    return face;
+}
+
+_X_EXPORT void
+XftUnlockFace (XftFont *public)
+{
+    XftFontInt	*font = (XftFontInt *) public;
+    _XftUnlockFile (font->info.file);
+}
+
+static FcBool
+XftFontInfoFill (Display *dpy, _Xconst FcPattern *pattern, XftFontInfo *fi)
+{
+    XftDisplayInfo  *info = _XftDisplayInfoGet (dpy, True);
+    FcChar8	    *filename;
+    int		    id;
+    double	    dsize;
+    double	    aspect;
+    FcMatrix	    *font_matrix;
+    FcBool	    hinting, vertical_layout, autohint, global_advance;
+#ifdef FC_HINT_STYLE
+    int             hint_style;
+#endif
+    FcChar32	    hash, *hashp;
+    FT_Face	    face;
+    int		    nhash;
+    FcBool	    bitmap;
+
+    if (!info)
+	return FcFalse;
+
+    /*
+     * Initialize the whole XftFontInfo so that padding doesn't interfere with
+     * hash or XftFontInfoEqual().
+     */
+ 
+    memset (fi, '\0', sizeof(*fi));
+
+    /*
+     * Find the associated file
+     */
+    switch (FcPatternGetString (pattern, FC_FILE, 0, &filename)) {
+    case FcResultNoMatch:
+	filename = NULL;
+	break;
+    case FcResultMatch:
+	break;
+    default:
+	goto bail0;
+    }
+    
+    switch (FcPatternGetInteger (pattern, FC_INDEX, 0, &id)) {
+    case FcResultNoMatch:
+	id = 0;
+	break;
+    case FcResultMatch:
+	break;
+    default:
+	goto bail0;
+    }
+    
+    if (filename)
+	fi->file = _XftGetFile (filename, id);
+    else if (FcPatternGetFTFace (pattern, FC_FT_FACE, 0, &face) == FcResultMatch
+	     && face)
+	fi->file = _XftGetFaceFile (face);
+    if (!fi->file)
+        goto bail0;
+
+    /*
+     * Compute pixel size
+     */
+    if (FcPatternGetDouble (pattern, FC_PIXEL_SIZE, 0, &dsize) != FcResultMatch)
+	goto bail1;
+
+    if (FcPatternGetDouble (pattern, FC_ASPECT, 0, &aspect) != FcResultMatch)
+	aspect = 1.0;
+    
+    fi->ysize = (FT_F26Dot6) (dsize * 64.0);
+    fi->xsize = (FT_F26Dot6) (dsize * aspect * 64.0);
+
+    if (XftDebug() & XFT_DBG_OPEN)
+	printf ("XftFontInfoFill: %s: %d (%g pixels)\n",
+		(filename ? filename : (FcChar8 *) "<none>"), id, dsize);
+    /*
+     * Get antialias value
+     */
+    switch (FcPatternGetBool (pattern, FC_ANTIALIAS, 0, &fi->antialias)) {
+    case FcResultNoMatch:
+	fi->antialias = True;
+	break;
+    case FcResultMatch:
+	break;
+    default:
+	goto bail1;
+    }
+    
+    /*
+     * Get rgba value
+     */
+    switch (FcPatternGetInteger (pattern, FC_RGBA, 0, &fi->rgba)) {
+    case FcResultNoMatch:
+	fi->rgba = FC_RGBA_UNKNOWN;
+	break;
+    case FcResultMatch:
+	break;
+    default:
+	goto bail1;
+    }
+    
+    /*
+     * Get matrix and transform values
+     */
+    switch (FcPatternGetMatrix (pattern, FC_MATRIX, 0, &font_matrix)) {
+    case FcResultNoMatch:
+	fi->matrix.xx = fi->matrix.yy = 0x10000;
+	fi->matrix.xy = fi->matrix.yx = 0;
+	break;
+    case FcResultMatch:
+	fi->matrix.xx = 0x10000L * font_matrix->xx;
+	fi->matrix.yy = 0x10000L * font_matrix->yy;
+	fi->matrix.xy = 0x10000L * font_matrix->xy;
+	fi->matrix.yx = 0x10000L * font_matrix->yx;
+	break;
+    default:
+	goto bail1;
+    }
+
+    fi->transform = (fi->matrix.xx != 0x10000 || fi->matrix.xy != 0 ||
+		     fi->matrix.yx != 0 || fi->matrix.yy != 0x10000);
+    
+    /* 
+     * Get render value, set to false if no Render extension present
+     */
+    if (info->hasRender)
+    {
+	switch (FcPatternGetBool (pattern, XFT_RENDER, 0, &fi->render)) {
+	case FcResultNoMatch:
+	    fi->render = info->hasRender;
+	    break;
+	case FcResultMatch:
+	    break;
+	default:
+	    goto bail1;
+	}
+    }
+    else
+	fi->render = FcFalse;
+    
+    /*
+     * Compute glyph load flags
+     */
+    fi->load_flags = FT_LOAD_DEFAULT;
+
+#ifndef XFT_EMBEDDED_BITMAP
+#define XFT_EMBEDDED_BITMAP "embeddedbitmap"
+#endif
+
+    switch (FcPatternGetBool (pattern, XFT_EMBEDDED_BITMAP, 0, &bitmap)) {
+    case FcResultNoMatch:
+	bitmap = FcFalse;
+	break;
+    case FcResultMatch:
+	break;
+    default:
+	goto bail1;
+    }
+
+    /* disable bitmaps when anti-aliasing or transforming glyphs */
+    if ((!bitmap && fi->antialias) || fi->transform)
+	fi->load_flags |= FT_LOAD_NO_BITMAP;
+    
+    /* disable hinting if requested */
+    switch (FcPatternGetBool (pattern, FC_HINTING, 0, &hinting)) {
+    case FcResultNoMatch:
+	hinting = FcTrue;
+	break;
+    case FcResultMatch:
+	break;
+    default:
+	goto bail1;
+    }
+
+#ifdef FC_EMBOLDEN
+    switch (FcPatternGetBool (pattern, FC_EMBOLDEN, 0, &fi->embolden)) {
+    case FcResultNoMatch:
+	fi->embolden = FcFalse;
+	break;
+    case FcResultMatch:
+	break;
+    default:
+	goto bail1;
+    }
+#else
+    fi->embolden = FcFalse;
+#endif
+    
+#ifdef FC_HINT_STYLE
+    switch (FcPatternGetInteger (pattern, FC_HINT_STYLE, 0, &hint_style)) {
+    case FcResultNoMatch:
+	hint_style = FC_HINT_FULL;
+	break;
+    case FcResultMatch:
+	break;
+    default:
+	goto bail1;
+    }
+#endif
+
+    if (!hinting
+#ifdef FC_HINT_STYLE
+	|| hint_style == FC_HINT_NONE
+#endif
+	)
+    {
+	fi->load_flags |= FT_LOAD_NO_HINTING;
+    }
+
+    /* Figure out the load target, which modifies the hinting
+     * behavior of FreeType based on the intended use of the glyphs.
+     */
+    if (fi->antialias)
+    {
+#ifdef FC_HINT_STYLE
+#ifdef FT_LOAD_TARGET_LIGHT
+	if (FC_HINT_NONE < hint_style && hint_style < FC_HINT_FULL)
+	{
+	    fi->load_flags |= FT_LOAD_TARGET_LIGHT;
+	}
+	else
+#endif
+#endif
+	{
+	    /* autohinter will snap stems to integer widths, when
+	     * the LCD targets are used.
+	     */
+	    switch (fi->rgba) {
+	    case FC_RGBA_RGB:
+	    case FC_RGBA_BGR:
+#ifdef FT_LOAD_TARGET_LCD
+		fi->load_flags |= FT_LOAD_TARGET_LCD;
+#endif
+		break;
+	    case FC_RGBA_VRGB:
+	    case FC_RGBA_VBGR:
+#ifdef FT_LOAD_TARGET_LCD_V
+		fi->load_flags |= FT_LOAD_TARGET_LCD_V;
+#endif
+		break;
+	    }
+	}
+    }
+#ifdef FT_LOAD_TARGET_MONO
+    else
+	fi->load_flags |= FT_LOAD_TARGET_MONO;
+#endif
+    
+    /* set vertical layout if requested */
+    switch (FcPatternGetBool (pattern, FC_VERTICAL_LAYOUT, 0, &vertical_layout)) {
+    case FcResultNoMatch:
+	vertical_layout = FcFalse;
+	break;
+    case FcResultMatch:
+	break;
+    default:
+	goto bail1;
+    }
+
+    if (vertical_layout)
+	fi->load_flags |= FT_LOAD_VERTICAL_LAYOUT;
+
+    /* force autohinting if requested */
+    switch (FcPatternGetBool (pattern, FC_AUTOHINT, 0, &autohint)) {
+    case FcResultNoMatch:
+	autohint = FcFalse;
+	break;
+    case FcResultMatch:
+	break;
+    default:
+	goto bail1;
+    }
+
+    if (autohint)
+	fi->load_flags |= FT_LOAD_FORCE_AUTOHINT;
+
+    /* disable global advance width (for broken DynaLab TT CJK fonts) */
+    switch (FcPatternGetBool (pattern, FC_GLOBAL_ADVANCE, 0, &global_advance)) {
+    case FcResultNoMatch:
+	global_advance = FcTrue;
+	break;
+    case FcResultMatch:
+	break;
+    default:
+	goto bail1;
+    }
+
+    if (!global_advance)
+	fi->load_flags |= FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH;
+    
+    /*
+     * Get requested spacing value
+     */
+    switch (FcPatternGetInteger (pattern, FC_SPACING, 0, &fi->spacing)) {
+    case FcResultNoMatch:
+	fi->spacing = FC_PROPORTIONAL;
+	break;
+    case FcResultMatch:
+	break;
+    default:
+	goto bail1;
+    }
+    
+    /*
+     * Check for minspace
+     */
+
+    switch (FcPatternGetBool (pattern, FC_MINSPACE, 0, &fi->minspace)) {
+    case FcResultNoMatch:
+	fi->minspace = FcFalse;
+	break;
+    case FcResultMatch:
+	break;
+    default:
+	goto bail1;
+    }
+    /*
+     * Check for fixed pixel spacing 
+     */
+    switch (FcPatternGetInteger (pattern, FC_CHAR_WIDTH, 0, &fi->char_width)) {
+    case FcResultNoMatch:
+	fi->char_width = 0;
+	break;
+    case FcResultMatch:
+	if (fi->char_width)
+	    fi->spacing = FC_MONO;
+	break;
+    default:
+	goto bail1;
+    }
+
+    /*
+     * Step over hash value in the structure
+     */
+    hash = 0;
+    hashp = (FcChar32 *) fi + 1;
+    nhash = (sizeof (XftFontInfo) / sizeof (FcChar32)) - 1;
+
+    while (nhash--)
+	hash += *hashp++;
+    fi->hash = hash;
+    
+    /*
+     * All done
+     */
+    return FcTrue;
+    
+bail1:
+    _XftReleaseFile (fi->file);
+    fi->file = NULL;
+bail0:
+    return FcFalse;
+}
+
+static void
+XftFontInfoEmpty (Display *dpy, XftFontInfo *fi)
+{
+    if (fi->file)
+	_XftReleaseFile (fi->file);
+}
+
+XftFontInfo *
+XftFontInfoCreate (Display *dpy, _Xconst FcPattern *pattern)
+{
+    XftFontInfo	*fi = malloc (sizeof (XftFontInfo));
+
+    if (!fi)
+	return NULL;
+    
+    if (!XftFontInfoFill (dpy, pattern, fi))
+    {
+	free (fi);
+	fi = NULL;
+    }
+    XftMemAlloc (XFT_MEM_FONT, sizeof (XftFontInfo));
+    return fi;
+}
+
+_X_EXPORT void
+XftFontInfoDestroy (Display *dpy, XftFontInfo *fi)
+{
+    XftFontInfoEmpty (dpy, fi);
+    XftMemFree (XFT_MEM_FONT, sizeof (XftFontInfo));
+    free (fi);
+}
+
+_X_EXPORT FcChar32
+XftFontInfoHash (_Xconst XftFontInfo *fi)
+{
+    return fi->hash;
+}
+    
+_X_EXPORT FcBool
+XftFontInfoEqual (_Xconst XftFontInfo *a, _Xconst XftFontInfo *b)
+{
+    return memcmp ((void *) a, (void *) b, sizeof (XftFontInfo)) == 0;
+}
+
+_X_EXPORT XftFont *
+XftFontOpenInfo (Display	*dpy, 
+		 FcPattern	*pattern, 
+		 XftFontInfo	*fi)
+{
+    XftDisplayInfo	*info = _XftDisplayInfoGet (dpy, True);
+    FT_Face		face;
+    XftFont		**bucket;
+    XftFontInt		*font;
+    XRenderPictFormat	*format;
+    FcCharSet		*charset;
+    FcChar32		num_unicode;
+    FcChar32		hash_value;
+    FcChar32		rehash_value;
+    FcBool		antialias;
+    int			max_glyph_memory;
+    int			alloc_size;
+    int			ascent, descent, height;
+    int			i;
+    int			num_glyphs;
+
+    if (!info)
+	return NULL;
+    /*
+     * Find a matching previously opened font
+     */
+    bucket = &info->fontHash[fi->hash % XFT_NUM_FONT_HASH];
+    for (font = (XftFontInt *) *bucket; font; font = (XftFontInt *) font->hash_next)
+	if (XftFontInfoEqual (&font->info, fi))
+	{
+	    if (!font->ref++)
+		--info->num_unref_fonts;
+	    FcPatternDestroy (pattern);
+	    return &font->public;
+	}
+
+    /*
+     * No existing font, create another.  
+     */
+    
+    if (XftDebug () & XFT_DBG_CACHE)
+	printf ("New font %s/%d size %dx%d\n",
+		fi->file->file, fi->file->id,
+		(int) fi->xsize >> 6, (int) fi->ysize >> 6);
+		
+    if (FcPatternGetInteger (pattern, XFT_MAX_GLYPH_MEMORY, 0,
+			     &max_glyph_memory) != FcResultMatch)
+	max_glyph_memory = XFT_FONT_MAX_GLYPH_MEMORY;
+
+    face = _XftLockFile (fi->file);
+    if (!face)
+	goto bail0;
+
+    if (!_XftSetFace (fi->file, fi->xsize, fi->ysize, &fi->matrix))
+	goto bail1;
+
+    /*
+     * Get the set of Unicode codepoints covered by the font.
+     * If the incoming pattern doesn't provide this data, go
+     * off and compute it.  Yes, this is expensive, but it's
+     * required to map Unicode to glyph indices.
+     */
+    if (FcPatternGetCharSet (pattern, FC_CHARSET, 0, &charset) == FcResultMatch)
+	charset = FcCharSetCopy (charset);
+    else
+	charset = FcFreeTypeCharSet (face, FcConfigGetBlanks (NULL));
+    
+    antialias = fi->antialias;
+    if (!(face->face_flags & FT_FACE_FLAG_SCALABLE))
+	antialias = FcFalse;
+
+    /*
+     * Find the appropriate picture format
+     */
+    if (fi->render)
+    {
+	if (antialias)
+	{
+	    switch (fi->rgba) {
+	    case FC_RGBA_RGB:
+	    case FC_RGBA_BGR:
+	    case FC_RGBA_VRGB:
+	    case FC_RGBA_VBGR:
+		format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
+		break;
+	    default:
+		format = XRenderFindStandardFormat (dpy, PictStandardA8);
+		break;
+	    }
+	}
+	else
+	{
+	    format = XRenderFindStandardFormat (dpy, PictStandardA1);
+	}
+	
+	if (!format)
+	    goto bail2;
+    }
+    else
+	format = NULL;
+    
+    if (charset)
+    {
+	num_unicode = FcCharSetCount (charset);
+	hash_value = _XftHashSize (num_unicode);
+	rehash_value = hash_value - 2;
+    }
+    else
+    {
+	num_unicode = 0;
+	hash_value = 0;
+	rehash_value = 0;
+    }
+    
+    /*
+     * Sometimes the glyphs are numbered 1..n, other times 0..n-1,
+     * accept either numbering scheme by making room in the table
+     */
+    num_glyphs = face->num_glyphs + 1;
+    alloc_size = (sizeof (XftFontInt) + 
+		  num_glyphs * sizeof (XftGlyph *) +
+		  hash_value * sizeof (XftUcsHash));
+    font = malloc (alloc_size);
+    
+    if (!font)
+	goto bail2;
+
+    XftMemAlloc (XFT_MEM_FONT, alloc_size);
+
+    /*
+     * Public fields
+     */
+    if (fi->transform)
+    {
+	FT_Vector	vector;
+	
+	vector.x = 0;
+	vector.y = face->size->metrics.descender;
+	FT_Vector_Transform (&vector, &fi->matrix);
+	descent = -(vector.y >> 6);
+	
+	vector.x = 0;
+	vector.y = face->size->metrics.ascender;
+	FT_Vector_Transform (&vector, &fi->matrix);
+	ascent = vector.y >> 6;
+
+	if (fi->minspace)
+	    height = ascent + descent;
+	else
+	{
+	    vector.x = 0;
+	    vector.y = face->size->metrics.height;
+	    FT_Vector_Transform (&vector, &fi->matrix);
+	    height = vector.y >> 6;
+	}
+    }
+    else
+    {
+	descent = -(face->size->metrics.descender >> 6);
+	ascent = face->size->metrics.ascender >> 6;
+	if (fi->minspace)
+	    height = ascent + descent;
+	else
+	    height = face->size->metrics.height >> 6;
+    }
+    font->public.ascent = ascent;
+    font->public.descent = descent;
+    font->public.height = height;
+    
+    if (fi->char_width)
+	font->public.max_advance_width = fi->char_width;
+    else
+    {
+	if (fi->transform)
+	{
+	    FT_Vector	vector;
+	    vector.x = face->size->metrics.max_advance;
+	    vector.y = 0;
+	    FT_Vector_Transform (&vector, &fi->matrix);
+	    font->public.max_advance_width = vector.x >> 6;
+	}
+	else
+	    font->public.max_advance_width = face->size->metrics.max_advance >> 6;
+    }
+    font->public.charset = charset;
+    font->public.pattern = pattern;
+    
+    /*
+     * Management fields
+     */
+    font->ref = 1;
+
+    font->next = info->fonts;
+    info->fonts = &font->public;
+    
+    font->hash_next = *bucket;
+    *bucket = &font->public;
+    
+    /*
+     * Copy the info over
+     */
+    font->info = *fi;
+    /*
+     * reset the antialias field.  It can't
+     * be set correctly until the font is opened,
+     * which doesn't happen in XftFontInfoFill
+     */
+    font->info.antialias = antialias;
+    /*
+     * bump XftFile reference count
+     */
+    font->info.file->ref++;
+    
+    /*
+     * Per glyph information
+     */
+    font->glyphs = (XftGlyph **) (font + 1);
+    memset (font->glyphs, '\0', num_glyphs * sizeof (XftGlyph *));
+    font->num_glyphs = num_glyphs;
+    /*
+     * Unicode hash table information
+     */
+    font->hash_table = (XftUcsHash *) (font->glyphs + font->num_glyphs);
+    for (i = 0; i < hash_value; i++)
+    {
+	font->hash_table[i].ucs4 = ((FcChar32) ~0);
+	font->hash_table[i].glyph = 0;
+    }
+    font->hash_value = hash_value;
+    font->rehash_value = rehash_value;
+    /*
+     * X specific fields
+     */
+    font->glyphset = 0;
+    font->format = format;
+    
+    /*
+     * Glyph memory management fields
+     */
+    font->glyph_memory = 0;
+    font->max_glyph_memory = max_glyph_memory;
+    font->use_free_glyphs = info->use_free_glyphs;
+    
+    _XftUnlockFile (fi->file);
+
+    return &font->public;
+    
+bail2:
+    FcCharSetDestroy (charset);
+bail1:
+    _XftUnlockFile (fi->file);
+bail0:
+    return NULL;
+}
+
+_X_EXPORT XftFont *
+XftFontOpenPattern (Display *dpy, FcPattern *pattern)
+{
+    XftFontInfo	    info;
+    XftFont	    *font;
+
+    if (!XftFontInfoFill (dpy, pattern, &info))
+	return NULL;
+
+    font = XftFontOpenInfo (dpy, pattern, &info);
+    XftFontInfoEmpty (dpy, &info);
+    return font;
+}
+
+_X_EXPORT XftFont *
+XftFontCopy (Display *dpy, XftFont *public)
+{
+    XftFontInt	    *font = (XftFontInt *) public;
+
+    font->ref++;
+    return public;
+}
+
+static void
+XftFontDestroy (Display *dpy, XftFont *public)
+{
+    XftDisplayInfo  *info = _XftDisplayInfoGet (dpy, False);
+    XftFontInt	    *font = (XftFontInt *) public;
+    int		    i;
+    
+    /* note reduction in memory use */
+    if (info)
+	info->glyph_memory -= font->glyph_memory;
+    /* Clean up the info */
+    XftFontInfoEmpty (dpy, &font->info);
+    /* Free the glyphset */
+    if (font->glyphset)
+	XRenderFreeGlyphSet (dpy, font->glyphset);
+    /* Free the glyphs */
+    for (i = 0; i < font->num_glyphs; i++)
+    {
+	XftGlyph	*xftg = font->glyphs[i];
+	if (xftg)
+	{
+	    if (xftg->bitmap)
+		free (xftg->bitmap);
+	    free (xftg);
+	}
+    }
+    
+    /* Free the pattern and the charset */
+    FcPatternDestroy (font->public.pattern);
+    FcCharSetDestroy (font->public.charset);
+    
+    /* Finally, free the font structure */
+    XftMemFree (XFT_MEM_FONT, sizeof (XftFontInt) +
+		font->num_glyphs * sizeof (XftGlyph *) +
+		font->hash_value * sizeof (XftUcsHash));
+    free (font);
+}
+
+static XftFont *
+XftFontFindNthUnref (XftDisplayInfo *info, int n)
+{
+    XftFont	*public;
+    XftFontInt	*font;
+    
+    for (public = info->fonts; public; public = font->next)
+    {
+	font = (XftFontInt*) public;
+	if (!font->ref && !n--)
+	    break;
+    }
+    return public;
+}
+
+_X_HIDDEN void
+XftFontManageMemory (Display *dpy)
+{
+    XftDisplayInfo  *info = _XftDisplayInfoGet (dpy, False);
+    XftFont	    **prev;
+    XftFont	    *public;
+    XftFontInt	    *font;
+
+    if (!info)
+	return;
+    while (info->num_unref_fonts > info->max_unref_fonts)
+    {
+	public = XftFontFindNthUnref (info, rand() % info->num_unref_fonts);
+	font = (XftFontInt *) public;
+
+	if (XftDebug () & XFT_DBG_CACHE)
+	    printf ("freeing unreferenced font %s/%d size %dx%d\n",
+		    font->info.file->file, font->info.file->id,
+		    (int) font->info.xsize >> 6, (int) font->info.ysize >> 6);
+
+	/* Unhook from display list */
+	for (prev = &info->fonts; *prev; prev = &(*(XftFontInt **) prev)->next)
+	{
+	    if (*prev == public)
+	    {
+		*prev = font->next;
+		break;
+	    }
+	}
+	/* Unhook from hash list */
+	for (prev = &info->fontHash[font->info.hash % XFT_NUM_FONT_HASH];
+	     *prev;
+	     prev = &(*(XftFontInt **) prev)->hash_next)
+	{
+	    if (*prev == public)
+	    {
+		*prev = font->hash_next;
+		break;
+	    }
+	}
+	/* Destroy the font */
+	XftFontDestroy (dpy, public);
+	--info->num_unref_fonts;
+    }
+}
+
+_X_EXPORT void
+XftFontClose (Display *dpy, XftFont *public)
+{
+    XftDisplayInfo  *info = _XftDisplayInfoGet (dpy, False);
+    XftFontInt	    *font = (XftFontInt *) public;
+    
+    if (--font->ref != 0)
+	return;
+    
+    if (info)
+    {
+	++info->num_unref_fonts;
+	XftFontManageMemory (dpy);
+    }
+    else
+    {
+	XftFontDestroy (dpy, public);
+    }
+}
+
+_X_EXPORT FcBool
+XftInitFtLibrary (void)
+{
+    if (_XftFTlibrary)
+	return FcTrue;
+    if (FT_Init_FreeType (&_XftFTlibrary))
+	return FcFalse;
+    return FcTrue;
+}
diff --git a/libXft/src/xftglyphs.c b/libXft/src/xftglyphs.c
new file mode 100644
index 000000000..10adb1587
--- /dev/null
+++ b/libXft/src/xftglyphs.c
@@ -0,0 +1,827 @@
+/*
+ * 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"
+#include <freetype/ftoutln.h>
+
+#if HAVE_FT_GLYPHSLOT_EMBOLDEN
+#include <freetype/ftsynth.h>
+#endif
+
+static const int    filters[3][3] = {
+    /* red */
+#if 0
+{    65538*4/7,65538*2/7,65538*1/7 },
+    /* green */
+{    65536*1/4, 65536*2/4, 65537*1/4 },
+    /* blue */
+{    65538*1/7,65538*2/7,65538*4/7 },
+#endif
+{    65538*9/13,65538*3/13,65538*1/13 },
+    /* green */
+{    65538*1/6, 65538*4/6, 65538*1/6 },
+    /* blue */
+{    65538*1/13,65538*3/13,65538*9/13 },
+};
+
+/*
+ * Validate the memory info for a font
+ */
+
+static void
+_XftFontValidateMemory (Display *dpy, XftFont *public)
+{
+    XftFontInt	    *font = (XftFontInt *) public;
+    unsigned long   glyph_memory;
+    FT_UInt	    glyphindex;
+    XftGlyph	    *xftg;
+
+    glyph_memory = 0;
+    for (glyphindex = 0; glyphindex < font->num_glyphs; glyphindex++)
+    {
+	xftg = font->glyphs[glyphindex];
+	if (xftg)
+	{
+	    glyph_memory += xftg->glyph_memory;
+	}
+    }
+    if (glyph_memory != font->glyph_memory)
+	printf ("Font glyph cache incorrect has %ld bytes, should have %ld\n",
+		font->glyph_memory, glyph_memory);
+}
+
+_X_EXPORT void
+XftFontLoadGlyphs (Display	    *dpy,
+		   XftFont	    *pub,
+		   FcBool	    need_bitmaps,
+		   _Xconst FT_UInt  *glyphs,
+		   int		    nglyph)
+{
+    XftDisplayInfo  *info = _XftDisplayInfoGet (dpy, True);
+    XftFontInt	    *font = (XftFontInt *) pub;
+    FT_Error	    error;
+    FT_UInt	    glyphindex;
+    FT_GlyphSlot    glyphslot;
+    XftGlyph	    *xftg;
+    Glyph	    glyph;
+    unsigned char   bufLocal[4096];
+    unsigned char   *bufBitmap = bufLocal;
+    int		    bufSize = sizeof (bufLocal);
+    int		    size, pitch;
+    unsigned char   bufLocalRgba[4096];
+    unsigned char   *bufBitmapRgba = bufLocalRgba;
+    int		    bufSizeRgba = sizeof (bufLocalRgba);
+    int		    sizergba, pitchrgba, widthrgba;
+    int		    width;
+    int		    height;
+    int		    left, right, top, bottom;
+    int		    hmul = 1;
+    int		    vmul = 1;
+    FT_Bitmap	    ftbit;
+    FT_Matrix	    matrix;
+    FT_Vector	    vector;
+    Bool	    subpixel = False;
+    FT_Face	    face;
+
+    if (!info)
+	return;
+
+    face = XftLockFace (&font->public);
+    
+    if (!face)
+	return;
+
+    matrix.xx = matrix.yy = 0x10000L;
+    matrix.xy = matrix.yx = 0;
+
+    if (font->info.antialias)
+    {
+	switch (font->info.rgba) {
+	case FC_RGBA_RGB:
+	case FC_RGBA_BGR:
+	    matrix.xx *= 3;
+	    subpixel = True;
+	    hmul = 3;
+	    break;
+	case FC_RGBA_VRGB:
+	case FC_RGBA_VBGR:
+	    matrix.yy *= 3;
+	    vmul = 3;
+	    subpixel = True;
+	    break;
+	}
+    }
+
+    while (nglyph--)
+    {
+	glyphindex = *glyphs++;
+	xftg = font->glyphs[glyphindex];
+	if (!xftg)
+	    continue;
+	
+	if (XftDebug() & XFT_DBG_CACHE)
+	    _XftFontValidateMemory (dpy, pub);
+	/*
+	 * Check to see if this glyph has just been loaded,
+	 * this happens when drawing the same glyph twice
+	 * in a single string
+	 */
+	if (xftg->glyph_memory)
+	    continue;
+	
+	error = FT_Load_Glyph (face, glyphindex, font->info.load_flags);
+	if (error)
+	{
+	    /*
+	     * If anti-aliasing or transforming glyphs and
+	     * no outline version exists, fallback to the
+	     * bitmap and let things look bad instead of
+	     * missing the glyph
+	     */
+	    if (font->info.load_flags & FT_LOAD_NO_BITMAP)
+		error = FT_Load_Glyph (face, glyphindex,
+				       font->info.load_flags & ~FT_LOAD_NO_BITMAP);
+	    if (error)
+		continue;
+	}
+
+#define FLOOR(x)    ((x) & -64)
+#define CEIL(x)	    (((x)+63) & -64)
+#define TRUNC(x)    ((x) >> 6)
+#define ROUND(x)    (((x)+32) & -64)
+		
+	glyphslot = face->glyph;
+
+#if HAVE_FT_GLYPHSLOT_EMBOLDEN
+	/*
+	 * Embolden if required
+	 */
+	if (font->info.embolden) FT_GlyphSlot_Embolden(glyphslot);
+#endif
+
+	/*
+	 * Compute glyph metrics from FreeType information
+	 */
+	if(font->info.transform && glyphslot->format != ft_glyph_format_bitmap) 
+	{
+	    /*
+	     * calculate the true width by transforming all four corners.
+	     */
+	    int xc, yc;
+	    left = right = top = bottom = 0;
+	    for(xc = 0; xc <= 1; xc ++) {
+		for(yc = 0; yc <= 1; yc++) {
+		    vector.x = glyphslot->metrics.horiBearingX + xc * glyphslot->metrics.width;
+		    vector.y = glyphslot->metrics.horiBearingY - yc * glyphslot->metrics.height;
+		    FT_Vector_Transform(&vector, &font->info.matrix);   
+		    if (XftDebug() & XFT_DBG_GLYPH)
+			printf("Trans %d %d: %d %d\n", (int) xc, (int) yc, 
+			       (int) vector.x, (int) vector.y);
+		    if(xc == 0 && yc == 0) {
+			left = right = vector.x;
+			top = bottom = vector.y;
+		    } else {
+			if(left > vector.x) left = vector.x;
+			if(right < vector.x) right = vector.x;
+			if(bottom > vector.y) bottom = vector.y;
+			if(top < vector.y) top = vector.y;
+		    }
+
+		}
+	    }
+	    left = FLOOR(left);
+	    right = CEIL(right);
+	    bottom = FLOOR(bottom);
+	    top = CEIL(top);
+
+	} else {
+	    left  = FLOOR( glyphslot->metrics.horiBearingX );
+	    right = CEIL( glyphslot->metrics.horiBearingX + glyphslot->metrics.width );
+
+	    top    = CEIL( glyphslot->metrics.horiBearingY );
+	    bottom = FLOOR( glyphslot->metrics.horiBearingY - glyphslot->metrics.height );
+	}
+
+	width = TRUNC(right - left);
+	height = TRUNC( top - bottom );
+
+	/*
+	 * Clip charcell glyphs to the bounding box
+	 * XXX transformed?
+	 */
+	if (font->info.spacing >= FC_CHARCELL && !font->info.transform)
+	{
+	    if (font->info.load_flags & FT_LOAD_VERTICAL_LAYOUT)
+	    {
+		if (TRUNC(bottom) > font->public.max_advance_width)
+		{
+		    int adjust;
+    
+		    adjust = bottom - (font->public.max_advance_width << 6);
+		    if (adjust > top)
+			adjust = top;
+		    top -= adjust;
+		    bottom -= adjust;
+		    height = font->public.max_advance_width;
+		}
+	    }
+	    else
+	    {
+		if (TRUNC(right) > font->public.max_advance_width)
+		{
+		    int adjust;
+    
+		    adjust = right - (font->public.max_advance_width << 6);
+		    if (adjust > left)
+			adjust = left;
+		    left -= adjust;
+		    right -= adjust;
+		    width = font->public.max_advance_width;
+		}
+	    }
+	}
+
+	if (font->info.antialias)
+	    pitch = (width * hmul + 3) & ~3;
+	else
+	    pitch = ((width + 31) & ~31) >> 3;
+
+	size = pitch * height * vmul;
+
+	xftg->metrics.width = width;
+	xftg->metrics.height = height;
+	xftg->metrics.x = -TRUNC(left);
+	xftg->metrics.y = TRUNC(top);
+
+	if (font->info.spacing >= FC_MONO)
+	{
+	    if (font->info.transform)
+	    {
+		if (font->info.load_flags & FT_LOAD_VERTICAL_LAYOUT)
+		{
+		    vector.x = 0;
+		    vector.y = -face->size->metrics.max_advance;
+		}
+		else
+		{
+		    vector.x = face->size->metrics.max_advance;
+		    vector.y = 0;
+		}
+		FT_Vector_Transform (&vector, &font->info.matrix);
+		xftg->metrics.xOff = vector.x >> 6;
+		xftg->metrics.yOff = -(vector.y >> 6);
+	    }
+	    else
+	    {
+		if (font->info.load_flags & FT_LOAD_VERTICAL_LAYOUT)
+		{
+		    xftg->metrics.xOff = 0;
+		    xftg->metrics.yOff = -font->public.max_advance_width;
+		}
+		else
+		{
+		    xftg->metrics.xOff = font->public.max_advance_width;
+		    xftg->metrics.yOff = 0;
+		}
+	    }
+	}
+	else
+	{
+	    xftg->metrics.xOff = TRUNC(ROUND(glyphslot->advance.x));
+	    xftg->metrics.yOff = -TRUNC(ROUND(glyphslot->advance.y));
+	}
+	
+	/*
+	 * If the glyph is relatively large (> 1% of server memory),
+	 * don't send it until necessary
+	 */
+	if (!need_bitmaps && size > info->max_glyph_memory / 100)
+	    continue;
+	
+	/*
+	 * Make sure there's enough buffer space for the glyph
+	 */
+	if (size > bufSize)
+	{
+	    if (bufBitmap != bufLocal)
+		free (bufBitmap);
+	    bufBitmap = (unsigned char *) malloc (size);
+	    if (!bufBitmap)
+		continue;
+	    bufSize = size;
+	}
+	memset (bufBitmap, 0, size);
+
+	/*
+	 * Rasterize into the local buffer
+	 */
+	switch (glyphslot->format) {
+	case ft_glyph_format_outline:
+	    ftbit.width      = width * hmul;
+	    ftbit.rows       = height * vmul;
+	    ftbit.pitch      = pitch;
+	    if (font->info.antialias)
+		ftbit.pixel_mode = ft_pixel_mode_grays;
+	    else
+		ftbit.pixel_mode = ft_pixel_mode_mono;
+	    
+	    ftbit.buffer     = bufBitmap;
+	    
+	    if (subpixel)
+		FT_Outline_Transform (&glyphslot->outline, &matrix);
+
+	    FT_Outline_Translate ( &glyphslot->outline, -left*hmul, -bottom*vmul );
+
+	    FT_Outline_Get_Bitmap( _XftFTlibrary, &glyphslot->outline, &ftbit );
+	    break;
+	case ft_glyph_format_bitmap:
+	    if (font->info.antialias)
+	    {
+		unsigned char	*srcLine, *dstLine;
+		int		height;
+		int		x;
+		int	    h, v;
+
+		srcLine = glyphslot->bitmap.buffer;
+		dstLine = bufBitmap;
+		height = glyphslot->bitmap.rows;
+		while (height--)
+		{
+		    for (x = 0; x < glyphslot->bitmap.width; x++)
+		    {
+			/* always MSB bitmaps */
+			unsigned char	a = ((srcLine[x >> 3] & (0x80 >> (x & 7))) ?
+					     0xff : 0x00);
+			if (subpixel)
+			{
+			    for (v = 0; v < vmul; v++)
+				for (h = 0; h < hmul; h++)
+				    dstLine[v * pitch + x*hmul + h] = a;
+			}
+			else
+			    dstLine[x] = a;
+		    }
+		    dstLine += pitch * vmul;
+		    srcLine += glyphslot->bitmap.pitch;
+		}
+	    }
+	    else
+	    {
+		unsigned char	*srcLine, *dstLine;
+		int		h, bytes;
+
+		srcLine = glyphslot->bitmap.buffer;
+		dstLine = bufBitmap;
+		h = glyphslot->bitmap.rows;
+		bytes = (glyphslot->bitmap.width + 7) >> 3;
+		while (h--)
+		{
+		    memcpy (dstLine, srcLine, bytes);
+		    dstLine += pitch;
+		    srcLine += glyphslot->bitmap.pitch;
+		}
+	    }
+	    break;
+	default:
+	    if (XftDebug() & XFT_DBG_GLYPH)
+		printf ("glyph %d is not in a usable format\n",
+			(int) glyphindex);
+	    continue;
+	}
+	
+	if (XftDebug() & XFT_DBG_GLYPH)
+	{
+	    printf ("glyph %d:\n", (int) glyphindex);
+	    printf (" xywh (%d %d %d %d), trans (%d %d %d %d) wh (%d %d)\n",
+		    (int) glyphslot->metrics.horiBearingX,
+		    (int) glyphslot->metrics.horiBearingY,
+		    (int) glyphslot->metrics.width,
+		    (int) glyphslot->metrics.height,
+		    left, right, top, bottom,
+		    width, height);
+	    if (XftDebug() & XFT_DBG_GLYPHV)
+	    {
+		int		x, y;
+		unsigned char	*line;
+
+		line = bufBitmap;
+		for (y = 0; y < height * vmul; y++)
+		{
+		    if (font->info.antialias) 
+		    {
+			static char    den[] = { " .:;=+*#" };
+			for (x = 0; x < pitch; x++)
+			    printf ("%c", den[line[x] >> 5]);
+		    }
+		    else
+		    {
+			for (x = 0; x < pitch * 8; x++)
+			{
+			    printf ("%c", line[x>>3] & (1 << (x & 7)) ? '#' : ' ');
+			}
+		    }
+		    printf ("|\n");
+		    line += pitch;
+		}
+		printf ("\n");
+	    }
+	}
+
+	/*
+	 * Use the glyph index as the wire encoding; it
+	 * might be more efficient for some locales to map
+	 * these by first usage to smaller values, but that
+	 * would require persistently storing the map when
+	 * glyphs were freed.
+	 */
+	glyph = (Glyph) glyphindex;
+
+	if (subpixel)
+	{
+	    int		    x, y;
+	    unsigned char   *in_line, *out_line, *in;
+	    unsigned int    *out;
+	    unsigned int    red, green, blue;
+	    int		    rf, gf, bf;
+	    int		    s;
+	    int		    o, os;
+	    
+	    /*
+	     * Filter the glyph to soften the color fringes
+	     */
+	    widthrgba = width;
+	    pitchrgba = (widthrgba * 4 + 3) & ~3;
+	    sizergba = pitchrgba * height;
+
+	    os = 1;
+	    switch (font->info.rgba) {
+	    case FC_RGBA_VRGB:
+		os = pitch;
+	    case FC_RGBA_RGB:
+	    default:
+		rf = 0;
+		gf = 1;
+		bf = 2;
+		break;
+	    case FC_RGBA_VBGR:
+		os = pitch;
+	    case FC_RGBA_BGR:
+		bf = 0;
+		gf = 1;
+		rf = 2;
+		break;
+	    }
+	    if (sizergba > bufSizeRgba)
+	    {
+		if (bufBitmapRgba != bufLocalRgba)
+		    free (bufBitmapRgba);
+		bufBitmapRgba = (unsigned char *) malloc (sizergba);
+		if (!bufBitmapRgba)
+		    continue;
+		bufSizeRgba = sizergba;
+	    }
+	    memset (bufBitmapRgba, 0, sizergba);
+	    in_line = bufBitmap;
+	    out_line = bufBitmapRgba;
+	    for (y = 0; y < height; y++)
+	    {
+		in = in_line;
+		out = (unsigned int *) out_line;
+		in_line += pitch * vmul;
+		out_line += pitchrgba;
+		for (x = 0; x < width * hmul; x += hmul)
+		{
+		    red = green = blue = 0;
+		    o = 0;
+		    for (s = 0; s < 3; s++)
+		    {
+			red += filters[rf][s]*in[x+o];
+			green += filters[gf][s]*in[x+o];
+			blue += filters[bf][s]*in[x+o];
+			o += os;
+		    }
+		    red = red / 65536;
+		    green = green / 65536;
+		    blue = blue / 65536;
+		    *out++ = (green << 24) | (red << 16) | (green << 8) | blue;
+		}
+	    }
+	    
+	    xftg->glyph_memory = sizergba + sizeof (XftGlyph);
+	    if (font->format)
+	    {
+		if (!font->glyphset)
+		    font->glyphset = XRenderCreateGlyphSet (dpy, font->format);
+		if (ImageByteOrder (dpy) != XftNativeByteOrder ())
+		    XftSwapCARD32 ((CARD32 *) bufBitmapRgba, sizergba >> 2);
+		XRenderAddGlyphs (dpy, font->glyphset, &glyph,
+				  &xftg->metrics, 1, 
+				  (char *) bufBitmapRgba, sizergba);
+	    }
+	    else
+	    {
+		if (sizergba)
+		{
+		    xftg->bitmap = malloc (sizergba);
+		    if (xftg->bitmap)
+			memcpy (xftg->bitmap, bufBitmapRgba, sizergba);
+		}
+		else
+		    xftg->bitmap = NULL;
+	    }
+	}
+	else
+	{
+	    xftg->glyph_memory = size + sizeof (XftGlyph);
+	    if (font->format)
+	    {
+		/*
+		 * swap bit order around; FreeType is always MSBFirst
+		 */
+		if (!font->info.antialias)
+		{
+		    if (BitmapBitOrder (dpy) != MSBFirst)
+		    {
+			unsigned char   *line;
+			unsigned char   c;
+			int		    i;
+
+			line = (unsigned char *) bufBitmap;
+			i = size;
+			while (i--)
+			{
+			    c = *line;
+			    c = ((c << 1) & 0xaa) | ((c >> 1) & 0x55);
+			    c = ((c << 2) & 0xcc) | ((c >> 2) & 0x33);
+			    c = ((c << 4) & 0xf0) | ((c >> 4) & 0x0f);
+			    *line++ = c;
+			}
+		    }
+		}
+		if (!font->glyphset)
+		    font->glyphset = XRenderCreateGlyphSet (dpy, font->format);
+		XRenderAddGlyphs (dpy, font->glyphset, &glyph,
+				  &xftg->metrics, 1, 
+				  (char *) bufBitmap, size);
+	    }
+	    else
+	    {
+		if (size)
+		{
+		    xftg->bitmap = malloc (size);
+		    if (xftg->bitmap)
+			memcpy (xftg->bitmap, bufBitmap, size);
+		}
+		else
+		    xftg->bitmap = NULL;
+	    }
+	}
+	font->glyph_memory += xftg->glyph_memory;
+	info->glyph_memory += xftg->glyph_memory;
+	if (XftDebug() & XFT_DBG_CACHE)
+	    _XftFontValidateMemory (dpy, pub);
+	if (XftDebug() & XFT_DBG_CACHEV)
+	    printf ("Caching glyph 0x%x size %ld\n", glyphindex,
+		    xftg->glyph_memory);
+    }
+    if (bufBitmap != bufLocal)
+	free (bufBitmap);
+    if (bufBitmapRgba != bufLocalRgba)
+	free (bufBitmapRgba);
+    XftUnlockFace (&font->public);
+}
+
+_X_EXPORT void
+XftFontUnloadGlyphs (Display		*dpy,
+		     XftFont		*pub,
+		     _Xconst FT_UInt	*glyphs,
+		     int		nglyph)
+{
+    XftDisplayInfo  *info = _XftDisplayInfoGet (dpy, False);
+    XftFontInt	    *font = (XftFontInt *) pub;
+    XftGlyph	    *xftg;
+    FT_UInt	    glyphindex;
+    Glyph	    glyphBuf[1024];
+    int		    nused;
+    
+    nused = 0;
+    while (nglyph--)
+    {
+	glyphindex = *glyphs++;
+	xftg = font->glyphs[glyphindex];
+	if (!xftg)
+	    continue;
+	if (xftg->glyph_memory)
+	{
+	    if (font->format)
+	    {
+		if (font->glyphset)
+		{
+		    glyphBuf[nused++] = (Glyph) glyphindex;
+		    if (nused == sizeof (glyphBuf) / sizeof (glyphBuf[0]))
+		    {
+			XRenderFreeGlyphs (dpy, font->glyphset, glyphBuf, nused);
+			nused = 0;
+		    }
+		}
+	    }
+	    else
+	    {
+		if (xftg->bitmap)
+		    free (xftg->bitmap);
+	    }
+	    font->glyph_memory -= xftg->glyph_memory;
+	    if (info)
+		info->glyph_memory -= xftg->glyph_memory;
+	}
+	free (xftg);
+	XftMemFree (XFT_MEM_GLYPH, sizeof (XftGlyph));
+	font->glyphs[glyphindex] = NULL;
+    }    
+    if (font->glyphset && nused)
+	XRenderFreeGlyphs (dpy, font->glyphset, glyphBuf, nused);
+}
+
+_X_EXPORT FcBool
+XftFontCheckGlyph (Display	*dpy,
+		   XftFont	*pub,
+		   FcBool	need_bitmaps,
+		   FT_UInt	glyph,
+		   FT_UInt	*missing,
+		   int		*nmissing)
+{
+    XftFontInt	    *font = (XftFontInt *) pub;
+    XftGlyph	    *xftg;
+    int		    n;
+    
+    if (glyph >= font->num_glyphs)
+	return FcFalse;
+    xftg = font->glyphs[glyph];
+    if (!xftg || (need_bitmaps && !xftg->glyph_memory))
+    {
+	if (!xftg)
+	{
+	    xftg = (XftGlyph *) malloc (sizeof (XftGlyph));
+	    if (!xftg)
+		return FcFalse;
+	    XftMemAlloc (XFT_MEM_GLYPH, sizeof (XftGlyph));
+	    xftg->bitmap = NULL;
+	    xftg->glyph_memory = 0;
+	    font->glyphs[glyph] = xftg;
+	}
+	n = *nmissing;
+	missing[n++] = glyph;
+	if (n == XFT_NMISSING)
+	{
+	    XftFontLoadGlyphs (dpy, pub, need_bitmaps, missing, n);
+	    n = 0;
+	}
+	*nmissing = n;
+	return FcTrue;
+    }
+    else
+	return FcFalse;
+}
+
+_X_EXPORT FcBool
+XftCharExists (Display	    *dpy,
+	       XftFont	    *pub,
+	       FcChar32    ucs4)
+{
+    if (pub->charset)
+	return FcCharSetHasChar (pub->charset, ucs4);
+    return FcFalse;
+}
+
+#define Missing	    ((FT_UInt) ~0)
+
+_X_EXPORT FT_UInt
+XftCharIndex (Display	    *dpy, 
+	      XftFont	    *pub,
+	      FcChar32	    ucs4)
+{
+    XftFontInt	*font = (XftFontInt *) pub;
+    FcChar32	ent, offset;
+    FT_Face	face;
+    
+    if (!font->hash_value)
+	return 0;
+
+    ent = ucs4 % font->hash_value;
+    offset = 0;
+    while (font->hash_table[ent].ucs4 != ucs4)
+    {
+	if (font->hash_table[ent].ucs4 == (FcChar32) ~0)
+	{
+	    if (!XftCharExists (dpy, pub, ucs4))
+		return 0;
+	    face  = XftLockFace (pub);
+	    if (!face)
+		return 0;
+	    font->hash_table[ent].ucs4 = ucs4;
+	    font->hash_table[ent].glyph = FcFreeTypeCharIndex (face, ucs4);
+	    XftUnlockFace (pub);
+	    break;
+	}
+	if (!offset)
+	{
+	    offset = ucs4 % font->rehash_value;
+	    if (!offset)
+		offset = 1;
+	}
+	ent = ent + offset;
+	if (ent >= font->hash_value)
+	    ent -= font->hash_value;
+    }
+    return font->hash_table[ent].glyph;
+}
+
+/*
+ * Pick a random glyph from the font and remove it from the cache
+ */
+_X_HIDDEN void
+_XftFontUncacheGlyph (Display *dpy, XftFont *pub)
+{
+    XftFontInt	    *font = (XftFontInt *) pub;
+    unsigned long   glyph_memory;
+    FT_UInt	    glyphindex;
+    XftGlyph	    *xftg;
+    
+    if (!font->glyph_memory)
+	return;
+    if (font->use_free_glyphs)
+    {
+	glyph_memory = rand() % font->glyph_memory;
+    }
+    else
+    {
+	if (font->glyphset)
+	{
+	    XRenderFreeGlyphSet (dpy, font->glyphset);
+	    font->glyphset = 0;
+	}
+	glyph_memory = 0;
+    }
+	
+    if (XftDebug() & XFT_DBG_CACHE)
+	_XftFontValidateMemory (dpy, pub);
+    for (glyphindex = 0; glyphindex < font->num_glyphs; glyphindex++)
+    {
+	xftg = font->glyphs[glyphindex];
+	if (xftg)
+	{
+	    if (xftg->glyph_memory > glyph_memory)
+	    {
+		if (XftDebug() & XFT_DBG_CACHEV)
+		    printf ("Uncaching glyph 0x%x size %ld\n",
+			    glyphindex, xftg->glyph_memory);
+		XftFontUnloadGlyphs (dpy, pub, &glyphindex, 1);
+		if (!font->use_free_glyphs)
+		    continue;
+		break;
+	    }
+	    glyph_memory -= xftg->glyph_memory;
+	}
+    }
+    if (XftDebug() & XFT_DBG_CACHE)
+	_XftFontValidateMemory (dpy, pub);
+}
+
+_X_HIDDEN void
+_XftFontManageMemory (Display *dpy, XftFont *pub)
+{
+    XftFontInt	*font = (XftFontInt *) pub;
+
+    if (font->max_glyph_memory)
+    {
+	if (XftDebug() & XFT_DBG_CACHE)
+	{
+	    if (font->glyph_memory > font->max_glyph_memory)
+		printf ("Reduce memory for font 0x%lx from %ld to %ld\n",
+			font->glyphset ? font->glyphset : (unsigned long) font,
+			font->glyph_memory, font->max_glyph_memory);
+	}
+	while (font->glyph_memory > font->max_glyph_memory)
+	    _XftFontUncacheGlyph (dpy, pub);
+    }
+    _XftDisplayManageMemory (dpy);
+}
diff --git a/libXft/src/xftinit.c b/libXft/src/xftinit.c
new file mode 100644
index 000000000..43efc00e1
--- /dev/null
+++ b/libXft/src/xftinit.c
@@ -0,0 +1,113 @@
+/*
+ * 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"
+
+static Bool _XftConfigInitialized;
+
+_X_EXPORT Bool
+XftInit (_Xconst char *config)
+{
+    if (_XftConfigInitialized)
+	return True;
+    _XftConfigInitialized = True;
+    if (!FcInit ())
+	return False;
+    _XftNameInit ();
+    return True;
+}
+
+_X_EXPORT int
+XftGetVersion (void)
+{
+    return XftVersion;
+}
+
+static struct {
+    char    *name;
+    int	    alloc_count;
+    int	    alloc_mem;
+    int	    free_count;
+    int	    free_mem;
+} XftInUse[XFT_MEM_NUM] = {
+    { "XftDraw", 0, 0 },
+    { "XftFont", 0 ,0 },
+    { "XftFtFile", 0, 0 },
+    { "XftGlyph", 0, 0 },
+};
+
+static int  XftAllocCount, XftAllocMem;
+static int  XftFreeCount, XftFreeMem;
+
+static int  XftMemNotice = 1*1024*1024;
+
+static int  XftAllocNotify, XftFreeNotify;
+
+_X_HIDDEN void
+XftMemReport (void)
+{
+    int	i;
+    printf ("Xft Memory Usage:\n");
+    printf ("\t   Which       Alloc           Free\n");
+    printf ("\t           count   bytes   count   bytes\n");
+    for (i = 0; i < XFT_MEM_NUM; i++)
+	printf ("\t%8.8s%8d%8d%8d%8d\n",
+		XftInUse[i].name,
+		XftInUse[i].alloc_count, XftInUse[i].alloc_mem,
+		XftInUse[i].free_count, XftInUse[i].free_mem);
+    printf ("\t%8.8s%8d%8d%8d%8d\n",
+	    "Total",
+	    XftAllocCount, XftAllocMem,
+	    XftFreeCount, XftFreeMem);
+    XftAllocNotify = 0;
+    XftFreeNotify = 0;
+}
+
+_X_HIDDEN void
+XftMemAlloc (int kind, int size)
+{
+    if (XftDebug() & XFT_DBG_MEMORY)
+    {
+	XftInUse[kind].alloc_count++;
+	XftInUse[kind].alloc_mem += size;
+	XftAllocCount++;
+	XftAllocMem += size;
+	XftAllocNotify += size;
+	if (XftAllocNotify > XftMemNotice)
+	    XftMemReport ();
+    }
+}
+
+_X_HIDDEN void
+XftMemFree (int kind, int size)
+{
+    if (XftDebug() & XFT_DBG_MEMORY)
+    {
+	XftInUse[kind].free_count++;
+	XftInUse[kind].free_mem += size;
+	XftFreeCount++;
+	XftFreeMem += size;
+	XftFreeNotify += size;
+	if (XftFreeNotify > XftMemNotice)
+	    XftMemReport ();
+    }
+}
diff --git a/libXft/src/xftint.h b/libXft/src/xftint.h
new file mode 100644
index 000000000..3aafecf86
--- /dev/null
+++ b/libXft/src/xftint.h
@@ -0,0 +1,465 @@
+/*
+ * 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.
+ */
+
+/*
+ * These definitions are solely for use by the implementation of Xft
+ * and constitute no kind of standard.  If you need any of these functions,
+ * please drop me a note.  Either the library needs new functionality,
+ * or there's a way to do what you need using the existing published
+ * interfaces. keithp@freedesktop.org
+ */
+
+#ifndef _XFTINT_H_
+#define _XFTINT_H_
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#else /* X monolithic tree */
+#define HAVE_STDLIB_H 1  /* assumed since all ANSI C platforms require it */
+#include <X11/Xosdefs.h> /* get string.h or strings.h as appropriate */
+#endif
+
+#include <stdio.h>
+#if HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#if HAVE_STRING_H
+#include <string.h>
+#else
+#if HAVE_STRINGS_H
+#include <strings.h>
+#endif
+#endif
+#include <ctype.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xmd.h>
+#include <X11/Xlibint.h>
+#define _XFT_NO_COMPAT_
+#include "Xft.h"
+#include <fontconfig/fcprivate.h>
+#include <fontconfig/fcfreetype.h>
+
+/* Added to <X11/Xfuncproto.h> in X11R6.9 and later */
+#ifndef _X_HIDDEN
+# define _X_HIDDEN /**/
+#endif
+#ifndef _X_EXPORT
+# define _X_EXPORT /**/
+#endif
+
+#ifndef HAVE_CONFIG_H
+# if (FREETYPE_MAJOR > 2 ||						    \
+      (FREETYPE_MAJOR == 2 && (FREETYPE_MINOR > 1 ||			    \
+			       (FREETYPE_MINOR == 1 && FREETYPE_PATCH >= 5))))
+#  define HAVE_FT_BITMAP_SIZE_Y_PPEM 1
+# else
+#  define HAVE_FT_BITMAP_SIZE_Y_PPEM 0
+# endif
+#endif
+
+typedef struct _XftMatcher {
+    char    *object;
+    double  (*compare) (char *object, FcValue value1, FcValue value2);
+} XftMatcher;
+
+typedef struct _XftSymbolic {
+    const char	*name;
+    int		value;
+} XftSymbolic;
+
+/*
+ * Glyphs are stored in this structure
+ */
+typedef struct _XftGlyph {
+    XGlyphInfo	    metrics;
+    void	    *bitmap;
+    unsigned long   glyph_memory;
+} XftGlyph;
+
+/*
+ * A hash table translates Unicode values into glyph indicies
+ */
+typedef struct _XftUcsHash {
+    FcChar32	    ucs4;
+    FT_UInt	    glyph;
+} XftUcsHash;
+
+/*
+ * Many fonts can share the same underlying face data; this
+ * structure references that.  Note that many faces may in fact
+ * live in the same font file; that is irrelevant to this structure
+ * which is concerned only with the individual faces themselves
+ */
+
+typedef struct _XftFtFile {
+    struct _XftFtFile	*next;
+    int			ref;	    /* number of font infos using this file */
+    
+    char		*file;	    /* file name */
+    int			id;	    /* font index within that file */
+
+    FT_F26Dot6		xsize;	    /* current xsize setting */
+    FT_F26Dot6		ysize;	    /* current ysize setting */
+    FT_Matrix		matrix;	    /* current matrix setting */
+    
+    int			lock;	    /* lock count; can't unload unless 0 */
+    FT_Face		face;	    /* pointer to face; only valid when lock */
+} XftFtFile;
+
+/*
+ * This structure holds the data extracted from a pattern
+ * needed to create a unique font object.
+ */
+
+struct _XftFontInfo {
+    /*
+     * Hash value (not include in hash value computation)
+     */
+    FcChar32		hash;
+    XftFtFile		*file;		/* face source */
+    /*
+     * Rendering options
+     */
+    FT_F26Dot6		xsize, ysize;	/* pixel size */
+    FcBool		antialias;	/* doing antialiasing */
+    FcBool		embolden;	/* force emboldening */
+    int			rgba;		/* subpixel order */
+    FT_Matrix		matrix;		/* glyph transformation matrix */
+    FcBool		transform;	/* non-identify matrix? */
+    FT_Int		load_flags;	/* glyph load flags */
+    FcBool		render;		/* whether to use the Render extension */
+    /*
+     * Internal fields
+     */
+    int			spacing;
+    FcBool		minspace;
+    int			char_width;
+};
+
+/*
+ * Internal version of the font with private data
+ */
+
+typedef struct _XftFontInt {
+    XftFont		public;		/* public fields */
+    XftFont		*next;		/* all fonts on display */
+    XftFont		*hash_next;	/* fonts in this hash chain */
+    XftFontInfo		info;		/* Data from pattern */
+    int			ref;		/* reference count */
+    /*
+     * Per-glyph information, indexed by glyph ID
+     * This array follows the font in memory
+     */
+    XftGlyph		**glyphs;
+    int			num_glyphs;	/* size of glyphs/bitmaps arrays */
+    /*
+     * Hash table to get from Unicode value to glyph ID
+     * This array follows the glyphs in memory
+     */
+    XftUcsHash		*hash_table;
+    int			hash_value;
+    int			rehash_value;
+    /*
+     * X specific fields
+     */
+    GlyphSet		glyphset;	/* Render glyphset */
+    XRenderPictFormat	*format;	/* Render format for glyphs */
+    /*
+     * Glyph memory management fields
+     */
+    unsigned long	glyph_memory;
+    unsigned long	max_glyph_memory;
+    FcBool		use_free_glyphs;   /* Use XRenderFreeGlyphs */
+} XftFontInt;
+
+typedef enum _XftClipType {
+    XftClipTypeNone, XftClipTypeRegion, XftClipTypeRectangles
+} XftClipType;
+
+typedef struct _XftClipRect {
+    int			xOrigin;
+    int			yOrigin;
+    int			n;
+} XftClipRect;
+
+#define XftClipRects(cr)    ((XRectangle *) ((cr) + 1))
+
+typedef union _XftClip {
+    XftClipRect	    *rect;
+    Region	    region;
+} XftClip;
+
+struct _XftDraw {
+    Display	    *dpy;
+    int		    screen;
+    unsigned int    bits_per_pixel;
+    unsigned int    depth;
+    Drawable	    drawable;
+    Visual	    *visual;	/* NULL for bitmaps */
+    Colormap	    colormap;
+    XftClipType	    clip_type;
+    XftClip	    clip;
+    int		    subwindow_mode;
+    struct {
+	Picture		pict;
+    } render;
+    struct {
+	GC		gc;
+	int		use_pixmap;
+    } core;
+};
+
+/*
+ * Instead of taking two round trips for each blending request,
+ * assume that if a particular drawable fails GetImage that it will
+ * fail for a "while"; use temporary pixmaps to avoid the errors
+ */
+
+#define XFT_ASSUME_PIXMAP	20
+
+typedef struct _XftSolidColor {
+    XRenderColor    color;
+    int		    screen;
+    Picture	    pict;
+} XftSolidColor;
+
+#define XFT_NUM_SOLID_COLOR	16
+
+#define XFT_NUM_FONT_HASH	127
+
+typedef struct _XftDisplayInfo {
+    struct _XftDisplayInfo  *next;
+    Display		    *display;
+    XExtCodes		    *codes;
+    FcPattern		    *defaults;
+    FcBool		    hasRender;
+    XftFont		    *fonts;
+    XRenderPictFormat	    *solidFormat;
+    unsigned long	    glyph_memory;
+    unsigned long	    max_glyph_memory;
+    FcBool		    use_free_glyphs;
+    int			    num_unref_fonts;
+    int			    max_unref_fonts;
+    XftSolidColor	    colors[XFT_NUM_SOLID_COLOR];
+    XftFont		    *fontHash[XFT_NUM_FONT_HASH];
+} XftDisplayInfo;
+
+/*
+ * By default, use no more than 4 meg of server memory total, and no
+ * more than 1 meg for any one font
+ */
+#define XFT_DPY_MAX_GLYPH_MEMORY    (4 * 1024 * 1024)
+#define XFT_FONT_MAX_GLYPH_MEMORY   (1024 * 1024)
+
+/*
+ * By default, keep the last 16 unreferenced fonts around to
+ * speed reopening them.  Note that the glyph caching code
+ * will keep the global memory usage reasonably limited
+ */
+#define XFT_DPY_MAX_UNREF_FONTS	    16
+
+extern XftDisplayInfo	*_XftDisplayInfo;
+
+#define XFT_DBG_OPEN	1
+#define XFT_DBG_OPENV	2
+#define XFT_DBG_RENDER	4
+#define XFT_DBG_DRAW	8
+#define XFT_DBG_REF	16
+#define XFT_DBG_GLYPH	32
+#define XFT_DBG_GLYPHV	64
+#define XFT_DBG_CACHE	128
+#define XFT_DBG_CACHEV	256
+#define XFT_DBG_MEMORY	512
+
+#define XFT_MEM_DRAW	0
+#define XFT_MEM_FONT	1
+#define XFT_MEM_FILE	2
+#define XFT_MEM_GLYPH	3
+#define XFT_MEM_NUM	4
+
+/* xftcompat.c */
+void XftFontSetDestroy (FcFontSet *s);
+FcBool XftMatrixEqual (_Xconst FcMatrix *mat1, _Xconst FcMatrix *mat2);
+void XftMatrixMultiply (FcMatrix *result, FcMatrix *a, FcMatrix *b);
+void XftMatrixRotate (FcMatrix *m, double c, double s);
+void XftMatrixScale (FcMatrix *m, double sx, double sy);
+void XftMatrixShear (FcMatrix *m, double sh, double sv);
+FcPattern *XftPatternCreate (void);
+void XftValueDestroy (FcValue v);
+void XftPatternDestroy (FcPattern *p);
+FcBool XftPatternAdd (FcPattern *p, _Xconst char *object, FcValue value, FcBool append);
+FcBool XftPatternDel (FcPattern *p, _Xconst char *object);
+FcBool XftPatternAddInteger (FcPattern *p, _Xconst char *object, int i);
+FcBool XftPatternAddDouble (FcPattern *p, _Xconst char *object, double i);
+FcBool XftPatternAddMatrix (FcPattern *p, _Xconst char *object, FcMatrix *i);
+FcBool XftPatternAddString (FcPattern *p, _Xconst char *object, char *i);
+FcBool XftPatternAddBool (FcPattern *p, _Xconst char *object, FcBool i);
+FcResult XftPatternGet (FcPattern *p, _Xconst char *object, int id, FcValue *v);
+FcResult XftPatternGetInteger (FcPattern *p, _Xconst char *object, int id, int *i);
+FcResult XftPatternGetDouble (FcPattern *p, _Xconst char *object, int id, double *i);
+FcResult XftPatternGetString (FcPattern *p, _Xconst char *object, int id, char **i);
+FcResult XftPatternGetMatrix (FcPattern *p, _Xconst char *object, int id, FcMatrix **i);
+FcResult XftPatternGetBool (FcPattern *p, _Xconst char *object, int id, FcBool *i);
+FcPattern *XftPatternDuplicate (FcPattern *orig);
+FcPattern *XftPatternVaBuild (FcPattern *orig, va_list va);
+FcPattern *XftPatternBuild (FcPattern *orig, ...);
+FcBool XftNameUnparse (FcPattern *pat, char *dest, int len);
+FcBool XftGlyphExists (Display *dpy, XftFont *font, FcChar32 ucs4);
+FcObjectSet *XftObjectSetCreate (void);
+Bool XftObjectSetAdd (FcObjectSet *os, _Xconst char *object);
+void XftObjectSetDestroy (FcObjectSet *os);
+FcObjectSet *XftObjectSetVaBuild (_Xconst char *first, va_list va);
+FcObjectSet *XftObjectSetBuild (_Xconst char *first, ...);
+FcFontSet *XftListFontSets (FcFontSet **sets, int nsets, FcPattern *p, FcObjectSet *os);
+
+/* xftcore.c */
+void
+XftRectCore (XftDraw		*draw,
+	     _Xconst XftColor	*color,
+	     int		x, 
+	     int		y,
+	     unsigned int	width,
+	     unsigned int	height);
+
+void
+XftGlyphCore (XftDraw		*draw,
+	      _Xconst XftColor	*color,
+	      XftFont		*public,
+	      int		x,
+	      int		y,
+	      _Xconst FT_UInt	*glyphs,
+	      int		nglyphs);
+
+void
+XftGlyphSpecCore (XftDraw		*draw,
+		  _Xconst XftColor	*color,
+		  XftFont		*public,
+		  _Xconst XftGlyphSpec	*glyphs,
+		  int			nglyphs);
+
+void
+XftGlyphFontSpecCore (XftDraw			*draw,
+		      _Xconst XftColor		*color,
+		      _Xconst XftGlyphFontSpec	*glyphs,
+		      int			nglyphs);
+
+/* xftdbg.c */
+int
+XftDebug (void);
+
+/* xftdpy.c */
+XftDisplayInfo *
+_XftDisplayInfoGet (Display *dpy, FcBool createIfNecessary);
+
+void
+_XftDisplayManageMemory (Display *dpy);
+
+int
+XftDefaultParseBool (char *v);
+
+FcBool
+XftDefaultGetBool (Display *dpy, const char *object, int screen, FcBool def);
+
+int
+XftDefaultGetInteger (Display *dpy, const char *object, int screen, int def);
+
+double
+XftDefaultGetDouble (Display *dpy, const char *object, int screen, double def);
+
+FcFontSet *
+XftDisplayGetFontSet (Display *dpy);
+
+/* xftdraw.c */
+unsigned int
+XftDrawDepth (XftDraw *draw);
+
+unsigned int
+XftDrawBitsPerPixel (XftDraw *draw);
+
+FcBool
+XftDrawRenderPrepare (XftDraw	*draw);
+
+/* xftextent.c */
+    
+/* xftfont.c */
+
+/* xftfreetype.c */
+FcBool
+_XftSetFace (XftFtFile *f, FT_F26Dot6 xsize, FT_F26Dot6 ysize, FT_Matrix *matrix);
+
+void
+XftFontManageMemory (Display *dpy);
+
+/* xftglyph.c */
+void
+_XftFontUncacheGlyph (Display *dpy, XftFont *public);
+
+void
+_XftFontManageMemory (Display *dpy, XftFont *public);
+
+/* xftinit.c */
+void
+XftMemReport (void);
+
+void
+XftMemAlloc (int kind, int size);
+
+void
+XftMemFree (int kind, int size);
+
+/* xftlist.c */
+FcFontSet *
+XftListFontsPatternObjects (Display	    *dpy,
+			    int		    screen,
+			    FcPattern	    *pattern,
+			    FcObjectSet    *os);
+
+/* xftname.c */
+void 
+_XftNameInit (void);
+
+/* xftrender.c */
+
+/* xftstr.c */
+int
+_XftMatchSymbolic (XftSymbolic *s, int n, const char *name, int def);
+
+/* xftswap.c */
+int
+XftNativeByteOrder (void);
+
+void
+XftSwapCARD32 (CARD32 *data, int n);
+
+void
+XftSwapCARD24 (CARD8 *data, int width, int height);
+
+void
+XftSwapCARD16 (CARD16 *data, int n);
+
+void
+XftSwapImage (XImage *image);
+
+/* xftxlfd.c */
+#endif /* _XFT_INT_H_ */
diff --git a/libXft/src/xftlist.c b/libXft/src/xftlist.c
new file mode 100644
index 000000000..0780f7ca8
--- /dev/null
+++ b/libXft/src/xftlist.c
@@ -0,0 +1,58 @@
+/*
+ * 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 FcFontSet *
+XftListFontsPatternObjects (Display	    *dpy,
+			    int		    screen,
+			    FcPattern	    *pattern,
+			    FcObjectSet    *os)
+{
+    return FcFontList (NULL, pattern, os);
+}
+
+_X_EXPORT FcFontSet *
+XftListFonts (Display	*dpy,
+	      int	screen,
+	      ...)
+{
+    va_list	    va;
+    FcFontSet	    *fs;
+    FcObjectSet	    *os;
+    FcPattern	    *pattern;
+    const char	    *first;
+
+    va_start (va, screen);
+
+    FcPatternVapBuild (pattern, NULL, va);
+    
+    first = va_arg (va, const char *);
+    FcObjectSetVapBuild (os, first, va);
+    
+    va_end (va);
+    
+    fs = XftListFontsPatternObjects (dpy, screen, pattern, os);
+    FcPatternDestroy (pattern);
+    FcObjectSetDestroy (os);
+    return fs;
+}
diff --git a/libXft/src/xftname.c b/libXft/src/xftname.c
new file mode 100644
index 000000000..a0c6be704
--- /dev/null
+++ b/libXft/src/xftname.c
@@ -0,0 +1,82 @@
+/*
+ * 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"
+
+static const FcObjectType	_XftObjectTypes[] = {
+    { XFT_CORE,		FcTypeBool, },
+    { XFT_XLFD,		FcTypeString, },
+    { XFT_RENDER,	FcTypeBool, },
+    { XFT_MAX_GLYPH_MEMORY, FcTypeInteger, },
+};
+
+#define NUM_OBJECT_TYPES    (sizeof _XftObjectTypes / sizeof _XftObjectTypes[0])
+
+static FcBool _XftNameInitialized;
+
+_X_HIDDEN void 
+_XftNameInit (void)
+{
+    if (_XftNameInitialized)
+	return;
+    _XftNameInitialized = FcTrue;
+    FcNameRegisterObjectTypes (_XftObjectTypes, NUM_OBJECT_TYPES);
+}
+
+_X_EXPORT FcPattern 
+*XftNameParse (const char *name)
+{ 
+    _XftNameInit ();
+    return FcNameParse ((FcChar8 *) name); 
+}
+
+_X_EXPORT FcBool
+XftNameUnparse (FcPattern *pat, char *dest, int len)
+{
+    FcChar8 *name;
+
+    _XftNameInit ();
+    name = FcNameUnparse (pat);
+    if (!name)
+	return FcFalse;
+    if (strlen ((char *) name) + 1 > len)
+    {
+	FcPattern *new = FcPatternDuplicate (pat);
+	free (name);
+	FcPatternDel (new, FC_LANG);
+	FcPatternDel (new, FC_CHARSET);
+	name = FcNameUnparse (new);
+	FcPatternDestroy (new);
+	if (!name)
+	    return FcFalse;
+	if (strlen ((char *) name) + 1 > len)
+	{
+	    strncpy (dest, ((char *) name), (size_t) len - 1);
+	    dest[len - 1] = '\0';
+	    free (name);
+	    return FcFalse;
+	}
+    }
+    strcpy (dest, ((char *) name));
+    free (name);
+    return FcTrue;
+}
diff --git a/libXft/src/xftrender.c b/libXft/src/xftrender.c
new file mode 100644
index 000000000..94c211bde
--- /dev/null
+++ b/libXft/src/xftrender.c
@@ -0,0 +1,1007 @@
+/*
+ * 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"
+
+#define NUM_LOCAL	1024
+#define NUM_ELT_LOCAL	128
+
+/*
+ * Use the Render extension to draw the glyphs
+ */
+
+_X_EXPORT void
+XftGlyphRender (Display		*dpy,
+		int		op,
+		Picture		src,
+		XftFont		*pub,
+		Picture		dst,
+		int		srcx,
+		int		srcy,
+		int		x,
+		int		y,
+		_Xconst FT_UInt	*glyphs,
+		int		nglyphs)
+{
+    XftFontInt	    *font = (XftFontInt *) pub;
+    int		    i;
+    FT_UInt	    missing[XFT_NMISSING];
+    int		    nmissing;
+    FT_UInt	    g, max;
+    int		    size, width;
+    Glyph	    wire;
+    char	    *char8;
+    unsigned short  *char16;
+    unsigned int    *char32;
+    unsigned int    char_local[NUM_LOCAL];
+    unsigned int    *chars;
+    FcBool	    glyphs_loaded;
+    
+    if (!font->format)
+	return;
+    
+    /*
+     * Load missing glyphs
+     */
+    nmissing = 0;
+    max = 0;
+    glyphs_loaded = FcFalse;
+    for (i = 0; i < nglyphs; i++)
+    {
+	g = glyphs[i];
+	if (g > max)
+	    max = g;
+	if (XftFontCheckGlyph (dpy, pub, FcTrue, g, missing, &nmissing))
+	    glyphs_loaded = FcTrue;
+    }
+    if (nmissing)
+	XftFontLoadGlyphs (dpy, pub, FcTrue, missing, nmissing);
+    
+    if (!font->glyphset)
+	goto bail1;
+    if (max < 0x100)
+    {
+	width = 1;
+	size = sizeof (char);
+    }
+    else if (max < 0x10000)
+    {
+	width = 2;
+	size = sizeof (unsigned short);
+    }
+    else
+    {
+	width = 4;
+	size = sizeof (unsigned int);
+    }
+    chars = char_local;
+    if (nglyphs * size > sizeof (char_local))
+    {
+	chars = malloc (nglyphs * size);
+	if (!chars)
+	    goto bail1;
+    }
+    char8 = (char *) chars;
+    char16 = (unsigned short *) chars;
+    char32 = (unsigned int *) chars;
+    for (i = 0; i < nglyphs; i++)
+    {
+	wire = (Glyph) glyphs[i];
+	if (wire >= font->num_glyphs || !font->glyphs[wire])
+	    wire = 0;
+	switch (width) {
+	case 1: char8[i] = (char) wire; break;
+	case 2: char16[i] = (unsigned short) wire; break;
+	case 4: char32[i] = (unsigned long) wire; break;
+	}
+    }
+    switch (width) {
+    case 1:
+    default:
+	XRenderCompositeString8 (dpy, op,
+				 src, dst, font->format, font->glyphset,
+				 srcx, srcy, x, y, char8, nglyphs);
+	break;
+    case 2:
+	XRenderCompositeString16(dpy, op,
+				 src, dst, font->format, font->glyphset,
+				 srcx, srcy, x, y, char16, nglyphs);
+	break;
+    case 4:
+	XRenderCompositeString32(dpy, op,
+				 src, dst, font->format, font->glyphset,
+				 srcx, srcy, x, y, char32, nglyphs);
+	break;
+    }
+    if (chars != char_local)
+	free (chars);
+bail1:
+    if (glyphs_loaded)
+	_XftFontManageMemory (dpy, pub);
+}
+
+_X_EXPORT void
+XftGlyphSpecRender (Display		    *dpy,
+		    int			    op,
+		    Picture		    src,
+		    XftFont		    *pub,
+		    Picture		    dst,
+		    int			    srcx,
+		    int			    srcy,
+		    _Xconst XftGlyphSpec    *glyphs,
+		    int			    nglyphs)
+{
+    XftFontInt	    *font = (XftFontInt *) pub;
+    int		    i, j;
+    FT_UInt	    missing[XFT_NMISSING];
+    int		    nmissing;
+    int		    n;
+    FT_UInt	    g;
+    XftGlyph	    *glyph;
+    FT_UInt	    max;
+    int		    size, width;
+    char	    *char8;
+    unsigned short  *char16;
+    unsigned int    *char32;
+    unsigned int    char_local[NUM_LOCAL];
+    unsigned int    *chars;
+    XGlyphElt8	    *elts;
+    XGlyphElt8	    elts_local[NUM_ELT_LOCAL];
+    FcBool	    glyphs_loaded;
+    int		    nelt;
+    int		    x, y;
+    
+    if (!font->format)
+	return;
+    if (!nglyphs)
+	return;
+    
+    /*
+     * Load missing glyphs
+     */
+    max = 0;
+    nmissing = 0;
+    glyphs_loaded = FcFalse;
+    g = glyphs[0].glyph;
+    for (i = 0; i < nglyphs; i++)
+    {
+	g = glyphs[i].glyph;
+	if (g > max)
+	    max = g;
+	if (XftFontCheckGlyph (dpy, pub, FcTrue, g, missing, &nmissing))
+	    glyphs_loaded = FcTrue;
+    }
+    if (nmissing)
+	XftFontLoadGlyphs (dpy, pub, FcTrue, missing, nmissing);
+    
+    if (!font->glyphset)
+	goto bail1;
+
+    /*
+     * See what encoding size is needed
+     */
+    if (max < 0x100)
+    {
+	size = sizeof (char);
+	width = 1;
+    }
+    else if (max < 0x10000)
+    {
+	size = sizeof (unsigned short);
+	width = 2;
+    }
+    else
+    {
+	size = sizeof (unsigned int);
+	width = 4;
+    }
+    chars = char_local;
+    if (nglyphs * size > NUM_LOCAL)
+    {
+	chars = malloc (nglyphs * size);
+	if (!chars)
+	    goto bail1;
+    }
+    char8 = (char *) chars;
+    char16 = (unsigned short *) chars;
+    char32 = (unsigned int *) chars;
+    
+    /*
+     * Compute the number of glyph elts needed
+     */
+    nelt = 1;
+    for (i = 0; i < nglyphs; i++)
+    {
+	g = glyphs[i].glyph;
+	/* Substitute default for non-existant glyphs */
+	if (g >= font->num_glyphs || !font->glyphs[g])
+	    g = 0;
+	if (font->glyphs[g])
+	     break;
+    }
+    if (i == nglyphs)
+	goto bail2;
+    glyph = font->glyphs[g];
+    x = glyphs[i].x + glyph->metrics.xOff;
+    y = glyphs[i].y + glyph->metrics.yOff;
+    while (++i < nglyphs)
+    {
+	g = glyphs[i].glyph;
+	/* Substitute default for non-existant glyphs */
+	if (g >= font->num_glyphs || !font->glyphs[g])
+	    g = 0;
+	/* 
+	 * check to see if the glyph is placed where it would
+	 * fall using the normal spacing
+	 */
+	if ((glyph = font->glyphs[g]))
+	{
+	    if (x != glyphs[i].x || y != glyphs[i].y)
+	    {
+		x = glyphs[i].x;
+		y = glyphs[i].y;
+		++nelt;
+	    }
+	    x += glyph->metrics.xOff;
+	    y += glyph->metrics.yOff;
+	}
+    }
+
+    elts = elts_local;
+    if (nelt > NUM_ELT_LOCAL)
+    {
+	elts = malloc (nelt * sizeof (XGlyphElt8));
+	if (!elts)
+	    goto bail2;
+    }
+
+    /*
+     * Generate the list of glyph elts
+     */
+    nelt = 0;
+    x = y = 0;
+    n = 0;
+    j = 0;
+    for (i = 0; i < nglyphs; i++)
+    {
+	g = glyphs[i].glyph;
+	/* Substitute default for non-existant glyphs */
+	if (g >= font->num_glyphs || !font->glyphs[g])
+	    g = 0;
+	if ((glyph = font->glyphs[g]))
+	{
+	    if (!i || x != glyphs[i].x || y != glyphs[i].y)
+	    {
+		if (n)
+		{
+		    elts[nelt].nchars = n;
+		    nelt++;
+		}
+		elts[nelt].glyphset = font->glyphset;
+		elts[nelt].chars = char8 + size * j;
+		elts[nelt].xOff = glyphs[i].x - x;
+		elts[nelt].yOff = glyphs[i].y - y;
+		x = glyphs[i].x;
+		y = glyphs[i].y;
+		n = 0;
+	    }
+	    switch (width) {
+	    case 1: char8[j] = (char) g; break;
+	    case 2: char16[j] = (unsigned short) g; break;
+	    case 4: char32[j] = (unsigned int) g; break;
+	    }
+	    x += glyph->metrics.xOff;
+	    y += glyph->metrics.yOff;
+	    j++;
+	    n++;
+	}
+    }
+    if (n)
+    {
+	elts[nelt].nchars = n;
+	nelt++;
+    }
+    switch (width) {
+    case 1:
+	XRenderCompositeText8 (dpy, op, src, dst, font->format,
+			       srcx, srcy, glyphs[0].x, glyphs[0].y,
+			       elts, nelt);
+	break;
+    case 2:
+	XRenderCompositeText16 (dpy, op, src, dst, font->format,
+				srcx, srcy, glyphs[0].x, glyphs[0].y,
+				(XGlyphElt16 *) elts, nelt);
+	break;
+    case 4:
+	XRenderCompositeText32 (dpy, op, src, dst, font->format,
+				srcx, srcy, glyphs[0].x, glyphs[0].y,
+				(XGlyphElt32 *) elts, nelt);
+	break;
+    }
+
+    if (elts != elts_local)
+	free (elts);
+bail2:
+    if (chars != char_local)
+	free (chars);
+bail1:
+    if (glyphs_loaded)
+	_XftFontManageMemory (dpy, pub);
+}
+
+_X_EXPORT void
+XftCharSpecRender (Display		*dpy,
+		   int			op,
+		   Picture		src,
+		   XftFont		*pub,
+		   Picture		dst,
+		   int			srcx, 
+		   int			srcy,
+		   _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(dpy, pub, chars[i].ucs4);
+	glyphs[i].x = chars[i].x;
+	glyphs[i].y = chars[i].y;
+    }
+
+    XftGlyphSpecRender (dpy, op, src, pub, dst, srcx, srcy, glyphs, len);
+
+    if (glyphs != glyphs_local)
+	free (glyphs);
+}
+
+/*
+ * Choose which format to draw text in when drawing with fonts
+ * of different formats.  The trick is that ARGB formats aren't
+ * compatible with A formats as PictOpAdd does the wrong thing, so
+ * fall back to an A format when presented with an ARGB and A format
+ */
+
+#define XftIsARGBFormat(a)  ((a)->depth == 32)
+
+static XRenderPictFormat *
+XftPreferFormat (Display *dpy, XRenderPictFormat *a, XRenderPictFormat *b)
+{
+    XRenderPictFormat	*prefer = NULL;
+    
+    if (a == b)
+	prefer = a;
+    else if (XftIsARGBFormat(a) != XftIsARGBFormat(b))
+	prefer = XRenderFindStandardFormat (dpy, PictStandardA8);
+    else if (a->depth > b->depth)
+	prefer = a;
+    else
+	prefer = b;
+    return prefer;
+}
+
+_X_EXPORT void
+XftGlyphFontSpecRender (Display			    *dpy,
+			int			    op,
+			Picture			    src,
+			Picture			    dst,
+			int			    srcx,
+			int			    srcy,
+			_Xconst XftGlyphFontSpec    *glyphs,
+			int			    nglyphs)
+{
+    int		    i, j;
+    XftFont	    *prevPublic;
+    XftFontInt	    *firstFont;
+    XRenderPictFormat	*format;
+    FT_UInt	    missing[XFT_NMISSING];
+    int		    nmissing;
+    int		    n;
+    FT_UInt	    g;
+    XftGlyph	    *glyph;
+    FT_UInt	    max;
+    int		    size, width;
+    char	    *char8;
+    unsigned short  *char16;
+    unsigned int    *char32;
+    unsigned int    char_local[NUM_LOCAL];
+    unsigned int    *chars;
+    XGlyphElt8	    *elts;
+    XGlyphElt8	    elts_local[NUM_ELT_LOCAL];
+    FcBool	    glyphs_loaded;
+    int		    nelt;
+    int		    x, y;
+    
+    if (!nglyphs)
+	return;
+    
+    /*
+     * Load missing glyphs.  Have to load them
+     * one at a time in case the font changes
+     */
+    max = 0;
+    glyphs_loaded = FcFalse;
+    g = glyphs[0].glyph;
+    for (i = 0; i < nglyphs; i++)
+    {
+	XftFont	    *pub = glyphs[i].font;
+	XftFontInt  *font = (XftFontInt *) pub;
+	g = glyphs[i].glyph;
+	if (g > max)
+	    max = g;
+	nmissing = 0;
+	if (XftFontCheckGlyph (dpy, pub, FcTrue, g, missing, &nmissing))
+	    glyphs_loaded = FcTrue;
+	if (nmissing)
+	    XftFontLoadGlyphs (dpy, pub, FcTrue, missing, nmissing);
+	if (!font->format)
+	    goto bail1;
+	if (!font->glyphset)
+	    goto bail1;
+    }
+    
+    /*
+     * See what encoding size is needed
+     */
+    if (max < 0x100)
+    {
+	size = sizeof (char);
+	width = 1;
+    }
+    else if (max < 0x10000)
+    {
+	size = sizeof (unsigned short);
+	width = 2;
+    }
+    else
+    {
+	size = sizeof (unsigned int);
+	width = 4;
+    }
+    chars = char_local;
+    if (nglyphs * size > NUM_LOCAL)
+    {
+	chars = malloc (nglyphs * size);
+	if (!chars)
+	    goto bail1;
+    }
+    char8 = (char *) chars;
+    char16 = (unsigned short *) chars;
+    char32 = (unsigned int *) chars;
+    
+    /*
+     * Compute the number of glyph elts needed
+     */
+    nelt = 1;
+    firstFont = NULL;
+    for (i = 0; i < nglyphs; i++)
+    {
+	XftFont	    *pub = glyphs[i].font;
+	XftFontInt  *font = (XftFontInt *) pub;
+	g = glyphs[i].glyph;
+	/* Substitute default for non-existant glyphs */
+	if (g >= font->num_glyphs || !font->glyphs[g])
+	    g = 0;
+	if (font->glyphs[g])
+	{
+	    firstFont = font;
+	    break;
+	}
+    }
+    if (i == nglyphs || !firstFont)
+	goto bail2;
+    glyph = firstFont->glyphs[g];
+    format = firstFont->format;
+    x = glyphs[i].x + glyph->metrics.xOff;
+    y = glyphs[i].y + glyph->metrics.yOff;
+    prevPublic = NULL;
+    while (++i < nglyphs)
+    {
+	XftFont	    *pub = glyphs[i].font;
+	XftFontInt  *font = (XftFontInt *) pub;
+	g = glyphs[i].glyph;
+	/* Substitute default for non-existant glyphs */
+	if (g >= font->num_glyphs || !font->glyphs[g])
+	    g = 0;
+	/* 
+	 * check to see if the glyph is placed where it would
+	 * fall using the normal spacing
+	 */
+	if ((glyph = font->glyphs[g]))
+	{
+	    if (pub != prevPublic || x != glyphs[i].x || y != glyphs[i].y)
+	    {
+		prevPublic = pub;
+		if (font->format != format)
+		    format = XftPreferFormat (dpy, font->format, format);
+		x = glyphs[i].x;
+		y = glyphs[i].y;
+		++nelt;
+	    }
+	    x += glyph->metrics.xOff;
+	    y += glyph->metrics.yOff;
+	}
+    }
+
+    elts = elts_local;
+    if (nelt > NUM_ELT_LOCAL)
+    {
+	elts = malloc (nelt * sizeof (XGlyphElt8));
+	if (!elts)
+	    goto bail2;
+    }
+
+    /*
+     * Generate the list of glyph elts
+     */
+    nelt = 0;
+    x = y = 0;
+    n = 0;
+    j = 0;
+    prevPublic = NULL;
+    for (i = 0; i < nglyphs; i++)
+    {
+	XftFont	    *pub = glyphs[i].font;
+	XftFontInt  *font = (XftFontInt *) pub;
+	
+	g = glyphs[i].glyph;
+	/* Substitute default for non-existant glyphs */
+	if (g >= font->num_glyphs || !font->glyphs[g])
+	    g = 0;
+	if ((glyph = font->glyphs[g]))
+	{
+	    if (!i || pub != prevPublic || x != glyphs[i].x || y != glyphs[i].y)
+	    {
+		if (n)
+		{
+		    elts[nelt].nchars = n;
+		    nelt++;
+		}
+		elts[nelt].glyphset = font->glyphset;
+		elts[nelt].chars = char8 + size * j;
+		elts[nelt].xOff = glyphs[i].x - x;
+		elts[nelt].yOff = glyphs[i].y - y;
+		prevPublic = pub;
+		x = glyphs[i].x;
+		y = glyphs[i].y;
+		n = 0;
+	    }
+	    switch (width) {
+	    case 1: char8[j] = (char) g; break;
+	    case 2: char16[j] = (unsigned short) g; break;
+	    case 4: char32[j] = (unsigned int) g; break;
+	    }
+	    x += glyph->metrics.xOff;
+	    y += glyph->metrics.yOff;
+	    j++;
+	    n++;
+	}
+    }
+    if (n)
+    {
+	elts[nelt].nchars = n;
+	nelt++;
+    }
+    switch (width) {
+    case 1:
+	XRenderCompositeText8 (dpy, op, src, dst, format,
+			       srcx, srcy, glyphs[0].x, glyphs[0].y,
+			       elts, nelt);
+	break;
+    case 2:
+	XRenderCompositeText16 (dpy, op, src, dst, format,
+				srcx, srcy, glyphs[0].x, glyphs[0].y,
+				(XGlyphElt16 *) elts, nelt);
+	break;
+    case 4:
+	XRenderCompositeText32 (dpy, op, src, dst, format,
+				srcx, srcy, glyphs[0].x, glyphs[0].y,
+				(XGlyphElt32 *) elts, nelt);
+	break;
+    }
+
+    if (elts != elts_local)
+	free (elts);
+bail2:
+    if (chars != char_local)
+	free (chars);
+bail1:
+    if (glyphs_loaded)
+	for (i = 0; i < nglyphs; i++)
+	    _XftFontManageMemory (dpy, glyphs[i].font);
+}
+
+_X_EXPORT void
+XftCharFontSpecRender (Display			*dpy,
+		       int			op,
+		       Picture			src,
+		       Picture			dst,
+		       int			srcx,
+		       int			srcy,
+		       _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(dpy, glyphs[i].font, chars[i].ucs4);
+	glyphs[i].x = chars[i].x;
+	glyphs[i].y = chars[i].y;
+    }
+
+    XftGlyphFontSpecRender (dpy, op, src, dst, srcx, srcy, glyphs, len);
+    if (glyphs != glyphs_local)
+	free (glyphs);
+}
+
+_X_EXPORT void
+XftTextRender8 (Display		*dpy,
+		int		op,
+		Picture		src,
+		XftFont		*pub,
+		Picture		dst,
+		int		srcx,
+		int		srcy,
+		int		x,
+		int		y,
+		_Xconst FcChar8	*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 (dpy, pub, string[i]);
+    XftGlyphRender (dpy, op, src, pub, dst, 
+		     srcx, srcy, x, y, glyphs, len);
+    if (glyphs != glyphs_local)
+	free (glyphs);
+}
+
+_X_EXPORT void
+XftTextRender16 (Display	    *dpy,
+		 int		    op,
+		 Picture	    src,
+		 XftFont	    *pub,
+		 Picture	    dst,
+		 int		    srcx,
+		 int		    srcy,
+		 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 (dpy, pub, string[i]);
+    XftGlyphRender (dpy, op, src, pub, dst, 
+		     srcx, srcy, x, y, glyphs, len);
+    if (glyphs != glyphs_local)
+	free (glyphs);
+}
+
+_X_EXPORT void
+XftTextRender16BE (Display	    *dpy,
+		   int		    op,
+		   Picture	    src,
+		   XftFont	    *pub,
+		   Picture	    dst,
+		   int		    srcx,
+		   int		    srcy,
+		   int		    x,
+		   int		    y,
+		   _Xconst FcChar8  *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 (dpy, pub, 
+				  (string[i*2]<<8) | string[i*2+1]);
+    XftGlyphRender (dpy, op, src, pub, dst, 
+		     srcx, srcy, x, y, glyphs, len);
+    if (glyphs != glyphs_local)
+	free (glyphs);
+}
+
+_X_EXPORT void
+XftTextRender16LE (Display	    *dpy,
+		   int		    op,
+		   Picture	    src,
+		   XftFont	    *pub,
+		   Picture	    dst,
+		   int		    srcx,
+		   int		    srcy,
+		   int		    x,
+		   int		    y,
+		   _Xconst FcChar8  *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 (dpy, pub, 
+				  string[i*2] | (string[i*2+1]<<8));
+    XftGlyphRender (dpy, op, src, pub, dst, 
+		     srcx, srcy, x, y, glyphs, len);
+    if (glyphs != glyphs_local)
+	free (glyphs);
+}
+
+_X_EXPORT void
+XftTextRender32 (Display	    *dpy,
+		 int		    op,
+		 Picture	    src,
+		 XftFont	    *pub,
+		 Picture	    dst,
+		 int		    srcx,
+		 int		    srcy,
+		 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 (dpy, pub, string[i]);
+    XftGlyphRender (dpy, op, src, pub, dst, 
+		     srcx, srcy, x, y, glyphs, len);
+    if (glyphs != glyphs_local)
+	free (glyphs);
+}
+
+_X_EXPORT void
+XftTextRender32BE (Display	    *dpy,
+		   int		    op,
+		   Picture	    src,
+		   XftFont	    *pub,
+		   Picture	    dst,
+		   int		    srcx,
+		   int		    srcy,
+		   int		    x,
+		   int		    y,
+		   _Xconst FcChar8  *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 (dpy, pub, 
+				  (string[i*4] << 24) |
+				  (string[i*4+1] << 16) |
+				  (string[i*4+2] << 8) |
+				  (string[i*4+3]));
+    XftGlyphRender (dpy, op, src, pub, dst, 
+		     srcx, srcy, x, y, glyphs, len);
+    if (glyphs != glyphs_local)
+	free (glyphs);
+}
+
+_X_EXPORT void
+XftTextRender32LE (Display	    *dpy,
+		   int		    op,
+		   Picture	    src,
+		   XftFont	    *pub,
+		   Picture	    dst,
+		   int		    srcx,
+		   int		    srcy,
+		   int		    x,
+		   int		    y,
+		   _Xconst FcChar8  *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 (dpy, pub, 
+				  (string[i*4]) |
+				  (string[i*4+1] << 8) |
+				  (string[i*4+2] << 16) |
+				  (string[i*4+3] << 24));
+    XftGlyphRender (dpy, op, src, pub, dst, 
+		     srcx, srcy, x, y, glyphs, len);
+    if (glyphs != glyphs_local)
+	free (glyphs);
+}
+
+_X_EXPORT void
+XftTextRenderUtf8 (Display	    *dpy,
+		   int		    op,
+		   Picture	    src,
+		   XftFont	    *pub,
+		   Picture	    dst,
+		   int		    srcx,
+		   int		    srcy,
+		   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 (dpy, pub, ucs4);
+	string += l;
+	len -= l;
+    }
+    XftGlyphRender (dpy, op, src, pub, dst,
+		     srcx, srcy, x, y, glyphs, i);
+    if (glyphs != glyphs_local)
+	free (glyphs);
+}
+
+_X_EXPORT void
+XftTextRenderUtf16 (Display	    *dpy,
+		    int		    op,
+		    Picture	    src,
+		    XftFont	    *pub,
+		    Picture	    dst,
+		    int		    srcx,
+		    int		    srcy,
+		    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 (dpy, pub, ucs4);
+	string += l;
+	len -= l;
+    }
+    XftGlyphRender (dpy, PictOpOver, src, pub, dst,
+		     srcx, srcy, x, y, glyphs, i);
+    if (glyphs != glyphs_local)
+	free (glyphs);
+}
diff --git a/libXft/src/xftstr.c b/libXft/src/xftstr.c
new file mode 100644
index 000000000..a5733f4bb
--- /dev/null
+++ b/libXft/src/xftstr.c
@@ -0,0 +1,35 @@
+/*
+ * 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 int
+_XftMatchSymbolic (XftSymbolic *s, int n, const char *name, int def)
+{
+    while (n--)
+    {
+	if (!FcStrCmpIgnoreCase ((FcChar8 *) s->name, (FcChar8 *) name))
+	    return s->value;
+	s++;
+    }
+    return def;
+}
diff --git a/libXft/src/xftswap.c b/libXft/src/xftswap.c
new file mode 100644
index 000000000..942efdb31
--- /dev/null
+++ b/libXft/src/xftswap.c
@@ -0,0 +1,119 @@
+/*
+ * Copyright © 2002 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 int
+XftNativeByteOrder (void)
+{
+    int	    whichbyte = 1;
+
+    if (*((char *) &whichbyte))
+	return LSBFirst;
+    return MSBFirst;
+}
+
+/* byte swap a 32-bit value */
+#define swapl(x, n) { \
+		 n = ((char *) (x))[0];\
+		 ((char *) (x))[0] = ((char *) (x))[3];\
+		 ((char *) (x))[3] = n;\
+		 n = ((char *) (x))[1];\
+		 ((char *) (x))[1] = ((char *) (x))[2];\
+		 ((char *) (x))[2] = n; }
+
+/* byte swap a short */
+#define swaps(x, n) { \
+		 n = ((char *) (x))[0];\
+		 ((char *) (x))[0] = ((char *) (x))[1];\
+		 ((char *) (x))[1] = n; }
+
+/* byte swap a three-byte unit */
+#define swapt(x, n) { \
+		 n = ((char *) (x))[0];\
+		 ((char *) (x))[0] = ((char *) (x))[2];\
+		 ((char *) (x))[2] = n; }
+
+_X_HIDDEN void
+XftSwapCARD32 (CARD32 *data, int u)
+{
+    char    n;
+    while (u--)
+    {
+	swapl (data, n);
+	data++;
+    }
+}
+
+_X_HIDDEN void
+XftSwapCARD24 (CARD8 *data, int width, int height)
+{
+    int	    units, u;
+    char    n;
+    CARD8   *d;
+
+    units = width / 3;
+    while (height--)
+    {
+	d = data;
+	data += width;
+	u = units;
+	while (u--)
+	{
+	    swapt (d, n);
+	    d += 3;
+	}
+    }
+}
+
+_X_HIDDEN void
+XftSwapCARD16 (CARD16 *data, int u)
+{
+    char    n;
+    while (u--)
+    {
+	swaps (data, n);
+	data++;
+    }
+}
+
+_X_HIDDEN void
+XftSwapImage (XImage *image)
+{
+    switch (image->bits_per_pixel) {
+    case 32:
+	XftSwapCARD32 ((CARD32 *) image->data, 
+		       image->height * image->bytes_per_line >> 2);
+	break;
+    case 24:
+	XftSwapCARD24 ((CARD8 *) image->data,
+		       image->bytes_per_line,
+		       image->height);
+	break;
+    case 16:
+	XftSwapCARD16 ((CARD16 *) image->data,
+		       image->height * image->bytes_per_line >> 1);
+	break;
+    default:
+	break;
+    }
+}
diff --git a/libXft/src/xftxlfd.c b/libXft/src/xftxlfd.c
new file mode 100644
index 000000000..7c1991163
--- /dev/null
+++ b/libXft/src/xftxlfd.c
@@ -0,0 +1,177 @@
+/*
+ * 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"
+
+static XftSymbolic XftXlfdWeights[] = {
+    {	"light",    FC_WEIGHT_LIGHT	},
+    {	"medium",   FC_WEIGHT_MEDIUM	},
+    {	"regular",  FC_WEIGHT_MEDIUM	},
+    {	"demibold", FC_WEIGHT_DEMIBOLD },
+    {	"bold",	    FC_WEIGHT_BOLD	},
+    {	"black",    FC_WEIGHT_BLACK	},
+};
+
+#define NUM_XLFD_WEIGHTS    (sizeof XftXlfdWeights/sizeof XftXlfdWeights[0])
+
+static XftSymbolic XftXlfdSlants[] = {
+    {	"r",	    FC_SLANT_ROMAN	},
+    {	"i",	    FC_SLANT_ITALIC	},
+    {	"o",	    FC_SLANT_OBLIQUE	},
+};
+
+#define NUM_XLFD_SLANTS    (sizeof XftXlfdSlants/sizeof XftXlfdSlants[0])
+
+/*
+ * Cut out one XLFD field, placing it in 'save' and return
+ * the start of 'save'
+ */
+static char *
+XftSplitStr (const char *field, char *save)
+{
+    char    *s = save;
+    char    c;
+
+    while (*field)
+    {
+	if (*field == '-')
+	    break;
+	c = *field++;
+	*save++ = c;
+    }
+    *save = 0;
+    return s;
+}
+
+/*
+ * convert one XLFD numeric field.  Return -1 if the field is '*'
+ */
+
+static const char *
+XftGetInt(const char *ptr, int *val)
+{
+    if (*ptr == '*') {
+	*val = -1;
+	ptr++;
+    } else
+	for (*val = 0; *ptr >= '0' && *ptr <= '9';)
+	    *val = *val * 10 + *ptr++ - '0';
+    if (*ptr == '-')
+	return ptr;
+    return (char *) 0;
+}
+
+_X_EXPORT FcPattern *
+XftXlfdParse (const char *xlfd_orig, FcBool ignore_scalable, FcBool complete)
+{
+    FcPattern	*pat;
+    const char	*xlfd = xlfd_orig;
+    const char	*foundry;
+    const char	*family;
+    const char	*weight_name;
+    const char	*slant;
+    const char	*registry;
+    const char	*encoding;
+    char	*save;
+    int		pixel;
+    int		point;
+    int		resx;
+    int		resy;
+    int		slant_value, weight_value;
+    double	dpixel;
+
+    if (*xlfd != '-')
+	return NULL;
+    if (!(xlfd = strchr (foundry = ++xlfd, '-'))) return NULL;
+    if (!(xlfd = strchr (family = ++xlfd, '-'))) return NULL;
+    if (!(xlfd = strchr (weight_name = ++xlfd, '-'))) return NULL;
+    if (!(xlfd = strchr (slant = ++xlfd, '-'))) return NULL;
+    if (!(xlfd = strchr (/* setwidth_name = */ ++xlfd, '-'))) return NULL;
+    if (!(xlfd = strchr (/* add_style_name = */ ++xlfd, '-'))) return NULL;
+    if (!(xlfd = XftGetInt (++xlfd, &pixel))) return NULL;
+    if (!(xlfd = XftGetInt (++xlfd, &point))) return NULL;
+    if (!(xlfd = XftGetInt (++xlfd, &resx))) return NULL;
+    if (!(xlfd = XftGetInt (++xlfd, &resy))) return NULL;
+    if (!(xlfd = strchr (/* spacing = */ ++xlfd, '-'))) return NULL;
+    if (!(xlfd = strchr (/* average_width = */ ++xlfd, '-'))) return NULL;
+    if (!(xlfd = strchr (registry = ++xlfd, '-'))) return NULL;
+    /* make sure no fields follow this one */
+    if ((xlfd = strchr (encoding = ++xlfd, '-'))) return NULL;
+
+    if (!pixel)
+	return NULL;
+    
+    pat = FcPatternCreate ();
+    if (!pat)
+	return NULL;
+    
+    save = (char *) malloc (strlen (foundry) + 1);
+    
+    if (!save) {
+	FcPatternDestroy (pat);
+	return NULL;
+    }
+
+    if (!FcPatternAddString (pat, XFT_XLFD, (FcChar8 *) xlfd_orig)) goto bail;
+    
+    XftSplitStr (foundry, save);
+    if (save[0] && strcmp (save, "*") != 0)
+	if (!FcPatternAddString (pat, FC_FOUNDRY, (FcChar8 *) save)) goto bail;
+    
+    XftSplitStr (family, save);
+    if (save[0] && strcmp (save, "*") != 0)
+	if (!FcPatternAddString (pat, FC_FAMILY, (FcChar8 *) save)) goto bail;
+    
+    weight_value = _XftMatchSymbolic (XftXlfdWeights, NUM_XLFD_WEIGHTS,
+				      XftSplitStr (weight_name, save),
+				      FC_WEIGHT_MEDIUM);
+    if (!FcPatternAddInteger (pat, FC_WEIGHT, weight_value)) 
+	goto bail;
+    
+    slant_value = _XftMatchSymbolic (XftXlfdSlants, NUM_XLFD_SLANTS,
+				     XftSplitStr (slant, save),
+				     FC_SLANT_ROMAN);
+    if (!FcPatternAddInteger (pat, FC_SLANT, slant_value)) 
+	goto bail;
+    
+    dpixel = (double) pixel;
+    
+    if (point > 0)
+    {
+	if (!FcPatternAddDouble (pat, FC_SIZE, ((double) point) / 10.0)) goto bail;
+	if (pixel <= 0 && resy > 0)
+	{
+	    dpixel = (double) point * (double) resy / 720.0;
+	}
+    }
+    
+    if (dpixel > 0)
+	if (!FcPatternAddDouble (pat, FC_PIXEL_SIZE, dpixel)) goto bail;
+    
+    free (save);
+    return pat;
+    
+bail:
+    free (save);
+    FcPatternDestroy (pat);
+    return NULL;
+}