aboutsummaryrefslogtreecommitdiff
path: root/libXft/src
diff options
context:
space:
mode:
authormarha <marha@users.sourceforge.net>2011-01-19 10:06:48 +0000
committermarha <marha@users.sourceforge.net>2011-01-19 10:06:48 +0000
commit6e3cfc5bc8ca969856e4d56dec01870df709d75a (patch)
tree92d253c403ac0ecfbb1c2859c283649bd46da65b /libXft/src
parentfe39224c389ccc187c2232d9cc796599e150fa6b (diff)
downloadvcxsrv-6e3cfc5bc8ca969856e4d56dec01870df709d75a.tar.gz
vcxsrv-6e3cfc5bc8ca969856e4d56dec01870df709d75a.tar.bz2
vcxsrv-6e3cfc5bc8ca969856e4d56dec01870df709d75a.zip
Added libXft-2.2.0 fontconfig-2.8.0 libXrender-0.9.6
Diffstat (limited to 'libXft/src')
-rw-r--r--libXft/src/Makefile.am32
-rw-r--r--libXft/src/xftcolor.c123
-rw-r--r--libXft/src/xftcore.c1373
-rw-r--r--libXft/src/xftdbg.c46
-rw-r--r--libXft/src/xftdpy.c552
-rw-r--r--libXft/src/xftdraw.c994
-rw-r--r--libXft/src/xftextent.c285
-rw-r--r--libXft/src/xftfont.c206
-rw-r--r--libXft/src/xftfreetype.c1174
-rw-r--r--libXft/src/xftglyphs.c827
-rw-r--r--libXft/src/xftinit.c113
-rw-r--r--libXft/src/xftint.h465
-rw-r--r--libXft/src/xftlist.c58
-rw-r--r--libXft/src/xftname.c82
-rw-r--r--libXft/src/xftrender.c1007
-rw-r--r--libXft/src/xftstr.c35
-rw-r--r--libXft/src/xftswap.c119
-rw-r--r--libXft/src/xftxlfd.c177
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;
+}