static XftPattern *
_XftDefaultInit (Display *dpy)
{
XftPattern *pat;
pat = XftPatternCreate ();
if (!pat)
goto bail0;
if (!_XftDefaultInitBool (dpy, pat, XFT_CORE))
goto bail1;
if (!_XftDefaultInitDouble (dpy, pat, XFT_SCALE))
goto bail1;
if (!_XftDefaultInitDouble (dpy, pat, XFT_DPI))
goto bail1;
if (!_XftDefaultInitBool (dpy, pat, XFT_RENDER))
goto bail1;
if (!_XftDefaultInitInteger (dpy, pat, XFT_RGBA))
goto bail1;
if (!_XftDefaultInitBool (dpy, pat, XFT_ANTIALIAS))
goto bail1;
if (!_XftDefaultInitBool (dpy, pat, XFT_MINSPACE))
goto bail1;
return pat;
bail1:
XftPatternDestroy (pat);
bail0:
return 0;
}
Bool
XftCoreAddFonts (XftFontSet *set, Display *dpy, Bool ignore_scalable)
{
char **xlfds;
int num;
int i;
XftPattern *font;
Bool ret;
xlfds = XListFonts (dpy,
"-*-*-*-*-*-*-*-*-*-*-*-*-*-*",
10000, &num);
if (!xlfds)
return False;
ret = True;
for (i = 0; ret && i < num; i++)
{
font = XftXlfdParse (xlfds[i], ignore_scalable, True);
if (font)
{
if (!XftFontSetAdd (set, font))
{
XftPatternDestroy (font);
ret = False;
}
}
}
XFreeFontNames (xlfds);
return ret;
}
Bool
XftDefaultSet (Display *dpy, XftPattern *defaults)
{
XftDisplayInfo *info = _XftDisplayInfoGet (dpy);
if (!info)
return False;
if (info->defaults)
XftPatternDestroy (info->defaults);
info->defaults = defaults;
return True;
}
static int
_XftCloseDisplay (Display *dpy, XExtCodes *codes)
{
XftDisplayInfo *info, **prev;
for (prev = &_XftDisplayInfo; (info = *prev); prev = &(*prev)->next)
if (info->codes == codes)
break;
if (!info)
return 0;
*prev = info->next;
if (info->defaults)
XftPatternDestroy (info->defaults);
if (info->coreFonts)
XftFontSetDestroy (info->coreFonts);
free (info);
return 0;
}
static Lisp_Object
xftfont_open (struct frame *f, Lisp_Object entity, int pixel_size)
{
FcResult result;
Display *display = FRAME_X_DISPLAY (f);
Lisp_Object val, filename, idx, font_object;
FcPattern *pat = NULL, *match;
struct xftfont_info *xftfont_info = NULL;
struct font *font;
double size = 0;
XftFont *xftfont = NULL;
int spacing;
char name[256];
int len, i;
XGlyphInfo extents;
FT_Face ft_face;
FcMatrix *matrix;
val = assq_no_quit (QCfont_entity, AREF (entity, FONT_EXTRA_INDEX));
if (! CONSP (val))
return Qnil;
val = XCDR (val);
filename = XCAR (val);
idx = XCDR (val);
size = XINT (AREF (entity, FONT_SIZE_INDEX));
if (size == 0)
size = pixel_size;
pat = FcPatternCreate ();
FcPatternAddInteger (pat, FC_WEIGHT, FONT_WEIGHT_NUMERIC (entity));
i = FONT_SLANT_NUMERIC (entity) - 100;
if (i < 0) i = 0;
FcPatternAddInteger (pat, FC_SLANT, i);
FcPatternAddInteger (pat, FC_WIDTH, FONT_WIDTH_NUMERIC (entity));
FcPatternAddDouble (pat, FC_PIXEL_SIZE, pixel_size);
val = AREF (entity, FONT_FAMILY_INDEX);
if (! NILP (val))
FcPatternAddString (pat, FC_FAMILY, (FcChar8 *) SDATA (SYMBOL_NAME (val)));
val = AREF (entity, FONT_FOUNDRY_INDEX);
if (! NILP (val))
FcPatternAddString (pat, FC_FOUNDRY, (FcChar8 *) SDATA (SYMBOL_NAME (val)));
val = AREF (entity, FONT_SPACING_INDEX);
if (! NILP (val))
FcPatternAddInteger (pat, FC_SPACING, XINT (val));
val = AREF (entity, FONT_DPI_INDEX);
if (! NILP (val))
{
double dbl = XINT (val);
FcPatternAddDouble (pat, FC_DPI, dbl);
}
val = AREF (entity, FONT_AVGWIDTH_INDEX);
if (INTEGERP (val) && XINT (val) == 0)
FcPatternAddBool (pat, FC_SCALABLE, FcTrue);
/* This is necessary to identify the exact font (e.g. 10x20.pcf.gz
over 10x20-ISO8859-1.pcf.gz). */
FcPatternAddCharSet (pat, FC_CHARSET, ftfont_get_fc_charset (entity));
xftfont_add_rendering_parameters (pat, entity);
FcPatternAddString (pat, FC_FILE, (FcChar8 *) SDATA (filename));
FcPatternAddInteger (pat, FC_INDEX, XINT (idx));
block_input ();
/* Make sure that the Xrender extension is added before the Xft one.
Otherwise, the close-display hook set by Xft is called after the
one for Xrender, and the former tries to re-add the latter. This
results in inconsistency of internal states and leads to X
protocol error when one reconnects to the same X server.
(Bug#1696) */
{
int event_base, error_base;
XRenderQueryExtension (display, &event_base, &error_base);
}
/* Substitute in values from X resources and XftDefaultSet. */
XftDefaultSubstitute (display, FRAME_X_SCREEN_NUMBER (f), pat);
match = XftFontMatch (display, FRAME_X_SCREEN_NUMBER (f), pat, &result);
xftfont_fix_match (pat, match);
FcPatternDestroy (pat);
xftfont = XftFontOpenPattern (display, match);
if (!xftfont)
{
unblock_input ();
XftPatternDestroy (match);
return Qnil;
}
ft_face = XftLockFace (xftfont);
unblock_input ();
/* We should not destroy PAT here because it is kept in XFTFONT and
destroyed automatically when XFTFONT is closed. */
font_object = font_make_object (VECSIZE (struct xftfont_info), entity, size);
ASET (font_object, FONT_TYPE_INDEX, Qxft);
len = font_unparse_xlfd (entity, size, name, 256);
if (len > 0)
ASET (font_object, FONT_NAME_INDEX, make_string (name, len));
len = font_unparse_fcname (entity, size, name, 256);
if (len > 0)
ASET (font_object, FONT_FULLNAME_INDEX, make_string (name, len));
else
ASET (font_object, FONT_FULLNAME_INDEX,
AREF (font_object, FONT_NAME_INDEX));
ASET (font_object, FONT_FILE_INDEX, filename);
ASET (font_object, FONT_FORMAT_INDEX,
ftfont_font_format (xftfont->pattern, filename));
font = XFONT_OBJECT (font_object);
font->pixel_size = size;
font->driver = &xftfont_driver;
font->encoding_charset = font->repertory_charset = -1;
xftfont_info = (struct xftfont_info *) font;
xftfont_info->display = display;
xftfont_info->xftfont = xftfont;
/* This means that there's no need of transformation. */
xftfont_info->matrix.xx = 0;
if (FcPatternGetMatrix (xftfont->pattern, FC_MATRIX, 0, &matrix)
== FcResultMatch)
{
xftfont_info->matrix.xx = 0x10000L * matrix->xx;
xftfont_info->matrix.yy = 0x10000L * matrix->yy;
xftfont_info->matrix.xy = 0x10000L * matrix->xy;
xftfont_info->matrix.yx = 0x10000L * matrix->yx;
}
if (INTEGERP (AREF (entity, FONT_SPACING_INDEX)))
spacing = XINT (AREF (entity, FONT_SPACING_INDEX));
else
spacing = FC_PROPORTIONAL;
if (! ascii_printable[0])
{
int ch;
for (ch = 0; ch < 95; ch++)
ascii_printable[ch] = ' ' + ch;
}
block_input ();
/* Unfortunately Xft doesn't provide a way to get minimum char
width. So, we set min_width to space_width. */
if (spacing != FC_PROPORTIONAL
#ifdef FC_DUAL
&& spacing != FC_DUAL
#endif /* FC_DUAL */
)
{
font->min_width = font->max_width = font->average_width
= font->space_width = xftfont->max_advance_width;
XftTextExtents8 (display, xftfont, ascii_printable + 1, 94, &extents);
}
else
{
XftTextExtents8 (display, xftfont, ascii_printable, 1, &extents);
font->min_width = font->max_width = font->space_width
= extents.xOff;
if (font->space_width <= 0)
/* dirty workaround */
font->space_width = pixel_size;
XftTextExtents8 (display, xftfont, ascii_printable + 1, 94, &extents);
font->average_width = (font->space_width + extents.xOff) / 95;
}
unblock_input ();
font->ascent = xftfont->ascent;
font->descent = xftfont->descent;
if (pixel_size >= 5)
{
/* The above condition is a dirty workaround because
XftTextExtents8 behaves strangely for some fonts
(e.g. "Dejavu Sans Mono") when pixel_size is less than 5. */
if (font->ascent < extents.y)
font->ascent = extents.y;
if (font->descent < extents.height - extents.y)
font->descent = extents.height - extents.y;
}
font->height = font->ascent + font->descent;
if (XINT (AREF (entity, FONT_SIZE_INDEX)) == 0)
{
int upEM = ft_face->units_per_EM;
font->underline_position = -ft_face->underline_position * size / upEM;
font->underline_thickness = ft_face->underline_thickness * size / upEM;
if (font->underline_thickness > 2)
font->underline_position -= font->underline_thickness / 2;
}
else
{
font->underline_position = -1;
font->underline_thickness = 0;
}
#ifdef HAVE_LIBOTF
xftfont_info->maybe_otf = (ft_face->face_flags & FT_FACE_FLAG_SFNT) != 0;
xftfont_info->otf = NULL;
#endif /* HAVE_LIBOTF */
xftfont_info->ft_size = ft_face->size;
font->baseline_offset = 0;
font->relative_compose = 0;
font->default_ascent = 0;
font->vertical_centering = 0;
#ifdef FT_BDF_H
if (! (ft_face->face_flags & FT_FACE_FLAG_SFNT))
{
BDF_PropertyRec rec;
if (FT_Get_BDF_Property (ft_face, "_MULE_BASELINE_OFFSET", &rec) == 0
&& rec.type == BDF_PROPERTY_TYPE_INTEGER)
font->baseline_offset = rec.u.integer;
if (FT_Get_BDF_Property (ft_face, "_MULE_RELATIVE_COMPOSE", &rec) == 0
&& rec.type == BDF_PROPERTY_TYPE_INTEGER)
font->relative_compose = rec.u.integer;
if (FT_Get_BDF_Property (ft_face, "_MULE_DEFAULT_ASCENT", &rec) == 0
&& rec.type == BDF_PROPERTY_TYPE_INTEGER)
font->default_ascent = rec.u.integer;
}
#endif
return font_object;
}
XftPattern *
XftXlfdParse (const char *xlfd_orig, Bool ignore_scalable, Bool complete)
{
XftPattern *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;
char style[128];
int pixel;
int point;
int resx;
int resy;
int slant_value, weight_value;
double dpixel;
if (*xlfd != '-')
return 0;
if (!(xlfd = strchr (foundry = ++xlfd, '-'))) return 0;
if (!(xlfd = strchr (family = ++xlfd, '-'))) return 0;
if (!(xlfd = strchr (weight_name = ++xlfd, '-'))) return 0;
if (!(xlfd = strchr (slant = ++xlfd, '-'))) return 0;
if (!(xlfd = strchr (/* setwidth_name = */ ++xlfd, '-'))) return 0;
if (!(xlfd = strchr (/* add_style_name = */ ++xlfd, '-'))) return 0;
if (!(xlfd = _XftGetInt (++xlfd, &pixel))) return 0;
if (!(xlfd = _XftGetInt (++xlfd, &point))) return 0;
if (!(xlfd = _XftGetInt (++xlfd, &resx))) return 0;
if (!(xlfd = _XftGetInt (++xlfd, &resy))) return 0;
if (!(xlfd = strchr (/* spacing = */ ++xlfd, '-'))) return 0;
if (!(xlfd = strchr (/* average_width = */ ++xlfd, '-'))) return 0;
if (!(xlfd = strchr (registry = ++xlfd, '-'))) return 0;
/* make sure no fields follow this one */
if ((xlfd = strchr (encoding = ++xlfd, '-'))) return 0;
if (ignore_scalable && !pixel)
return 0;
pat = XftPatternCreate ();
if (!pat)
return 0;
save = (char *) malloc (strlen (foundry) + 1);
if (!save)
return 0;
if (!XftPatternAddString (pat, XFT_XLFD, xlfd_orig)) goto bail;
_XftSplitStr (foundry, save);
if (save[0] && strcmp (save, "*") != 0)
if (!XftPatternAddString (pat, XFT_FOUNDRY, save)) goto bail;
_XftSplitStr (family, save);
if (save[0] && strcmp (save, "*") != 0)
if (!XftPatternAddString (pat, XFT_FAMILY, save)) goto bail;
weight_value = _XftMatchSymbolic (XftXlfdWeights, NUM_XLFD_WEIGHTS,
_XftSplitStr (weight_name, save),
XFT_WEIGHT_MEDIUM);
if (!XftPatternAddInteger (pat, XFT_WEIGHT, weight_value))
goto bail;
slant_value = _XftMatchSymbolic (XftXlfdSlants, NUM_XLFD_SLANTS,
_XftSplitStr (slant, save),
XFT_SLANT_ROMAN);
if (!XftPatternAddInteger (pat, XFT_SLANT, slant_value))
goto bail;
dpixel = (double) pixel;
if (complete)
{
/*
* Build a style name
*/
style[0] = '\0';
switch (weight_value) {
case XFT_WEIGHT_LIGHT: strcat (style, "light"); break;
case XFT_WEIGHT_DEMIBOLD: strcat (style, "demibold"); break;
case XFT_WEIGHT_BOLD: strcat (style, "bold"); break;
case XFT_WEIGHT_BLACK: strcat (style, "black"); break;
}
if (slant_value != XFT_SLANT_ROMAN) {
if (style[0])
strcat (style, " ");
switch (slant_value) {
case XFT_SLANT_ITALIC: strcat (style, "italic"); break;
case XFT_SLANT_OBLIQUE: strcat (style, "oblique"); break;
}
}
if (!style[0])
strcat (style, "Regular");
if (!XftPatternAddString (pat, XFT_STYLE, style))
goto bail;
if (!XftPatternAddBool (pat, XFT_SCALABLE, pixel == 0)) goto bail;
if (!XftPatternAddBool (pat, XFT_CORE, True)) goto bail;
if (!XftPatternAddBool (pat, XFT_ANTIALIAS, False)) goto bail;
}
else
{
if (point > 0)
{
if (!XftPatternAddDouble (pat, XFT_SIZE, ((double) point) / 10.0)) goto bail;
if (pixel <= 0 && resy > 0)
{
dpixel = (double) point * (double) resy / 720.0;
}
}
}
if (dpixel > 0)
if (!XftPatternAddDouble (pat, XFT_PIXEL_SIZE, dpixel)) goto bail;
_XftDownStr (registry, save);
if (registry[0] && !strchr (registry, '*'))
if (!XftPatternAddString (pat, XFT_ENCODING, save)) goto bail;
free (save);
return pat;
bail:
free (save);
XftPatternDestroy (pat);
return 0;
}
