/* xftfont.c -- XFT font driver.
- Copyright (C) 2006, 2007, 2008 Free Software Foundation, Inc.
- Copyright (C) 2006, 2007, 2008
+ Copyright (C) 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2006, 2007, 2008, 2009
National Institute of Advanced Industrial Science and Technology (AIST)
Registration Number H13PRO009
#include <config.h>
#include <stdio.h>
+#include <setjmp.h>
#include <X11/Xlib.h>
#include <X11/Xft/Xft.h>
struct xftfont_info
{
struct font font;
- /* The following three members must be here in this order to be
+ /* The following five members must be here in this order to be
compatible with struct ftfont_info (in ftfont.c). */
#ifdef HAVE_LIBOTF
int maybe_otf; /* Flag to tell if this may be OTF or not. */
OTF *otf;
#endif /* HAVE_LIBOTF */
FT_Size ft_size;
+ int index;
+ FT_Matrix matrix;
Display *display;
int screen;
XftFont *xftfont;
static void xftfont_close P_ ((FRAME_PTR, struct font *));
static int xftfont_prepare_face P_ ((FRAME_PTR, struct face *));
static void xftfont_done_face P_ ((FRAME_PTR, struct face *));
+static int xftfont_has_char P_ ((Lisp_Object, int));
static unsigned xftfont_encode_char P_ ((struct font *, int));
static int xftfont_text_extents P_ ((struct font *, unsigned *, int,
struct font_metrics *));
Lisp_Object spec;
{
Lisp_Object list = ftfont_driver.list (frame, spec), tail;
-
+
for (tail = list; CONSP (tail); tail = XCDR (tail))
ASET (XCAR (tail), FONT_TYPE_INDEX, Qxft);
return list;
static FcChar8 ascii_printable[95];
+static void
+xftfont_fix_match (pat, match)
+ FcPattern *pat, *match;
+{
+ /* These values are not used for matching (except antialias), but for
+ rendering, so make sure they are carried over to the match.
+ We also put antialias here because most fonts are antialiased, so
+ the match will have antialias true. */
+
+ FcBool b = FcTrue;
+ int i;
+ double dpi;
+
+ FcPatternGetBool (pat, FC_ANTIALIAS, 0, &b);
+ if (! b)
+ {
+ FcPatternDel (match, FC_ANTIALIAS);
+ FcPatternAddBool (match, FC_ANTIALIAS, FcFalse);
+ }
+ FcPatternGetBool (pat, FC_HINTING, 0, &b);
+ if (! b)
+ {
+ FcPatternDel (match, FC_HINTING);
+ FcPatternAddBool (match, FC_HINTING, FcFalse);
+ }
+ if (FcResultMatch == FcPatternGetInteger (pat, FC_HINT_STYLE, 0, &i))
+ {
+ FcPatternDel (match, FC_HINT_STYLE);
+ FcPatternAddInteger (match, FC_HINT_STYLE, i);
+ }
+#ifndef FC_LCD_FILTER
+ /* Older fontconfig versions don't have FC_LCD_FILTER. */
+#define FC_LCD_FILTER "lcdfilter"
+#endif
+ if (FcResultMatch == FcPatternGetInteger (pat, FC_LCD_FILTER, 0, &i))
+ {
+ FcPatternDel (match, FC_LCD_FILTER);
+ FcPatternAddInteger (match, FC_LCD_FILTER, i);
+ }
+ if (FcResultMatch == FcPatternGetInteger (pat, FC_RGBA, 0, &i))
+ {
+ FcPatternDel (match, FC_RGBA);
+ FcPatternAddInteger (match, FC_RGBA, i);
+ }
+ if (FcResultMatch == FcPatternGetDouble (pat, FC_DPI, 0, &dpi))
+ {
+ FcPatternDel (match, FC_DPI);
+ FcPatternAddDouble (match, FC_DPI, dpi);
+ }
+}
+
static Lisp_Object
xftfont_open (f, entity, pixel_size)
FRAME_PTR f;
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))
key = XCAR (XCAR (tail)), val = XCDR (XCAR (tail));
if (EQ (key, QCantialias))
- FcPatternAddBool (pat, FC_ANTIALIAS, NILP (val) ? FcFalse : FcTrue);
+ FcPatternAddBool (pat, FC_ANTIALIAS, NILP (val) ? FcFalse : FcTrue);
else if (EQ (key, QChinting))
FcPatternAddBool (pat, FC_HINTING, NILP (val) ? FcFalse : FcTrue);
else if (EQ (key, QCautohint))
else if (EQ (key, QChintstyle))
{
if (INTEGERP (val))
- FcPatternAddInteger (pat, FC_RGBA, XINT (val));
+ FcPatternAddInteger (pat, FC_HINT_STYLE, XINT (val));
}
else if (EQ (key, QCrgba))
{
FcPatternAddString (pat, FC_FILE, (FcChar8 *) SDATA (filename));
FcPatternAddInteger (pat, FC_INDEX, XINT (index));
-
+
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;
- if (! xftfont)
- return Qnil;
/* 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_unibyte_string (name, len));
+ 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_unibyte_string (name, len));
+ ASET (font_object, FONT_FULLNAME_INDEX, make_string (name, len));
else
ASET (font_object, FONT_FULLNAME_INDEX,
AREF (font_object, FONT_NAME_INDEX));
xftfont_info->display = display;
xftfont_info->screen = FRAME_X_SCREEN_NUMBER (f);
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;
+ }
font->pixel_size = size;
font->driver = &xftfont_driver;
if (INTEGERP (AREF (entity, FONT_SPACING_INDEX)))
font->space_width = extents.xOff;
if (font->space_width <= 0)
/* dirty workaround */
- font->space_width = pixel_size;
+ font->space_width = pixel_size;
XftTextExtents8 (display, xftfont, ascii_printable + 1, 94, &extents);
font->average_width = (font->space_width + extents.xOff) / 95;
}
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;
+ font->underline_thickness = ft_face->underline_thickness * size / upEM;
if (font->underline_thickness > 2)
font->underline_position -= font->underline_thickness / 2;
}
struct face *face;
{
struct xftface_info *xftface_info;
-
+
#if 0
/* This doesn't work if face->ascii_face doesn't use an Xft font. */
if (face != face->ascii_face
}
}
+extern Lisp_Object Qja, Qko;
+
+static int
+xftfont_has_char (font, c)
+ Lisp_Object font;
+ int c;
+{
+ struct xftfont_info *xftfont_info;
+ struct charset *cs = NULL;
+
+ if (EQ (AREF (font, FONT_ADSTYLE_INDEX), Qja)
+ && charset_jisx0208 >= 0)
+ cs = CHARSET_FROM_ID (charset_jisx0208);
+ else if (EQ (AREF (font, FONT_ADSTYLE_INDEX), Qko)
+ && charset_ksc5601 >= 0)
+ cs = CHARSET_FROM_ID (charset_ksc5601);
+ if (cs)
+ return (ENCODE_CHAR (cs, c) != CHARSET_INVALID_CODE (cs));
+
+ if (FONT_ENTITY_P (font))
+ return ftfont_driver.has_char (font, c);
+ xftfont_info = (struct xftfont_info *) XFONT_OBJECT (font);
+ return (XftCharExists (xftfont_info->display, xftfont_info->xftfont,
+ (FcChar32) c) == FcTrue);
+}
+
static unsigned
xftfont_encode_char (font, c)
struct font *font;
struct xftfont_info *xftfont_info = (struct xftfont_info *) font;
unsigned code = XftCharIndex (xftfont_info->display, xftfont_info->xftfont,
(FcChar32) c);
-
+
return (code ? code : FONT_INVALID_CODE);
}
xftfont_get_xft_draw (f)
FRAME_PTR f;
{
- XftDraw *xft_draw = font_get_frame_data (f, &xftfont_driver);;
+ XftDraw *xft_draw = font_get_frame_data (f, &xftfont_driver);
if (! xft_draw)
{
xftfont_end_for_frame (f)
FRAME_PTR f;
{
- XftDraw *xft_draw = font_get_frame_data (f, &xftfont_driver);
+ XftDraw *xft_draw;
+
+ /* Don't do anything if display is dead */
+ if (FRAME_X_DISPLAY (f) == NULL) return 0;
+
+ xft_draw = font_get_frame_data (f, &xftfont_driver);
if (xft_draw)
{
{
DEFSYM (Qxft, "xft");
DEFSYM (QChinting, ":hinting");
- DEFSYM (QCautohint, ":autohing");
+ DEFSYM (QCautohint, ":autohint");
DEFSYM (QChintstyle, ":hintstyle");
DEFSYM (QCrgba, ":rgba");
DEFSYM (QCembolden, ":embolden");
xftfont_driver.close = xftfont_close;
xftfont_driver.prepare_face = xftfont_prepare_face;
xftfont_driver.done_face = xftfont_done_face;
+ xftfont_driver.has_char = xftfont_has_char;
xftfont_driver.encode_char = xftfont_encode_char;
xftfont_driver.text_extents = xftfont_text_extents;
xftfont_driver.draw = xftfont_draw;
HCoop / bpt / emacs.git / blobdiff