src/xftfont.c

   1 /* xftfont.c -- XFT font driver.
   2    Copyright (C) 2006-2012 Free Software Foundation, Inc.
   3    Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
   4      National Institute of Advanced Industrial Science and Technology (AIST)
   5      Registration Number H13PRO009
   6
   7 This file is part of GNU Emacs.
   8
   9 GNU Emacs is free software: you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation, either version 3 of the License, or
  12 (at your option) any later version.
  13
  14 GNU Emacs is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include <config.h>
  23 #include <stdio.h>
  24 #include <setjmp.h>
  25 #include <X11/Xlib.h>
  26 #include <X11/Xft/Xft.h>
  27
  28 #include "lisp.h"
  29 #include "dispextern.h"
  30 #include "xterm.h"
  31 #include "frame.h"
  32 #include "blockinput.h"
  33 #include "character.h"
  34 #include "charset.h"
  35 #include "composite.h"
  36 #include "fontset.h"
  37 #include "font.h"
  38 #include "ftfont.h"
  39
  40 /* Xft font driver.  */
  41
  42 static Lisp_Object Qxft;
  43 static Lisp_Object QChinting, QCautohint, QChintstyle, QCrgba, QCembolden,
  44   QClcdfilter;
  45
  46 /* The actual structure for Xft font that can be casted to struct
  47    font.  */
  48
  49 struct xftfont_info
  50 {
  51   struct font font;
  52   /* The following five members must be here in this order to be
  53      compatible with struct ftfont_info (in ftfont.c).  */
  54 #ifdef HAVE_LIBOTF
  55   int maybe_otf;          /* Flag to tell if this may be OTF or not.  */
  56   OTF *otf;
  57 #endif  /* HAVE_LIBOTF */
  58   FT_Size ft_size;
  59   int index;
  60   FT_Matrix matrix;
  61   Display *display;
  62   int screen;
  63   XftFont *xftfont;
  64 };
  65
  66 /* Structure pointed by (struct face *)->extra  */
  67
  68 struct xftface_info
  69 {
  70   XftColor xft_fg;              /* color for face->foreground */
  71   XftColor xft_bg;              /* color for face->background */
  72 };
  73
  74 static void xftfont_get_colors (FRAME_PTR, struct face *, GC gc,
  75                                 struct xftface_info *,
  76                                 XftColor *fg, XftColor *bg);
  77
  78
  79 /* Setup foreground and background colors of GC into FG and BG.  If
  80    XFTFACE_INFO is not NULL, reuse the colors in it if possible.  BG
  81    may be NULL.  */
  82
  83 static void
  84 xftfont_get_colors (FRAME_PTR f, struct face *face, GC gc, struct xftface_info *xftface_info, XftColor *fg, XftColor *bg)
  85 {
  86   if (xftface_info && face->gc == gc)
  87     {
  88       *fg = xftface_info->xft_fg;
  89       if (bg)
  90         *bg = xftface_info->xft_bg;
  91     }
  92   else
  93     {
  94       XGCValues xgcv;
  95       int fg_done = 0, bg_done = 0;
  96
  97       BLOCK_INPUT;
  98       XGetGCValues (FRAME_X_DISPLAY (f), gc,
  99                     GCForeground | GCBackground, &xgcv);
 100       if (xftface_info)
 101         {
 102           if (xgcv.foreground == face->foreground)
 103             *fg = xftface_info->xft_fg, fg_done = 1;
 104           else if (xgcv.foreground == face->background)
 105             *fg = xftface_info->xft_bg, fg_done = 1;
 106           if (! bg)
 107             bg_done = 1;
 108           else if (xgcv.background == face->background)
 109             *bg = xftface_info->xft_bg, bg_done = 1;
 110           else if (xgcv.background == face->foreground)
 111             *bg = xftface_info->xft_fg, bg_done = 1;
 112         }
 113
 114       if (fg_done + bg_done < 2)
 115         {
 116           XColor colors[2];
 117
 118           colors[0].pixel = fg->pixel = xgcv.foreground;
 119           if (bg)
 120             colors[1].pixel = bg->pixel = xgcv.background;
 121           XQueryColors (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), colors,
 122                         bg ? 2 : 1);
 123           fg->color.alpha = 0xFFFF;
 124           fg->color.red = colors[0].red;
 125           fg->color.green = colors[0].green;
 126           fg->color.blue = colors[0].blue;
 127           if (bg)
 128             {
 129               bg->color.alpha = 0xFFFF;
 130               bg->color.red = colors[1].red;
 131               bg->color.green = colors[1].green;
 132               bg->color.blue = colors[1].blue;
 133             }
 134         }
 135       UNBLOCK_INPUT;
 136     }
 137 }
 138
 139
 140 static Lisp_Object xftfont_list (Lisp_Object, Lisp_Object);
 141 static Lisp_Object xftfont_match (Lisp_Object, Lisp_Object);
 142 static Lisp_Object xftfont_open (FRAME_PTR, Lisp_Object, int);
 143 static void xftfont_close (FRAME_PTR, struct font *);
 144 static int xftfont_prepare_face (FRAME_PTR, struct face *);
 145 static void xftfont_done_face (FRAME_PTR, struct face *);
 146 static int xftfont_has_char (Lisp_Object, int);
 147 static unsigned xftfont_encode_char (struct font *, int);
 148 static int xftfont_text_extents (struct font *, unsigned *, int,
 149                                  struct font_metrics *);
 150 static int xftfont_draw (struct glyph_string *, int, int, int, int, int);
 151 static int xftfont_end_for_frame (FRAME_PTR f);
 152
 153 struct font_driver xftfont_driver;
 154
 155 static Lisp_Object
 156 xftfont_list (Lisp_Object frame, Lisp_Object spec)
 157 {
 158   Lisp_Object list = ftfont_driver.list (frame, spec), tail;
 159
 160   for (tail = list; CONSP (tail); tail = XCDR (tail))
 161     ASET (XCAR (tail), FONT_TYPE_INDEX, Qxft);
 162   return list;
 163 }
 164
 165 static Lisp_Object
 166 xftfont_match (Lisp_Object frame, Lisp_Object spec)
 167 {
 168   Lisp_Object entity = ftfont_driver.match (frame, spec);
 169
 170   if (! NILP (entity))
 171     ASET (entity, FONT_TYPE_INDEX, Qxft);
 172   return entity;
 173 }
 174
 175 static FcChar8 ascii_printable[95];
 176
 177 static void
 178 xftfont_fix_match (FcPattern *pat, FcPattern *match)
 179 {
 180   /*  These values are not used for matching (except antialias), but for
 181       rendering, so make sure they are carried over to the match.
 182       We also put antialias here because most fonts are antialiased, so
 183       the match will have antialias true.  */
 184
 185   FcBool b = FcTrue;
 186   int i;
 187   double dpi;
 188
 189   FcPatternGetBool (pat, FC_ANTIALIAS, 0, &b);
 190   if (! b)
 191     {
 192       FcPatternDel (match, FC_ANTIALIAS);
 193       FcPatternAddBool (match, FC_ANTIALIAS, FcFalse);
 194     }
 195   FcPatternGetBool (pat, FC_HINTING, 0, &b);
 196   if (! b)
 197     {
 198       FcPatternDel (match, FC_HINTING);
 199       FcPatternAddBool (match, FC_HINTING, FcFalse);
 200     }
 201 #ifndef FC_HINT_STYLE
 202 # define FC_HINT_STYLE "hintstyle"
 203 #endif
 204   if (FcResultMatch == FcPatternGetInteger (pat, FC_HINT_STYLE, 0, &i))
 205     {
 206       FcPatternDel (match, FC_HINT_STYLE);
 207       FcPatternAddInteger (match, FC_HINT_STYLE, i);
 208     }
 209 #ifndef FC_LCD_FILTER
 210   /* Older fontconfig versions don't have FC_LCD_FILTER. */
 211 #define FC_LCD_FILTER "lcdfilter"
 212 #endif
 213   if (FcResultMatch == FcPatternGetInteger (pat, FC_LCD_FILTER, 0, &i))
 214     {
 215       FcPatternDel (match, FC_LCD_FILTER);
 216       FcPatternAddInteger (match, FC_LCD_FILTER, i);
 217     }
 218   if (FcResultMatch == FcPatternGetInteger (pat, FC_RGBA, 0, &i))
 219     {
 220       FcPatternDel (match, FC_RGBA);
 221       FcPatternAddInteger (match, FC_RGBA, i);
 222     }
 223   if (FcResultMatch == FcPatternGetDouble (pat, FC_DPI, 0, &dpi))
 224     {
 225       FcPatternDel (match, FC_DPI);
 226       FcPatternAddDouble (match, FC_DPI, dpi);
 227     }
 228 }
 229
 230 static void
 231 xftfont_add_rendering_parameters (FcPattern *pat, Lisp_Object entity)
 232 {
 233   Lisp_Object tail;
 234   int ival;
 235
 236   for (tail = AREF (entity, FONT_EXTRA_INDEX); CONSP (tail); tail = XCDR (tail))
 237     {
 238       Lisp_Object key = XCAR (XCAR (tail));
 239       Lisp_Object val = XCDR (XCAR (tail));
 240
 241       if (EQ (key, QCantialias))
 242           FcPatternAddBool (pat, FC_ANTIALIAS, NILP (val) ? FcFalse : FcTrue);
 243       else if (EQ (key, QChinting))
 244         FcPatternAddBool (pat, FC_HINTING, NILP (val) ? FcFalse : FcTrue);
 245       else if (EQ (key, QCautohint))
 246         FcPatternAddBool (pat, FC_AUTOHINT, NILP (val) ? FcFalse : FcTrue);
 247       else if (EQ (key, QChintstyle))
 248         {
 249           if (INTEGERP (val))
 250             FcPatternAddInteger (pat, FC_HINT_STYLE, XINT (val));
 251           else if (SYMBOLP (val)
 252                    && FcNameConstant (SDATA (SYMBOL_NAME (val)), &ival))
 253             FcPatternAddInteger (pat, FC_HINT_STYLE, ival);
 254         }
 255       else if (EQ (key, QCrgba))
 256         {
 257           if (INTEGERP (val))
 258             FcPatternAddInteger (pat, FC_RGBA, XINT (val));
 259           else if (SYMBOLP (val)
 260                    && FcNameConstant (SDATA (SYMBOL_NAME (val)), &ival))
 261             FcPatternAddInteger (pat, FC_RGBA, ival);
 262         }
 263       else if (EQ (key, QClcdfilter))
 264         {
 265           if (INTEGERP (val))
 266             FcPatternAddInteger (pat, FC_LCD_FILTER, ival = XINT (val));
 267           else if (SYMBOLP (val)
 268                    && FcNameConstant (SDATA (SYMBOL_NAME (val)), &ival))
 269             FcPatternAddInteger (pat, FC_LCD_FILTER, ival);
 270         }
 271 #ifdef FC_EMBOLDEN
 272       else if (EQ (key, QCembolden))
 273         FcPatternAddBool (pat, FC_EMBOLDEN, NILP (val) ? FcFalse : FcTrue);
 274 #endif
 275     }
 276 }
 277
 278 static Lisp_Object
 279 xftfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
 280 {
 281   FcResult result;
 282   Display *display = FRAME_X_DISPLAY (f);
 283   Lisp_Object val, filename, idx, font_object;
 284   FcPattern *pat = NULL, *match;
 285   struct xftfont_info *xftfont_info = NULL;
 286   struct font *font;
 287   double size = 0;
 288   XftFont *xftfont = NULL;
 289   int spacing;
 290   char name[256];
 291   int len, i;
 292   XGlyphInfo extents;
 293   FT_Face ft_face;
 294   FcMatrix *matrix;
 295
 296   val = assq_no_quit (QCfont_entity, AREF (entity, FONT_EXTRA_INDEX));
 297   if (! CONSP (val))
 298     return Qnil;
 299   val = XCDR (val);
 300   filename = XCAR (val);
 301   idx = XCDR (val);
 302   size = XINT (AREF (entity, FONT_SIZE_INDEX));
 303   if (size == 0)
 304     size = pixel_size;
 305   pat = FcPatternCreate ();
 306   FcPatternAddInteger (pat, FC_WEIGHT, FONT_WEIGHT_NUMERIC (entity));
 307   i = FONT_SLANT_NUMERIC (entity) - 100;
 308   if (i < 0) i = 0;
 309   FcPatternAddInteger (pat, FC_SLANT, i);
 310   FcPatternAddInteger (pat, FC_WIDTH, FONT_WIDTH_NUMERIC (entity));
 311   FcPatternAddDouble (pat, FC_PIXEL_SIZE, pixel_size);
 312   val = AREF (entity, FONT_FAMILY_INDEX);
 313   if (! NILP (val))
 314     FcPatternAddString (pat, FC_FAMILY, (FcChar8 *) SDATA (SYMBOL_NAME (val)));
 315   val = AREF (entity, FONT_FOUNDRY_INDEX);
 316   if (! NILP (val))
 317     FcPatternAddString (pat, FC_FOUNDRY, (FcChar8 *) SDATA (SYMBOL_NAME (val)));
 318   val = AREF (entity, FONT_SPACING_INDEX);
 319   if (! NILP (val))
 320     FcPatternAddInteger (pat, FC_SPACING, XINT (val));
 321   val = AREF (entity, FONT_DPI_INDEX);
 322   if (! NILP (val))
 323     {
 324       double dbl = XINT (val);
 325
 326       FcPatternAddDouble (pat, FC_DPI, dbl);
 327     }
 328   val = AREF (entity, FONT_AVGWIDTH_INDEX);
 329   if (INTEGERP (val) && XINT (val) == 0)
 330     FcPatternAddBool (pat, FC_SCALABLE, FcTrue);
 331   /* This is necessary to identify the exact font (e.g. 10x20.pcf.gz
 332      over 10x20-ISO8859-1.pcf.gz).  */
 333   FcPatternAddCharSet (pat, FC_CHARSET, ftfont_get_fc_charset (entity));
 334
 335   xftfont_add_rendering_parameters (pat, entity);
 336
 337   FcPatternAddString (pat, FC_FILE, (FcChar8 *) SDATA (filename));
 338   FcPatternAddInteger (pat, FC_INDEX, XINT (idx));
 339
 340
 341   BLOCK_INPUT;
 342   /* Make sure that the Xrender extension is added before the Xft one.
 343      Otherwise, the close-display hook set by Xft is called after the
 344      one for Xrender, and the former tries to re-add the latter.  This
 345      results in inconsistency of internal states and leads to X
 346      protocol error when one reconnects to the same X server.
 347      (Bug#1696)  */
 348   {
 349     int event_base, error_base;
 350     XRenderQueryExtension (display, &event_base, &error_base);
 351   }
 352
 353   /* Substitute in values from X resources and XftDefaultSet.  */
 354   XftDefaultSubstitute (display, FRAME_X_SCREEN_NUMBER (f), pat);
 355   match = XftFontMatch (display, FRAME_X_SCREEN_NUMBER (f), pat, &result);
 356   xftfont_fix_match (pat, match);
 357
 358   FcPatternDestroy (pat);
 359   xftfont = XftFontOpenPattern (display, match);
 360   if (!xftfont)
 361     {
 362       UNBLOCK_INPUT;
 363       XftPatternDestroy (match);
 364       return Qnil;
 365     }
 366   ft_face = XftLockFace (xftfont);
 367   UNBLOCK_INPUT;
 368
 369   /* We should not destroy PAT here because it is kept in XFTFONT and
 370      destroyed automatically when XFTFONT is closed.  */
 371   font_object = font_make_object (VECSIZE (struct xftfont_info), entity, size);
 372   ASET (font_object, FONT_TYPE_INDEX, Qxft);
 373   len = font_unparse_xlfd (entity, size, name, 256);
 374   if (len > 0)
 375     ASET (font_object, FONT_NAME_INDEX, make_string (name, len));
 376   len = font_unparse_fcname (entity, size, name, 256);
 377   if (len > 0)
 378     ASET (font_object, FONT_FULLNAME_INDEX, make_string (name, len));
 379   else
 380     ASET (font_object, FONT_FULLNAME_INDEX,
 381           AREF (font_object, FONT_NAME_INDEX));
 382   ASET (font_object, FONT_FILE_INDEX, filename);
 383   ASET (font_object, FONT_FORMAT_INDEX,
 384         ftfont_font_format (xftfont->pattern, filename));
 385   font = XFONT_OBJECT (font_object);
 386   font->pixel_size = pixel_size;
 387   font->driver = &xftfont_driver;
 388   font->encoding_charset = font->repertory_charset = -1;
 389
 390   xftfont_info = (struct xftfont_info *) font;
 391   xftfont_info->display = display;
 392   xftfont_info->screen = FRAME_X_SCREEN_NUMBER (f);
 393   xftfont_info->xftfont = xftfont;
 394   /* This means that there's no need of transformation.  */
 395   xftfont_info->matrix.xx = 0;
 396   if (FcPatternGetMatrix (xftfont->pattern, FC_MATRIX, 0, &matrix)
 397       == FcResultMatch)
 398     {
 399       xftfont_info->matrix.xx = 0x10000L * matrix->xx;
 400       xftfont_info->matrix.yy = 0x10000L * matrix->yy;
 401       xftfont_info->matrix.xy = 0x10000L * matrix->xy;
 402       xftfont_info->matrix.yx = 0x10000L * matrix->yx;
 403     }
 404   font->pixel_size = size;
 405   font->driver = &xftfont_driver;
 406   if (INTEGERP (AREF (entity, FONT_SPACING_INDEX)))
 407     spacing = XINT (AREF (entity, FONT_SPACING_INDEX));
 408   else
 409     spacing = FC_PROPORTIONAL;
 410   if (! ascii_printable[0])
 411     {
 412       int ch;
 413       for (ch = 0; ch < 95; ch++)
 414         ascii_printable[ch] = ' ' + ch;
 415     }
 416   BLOCK_INPUT;
 417   if (spacing != FC_PROPORTIONAL
 418 #ifdef FC_DUAL
 419       && spacing != FC_DUAL
 420 #endif  /* FC_DUAL */
 421       )
 422     {
 423       font->min_width = font->average_width = font->space_width
 424         = xftfont->max_advance_width;
 425       XftTextExtents8 (display, xftfont, ascii_printable + 1, 94, &extents);
 426     }
 427   else
 428     {
 429       XftTextExtents8 (display, xftfont, ascii_printable, 1, &extents);
 430       font->space_width = extents.xOff;
 431       if (font->space_width <= 0)
 432         /* dirty workaround */
 433         font->space_width = pixel_size;
 434       XftTextExtents8 (display, xftfont, ascii_printable + 1, 94, &extents);
 435       font->average_width = (font->space_width + extents.xOff) / 95;
 436     }
 437   UNBLOCK_INPUT;
 438
 439   font->ascent = xftfont->ascent;
 440   font->descent = xftfont->descent;
 441   if (pixel_size >= 5)
 442     {
 443       /* The above condition is a dirty workaround because
 444          XftTextExtents8 behaves strangely for some fonts
 445          (e.g. "Dejavu Sans Mono") when pixel_size is less than 5. */
 446       if (font->ascent < extents.y)
 447         font->ascent = extents.y;
 448       if (font->descent < extents.height - extents.y)
 449         font->descent = extents.height - extents.y;
 450     }
 451   font->height = font->ascent + font->descent;
 452
 453   if (XINT (AREF (entity, FONT_SIZE_INDEX)) == 0)
 454     {
 455       int upEM = ft_face->units_per_EM;
 456
 457       font->underline_position = -ft_face->underline_position * size / upEM;
 458       font->underline_thickness = ft_face->underline_thickness * size / upEM;
 459       if (font->underline_thickness > 2)
 460         font->underline_position -= font->underline_thickness / 2;
 461     }
 462   else
 463     {
 464       font->underline_position = -1;
 465       font->underline_thickness = 0;
 466     }
 467 #ifdef HAVE_LIBOTF
 468   xftfont_info->maybe_otf = ft_face->face_flags & FT_FACE_FLAG_SFNT;
 469   xftfont_info->otf = NULL;
 470 #endif  /* HAVE_LIBOTF */
 471   xftfont_info->ft_size = ft_face->size;
 472
 473   /* Unfortunately Xft doesn't provide a way to get minimum char
 474      width.  So, we use space_width instead.  */
 475   font->min_width = font->space_width;
 476
 477   font->baseline_offset = 0;
 478   font->relative_compose = 0;
 479   font->default_ascent = 0;
 480   font->vertical_centering = 0;
 481 #ifdef FT_BDF_H
 482   if (! (ft_face->face_flags & FT_FACE_FLAG_SFNT))
 483     {
 484       BDF_PropertyRec rec;
 485
 486       if (FT_Get_BDF_Property (ft_face, "_MULE_BASELINE_OFFSET", &rec) == 0
 487           && rec.type == BDF_PROPERTY_TYPE_INTEGER)
 488         font->baseline_offset = rec.u.integer;
 489       if (FT_Get_BDF_Property (ft_face, "_MULE_RELATIVE_COMPOSE", &rec) == 0
 490           && rec.type == BDF_PROPERTY_TYPE_INTEGER)
 491         font->relative_compose = rec.u.integer;
 492       if (FT_Get_BDF_Property (ft_face, "_MULE_DEFAULT_ASCENT", &rec) == 0
 493           && rec.type == BDF_PROPERTY_TYPE_INTEGER)
 494         font->default_ascent = rec.u.integer;
 495     }
 496 #endif
 497
 498   return font_object;
 499 }
 500
 501 static void
 502 xftfont_close (FRAME_PTR f, struct font *font)
 503 {
 504   struct xftfont_info *xftfont_info = (struct xftfont_info *) font;
 505
 506 #ifdef HAVE_LIBOTF
 507   if (xftfont_info->otf)
 508     OTF_close (xftfont_info->otf);
 509 #endif
 510   BLOCK_INPUT;
 511   XftUnlockFace (xftfont_info->xftfont);
 512   XftFontClose (xftfont_info->display, xftfont_info->xftfont);
 513   UNBLOCK_INPUT;
 514 }
 515
 516 static int
 517 xftfont_prepare_face (FRAME_PTR f, struct face *face)
 518 {
 519   struct xftface_info *xftface_info;
 520
 521 #if 0
 522   /* This doesn't work if face->ascii_face doesn't use an Xft font. */
 523   if (face != face->ascii_face)
 524     {
 525       face->extra = face->ascii_face->extra;
 526       return 0;
 527     }
 528 #endif
 529
 530   xftface_info = malloc (sizeof (struct xftface_info));
 531   if (! xftface_info)
 532     return -1;
 533   xftfont_get_colors (f, face, face->gc, NULL,
 534                       &xftface_info->xft_fg, &xftface_info->xft_bg);
 535   face->extra = xftface_info;
 536   return 0;
 537 }
 538
 539 static void
 540 xftfont_done_face (FRAME_PTR f, struct face *face)
 541 {
 542   struct xftface_info *xftface_info;
 543
 544 #if 0
 545   /* This doesn't work if face->ascii_face doesn't use an Xft font. */
 546   if (face != face->ascii_face
 547       || ! face->extra)
 548     return;
 549 #endif
 550
 551   xftface_info = (struct xftface_info *) face->extra;
 552   if (xftface_info)
 553     {
 554       free (xftface_info);
 555       face->extra = NULL;
 556     }
 557 }
 558
 559 static int
 560 xftfont_has_char (Lisp_Object font, int c)
 561 {
 562   struct xftfont_info *xftfont_info;
 563   struct charset *cs = NULL;
 564
 565   if (EQ (AREF (font, FONT_ADSTYLE_INDEX), Qja)
 566       && charset_jisx0208 >= 0)
 567     cs = CHARSET_FROM_ID (charset_jisx0208);
 568   else if (EQ (AREF (font, FONT_ADSTYLE_INDEX), Qko)
 569       && charset_ksc5601 >= 0)
 570     cs = CHARSET_FROM_ID (charset_ksc5601);
 571   if (cs)
 572     return (ENCODE_CHAR (cs, c) != CHARSET_INVALID_CODE (cs));
 573
 574   if (FONT_ENTITY_P (font))
 575     return ftfont_driver.has_char (font, c);
 576   xftfont_info = (struct xftfont_info *) XFONT_OBJECT (font);
 577   return (XftCharExists (xftfont_info->display, xftfont_info->xftfont,
 578                          (FcChar32) c) == FcTrue);
 579 }
 580
 581 static unsigned
 582 xftfont_encode_char (struct font *font, int c)
 583 {
 584   struct xftfont_info *xftfont_info = (struct xftfont_info *) font;
 585   unsigned code = XftCharIndex (xftfont_info->display, xftfont_info->xftfont,
 586                                 (FcChar32) c);
 587
 588   return (code ? code : FONT_INVALID_CODE);
 589 }
 590
 591 static int
 592 xftfont_text_extents (struct font *font, unsigned int *code, int nglyphs, struct font_metrics *metrics)
 593 {
 594   struct xftfont_info *xftfont_info = (struct xftfont_info *) font;
 595   XGlyphInfo extents;
 596
 597   BLOCK_INPUT;
 598   XftGlyphExtents (xftfont_info->display, xftfont_info->xftfont, code, nglyphs,
 599                    &extents);
 600   UNBLOCK_INPUT;
 601   if (metrics)
 602     {
 603       metrics->lbearing = - extents.x;
 604       metrics->rbearing = - extents.x + extents.width;
 605       metrics->width = extents.xOff;
 606       metrics->ascent = extents.y;
 607       metrics->descent = extents.height - extents.y;
 608     }
 609   return extents.xOff;
 610 }
 611
 612 static XftDraw *
 613 xftfont_get_xft_draw (FRAME_PTR f)
 614 {
 615   XftDraw *xft_draw = font_get_frame_data (f, &xftfont_driver);
 616
 617   if (! xft_draw)
 618     {
 619       BLOCK_INPUT;
 620       xft_draw= XftDrawCreate (FRAME_X_DISPLAY (f),
 621                                FRAME_X_WINDOW (f),
 622                                FRAME_X_VISUAL (f),
 623                                FRAME_X_COLORMAP (f));
 624       UNBLOCK_INPUT;
 625       if (! xft_draw)
 626         abort ();
 627       font_put_frame_data (f, &xftfont_driver, xft_draw);
 628     }
 629   return xft_draw;
 630 }
 631
 632 static int
 633 xftfont_draw (struct glyph_string *s, int from, int to, int x, int y, int with_background)
 634 {
 635   FRAME_PTR f = s->f;
 636   struct face *face = s->face;
 637   struct xftfont_info *xftfont_info = (struct xftfont_info *) s->font;
 638   struct xftface_info *xftface_info = NULL;
 639   XftDraw *xft_draw = xftfont_get_xft_draw (f);
 640   FT_UInt *code;
 641   XftColor fg, bg;
 642   int len = to - from;
 643   int i;
 644
 645   if (s->font == face->font)
 646     xftface_info = (struct xftface_info *) face->extra;
 647   xftfont_get_colors (f, face, s->gc, xftface_info,
 648                       &fg, with_background ? &bg : NULL);
 649   BLOCK_INPUT;
 650   if (s->num_clips > 0)
 651     XftDrawSetClipRectangles (xft_draw, 0, 0, s->clip, s->num_clips);
 652   else
 653     XftDrawSetClip (xft_draw, NULL);
 654
 655   if (with_background)
 656     XftDrawRect (xft_draw, &bg,
 657                  x, y - s->font->ascent, s->width, s->font->height);
 658   code = alloca (sizeof (FT_UInt) * len);
 659   for (i = 0; i < len; i++)
 660     code[i] = ((XCHAR2B_BYTE1 (s->char2b + from + i) << 8)
 661                | XCHAR2B_BYTE2 (s->char2b + from + i));
 662
 663   if (s->padding_p)
 664     for (i = 0; i < len; i++)
 665       XftDrawGlyphs (xft_draw, &fg, xftfont_info->xftfont,
 666                      x + i, y, code + i, 1);
 667   else
 668     XftDrawGlyphs (xft_draw, &fg, xftfont_info->xftfont,
 669                    x, y, code, len);
 670   UNBLOCK_INPUT;
 671
 672   return len;
 673 }
 674
 675 #if defined HAVE_M17N_FLT && defined HAVE_LIBOTF
 676 static Lisp_Object
 677 xftfont_shape (Lisp_Object lgstring)
 678 {
 679   struct font *font;
 680   struct xftfont_info *xftfont_info;
 681   FT_Face ft_face;
 682   Lisp_Object val;
 683
 684   CHECK_FONT_GET_OBJECT (LGSTRING_FONT (lgstring), font);
 685   xftfont_info = (struct xftfont_info *) font;
 686   ft_face = XftLockFace (xftfont_info->xftfont);
 687   xftfont_info->ft_size = ft_face->size;
 688   val = ftfont_driver.shape (lgstring);
 689   XftUnlockFace (xftfont_info->xftfont);
 690   return val;
 691 }
 692 #endif
 693
 694 static int
 695 xftfont_end_for_frame (FRAME_PTR f)
 696 {
 697   XftDraw *xft_draw;
 698
 699   /* Don't do anything if display is dead */
 700   if (FRAME_X_DISPLAY (f) == NULL) return 0;
 701
 702   xft_draw = font_get_frame_data (f, &xftfont_driver);
 703
 704   if (xft_draw)
 705     {
 706       BLOCK_INPUT;
 707       XftDrawDestroy (xft_draw);
 708       UNBLOCK_INPUT;
 709       font_put_frame_data (f, &xftfont_driver, NULL);
 710     }
 711   return 0;
 712 }
 713
 714 static int
 715 xftfont_cached_font_ok (struct frame *f, Lisp_Object font_object, Lisp_Object entity)
 716 {
 717   struct xftfont_info *info = (struct xftfont_info *) XFONT_OBJECT (font_object);
 718   FcPattern *oldpat = info->xftfont->pattern;
 719   Display *display = FRAME_X_DISPLAY (f);
 720   FcPattern *pat = FcPatternCreate ();
 721   FcBool b1, b2;
 722   int ok = 0, i1, i2, r1, r2;
 723
 724   xftfont_add_rendering_parameters (pat, entity);
 725   XftDefaultSubstitute (display, FRAME_X_SCREEN_NUMBER (f), pat);
 726
 727   r1 = FcPatternGetBool (pat, FC_ANTIALIAS, 0, &b1);
 728   r2 = FcPatternGetBool (oldpat, FC_ANTIALIAS, 0, &b2);
 729   if (r1 != r2 || b1 != b2) goto out;
 730   r1 = FcPatternGetBool (pat, FC_HINTING, 0, &b1);
 731   r2 = FcPatternGetBool (oldpat, FC_HINTING, 0, &b2);
 732   if (r1 != r2 || b1 != b2) goto out;
 733   r1 = FcPatternGetBool (pat, FC_AUTOHINT, 0, &b1);
 734   r2 = FcPatternGetBool (oldpat, FC_AUTOHINT, 0, &b2);
 735   if (r1 != r2 || b1 != b2) goto out;
 736 #ifdef FC_EMBOLDEN
 737   r1 = FcPatternGetBool (pat, FC_EMBOLDEN, 0, &b1);
 738   r2 = FcPatternGetBool (oldpat, FC_EMBOLDEN, 0, &b2);
 739   if (r1 != r2 || b1 != b2) goto out;
 740 #endif
 741   r1 = FcPatternGetInteger (pat, FC_HINT_STYLE, 0, &i1);
 742   r2 = FcPatternGetInteger (oldpat, FC_HINT_STYLE, 0, &i2);
 743   if (r1 != r2 || i1 != i2) goto out;
 744   r1 = FcPatternGetInteger (pat, FC_LCD_FILTER, 0, &i1);
 745   r2 = FcPatternGetInteger (oldpat, FC_LCD_FILTER, 0, &i2);
 746   if (r1 != r2 || i1 != i2) goto out;
 747   r1 = FcPatternGetInteger (pat, FC_RGBA, 0, &i1);
 748   r2 = FcPatternGetInteger (oldpat, FC_RGBA, 0, &i2);
 749   if (r1 != r2 || i1 != i2) goto out;
 750
 751   ok = 1;
 752  out:
 753   FcPatternDestroy (pat);
 754   return ok;
 755 }
 756
 757 void
 758 syms_of_xftfont (void)
 759 {
 760   DEFSYM (Qxft, "xft");
 761   DEFSYM (QChinting, ":hinting");
 762   DEFSYM (QCautohint, ":autohint");
 763   DEFSYM (QChintstyle, ":hintstyle");
 764   DEFSYM (QCrgba, ":rgba");
 765   DEFSYM (QCembolden, ":embolden");
 766   DEFSYM (QClcdfilter, ":lcdfilter");
 767
 768   xftfont_driver = ftfont_driver;
 769   xftfont_driver.type = Qxft;
 770   xftfont_driver.get_cache = xfont_driver.get_cache;
 771   xftfont_driver.list = xftfont_list;
 772   xftfont_driver.match = xftfont_match;
 773   xftfont_driver.open = xftfont_open;
 774   xftfont_driver.close = xftfont_close;
 775   xftfont_driver.prepare_face = xftfont_prepare_face;
 776   xftfont_driver.done_face = xftfont_done_face;
 777   xftfont_driver.has_char = xftfont_has_char;
 778   xftfont_driver.encode_char = xftfont_encode_char;
 779   xftfont_driver.text_extents = xftfont_text_extents;
 780   xftfont_driver.draw = xftfont_draw;
 781   xftfont_driver.end_for_frame = xftfont_end_for_frame;
 782   xftfont_driver.cached_font_ok = xftfont_cached_font_ok;
 783 #if defined (HAVE_M17N_FLT) && defined (HAVE_LIBOTF)
 784   xftfont_driver.shape = xftfont_shape;
 785 #endif
 786
 787   register_font_driver (&xftfont_driver, NULL);
 788 }