src/ftfont.c

   1 /* ftfont.c -- FreeType font driver.
   2    Copyright (C) 2006 Free Software Foundation, Inc.
   3    Copyright (C) 2006
   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 2, or (at your option)
  12 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; see the file COPYING.  If not, write to
  21 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22 Boston, MA 02110-1301, USA.  */
  23
  24 #include <config.h>
  25 #include <stdio.h>
  26
  27 #include <fontconfig/fontconfig.h>
  28 #include <fontconfig/fcfreetype.h>
  29
  30 #include "lisp.h"
  31 #include "dispextern.h"
  32 #include "frame.h"
  33 #include "blockinput.h"
  34 #include "character.h"
  35 #include "charset.h"
  36 #include "coding.h"
  37 #include "fontset.h"
  38 #include "font.h"
  39 #include "ftfont.h"
  40
  41 /* Symbolic type of this font-driver.  */
  42 Lisp_Object Qfreetype;
  43
  44 /* Fontconfig's generic families and their aliases.  */
  45 static Lisp_Object Qmonospace, Qsans_serif, Qserif, Qmono, Qsans, Qsans__serif;
  46
  47 /* Flag to tell if FcInit is areadly called or not.  */
  48 static int fc_initialized;
  49
  50 /* Handle to a FreeType library instance.  */
  51 static FT_Library ft_library;
  52
  53 /* Cache for FreeType fonts.  */
  54 static Lisp_Object freetype_font_cache;
  55
  56 /* Fontconfig's charset used for finding fonts of registry
  57    "iso8859-1".  */
  58 static FcCharSet *cs_iso8859_1;
  59
  60 /* The actual structure for FreeType font that can be casted to struct
  61    font.  */
  62
  63 struct ftfont_info
  64 {
  65   struct font font;
  66   FT_Size ft_size;
  67 #ifdef HAVE_LIBOTF
  68   int maybe_otf;        /* Flag to tell if this may be OTF or not.  */
  69   OTF *otf;
  70 #endif  /* HAVE_LIBOTF */
  71 };
  72
  73 static int ftfont_build_basic_charsets P_ ((void));
  74 static Lisp_Object ftfont_pattern_entity P_ ((FcPattern *,
  75                                               Lisp_Object, Lisp_Object));
  76 static Lisp_Object ftfont_list_generic_family P_ ((Lisp_Object, Lisp_Object,
  77                                                    Lisp_Object));
  78 Lisp_Object ftfont_font_format P_ ((FcPattern *));
  79
  80 #define SYMBOL_FcChar8(SYM) (FcChar8 *) SDATA (SYMBOL_NAME (SYM))
  81
  82 static int
  83 ftfont_build_basic_charsets ()
  84 {
  85   FcChar32 c;
  86
  87   cs_iso8859_1 = FcCharSetCreate ();
  88   if (! cs_iso8859_1)
  89     return -1;
  90   for (c = ' '; c < 127; c++)
  91     if (! FcCharSetAddChar (cs_iso8859_1, c))
  92       return -1;
  93 #if 0
  94   /* This part is currently disabled.  Should be fixed later.  */
  95   for (c = 192; c < 256; c++)
  96     if (! FcCharSetAddChar (cs_iso8859_1, c))
  97       return -1;
  98 #endif
  99   return 0;
 100 }
 101
 102 static Lisp_Object
 103 ftfont_pattern_entity (p, frame, registry)
 104      FcPattern *p;
 105      Lisp_Object frame, registry;
 106 {
 107   Lisp_Object entity;
 108   FcChar8 *file, *fontformat;
 109   FcCharSet *charset;
 110   char *str;
 111   int numeric;
 112   double dbl;
 113
 114   if (FcPatternGetString (p, FC_FILE, 0, &file) != FcResultMatch)
 115     return Qnil;
 116   if (FcPatternGetCharSet (p, FC_CHARSET, 0, &charset) != FcResultMatch)
 117     charset = NULL;
 118 #ifdef FC_FONTFORMAT
 119   if (FcPatternGetString (p, FC_FONTFORMAT, 0, &fontformat) != FcResultMatch)
 120 #endif  /* FC_FONTFORMAT */
 121     fontformat = NULL;
 122
 123   entity = Fmake_vector (make_number (FONT_ENTITY_MAX), null_string);
 124
 125   ASET (entity, FONT_TYPE_INDEX, Qfreetype);
 126   ASET (entity, FONT_REGISTRY_INDEX, registry);
 127   ASET (entity, FONT_FRAME_INDEX, frame);
 128   ASET (entity, FONT_OBJLIST_INDEX, Qnil);
 129
 130   if (FcPatternGetString (p, FC_FOUNDRY, 0, (FcChar8 **) &str) == FcResultMatch)
 131     ASET (entity, FONT_FOUNDRY_INDEX, intern_downcase (str, strlen (str)));
 132   if (FcPatternGetString (p, FC_FAMILY, 0, (FcChar8 **) &str) == FcResultMatch)
 133     ASET (entity, FONT_FAMILY_INDEX, intern_downcase (str, strlen (str)));
 134   if (FcPatternGetInteger (p, FC_WEIGHT, 0, &numeric) == FcResultMatch)
 135     {
 136       if (numeric == FC_WEIGHT_REGULAR)
 137         numeric = 100;
 138       ASET (entity, FONT_WEIGHT_INDEX, make_number (numeric));
 139     }
 140   if (FcPatternGetInteger (p, FC_SLANT, 0, &numeric) == FcResultMatch)
 141     ASET (entity, FONT_SLANT_INDEX, make_number (numeric + 100));
 142   if (FcPatternGetInteger (p, FC_WIDTH, 0, &numeric) == FcResultMatch)
 143     ASET (entity, FONT_WIDTH_INDEX, make_number (numeric));
 144   if (FcPatternGetDouble (p, FC_PIXEL_SIZE, 0, &dbl) == FcResultMatch)
 145     ASET (entity, FONT_SIZE_INDEX, make_number (dbl));
 146   else
 147     ASET (entity, FONT_SIZE_INDEX, make_number (0));
 148
 149   if (FcPatternGetInteger (p, FC_SPACING, 0, &numeric) != FcResultMatch)
 150     numeric = -1;
 151   file = FcStrCopy (file);
 152   if (! file)
 153     return Qnil;
 154
 155   p = FcPatternCreate ();
 156   if (! p)
 157     return Qnil;
 158
 159   if (FcPatternAddString (p, FC_FILE, file) == FcFalse
 160       || (charset
 161           && FcPatternAddCharSet (p, FC_CHARSET, charset) == FcFalse)
 162 #ifdef FC_FONTFORMAT
 163       || (fontformat
 164           && FcPatternAddString (p, FC_FONTFORMAT, fontformat) == FcFalse)
 165 #endif  /* FC_FONTFORMAT */
 166       || (numeric >= 0
 167           && FcPatternAddInteger (p, FC_SPACING, numeric) == FcFalse))
 168     {
 169       FcPatternDestroy (p);
 170       return Qnil;
 171     }
 172   ASET (entity, FONT_EXTRA_INDEX, make_save_value (p, 0));
 173   return entity;
 174 }
 175
 176 static Lisp_Object ftfont_generic_family_list;
 177
 178 static Lisp_Object
 179 ftfont_list_generic_family (spec, frame, registry)
 180      Lisp_Object spec, frame, registry;
 181 {
 182   Lisp_Object family = AREF (spec, FONT_FAMILY_INDEX);
 183   Lisp_Object slot, list, val;
 184
 185   if (EQ (family, Qmono))
 186     family = Qmonospace;
 187   else if (EQ (family, Qsans) || EQ (family, Qsans__serif))
 188     family = Qsans_serif;
 189   slot = assq_no_quit (family, ftfont_generic_family_list);
 190   if (! CONSP (slot))
 191     return null_vector;
 192   list = XCDR (slot);
 193   if (EQ (list, Qt))
 194     {
 195       /* Not yet listed.  */
 196       FcObjectSet *objset = NULL;
 197       FcPattern *pattern = NULL, *pat = NULL;
 198       FcFontSet *fontset = NULL;
 199       FcChar8 *fam;
 200       int i, j;
 201
 202       objset = FcObjectSetBuild (FC_FOUNDRY, FC_FAMILY, FC_WEIGHT, FC_SLANT,
 203                                  FC_WIDTH, FC_PIXEL_SIZE, FC_SPACING,
 204                                  FC_CHARSET, FC_FILE,
 205 #ifdef FC_FONTFORMAT
 206                                  FC_FONTFORMAT,
 207 #endif  /* FC_FONTFORMAT */
 208                                  NULL);
 209       if (! objset)
 210         goto err;
 211       pattern = FcPatternBuild (NULL, FC_FAMILY, FcTypeString,
 212                                 SYMBOL_FcChar8 (family), (char *) 0);
 213       if (! pattern)
 214         goto err;
 215       pat = FcPatternCreate ();
 216       if (! pat)
 217         goto err;
 218       FcConfigSubstitute (NULL, pattern, FcMatchPattern);
 219       for (i = 0, val = Qnil;
 220            FcPatternGetString (pattern, FC_FAMILY, i, &fam) == FcResultMatch;
 221            i++)
 222         {
 223           if (strcmp ((char *) fam, (char *) SYMBOL_FcChar8 (family)) == 0)
 224             continue;
 225           if (! FcPatternAddString (pat, FC_FAMILY, fam))
 226             goto err;
 227           fontset = FcFontList (NULL, pat, objset);
 228           if (! fontset)
 229             goto err;
 230           /* Here we build the list in reverse order so that the last
 231              loop in this function build a list in the correct
 232              order.  */
 233           for (j = 0; j < fontset->nfont; j++)
 234             {
 235               Lisp_Object entity;
 236
 237               entity = ftfont_pattern_entity (fontset->fonts[j],
 238                                               frame, registry);
 239               if (! NILP (entity))
 240                 val = Fcons (entity, val);
 241             }
 242           FcFontSetDestroy (fontset);
 243           fontset = NULL;
 244           FcPatternDel (pat, FC_FAMILY);
 245         }
 246       list = val;
 247       XSETCDR (slot, list);
 248     err:
 249       if (pat) FcPatternDestroy (pat);
 250       if (pattern) FcPatternDestroy (pattern);
 251       if (fontset) FcFontSetDestroy (fontset);
 252       if (objset) FcObjectSetDestroy (objset);
 253       if (EQ (list, Qt))
 254         return Qnil;
 255     }
 256   ASET (spec, FONT_FAMILY_INDEX, Qnil);
 257   for (val = Qnil; CONSP (list); list = XCDR (list))
 258     if (font_match_p (spec, XCAR (list)))
 259       val = Fcons (XCAR (list), val);
 260   ASET (spec, FONT_FAMILY_INDEX, family);
 261   return Fvconcat (1, &val);
 262 }
 263
 264
 265 static Lisp_Object ftfont_get_cache P_ ((Lisp_Object));
 266 static Lisp_Object ftfont_list P_ ((Lisp_Object, Lisp_Object));
 267 static Lisp_Object ftfont_match P_ ((Lisp_Object, Lisp_Object));
 268 static Lisp_Object ftfont_list_family P_ ((Lisp_Object));
 269 static void ftfont_free_entity P_ ((Lisp_Object));
 270 static struct font *ftfont_open P_ ((FRAME_PTR, Lisp_Object, int));
 271 static void ftfont_close P_ ((FRAME_PTR, struct font *));
 272 static int ftfont_has_char P_ ((Lisp_Object, int));
 273 static unsigned ftfont_encode_char P_ ((struct font *, int));
 274 static int ftfont_text_extents P_ ((struct font *, unsigned *, int,
 275                                     struct font_metrics *));
 276 static int ftfont_get_bitmap P_ ((struct font *, unsigned,
 277                                   struct font_bitmap *, int));
 278 static int ftfont_anchor_point P_ ((struct font *, unsigned, int,
 279                                     int *, int *));
 280 static Lisp_Object ftfont_shape P_ ((Lisp_Object));
 281
 282 struct font_driver ftfont_driver =
 283   {
 284     0,                          /* Qfreetype */
 285     ftfont_get_cache,
 286     ftfont_list,
 287     ftfont_match,
 288     ftfont_list_family,
 289     ftfont_free_entity,
 290     ftfont_open,
 291     ftfont_close,
 292     /* We can't draw a text without device dependent functions.  */
 293     NULL,
 294     NULL,
 295     ftfont_has_char,
 296     ftfont_encode_char,
 297     ftfont_text_extents,
 298     /* We can't draw a text without device dependent functions.  */
 299     NULL,
 300     ftfont_get_bitmap,
 301     NULL,
 302     NULL,
 303     NULL,
 304     ftfont_anchor_point,
 305     NULL,
 306     NULL,
 307     NULL,
 308     NULL,
 309 #ifdef HAVE_M17N_FLT
 310     ftfont_shape
 311 #else  /* not HAVE_M17N_FLT */
 312     NULL
 313 #endif  /* not HAVE_M17N_FLT */
 314   };
 315
 316 extern Lisp_Object QCname;
 317
 318 static Lisp_Object
 319 ftfont_get_cache (frame)
 320      Lisp_Object frame;
 321 {
 322   return freetype_font_cache;
 323 }
 324
 325 struct OpenTypeSpec
 326 {
 327   Lisp_Object script;
 328   unsigned int script_tag, langsys_tag;
 329   int nfeatures[2];
 330   unsigned int *features[2];
 331 };
 332
 333 #define OTF_SYM_TAG(SYM, TAG)                                   \
 334   do {                                                          \
 335     unsigned char *p = SDATA (SYMBOL_NAME (SYM));               \
 336     TAG = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];     \
 337   } while (0)
 338
 339 #define OTF_TAG_STR(TAG, P)                     \
 340   do {                                          \
 341     (P)[0] = (char) (TAG >> 24);                \
 342     (P)[1] = (char) ((TAG >> 16) & 0xFF);       \
 343     (P)[2] = (char) ((TAG >> 8) & 0xFF);        \
 344     (P)[3] = (char) (TAG & 0xFF);               \
 345     (P)[4] = '\0';                              \
 346   } while (0)
 347
 348 static struct OpenTypeSpec *
 349 ftfont_get_open_type_spec (Lisp_Object otf_spec)
 350 {
 351   struct OpenTypeSpec *spec = malloc (sizeof (struct OpenTypeSpec));
 352   Lisp_Object val;
 353   int i, j, negative;
 354
 355   if (! spec)
 356     return NULL;
 357   spec->script = XCAR (otf_spec);
 358   if (! NILP (val))
 359     {
 360       OTF_SYM_TAG (spec->script, spec->script_tag);
 361       val = assq_no_quit (spec->script, Votf_script_alist);
 362       if (CONSP (val) && SYMBOLP (XCDR (val)))
 363         spec->script = XCDR (val);
 364       else
 365         spec->script = Qnil;
 366     }
 367   else
 368     spec->script_tag = 0x44464C54;      /* "DFLT" */
 369   otf_spec = XCDR (otf_spec);
 370   val = XCAR (otf_spec);
 371   if (! NILP (val))
 372     OTF_SYM_TAG (val, spec->langsys_tag);
 373   else
 374     spec->langsys_tag = 0;
 375   spec->nfeatures[0] = spec->nfeatures[1] = 0;
 376   for (i = 0; i < 2; i++)
 377     {
 378       Lisp_Object len;
 379
 380       otf_spec = XCDR (otf_spec);
 381       if (NILP (otf_spec))
 382         break;
 383       val = XCAR (otf_spec);
 384       if (NILP (val))
 385         continue;
 386       len = Flength (val);
 387       spec->features[i] = malloc (sizeof (int) * XINT (len));
 388       if (! spec->features[i])
 389         {
 390           if (i > 0 && spec->features[0])
 391             free (spec->features[0]);
 392           free (spec);
 393           return NULL;
 394         }
 395       for (j = 0, negative = 0; CONSP (val); val = XCDR (val))
 396         {
 397           if (NILP (XCAR (val)))
 398             negative = 1;
 399           else
 400             {
 401               unsigned int tag;
 402
 403               OTF_SYM_TAG (XCAR (val), tag);
 404               spec->features[i][j++] = negative ? tag & 0x80000000 : tag;
 405             }
 406         }
 407       spec->nfeatures[i] = j;
 408     }
 409   return spec;
 410 }
 411
 412 static Lisp_Object
 413 ftfont_list (frame, spec)
 414      Lisp_Object frame, spec;
 415 {
 416   Lisp_Object val, tmp, extra;
 417   int i;
 418   FcPattern *pattern = NULL;
 419   FcCharSet *charset = NULL;
 420   FcLangSet *langset = NULL;
 421   FcFontSet *fontset = NULL;
 422   FcObjectSet *objset = NULL;
 423   Lisp_Object script;
 424   Lisp_Object registry = Qunicode_bmp;
 425   struct OpenTypeSpec *otspec= NULL;
 426   int weight = 0;
 427   double dpi = -1;
 428   int spacing = -1;
 429   int scalable = -1;
 430   char otlayout[15];            /* For "otlayout:XXXX" */
 431
 432   val = null_vector;
 433
 434   if (! fc_initialized)
 435     {
 436       FcInit ();
 437       fc_initialized = 1;
 438     }
 439
 440   if (! NILP (AREF (spec, FONT_ADSTYLE_INDEX))
 441       && ! EQ (AREF (spec, FONT_ADSTYLE_INDEX), null_string))
 442     return val;
 443   if (! NILP (AREF (spec, FONT_SLANT_INDEX))
 444       && XINT (AREF (spec, FONT_SLANT_INDEX)) < 100)
 445     /* Fontconfig doesn't support reverse-italic/obligue.  */
 446     return val;
 447
 448   if (! NILP (AREF (spec, FONT_REGISTRY_INDEX)))
 449     {
 450       registry = AREF (spec, FONT_REGISTRY_INDEX);
 451       if (EQ (registry, Qiso8859_1))
 452         {
 453           if (! cs_iso8859_1
 454               && ftfont_build_basic_charsets () < 0)
 455             return Qnil;
 456           charset = cs_iso8859_1;
 457         }
 458       else if (! EQ (registry, Qiso10646_1)
 459                && ! EQ (registry, Qunicode_bmp)
 460                && ! EQ (registry, Qunicode_sip))
 461         return val;
 462     }
 463
 464   otlayout[0] = '\0';
 465   script = Qnil;
 466   for (extra = AREF (spec, FONT_EXTRA_INDEX);
 467        CONSP (extra); extra = XCDR (extra))
 468     {
 469       Lisp_Object key, val;
 470
 471       tmp = XCAR (extra);
 472       key = XCAR (tmp), val = XCDR (tmp);
 473       if (EQ (key, QCotf))
 474         {
 475           otspec = ftfont_get_open_type_spec (val);
 476           if (! otspec)
 477             return null_vector;
 478           strcat (otlayout, "otlayout:");
 479           OTF_TAG_STR (otspec->script_tag, otlayout + 9);
 480           script = otspec->script;
 481         }
 482       else if (EQ (key, QClanguage))
 483         {
 484           langset = FcLangSetCreate ();
 485           if (! langset)
 486             goto err;
 487           if (SYMBOLP (val))
 488             {
 489               if (! FcLangSetAdd (langset, SYMBOL_FcChar8 (val)))
 490                 goto err;
 491             }
 492           else
 493             for (; CONSP (val); val = XCDR (val))
 494               if (SYMBOLP (XCAR (val))
 495                   && ! FcLangSetAdd (langset, SYMBOL_FcChar8 (XCAR (val))))
 496                 goto err;
 497         }
 498       else if (EQ (key, QCscript))
 499         script = val;
 500       else if (EQ (key, QCdpi))
 501         dpi = XINT (val);
 502       else if (EQ (key, QCspacing))
 503         spacing = XINT (val);
 504       else if (EQ (key, QCscalable))
 505         scalable = ! NILP (val);
 506     }
 507
 508   if (! NILP (script) && ! charset)
 509     {
 510       Lisp_Object chars = assq_no_quit (script, Vscript_representative_chars);
 511
 512       if (CONSP (chars))
 513         {
 514           charset = FcCharSetCreate ();
 515           if (! charset)
 516             goto err;
 517           for (chars = XCDR (chars); CONSP (chars); chars = XCDR (chars))
 518             if (CHARACTERP (XCAR (chars))
 519                 && ! FcCharSetAddChar (charset, XUINT (XCAR (chars))))
 520               goto err;
 521         }
 522     }
 523
 524   pattern = FcPatternCreate ();
 525   if (! pattern)
 526     goto err;
 527   tmp = AREF (spec, FONT_FOUNDRY_INDEX);
 528   if (SYMBOLP (tmp) && ! NILP (tmp)
 529       && ! FcPatternAddString (pattern, FC_FOUNDRY, SYMBOL_FcChar8 (tmp)))
 530     goto err;
 531   tmp = AREF (spec, FONT_FAMILY_INDEX);
 532   if (SYMBOLP (tmp) && ! NILP (tmp)
 533       && ! FcPatternAddString (pattern, FC_FAMILY, SYMBOL_FcChar8 (tmp)))
 534     goto err;
 535   /* Emacs conventionally doesn't distinguish normal, regular, and
 536      medium weight, but fontconfig does.  So, we can't restrict font
 537      listing by weight.  We check it after getting a list.  */
 538   tmp = AREF (spec, FONT_WEIGHT_INDEX);
 539   if (INTEGERP (tmp))
 540     weight = XINT (tmp);
 541   tmp = AREF (spec, FONT_SLANT_INDEX);
 542   if (INTEGERP (tmp)
 543       && ! FcPatternAddInteger (pattern, FC_SLANT, XINT (tmp) - 100))
 544     goto err;
 545   tmp = AREF (spec, FONT_WIDTH_INDEX);
 546   if (INTEGERP (tmp)
 547       && ! FcPatternAddInteger (pattern, FC_WIDTH, XINT (tmp)))
 548     goto err;
 549
 550   if (charset
 551       && ! FcPatternAddCharSet (pattern, FC_CHARSET, charset))
 552     goto err;
 553   if (langset
 554       && ! FcPatternAddLangSet (pattern, FC_LANG, langset))
 555     goto err;
 556   if (dpi >= 0
 557       && ! FcPatternAddDouble (pattern, FC_DPI, dpi))
 558     goto err;
 559   if (spacing >= 0
 560       && ! FcPatternAddInteger (pattern, FC_SPACING, spacing))
 561     goto err;
 562   if (scalable >= 0
 563       && ! FcPatternAddBool (pattern, FC_SCALABLE, scalable ? FcTrue : FcFalse))
 564     goto err;
 565
 566   objset = FcObjectSetBuild (FC_FOUNDRY, FC_FAMILY, FC_WEIGHT, FC_SLANT,
 567                              FC_WIDTH, FC_PIXEL_SIZE, FC_SPACING,
 568                              FC_CHARSET, FC_FILE,
 569 #ifdef FC_FONTFORMAT
 570                              FC_FONTFORMAT,
 571 #endif  /* FC_FONTFORMAT */
 572                              NULL);
 573   if (! objset)
 574     goto err;
 575   if (otlayout[0])
 576     {
 577 #ifdef FC_CAPABILITY
 578       if (! FcObjectSetAdd (objset, FC_CAPABILITY))
 579         goto err;
 580 #else  /* not FC_CAPABILITY */
 581       goto finish;
 582 #endif  /* not FC_CAPABILITY */
 583     }
 584
 585   fontset = FcFontList (NULL, pattern, objset);
 586   if (! fontset)
 587     goto err;
 588
 589   if (fontset->nfont > 0)
 590     {
 591       double pixel_size;
 592
 593       if (NILP (AREF (spec, FONT_SIZE_INDEX)))
 594         pixel_size = 0;
 595       else
 596         pixel_size = XINT (AREF (spec, FONT_SIZE_INDEX));
 597
 598       for (i = 0, val = Qnil; i < fontset->nfont; i++)
 599         {
 600           Lisp_Object entity;
 601
 602           if (pixel_size > 0)
 603             {
 604               double this;
 605
 606               if (FcPatternGetDouble (fontset->fonts[i], FC_PIXEL_SIZE, 0,
 607                                       &this) == FcResultMatch
 608                   && ((this < pixel_size - FONT_PIXEL_SIZE_QUANTUM)
 609                       || (this > pixel_size + FONT_PIXEL_SIZE_QUANTUM)))
 610                 continue;
 611             }
 612           if (weight > 0)
 613             {
 614               int this;
 615
 616               if (FcPatternGetInteger (fontset->fonts[i], FC_WEIGHT, 0,
 617                                        &this) != FcResultMatch
 618                   || (this != weight
 619                       && (weight != 100
 620                           || this < FC_WEIGHT_REGULAR
 621                           || this > FC_WEIGHT_MEDIUM)))
 622                 continue;
 623             }
 624 #ifdef FC_CAPABILITY
 625           if (otlayout[0])
 626             {
 627               FcChar8 *this;
 628
 629               if (FcPatternGetString (fontset->fonts[i], FC_CAPABILITY, 0,
 630                                       &this) != FcResultMatch
 631                   || ! strstr ((char *) this, otlayout))
 632                 continue;
 633             }
 634 #endif  /* FC_CAPABILITY */
 635 #ifdef HAVE_LIBOTF
 636           if (otspec)
 637             {
 638               FcChar8 *file;
 639               OTF *otf;
 640
 641               if (FcPatternGetString (fontset->fonts[i], FC_FILE, 0, &file)
 642                   != FcResultMatch)
 643                 continue;
 644               otf = OTF_open ((char *) file);
 645               if (! otf)
 646                 continue;
 647               if (OTF_check_features (otf, 1,
 648                                       otspec->script_tag, otspec->langsys_tag,
 649                                       otspec->features[0],
 650                                       otspec->nfeatures[0]) != 1
 651                   || OTF_check_features (otf, 0,
 652                                          otspec->script_tag, otspec->langsys_tag,
 653                                          otspec->features[1],
 654                                          otspec->nfeatures[1]) != 1)
 655                 continue;
 656             }
 657 #endif  /* HAVE_LIBOTF */
 658           entity = ftfont_pattern_entity (fontset->fonts[i], frame, registry);
 659           if (! NILP (entity))
 660             val = Fcons (entity, val);
 661         }
 662       val = Fvconcat (1, &val);
 663     }
 664   else if (! NILP (AREF (spec, FONT_FAMILY_INDEX)))
 665     val = ftfont_list_generic_family (spec, frame, registry);
 666   goto finish;
 667
 668  err:
 669   /* We come here because of unexpected error in fontconfig API call
 670      (usually insufficient memory).  */
 671   val = Qnil;
 672
 673  finish:
 674   if (charset && charset != cs_iso8859_1) FcCharSetDestroy (charset);
 675   if (objset) FcObjectSetDestroy (objset);
 676   if (fontset) FcFontSetDestroy (fontset);
 677   if (langset) FcLangSetDestroy (langset);
 678   if (pattern) FcPatternDestroy (pattern);
 679   if (otspec)
 680     {
 681       if (otspec->nfeatures[0] > 0)
 682         free (otspec->features[0]);
 683       if (otspec->nfeatures[1] > 0)
 684         free (otspec->features[1]);
 685       free (otspec);
 686     }
 687   return val;
 688 }
 689
 690 static Lisp_Object
 691 ftfont_match (frame, spec)
 692      Lisp_Object frame, spec;
 693 {
 694   Lisp_Object extra, val, entity;
 695   FcPattern *pattern = NULL, *match = NULL;
 696   FcResult result;
 697
 698   if (! fc_initialized)
 699     {
 700       FcInit ();
 701       fc_initialized = 1;
 702     }
 703
 704   extra = AREF (spec, FONT_EXTRA_INDEX);
 705   val = assq_no_quit (QCname, extra);
 706   if (! CONSP (val) || ! STRINGP (XCDR (val)))
 707     return Qnil;
 708
 709   entity = Qnil;
 710   pattern = FcNameParse (SDATA (XCDR (val)));
 711   if (pattern)
 712     {
 713       if (FcConfigSubstitute (NULL, pattern, FcMatchPattern) == FcTrue)
 714         {
 715           FcDefaultSubstitute (pattern);
 716           match = FcFontMatch (NULL, pattern, &result);
 717           if (match)
 718             {
 719               entity = ftfont_pattern_entity (match, frame, Qunicode_bmp);
 720               FcPatternDestroy (match);
 721             }
 722         }
 723       FcPatternDestroy (pattern);
 724     }
 725
 726   return entity;
 727 }
 728
 729 static Lisp_Object
 730 ftfont_list_family (frame)
 731      Lisp_Object frame;
 732 {
 733   Lisp_Object list;
 734   FcPattern *pattern = NULL;
 735   FcFontSet *fontset = NULL;
 736   FcObjectSet *objset = NULL;
 737   int i;
 738
 739   if (! fc_initialized)
 740     {
 741       FcInit ();
 742       fc_initialized = 1;
 743     }
 744
 745   pattern = FcPatternCreate ();
 746   if (! pattern)
 747     goto finish;
 748   objset = FcObjectSetBuild (FC_FAMILY, NULL);
 749   if (! objset)
 750     goto finish;
 751   fontset = FcFontList (NULL, pattern, objset);
 752   if (! fontset)
 753     goto finish;
 754
 755   list = Qnil;
 756   for (i = 0; i < fontset->nfont; i++)
 757     {
 758       FcPattern *pat = fontset->fonts[i];
 759       FcChar8 *str;
 760
 761       if (FcPatternGetString (pat, FC_FAMILY, 0, &str) == FcResultMatch)
 762         list = Fcons (intern_downcase ((char *) str, strlen ((char *) str)),
 763                       list);
 764     }
 765
 766  finish:
 767   if (objset) FcObjectSetDestroy (objset);
 768   if (fontset) FcFontSetDestroy (fontset);
 769   if (pattern) FcPatternDestroy (pattern);
 770
 771   return list;
 772 }
 773
 774
 775 static void
 776 ftfont_free_entity (entity)
 777      Lisp_Object entity;
 778 {
 779   Lisp_Object val = AREF (entity, FONT_EXTRA_INDEX);
 780   FcPattern *pattern = XSAVE_VALUE (val)->pointer;
 781
 782   FcPatternDestroy (pattern);
 783 }
 784
 785 static struct font *
 786 ftfont_open (f, entity, pixel_size)
 787      FRAME_PTR f;
 788      Lisp_Object entity;
 789      int pixel_size;
 790 {
 791   struct ftfont_info *ftfont_info;
 792   struct font *font;
 793   FT_Face ft_face;
 794   FT_Size ft_size;
 795   FT_UInt size;
 796   Lisp_Object val;
 797   FcPattern *pattern;
 798   FcChar8 *file;
 799   int spacing;
 800   char *name;
 801   int len;
 802
 803   val = AREF (entity, FONT_EXTRA_INDEX);
 804   if (XTYPE (val) != Lisp_Misc
 805       || XMISCTYPE (val) != Lisp_Misc_Save_Value)
 806     return NULL;
 807   pattern = XSAVE_VALUE (val)->pointer;
 808   if (XSAVE_VALUE (val)->integer == 0)
 809     {
 810       /* We have not yet created FT_Face for this font.  */
 811       if (! ft_library
 812           && FT_Init_FreeType (&ft_library) != 0)
 813         return NULL;
 814       if (FcPatternGetString (pattern, FC_FILE, 0, &file) != FcResultMatch)
 815         return NULL;
 816       if (FT_New_Face (ft_library, (char *) file, 0, &ft_face) != 0)
 817         return NULL;
 818       FcPatternAddFTFace (pattern, FC_FT_FACE, ft_face);
 819       ft_size = ft_face->size;
 820     }
 821   else
 822     {
 823       if (FcPatternGetFTFace (pattern, FC_FT_FACE, 0, &ft_face)
 824           != FcResultMatch)
 825         return NULL;
 826       if (FT_New_Size (ft_face, &ft_size) != 0)
 827         return NULL;
 828       if (FT_Activate_Size (ft_size) != 0)
 829         {
 830           FT_Done_Size (ft_size);
 831           return NULL;
 832         }
 833     }
 834
 835   size = XINT (AREF (entity, FONT_SIZE_INDEX));
 836   if (size == 0)
 837     size = pixel_size;
 838   if (FT_Set_Pixel_Sizes (ft_face, size, size) != 0)
 839     {
 840       if (XSAVE_VALUE (val)->integer == 0)
 841         FT_Done_Face (ft_face);
 842       return NULL;
 843     }
 844
 845   ftfont_info = malloc (sizeof (struct ftfont_info));
 846   if (! ftfont_info)
 847     return NULL;
 848   ftfont_info->ft_size = ft_size;
 849 #ifdef HAVE_LIBOTF
 850   ftfont_info->maybe_otf = ft_face->face_flags & FT_FACE_FLAG_SFNT;
 851   ftfont_info->otf = NULL;
 852 #endif  /* HAVE_LIBOTF */
 853
 854   font = (struct font *) ftfont_info;
 855   font->format = ftfont_font_format (pattern);
 856   font->entity = entity;
 857   font->pixel_size = size;
 858   font->driver = &ftfont_driver;
 859   len = 96;
 860   name = malloc (len);
 861   while (name && font_unparse_fcname (entity, pixel_size, name, len) < 0)
 862     {
 863       char *new = realloc (name, len += 32);
 864
 865       if (! new)
 866         free (name);
 867       name = new;
 868     }
 869   font->font.full_name = font->font.name = name;
 870   font->file_name = (char *) file;
 871   font->font.size = ft_face->size->metrics.max_advance >> 6;
 872   if (font->font.size <= 0)
 873     font->font.size = size;
 874   font->font.charset = font->encoding_charset = font->repertory_charset = -1;
 875   font->ascent = ft_face->size->metrics.ascender >> 6;
 876   font->descent = - ft_face->size->metrics.descender >> 6;
 877   font->font.height = font->ascent + font->descent;
 878   if (FcPatternGetInteger (pattern, FC_SPACING, 0, &spacing) != FcResultMatch)
 879     spacing = FC_PROPORTIONAL;
 880   if (spacing != FC_PROPORTIONAL)
 881     font->font.average_width = font->font.space_width = font->font.size;
 882   else
 883     {
 884       int i;
 885
 886       for (i = 32; i < 127; i++)
 887         {
 888           if (FT_Load_Char (ft_face, i, FT_LOAD_DEFAULT) != 0)
 889             break;
 890           if (i == 32)
 891             font->font.space_width = ft_face->glyph->metrics.horiAdvance >> 6;
 892           font->font.average_width += ft_face->glyph->metrics.horiAdvance >> 6;
 893         }
 894       if (i == 127)
 895         {
 896           /* The font contains all ASCII printable characters.  */
 897           font->font.average_width /= 95;
 898         }
 899       else
 900         {
 901           if (i == 32)
 902             font->font.space_width = font->font.size;
 903           font->font.average_width = font->font.size;
 904         }
 905     }
 906
 907   /* Unfortunately FreeType doesn't provide a way to get minimum char
 908      width.  So, we use space_width instead.  */
 909   font->min_width = font->font.space_width;
 910
 911   font->font.baseline_offset = 0;
 912   font->font.relative_compose = 0;
 913   font->font.default_ascent = 0;
 914   font->font.vertical_centering = 0;
 915
 916   (XSAVE_VALUE (val)->integer)++;
 917
 918   return font;
 919 }
 920
 921 static void
 922 ftfont_close (f, font)
 923      FRAME_PTR f;
 924      struct font *font;
 925 {
 926   struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
 927   Lisp_Object entity = font->entity;
 928   Lisp_Object val = AREF (entity, FONT_EXTRA_INDEX);
 929
 930   (XSAVE_VALUE (val)->integer)--;
 931   if (XSAVE_VALUE (val)->integer == 0)
 932     {
 933       FT_Done_Face (ftfont_info->ft_size->face);
 934 #ifdef HAVE_LIBOTF
 935       if (ftfont_info->otf)
 936         OTF_close (ftfont_info->otf);
 937 #endif
 938     }
 939   else
 940     FT_Done_Size (ftfont_info->ft_size);
 941
 942   free (font);
 943 }
 944
 945 static int
 946 ftfont_has_char (entity, c)
 947      Lisp_Object entity;
 948      int c;
 949 {
 950   Lisp_Object val;
 951   FcPattern *pattern;
 952   FcCharSet *charset;
 953
 954   val = AREF (entity, FONT_EXTRA_INDEX);
 955   pattern = XSAVE_VALUE (val)->pointer;
 956   if (FcPatternGetCharSet (pattern, FC_CHARSET, 0, &charset) != FcResultMatch)
 957     return -1;
 958   return (FcCharSetHasChar (charset, (FcChar32) c) == FcTrue);
 959 }
 960
 961 static unsigned
 962 ftfont_encode_char (font, c)
 963      struct font *font;
 964      int c;
 965 {
 966   struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
 967   FT_Face ft_face = ftfont_info->ft_size->face;
 968   FT_ULong charcode = c;
 969   FT_UInt code = FT_Get_Char_Index (ft_face, charcode);
 970
 971   return (code > 0 ? code : 0xFFFFFFFF);
 972 }
 973
 974 static int
 975 ftfont_text_extents (font, code, nglyphs, metrics)
 976      struct font *font;
 977      unsigned *code;
 978      int nglyphs;
 979      struct font_metrics *metrics;
 980 {
 981   struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
 982   FT_Face ft_face = ftfont_info->ft_size->face;
 983   int width = 0;
 984   int i;
 985
 986   if (ftfont_info->ft_size != ft_face->size)
 987     FT_Activate_Size (ftfont_info->ft_size);
 988   if (metrics)
 989     bzero (metrics, sizeof (struct font_metrics));
 990   for (i = 0; i < nglyphs; i++)
 991     {
 992       if (FT_Load_Glyph (ft_face, code[i], FT_LOAD_DEFAULT) == 0)
 993         {
 994           FT_Glyph_Metrics *m = &ft_face->glyph->metrics;
 995
 996           if (metrics)
 997             {
 998               if (metrics->lbearing > width + (m->horiBearingX >> 6))
 999                 metrics->lbearing = width + (m->horiBearingX >> 6);
1000               if (metrics->rbearing
1001                   < width + ((m->horiBearingX + m->width) >> 6))
1002                 metrics->rbearing
1003                   = width + ((m->horiBearingX + m->width) >> 6);
1004               if (metrics->ascent < (m->horiBearingY >> 6))
1005                 metrics->ascent = m->horiBearingY >> 6;
1006               if (metrics->descent > ((m->horiBearingY + m->height) >> 6))
1007                 metrics->descent = (m->horiBearingY + m->height) >> 6;
1008             }
1009           width += m->horiAdvance >> 6;
1010         }
1011       else
1012         {
1013           width += font->font.space_width;
1014         }
1015     }
1016   if (metrics)
1017     metrics->width = width;
1018
1019   return width;
1020 }
1021
1022 static int
1023 ftfont_get_bitmap (font, code, bitmap, bits_per_pixel)
1024      struct font *font;
1025      unsigned code;
1026      struct font_bitmap *bitmap;
1027      int bits_per_pixel;
1028 {
1029   struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
1030   FT_Face ft_face = ftfont_info->ft_size->face;
1031   FT_Int32 load_flags = FT_LOAD_RENDER;
1032
1033   if (ftfont_info->ft_size != ft_face->size)
1034     FT_Activate_Size (ftfont_info->ft_size);
1035   if (bits_per_pixel == 1)
1036     {
1037 #ifdef FT_LOAD_TARGET_MONO
1038       load_flags |= FT_LOAD_TARGET_MONO;
1039 #else
1040       load_flags |= FT_LOAD_MONOCHROME;
1041 #endif
1042     }
1043   else if (bits_per_pixel != 8)
1044     /* We don't support such a rendering.  */
1045     return -1;
1046
1047   if (FT_Load_Glyph (ft_face, code, load_flags) != 0)
1048     return -1;
1049   bitmap->bits_per_pixel
1050     = (ft_face->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_MONO ? 1
1051        : ft_face->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_GRAY ? 8
1052        : ft_face->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_LCD ? 8
1053        : ft_face->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_LCD_V ? 8
1054        : -1);
1055   if (bitmap->bits_per_pixel < 0)
1056     /* We don't suport that kind of pixel mode.  */
1057     return -1;
1058   bitmap->rows = ft_face->glyph->bitmap.rows;
1059   bitmap->width = ft_face->glyph->bitmap.width;
1060   bitmap->pitch = ft_face->glyph->bitmap.pitch;
1061   bitmap->buffer = ft_face->glyph->bitmap.buffer;
1062   bitmap->left = ft_face->glyph->bitmap_left;
1063   bitmap->top = ft_face->glyph->bitmap_top;
1064   bitmap->advance = ft_face->glyph->metrics.horiAdvance >> 6;
1065   bitmap->extra = NULL;
1066
1067   return 0;
1068 }
1069
1070 static int
1071 ftfont_anchor_point (font, code, index, x, y)
1072      struct font *font;
1073      unsigned code;
1074      int index;
1075      int *x, *y;
1076 {
1077   struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
1078   FT_Face ft_face = ftfont_info->ft_size->face;
1079
1080   if (ftfont_info->ft_size != ft_face->size)
1081     FT_Activate_Size (ftfont_info->ft_size);
1082   if (FT_Load_Glyph (ft_face, code, FT_LOAD_DEFAULT) != 0)
1083     return -1;
1084   if (ft_face->glyph->format != FT_GLYPH_FORMAT_OUTLINE)
1085     return -1;
1086   if (index >= ft_face->glyph->outline.n_points)
1087     return -1;
1088   *x = ft_face->glyph->outline.points[index].x;
1089   *y = ft_face->glyph->outline.points[index].y;
1090   return 0;
1091 }
1092
1093 #ifdef HAVE_LIBOTF
1094 #ifdef HAVE_M17N_FLT
1095
1096 struct MFLTFontFT
1097 {
1098   MFLTFont flt_font;
1099   struct font *font;
1100   FT_Face ft_face;
1101   OTF *otf;
1102 };
1103
1104 static int
1105 ftfont_get_glyph_id (font, gstring, from, to)
1106      MFLTFont *font;
1107      MFLTGlyphString *gstring;
1108      int from, to;
1109 {
1110   struct MFLTFontFT *flt_font_ft = (struct MFLTFontFT *) font;
1111   FT_Face ft_face = flt_font_ft->ft_face;
1112   MFLTGlyph *g;
1113
1114   for (g = gstring->glyphs + from; from < to; g++, from++)
1115     if (! g->encoded)
1116       {
1117         FT_UInt code = FT_Get_Char_Index (ft_face, g->code);
1118
1119         g->code = code > 0 ? code : FONT_INVALID_CODE;
1120         g->encoded = 1;
1121       }
1122   return 0;
1123 }
1124
1125 static int
1126 ftfont_get_metrics (font, gstring, from, to)
1127      MFLTFont *font;
1128      MFLTGlyphString *gstring;
1129      int from, to;
1130 {
1131   struct MFLTFontFT *flt_font_ft = (struct MFLTFontFT *) font;
1132   FT_Face ft_face = flt_font_ft->ft_face;
1133   MFLTGlyph *g;
1134
1135   for (g = gstring->glyphs + from; from < to; g++, from++)
1136     if (! g->measured)
1137       {
1138         if (g->code != FONT_INVALID_CODE)
1139           {
1140             FT_Glyph_Metrics *m;
1141
1142             if (FT_Load_Glyph (ft_face, g->code, FT_LOAD_DEFAULT) != 0)
1143               abort ();
1144             m = &ft_face->glyph->metrics;
1145
1146             g->lbearing = m->horiBearingX;
1147             g->rbearing = m->horiBearingX + m->width;
1148             g->ascent = m->horiBearingY;
1149             g->descent = m->height - m->horiBearingY;
1150             g->xadv = m->horiAdvance;
1151           }
1152         else
1153           {
1154             g->lbearing = 0;
1155             g->rbearing = g->xadv = flt_font_ft->font->font.space_width << 6;
1156             g->ascent = flt_font_ft->font->ascent << 6;
1157             g->descent = flt_font_ft->font->descent << 6;
1158           }
1159         g->yadv = 0;
1160         g->measured = 1;
1161       }
1162   return 0;
1163 }
1164
1165 static int
1166 ftfont_check_otf (MFLTFont *font, MFLTOtfSpec *spec)
1167 {
1168   struct MFLTFontFT *flt_font_ft = (struct MFLTFontFT *) font;
1169   OTF *otf = flt_font_ft->otf;
1170   OTF_Tag *tags;
1171   int i, n, negative;
1172
1173   for (i = 0; i < 2; i++)
1174     {
1175       if (! spec->features[i])
1176         continue;
1177       for (n = 0; spec->features[i][n]; n++);
1178       tags = alloca (sizeof (OTF_Tag) * n);
1179       for (n = 0, negative = 0; spec->features[i][n]; n++)
1180         {
1181           if (spec->features[i][n] == 0xFFFFFFFF)
1182             negative = 1;
1183           else if (negative)
1184             tags[n - 1] = spec->features[i][n] | 0x80000000;
1185           else
1186             tags[n] = spec->features[i][n];
1187         }
1188       if (n - negative > 0
1189           && OTF_check_features (otf, i == 0, spec->script, spec->langsys,
1190                                  tags, n - negative) != 1)
1191         return 0;
1192     }
1193   return 1;
1194 }
1195
1196 #define DEVICE_DELTA(table, size)                               \
1197   (((size) >= (table).StartSize && (size) <= (table).EndSize)   \
1198    ? (table).DeltaValue[(size) - (table).StartSize] << 6        \
1199    : 0)
1200
1201 static void
1202 adjust_anchor (FT_Face ft_face, OTF_Anchor *anchor,
1203                unsigned code, int x_ppem, int y_ppem, int *x, int *y)
1204 {
1205   if (anchor->AnchorFormat == 2)
1206     {
1207       FT_Outline *outline;
1208       int ap = anchor->f.f1.AnchorPoint;
1209
1210       FT_Load_Glyph (ft_face, (FT_UInt) code, FT_LOAD_MONOCHROME);
1211       outline = &ft_face->glyph->outline;
1212       if (ap < outline->n_points)
1213         {
1214           *x = outline->points[ap].x << 6;
1215           *y = outline->points[ap].y << 6;
1216         }
1217     }
1218   else if (anchor->AnchorFormat == 3)
1219     {
1220       if (anchor->f.f2.XDeviceTable.offset)
1221         *x += DEVICE_DELTA (anchor->f.f2.XDeviceTable, x_ppem);
1222       if (anchor->f.f2.YDeviceTable.offset)
1223         *y += DEVICE_DELTA (anchor->f.f2.YDeviceTable, y_ppem);
1224     }
1225 }
1226
1227 static OTF_GlyphString otf_gstring;
1228
1229 static int
1230 ftfont_drive_otf (font, spec, in, from, to, out, adjustment)
1231      MFLTFont *font;
1232      MFLTOtfSpec *spec;
1233      MFLTGlyphString *in;
1234      int from, to;
1235      MFLTGlyphString *out;
1236      MFLTGlyphAdjustment *adjustment;
1237 {
1238   struct MFLTFontFT *flt_font_ft = (struct MFLTFontFT *) font;
1239   FT_Face ft_face = flt_font_ft->ft_face;
1240   OTF *otf = flt_font_ft->otf;
1241   int len = to - from;
1242   int i, j, gidx;
1243   OTF_Glyph *otfg;
1244   char script[5], *langsys = NULL;
1245   char *gsub_features = NULL, *gpos_features = NULL;
1246
1247   if (len == 0)
1248     return from;
1249   OTF_tag_name (spec->script, script);
1250   if (spec->langsys)
1251     {
1252       langsys = alloca (5);
1253       OTF_tag_name (spec->langsys, langsys);
1254     }
1255   for (i = 0; i < 2; i++)
1256     {
1257       char *p;
1258
1259       if (spec->features[i] && spec->features[i][1] != 0xFFFFFFFF)
1260         {
1261           for (j = 0; spec->features[i][j]; j++);
1262           if (i == 0)
1263             p = gsub_features = alloca (6 * j);
1264           else
1265             p = gpos_features = alloca (6 * j);
1266           for (j = 0; spec->features[i][j]; j++)
1267             {
1268               if (spec->features[i][j] == 0xFFFFFFFF)
1269                 *p++ = '*', *p++ = ',';
1270               else
1271                 {
1272                   OTF_tag_name (spec->features[i][j], p);
1273                   p[4] = ',';
1274                   p += 5;
1275                 }
1276             }
1277           *--p = '\0';
1278         }
1279     }
1280
1281   if (otf_gstring.size == 0)
1282     {
1283       otf_gstring.glyphs = (OTF_Glyph *) malloc (sizeof (OTF_Glyph) * len);
1284       otf_gstring.size = len;
1285     }
1286   else if (otf_gstring.size < len)
1287     {
1288       otf_gstring.glyphs = (OTF_Glyph *) realloc (otf_gstring.glyphs,
1289                                                   sizeof (OTF_Glyph) * len);
1290       otf_gstring.size = len;
1291     }
1292   otf_gstring.used = len;
1293   memset (otf_gstring.glyphs, 0, sizeof (OTF_Glyph) * len);
1294   for (i = 0; i < len; i++)
1295     {
1296       otf_gstring.glyphs[i].c = in->glyphs[from + i].c;
1297       otf_gstring.glyphs[i].glyph_id = in->glyphs[from + i].code;
1298     }
1299
1300   OTF_drive_gdef (otf, &otf_gstring);
1301   gidx = out->used;
1302
1303   if (gsub_features)
1304     {
1305       if (OTF_drive_gsub (otf, &otf_gstring, script, langsys, gsub_features)
1306           < 0)
1307         goto simple_copy;
1308       if (out->allocated < out->used + otf_gstring.used)
1309         return -2;
1310       for (i = 0, otfg = otf_gstring.glyphs; i < otf_gstring.used; i++, otfg++)
1311         {
1312           MFLTGlyph *g = out->glyphs + out->used;
1313           int j;
1314
1315           *g = in->glyphs[from + otfg->f.index.from];
1316           g->c = 0;
1317           for (j = from + otfg->f.index.from; j <= from + otfg->f.index.to; j++)
1318             if (in->glyphs[j].code == otfg->glyph_id)
1319               {
1320                 g->c = in->glyphs[j].c;
1321                 break;
1322               }
1323           if (g->code != otfg->glyph_id)
1324             {
1325               g->code = otfg->glyph_id;
1326               g->measured = 0;
1327             }
1328           out->used++;
1329         }
1330     }
1331   else
1332     {
1333       if (out->allocated < out->used + len)
1334         return -2;
1335       for (i = 0; i < len; i++)
1336         out->glyphs[out->used++] = in->glyphs[from + i];
1337     }
1338
1339   if (gpos_features)
1340     {
1341       MFLTGlyph *base = NULL, *mark = NULL, *g;
1342       int x_ppem, y_ppem, x_scale, y_scale;
1343
1344       if (OTF_drive_gpos (otf, &otf_gstring, script, langsys, gpos_features)
1345           < 0)
1346         return to;
1347
1348       x_ppem = ft_face->size->metrics.x_ppem;
1349       y_ppem = ft_face->size->metrics.y_ppem;
1350       x_scale = ft_face->size->metrics.x_scale;
1351       y_scale = ft_face->size->metrics.y_scale;
1352
1353       for (i = 0, otfg = otf_gstring.glyphs, g = out->glyphs + gidx;
1354            i < otf_gstring.used; i++, otfg++, g++)
1355         {
1356           MFLTGlyph *prev;
1357
1358           if (! otfg->glyph_id)
1359             continue;
1360           switch (otfg->positioning_type)
1361             {
1362             case 0:
1363               break;
1364             case 1:             /* Single */
1365             case 2:             /* Pair */
1366               {
1367                 int format = otfg->f.f1.format;
1368
1369                 if (format & OTF_XPlacement)
1370                   adjustment[i].xoff
1371                     = otfg->f.f1.value->XPlacement * x_scale / 0x10000;
1372                 if (format & OTF_XPlaDevice)
1373                   adjustment[i].xoff
1374                     += DEVICE_DELTA (otfg->f.f1.value->XPlaDevice, x_ppem);
1375                 if (format & OTF_YPlacement)
1376                   adjustment[i].yoff
1377                     = - (otfg->f.f1.value->YPlacement * y_scale / 0x10000);
1378                 if (format & OTF_YPlaDevice)
1379                   adjustment[i].yoff
1380                     -= DEVICE_DELTA (otfg->f.f1.value->YPlaDevice, y_ppem);
1381                 if (format & OTF_XAdvance)
1382                   adjustment[i].xadv
1383                     += otfg->f.f1.value->XAdvance * x_scale / 0x10000;
1384                 if (format & OTF_XAdvDevice)
1385                   adjustment[i].xadv
1386                     += DEVICE_DELTA (otfg->f.f1.value->XAdvDevice, x_ppem);
1387                 if (format & OTF_YAdvance)
1388                   adjustment[i].yadv
1389                     += otfg->f.f1.value->YAdvance * y_scale / 0x10000;
1390                 if (format & OTF_YAdvDevice)
1391                   adjustment[i].yadv
1392                     += DEVICE_DELTA (otfg->f.f1.value->YAdvDevice, y_ppem);
1393                 adjustment[i].set = 1;
1394               }
1395               break;
1396             case 3:             /* Cursive */
1397               /* Not yet supported.  */
1398               break;
1399             case 4:             /* Mark-to-Base */
1400             case 5:             /* Mark-to-Ligature */
1401               if (! base)
1402                 break;
1403               prev = base;
1404               goto label_adjust_anchor;
1405             default:            /* i.e. case 6 Mark-to-Mark */
1406               if (! mark)
1407                 break;
1408               prev = mark;
1409
1410             label_adjust_anchor:
1411               {
1412                 int base_x, base_y, mark_x, mark_y;
1413                 int this_from, this_to;
1414
1415                 base_x = otfg->f.f4.base_anchor->XCoordinate * x_scale / 0x10000;
1416                 base_y = otfg->f.f4.base_anchor->YCoordinate * y_scale / 0x10000;
1417                 mark_x = otfg->f.f4.mark_anchor->XCoordinate * x_scale / 0x10000;
1418                 mark_y = otfg->f.f4.mark_anchor->YCoordinate * y_scale / 0x10000;;
1419
1420                 if (otfg->f.f4.base_anchor->AnchorFormat != 1)
1421                   adjust_anchor (ft_face, otfg->f.f4.base_anchor,
1422                                  prev->code, x_ppem, y_ppem, &base_x, &base_y);
1423                 if (otfg->f.f4.mark_anchor->AnchorFormat != 1)
1424                   adjust_anchor (ft_face, otfg->f.f4.mark_anchor, g->code,
1425                                  x_ppem, y_ppem, &mark_x, &mark_y);
1426                 adjustment[i].xoff = (base_x - mark_x);
1427                 adjustment[i].yoff = - (base_y - mark_y);
1428                 adjustment[i].back = (g - prev);
1429                 adjustment[i].xadv = 0;
1430                 adjustment[i].advance_is_absolute = 1;
1431                 adjustment[i].set = 1;
1432                 this_from = g->from;
1433                 this_to = g->to;
1434                 for (j = 0; prev + j < g; j++)
1435                   {
1436                     if (this_from > prev[j].from)
1437                       this_from = prev[j].from;
1438                     if (this_to < prev[j].to)
1439                       this_to = prev[j].to;
1440                   }
1441                 for (; prev <= g; prev++)
1442                   {
1443                     prev->from = this_from;
1444                     prev->to = this_to;
1445                   }
1446               }
1447             }
1448           if (otfg->GlyphClass == OTF_GlyphClass0)
1449             base = mark = g;
1450           else if (otfg->GlyphClass == OTF_GlyphClassMark)
1451             mark = g;
1452           else
1453             base = g;
1454         }
1455     }
1456   return to;
1457
1458  simple_copy:
1459   if (out->allocated < out->used + len)
1460     return -2;
1461   font->get_metrics (font, in, from, to);
1462   memcpy (out->glyphs + out->used, in->glyphs + from,
1463           sizeof (MFLTGlyph) * len);
1464   out->used += len;
1465   return to;
1466 }
1467
1468 static MFLTGlyphString gstring;
1469
1470 static int m17n_flt_initialized;
1471
1472 extern Lisp_Object QCfamily;
1473
1474 Lisp_Object
1475 ftfont_shape_by_flt (lgstring, font, ft_face, otf)
1476      Lisp_Object lgstring;
1477      struct font *font;
1478      FT_Face ft_face;
1479      OTF *otf;
1480 {
1481   EMACS_UINT len = LGSTRING_LENGTH (lgstring);
1482   EMACS_UINT i;
1483   struct MFLTFontFT flt_font_ft;
1484
1485   if (! m17n_flt_initialized)
1486     {
1487       M17N_INIT ();
1488       m17n_flt_initialized = 1;
1489     }
1490
1491   for (i = 0; i < len; i++)
1492     if (NILP (LGSTRING_GLYPH (lgstring, i)))
1493       break;
1494   len = i;
1495
1496   if (gstring.allocated == 0)
1497     {
1498       gstring.allocated = len * 2;
1499       gstring.glyph_size = sizeof (MFLTGlyph);
1500       gstring.glyphs = malloc (sizeof (MFLTGlyph) * gstring.allocated);
1501     }
1502   else if (gstring.allocated < len * 2)
1503     {
1504       gstring.allocated = len * 2;
1505       gstring.glyphs = realloc (gstring.glyphs,
1506                                 sizeof (MFLTGlyph) * gstring.allocated);
1507     }
1508   for (i = 0; i < len; i++)
1509     gstring.glyphs[i].c = LGLYPH_CHAR (LGSTRING_GLYPH (lgstring, i));
1510   gstring.used = len;
1511   gstring.r2l = 0;
1512
1513   {
1514     Lisp_Object family = Ffont_get (LGSTRING_FONT (lgstring), QCfamily);
1515
1516     if (NILP (family))
1517       flt_font_ft.flt_font.family = Mnil;
1518     else
1519       flt_font_ft.flt_font.family = msymbol (SDATA (SYMBOL_NAME (family)));
1520   }
1521   flt_font_ft.flt_font.x_ppem = ft_face->size->metrics.x_ppem;
1522   flt_font_ft.flt_font.y_ppem = ft_face->size->metrics.y_ppem;
1523   flt_font_ft.flt_font.get_glyph_id = ftfont_get_glyph_id;
1524   flt_font_ft.flt_font.get_metrics = ftfont_get_metrics;
1525   flt_font_ft.flt_font.check_otf = ftfont_check_otf;
1526   flt_font_ft.flt_font.drive_otf = ftfont_drive_otf;
1527   flt_font_ft.flt_font.internal = NULL;
1528   flt_font_ft.font = font;
1529   flt_font_ft.ft_face = ft_face;
1530   flt_font_ft.otf = otf;
1531   for (i = 0; i < 3; i++)
1532     {
1533       int result = mflt_run (&gstring, 0, len, &flt_font_ft.flt_font, NULL);
1534       if (result != -2)
1535         break;
1536       gstring.allocated += gstring.allocated;
1537       gstring.glyphs = realloc (gstring.glyphs,
1538                                 sizeof (MFLTGlyph) * gstring.allocated);
1539     }
1540   if (gstring.used > LGSTRING_LENGTH (lgstring))
1541     return Qnil;
1542   for (i = 0; i < gstring.used; i++)
1543     {
1544       MFLTGlyph *g = gstring.glyphs + i;
1545
1546       g->from = LGLYPH_FROM (LGSTRING_GLYPH (lgstring, g->from));
1547       g->to = LGLYPH_TO (LGSTRING_GLYPH (lgstring, g->to));
1548     }
1549
1550   for (i = 0; i < gstring.used; i++)
1551     {
1552       Lisp_Object lglyph = LGSTRING_GLYPH (lgstring, i);
1553       MFLTGlyph *g = gstring.glyphs + i;
1554
1555       LGLYPH_SET_FROM (lglyph, g->from);
1556       LGLYPH_SET_TO (lglyph, g->to);
1557       LGLYPH_SET_CHAR (lglyph, g->c);
1558       LGLYPH_SET_CODE (lglyph, g->code);
1559       LGLYPH_SET_WIDTH (lglyph, g->xadv >> 6);
1560       LGLYPH_SET_LBEARING (lglyph, g->lbearing >> 6);
1561       LGLYPH_SET_RBEARING (lglyph, g->rbearing >> 6);
1562       LGLYPH_SET_ASCENT (lglyph, g->ascent >> 6);
1563       LGLYPH_SET_DESCENT (lglyph, g->descent >> 6);
1564       if (g->adjusted)
1565         {
1566           Lisp_Object vec;
1567
1568           vec = Fmake_vector (make_number (3), Qnil);
1569           ASET (vec, 0, make_number (g->xoff >> 6));
1570           ASET (vec, 1, make_number (g->yoff >> 6));
1571           ASET (vec, 2, make_number (g->xadv >> 6));
1572           LGLYPH_SET_ADJUSTMENT (lglyph, vec);
1573         }
1574     }
1575   return make_number (i);
1576 }
1577
1578 Lisp_Object
1579 ftfont_shape (lgstring)
1580      Lisp_Object lgstring;
1581 {
1582   struct font *font;
1583   struct ftfont_info *ftfont_info;
1584
1585   CHECK_FONT_GET_OBJECT (LGSTRING_FONT (lgstring), font);
1586   ftfont_info = (struct ftfont_info *) font;
1587   if (! ftfont_info->maybe_otf)
1588     return 0;
1589   if (! ftfont_info->otf)
1590     {
1591       OTF *otf = OTF_open_ft_face (ftfont_info->ft_size->face);
1592
1593       if (! otf || OTF_get_table (otf, "head") < 0)
1594         {
1595           if (otf)
1596             OTF_close (otf);
1597           ftfont_info->maybe_otf = 0;
1598           return 0;
1599         }
1600
1601       ftfont_info->otf = otf;
1602     }
1603
1604   return ftfont_shape_by_flt (lgstring, font, ftfont_info->ft_size->face,
1605                               ftfont_info->otf);
1606 }
1607
1608 #endif  /* HAVE_M17N_FLT */
1609 #endif  /* HAVE_LIBOTF */
1610
1611 Lisp_Object
1612 ftfont_font_format (FcPattern *pattern)
1613 {
1614   FcChar8 *str;
1615
1616 #ifdef FC_FONTFORMAT
1617   if (FcPatternGetString (pattern, FC_FONTFORMAT, 0, &str) != FcResultMatch)
1618     return Qnil;
1619   if (strcmp ((char *) str, "TrueType") == 0)
1620     return intern ("truetype");
1621   if (strcmp ((char *) str, "Type 1") == 0)
1622     return intern ("type1");
1623   if (strcmp ((char *) str, "PCF") == 0)
1624     return intern ("pcf");
1625   if (strcmp ((char *) str, "BDF") == 0)
1626     return intern ("bdf");
1627 #else  /* not FC_FONTFORMAT */
1628   if (FcPatternGetString (pattern, FC_FILE, 0, &str) != FcResultMatch)
1629     return Qnil;
1630   if (strcasestr ((char *) str, ".ttf") == 0)
1631     return intern ("truetype");
1632   if (strcasestr ((char *) str, "pfb") == 0)
1633     return intern ("type1");
1634   if (strcasestr ((char *) str, "pcf") == 0)
1635     return intern ("pcf");
1636   if (strcasestr ((char *) str, "bdf") == 0)
1637     return intern ("bdf");
1638 #endif  /* not FC_FONTFORMAT */
1639   return intern ("unknown");
1640 }
1641
1642 \f
1643 void
1644 syms_of_ftfont ()
1645 {
1646   DEFSYM (Qfreetype, "freetype");
1647   DEFSYM (Qmonospace, "monospace");
1648   DEFSYM (Qsans_serif, "sans-serif");
1649   DEFSYM (Qserif, "serif");
1650   DEFSYM (Qmono, "mono");
1651   DEFSYM (Qsans, "sans");
1652   DEFSYM (Qsans__serif, "sans serif");
1653
1654   staticpro (&freetype_font_cache);
1655   freetype_font_cache = Fcons (Qt, Qnil);
1656
1657   staticpro (&ftfont_generic_family_list);
1658   ftfont_generic_family_list
1659     = Fcons (Fcons (Qmonospace, Qt),
1660              Fcons (Fcons (Qsans_serif, Qt),
1661                     Fcons (Fcons (Qsans, Qt), Qnil)));
1662
1663   ftfont_driver.type = Qfreetype;
1664   register_font_driver (&ftfont_driver, NULL);
1665 }
1666
1667 /* arch-tag: 7cfa432c-33a6-4988-83d2-a82ed8604aca
1668    (do not change this comment) */