aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/lib/Xft/xftglyphs.c
diff options
context:
space:
mode:
authorReinhard Tartler <siretart@tauware.de>2011-10-10 17:43:39 +0200
committerReinhard Tartler <siretart@tauware.de>2011-10-10 17:43:39 +0200
commitf4092abdf94af6a99aff944d6264bc1284e8bdd4 (patch)
tree2ac1c9cc16ceb93edb2c4382c088dac5aeafdf0f /nx-X11/lib/Xft/xftglyphs.c
parenta840692edc9c6d19cd7c057f68e39c7d95eb767d (diff)
downloadnx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.tar.gz
nx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.tar.bz2
nx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.zip
Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1
Summary: Imported nx-X11-3.1.0-1.tar.gz Keywords: Imported nx-X11-3.1.0-1.tar.gz into Git repository
Diffstat (limited to 'nx-X11/lib/Xft/xftglyphs.c')
-rw-r--r--nx-X11/lib/Xft/xftglyphs.c825
1 files changed, 825 insertions, 0 deletions
diff --git a/nx-X11/lib/Xft/xftglyphs.c b/nx-X11/lib/Xft/xftglyphs.c
new file mode 100644
index 000000000..c1ee42142
--- /dev/null
+++ b/nx-X11/lib/Xft/xftglyphs.c
@@ -0,0 +1,825 @@
+/*
+ * $Id: xftglyphs.c,v 1.4 2005/07/03 07:00:57 daniels Exp $
+ *
+ * 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>
+
+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);
+}
+
+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 = 0;
+ }
+ }
+ 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 = 0;
+ }
+ }
+ 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);
+}
+
+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] = 0;
+ }
+ if (font->glyphset && nused)
+ XRenderFreeGlyphs (dpy, font->glyphset, glyphBuf, nused);
+}
+
+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 = 0;
+ 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;
+}
+
+FcBool
+XftCharExists (Display *dpy,
+ XftFont *pub,
+ FcChar32 ucs4)
+{
+ if (pub->charset)
+ return FcCharSetHasChar (pub->charset, ucs4);
+ return FcFalse;
+}
+
+#define Missing ((FT_UInt) ~0)
+
+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
+ */
+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);
+}
+
+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);
+}