src/font.h

   1 /* font.h -- Interface definition for font handling.
   2    Copyright (C) 2006-2014 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 #ifndef EMACS_FONT_H
  23 #define EMACS_FONT_H
  24
  25 #include "ccl.h"
  26 #include "frame.h"
  27
  28 INLINE_HEADER_BEGIN
  29
  30 /* We have three types of Lisp objects related to font.
  31
  32    FONT-SPEC
  33
  34         Pseudo vector (length FONT_SPEC_MAX) of font properties.  Some
  35         properties can be left unspecified (i.e. nil).  Emacs asks
  36         font-drivers to find a font by FONT-SPEC.  A fontset entry
  37         specifies requisite properties whereas a face specifies just
  38         preferable properties.
  39
  40    FONT-ENTITY
  41
  42         Pseudo vector (length FONT_ENTITY_MAX) of fully instantiated
  43         font properties that a font-driver returns upon a request of
  44         FONT-SPEC.
  45
  46         Note: Only the method `list' and `match' of a font-driver can
  47         create this object, and it should never be modified by Lisp.
  48
  49    FONT-OBJECT
  50
  51         Pseudo vector (length FONT_OBJECT_MAX) of an opened font.
  52
  53         Lisp object encapsulating "struct font".  This corresponds to
  54         an opened font.
  55
  56         Note: Only the method `open' of a font-driver can create this
  57         object, and it should never be modified by Lisp.  */
  58
  59 extern Lisp_Object Qfont_spec, Qfont_entity, Qfont_object;
  60
  61 /* An enumerator for each font property.  This is used as an index to
  62    the vector of FONT-SPEC and FONT-ENTITY.
  63
  64    Note: The order is important and should not be changed.  */
  65
  66 enum font_property_index
  67   {
  68     /* FONT-TYPE is a symbol indicating a font backend; currently `x',
  69        `xft', and `ftx' are available on X, `uniscribe' and `gdi' on
  70        Windows, and `ns' under Cocoa / GNUstep.  */
  71     FONT_TYPE_INDEX,
  72
  73     /* FONT-FOUNDRY is a foundry name (symbol).  */
  74     FONT_FOUNDRY_INDEX,
  75
  76     /* FONT-FAMILY is a family name (symbol).  */
  77     FONT_FAMILY_INDEX,
  78
  79     /* FONT-ADSTYLE is an additional style name (symbol).  */
  80     FONT_ADSTYLE_INDEX,
  81
  82     /* FONT-REGISTRY is a combination of a charset-registry and
  83        charset-encoding name (symbol).  */
  84     FONT_REGISTRY_INDEX,
  85
  86     /* FONT-WEIGHT is a numeric value of weight (e.g. medium, bold) of
  87        the font.  The lowest 8 bits is an index determining the
  88        symbolic name, and the higher bits is the actual numeric value
  89        defined in `font-weight-table'. */
  90     FONT_WEIGHT_INDEX,
  91
  92     /* FONT-SLANT is a numeric value of slant (e.g. r, i, o) of the
  93        font.  The lowest 8 bits is an index determining the symbolic
  94        name, and the higher bits is the actual numeric value defined
  95        in `font-slant-table'.  */
  96     FONT_SLANT_INDEX,
  97
  98     /* FONT-WIDTH is a numeric value of setwidth (e.g. normal) of the
  99        font.  The lowest 8 bits is an index determining the symbolic
 100        name, and the higher bits is the actual numeric value defined
 101        `font-width-table'.  */
 102     FONT_WIDTH_INDEX,
 103
 104     /* FONT-SIZE is a size of the font.  If integer, it is a pixel
 105        size.  For a font-spec, the value can be a float specifying
 106        the point size.  The value zero means that the font is
 107        scalable.  */
 108     FONT_SIZE_INDEX,
 109
 110     /* FONT-DPI is a resolution (dot per inch) for which the font is
 111        designed. */
 112     FONT_DPI_INDEX,
 113
 114     /* FONT-SPACING is a spacing (mono, proportional, charcell) of the
 115        font (integer; one of enum font_spacing).  */
 116     FONT_SPACING_INDEX,
 117
 118     /* FONT-AVGWIDTH is an average width (1/10 pixel unit) of the
 119        font.  */
 120     FONT_AVGWIDTH_INDEX,
 121
 122 #if false
 123     /* The following two members are to substitute for the above 6
 124        members (FONT_WEIGHT_INDEX to FONT_AVGWIDTH_INDEX excluding
 125        FONT_SIZE_INDEX) if it is found that font-entities consumes too
 126        much memory.  */
 127
 128     /* FONT-STYLE is a 24-bit integer containing indices for
 129        style-related properties WEIGHT, SLANT, and WIDTH.  The lowest
 130        8 bits is an index to the weight table AREF (font_style_table,
 131        0), the next 8 bits is an index to the slant table AREF
 132        (font_style_table, 1), the highest 8 bits is an index to the
 133        slant table AREF (font_style_table, 2).  The index 0 indicates
 134        that the corresponding style is not specified.  This way, we
 135        can represent at most 255 different names for each style, which
 136        is surely sufficient.  */
 137     FONT_STYLE_INDEX,
 138
 139     /* FONT-METRICS is a 27-bit integer containing metrics-related
 140        properties DPI, AVGWIDTH, SPACING.  The lowest 12 bits is for
 141        DPI, the next 12 bits is for AVGWIDTH, the highest 3 bits is for
 142        SPACING.  In each bit field, the highest bit indicates that the
 143        corresponding value is set or not.  This way, we can represent
 144        DPI by 11-bit (0 to 2047), AVGWIDTH by 11-bit (0 to 2047),
 145        SPACING by 3-bit (0 for proportional, 1 for dual, 2 for mono, 3
 146        for charcell), which is surely sufficient.  */
 147     FONT_METRICS_INDEX,
 148 #endif
 149
 150     /* In a font-spec, the value is an alist of extra information of a
 151        font such as name, OpenType features, and language coverage.
 152        In addition, in a font-entity, the value may contain a pair
 153        (font-entity . INFO) where INFO is extra information to identify
 154        a font (font-driver dependent).  */
 155     FONT_EXTRA_INDEX,           /* alist                alist */
 156
 157     /* This value is the length of font-spec vector.  */
 158     FONT_SPEC_MAX,
 159
 160     /* The followings are used only for a font-entity and a font-object.  */
 161
 162     /* List of font-objects opened from the font-entity.  */
 163     FONT_OBJLIST_INDEX = FONT_SPEC_MAX,
 164
 165     /* This value is the length of font-entity vector.  */
 166     FONT_ENTITY_MAX,
 167
 168     /* The followings are used only for a font-object.  */
 169
 170     /* XLFD name of the font (string). */
 171     FONT_NAME_INDEX = FONT_ENTITY_MAX,
 172
 173     /* Full name of the font (string).  It is the name extracted from
 174        the opened font, and may be different from the above.  It may be
 175        nil if the opened font doesn't give a name.  */
 176     FONT_FULLNAME_INDEX,
 177
 178     /* File name of the font or nil if a file associated with the font
 179        is not available.  */
 180     FONT_FILE_INDEX,
 181
 182     /* This value is the length of font-object vector.  */
 183     FONT_OBJECT_MAX
 184   };
 185
 186 /* Return the numeric weight value of FONT.  */
 187 #define FONT_WEIGHT_NUMERIC(font)               \
 188   (INTEGERP (AREF ((font), FONT_WEIGHT_INDEX))  \
 189    ? (XINT (AREF ((font), FONT_WEIGHT_INDEX)) >> 8) : -1)
 190 /* Return the numeric slant value of FONT.  */
 191 #define FONT_SLANT_NUMERIC(font)                \
 192   (INTEGERP (AREF ((font), FONT_SLANT_INDEX))   \
 193    ? (XINT (AREF ((font), FONT_SLANT_INDEX)) >> 8) : -1)
 194 /* Return the numeric width value of FONT.  */
 195 #define FONT_WIDTH_NUMERIC(font)                \
 196   (INTEGERP (AREF ((font), FONT_WIDTH_INDEX))   \
 197    ? (XINT (AREF ((font), FONT_WIDTH_INDEX)) >> 8) : -1)
 198 /* Return the symbolic weight value of FONT.  */
 199 #define FONT_WEIGHT_SYMBOLIC(font)      \
 200   font_style_symbolic (font, FONT_WEIGHT_INDEX, false)
 201 /* Return the symbolic slant value of FONT.  */
 202 #define FONT_SLANT_SYMBOLIC(font)       \
 203   font_style_symbolic (font, FONT_SLANT_INDEX, false)
 204 /* Return the symbolic width value of FONT.  */
 205 #define FONT_WIDTH_SYMBOLIC(font)       \
 206   font_style_symbolic (font, FONT_WIDTH_INDEX, false)
 207 /* Return the face-weight corresponding to the weight of FONT.  */
 208 #define FONT_WEIGHT_FOR_FACE(font)      \
 209   font_style_symbolic (font, FONT_WEIGHT_INDEX, true)
 210 /* Return the face-slant corresponding to the slant of FONT.  */
 211 #define FONT_SLANT_FOR_FACE(font)       \
 212   font_style_symbolic (font, FONT_SLANT_INDEX, true)
 213 /* Return the face-swidth corresponding to the slant of FONT.  */
 214 #define FONT_WIDTH_FOR_FACE(font)       \
 215   font_style_symbolic (font, FONT_WIDTH_INDEX, true)
 216
 217 /* Return the numeric weight value corresponding ot the symbol NAME.  */
 218 #define FONT_WEIGHT_NAME_NUMERIC(name)  \
 219   (font_style_to_value (FONT_WEIGHT_INDEX, (name), false) >> 8)
 220 /* Return the numeric slant value corresponding ot the symbol NAME.  */
 221 #define FONT_SLANT_NAME_NUMERIC(name)   \
 222   (font_style_to_value (FONT_SLANT_INDEX, (name), false) >> 8)
 223 /* Return the numeric width value corresponding ot the symbol NAME.  */
 224 #define FONT_WIDTH_NAME_NUMERIC(name)   \
 225   (font_style_to_value (FONT_WIDTH_INDEX, (name), false) >> 8)
 226
 227 /* Set the font property PROP of FONT to VAL.  PROP is one of
 228    style-related font property index (FONT_WEIGHT/SLANT/WIDTH_INDEX).
 229    VAL (integer or symbol) is the numeric or symbolic style value.  */
 230 #define FONT_SET_STYLE(font, prop, val) \
 231   ASET ((font), prop, make_number (font_style_to_value (prop, val, true)))
 232
 233 #ifndef MSDOS
 234 #define FONT_WIDTH(f) ((f)->max_width)
 235 #else
 236 #define FONT_WIDTH(f) 1
 237 #endif
 238 #define FONT_HEIGHT(f) ((f)->height)
 239 #define FONT_BASE(f) ((f)->ascent)
 240 #define FONT_DESCENT(f) ((f)->descent)
 241
 242 extern Lisp_Object QCspacing, QCdpi, QCscalable, QCotf, QClang, QCscript;
 243 extern Lisp_Object QCavgwidth, QCantialias, QCfont_entity;
 244 extern Lisp_Object Qp;
 245
 246
 247 /* Important character set symbols.  */
 248 extern Lisp_Object Qascii_0;
 249 extern Lisp_Object Qiso8859_1, Qiso10646_1, Qunicode_bmp, Qunicode_sip;
 250
 251 /* Special ADSTYLE properties to avoid fonts used for Latin characters.  */
 252 extern Lisp_Object Qja, Qko;
 253
 254 /* Structure for a font-spec.  */
 255
 256 struct font_spec
 257 {
 258   struct vectorlike_header header;
 259   Lisp_Object props[FONT_SPEC_MAX];
 260 };
 261
 262 /* Structure for a font-entity.  */
 263
 264 struct font_entity
 265 {
 266   struct vectorlike_header header;
 267   Lisp_Object props[FONT_ENTITY_MAX];
 268 };
 269
 270 /* A value which may appear in the member `encoding' of struct font
 271    indicating that a font itself doesn't tell which encoding to be
 272    used.  */
 273 #define FONT_ENCODING_NOT_DECIDED 255
 274
 275 /* Structure for a font-object.  */
 276
 277 struct font
 278 {
 279   struct vectorlike_header header;
 280
 281   /* All Lisp_Object components must come first.
 282      That ensures they are all aligned normally.  */
 283
 284   Lisp_Object props[FONT_OBJECT_MAX];
 285
 286   /* Beyond here, there should be no more Lisp_Object components.  */
 287
 288   /* Minimum and maximum glyph widths, in pixels.  Some font backends,
 289      such as xft, lack the information to easily compute minimum and
 290      maximum widths over all characters; in that case, these values
 291      are approximate.  */
 292   int min_width;
 293   int max_width;
 294
 295   /* By which pixel size the font is opened.  */
 296   int pixel_size;
 297
 298   /* Height of the font.  On X window, this is the same as
 299      (font->ascent + font->descent).  */
 300   int height;
 301
 302   /* Width of the space glyph of the font.  If the font doesn't have a
 303      SPACE glyph, the value is 0.  */
 304   int space_width;
 305
 306   /* Average width of glyphs in the font.  If the font itself doesn't
 307      have that information but has glyphs of ASCII characters, the
 308      value is the average width of those glyphs.  Otherwise, the value
 309      is 0.  */
 310   int average_width;
 311
 312   /* Ascent and descent of the font (in pixels).  */
 313   int ascent, descent;
 314
 315   /* The following members makes sense on graphic displays only.  */
 316
 317 #if defined (HAVE_WINDOW_SYSTEM)
 318
 319   /* Vertical pixel width of the underline.  If is zero if that
 320      information is not in the font.  */
 321   int underline_thickness;
 322
 323   /* Vertical pixel position (relative to the baseline) of the
 324      underline.  If it is positive, it is below the baseline.  It is
 325      negative if that information is not in the font.  */
 326   int underline_position;
 327
 328   /* True if `vertical-centering-font-regexp' matches this font name.
 329      In this case, we render characters at vertical center positions
 330      of lines.  */
 331   bool vertical_centering;
 332
 333   /* The baseline position of a font is normally `ascent' value of the
 334      font.  However, there exist many fonts which don't set `ascent' to
 335      an appropriate value to be used as baseline position.  This is
 336      typical in such ASCII fonts which are designed to be used with
 337      Chinese, Japanese, Korean characters.  When we use mixture of
 338      such fonts and normal fonts (having correct `ascent' value), a
 339      display line gets very ugly.  Since we have no way to fix it
 340      automatically, it is user's responsibility to supply well designed
 341      fonts or correct `ascent' value of fonts.  But, the latter
 342      requires heavy work (modifying all bitmap data in BDF files).
 343      So, Emacs accepts a private font property
 344      `_MULE_BASELINE_OFFSET'.  If a font has this property, we
 345      calculate the baseline position by subtracting the value from
 346      `ascent'.  In other words, the value indicates how many pixels
 347      higher than normal ASCII text we should draw a character of the
 348      font for better appearance.
 349
 350      We also have to consider the fact that the concept of `baseline'
 351      differs among scripts to which each character belongs.  For
 352      instance, baseline should be at the bottom-most position of all
 353      glyphs for Chinese, Japanese, and Korean.  But, many of existing
 354      fonts for those characters don't have correct `ascent' values
 355      because they are designed to be used with ASCII fonts.  To
 356      display characters of different language on the same line, the
 357      best way will be to arrange them in the middle of the line.  So,
 358      in such a case, again, we utilize the font property
 359      `_MULE_BASELINE_OFFSET'.  If the value is larger than `ascent' we
 360      calculate baseline so that a character is arranged in the middle
 361      of a line.  */
 362   int baseline_offset;
 363
 364   /* Non-zero means a character should be composed at a position
 365      relative to the height (or depth) of previous glyphs in the
 366      following cases:
 367         (1) The bottom of the character is higher than this value.  In
 368         this case, the character is drawn above the previous glyphs.
 369         (2) The top of the character is lower than 0 (i.e. baseline
 370         height).  In this case, the character is drawn below the
 371         previous glyphs.
 372
 373      This value is taken from a private font property
 374      `_MULE_RELATIVE_COMPOSE' which is introduced by Emacs.  */
 375   int relative_compose;
 376
 377   /* Non-zero means an ascent value to be used for a character
 378      registered in char-table `use-default-ascent'.  */
 379   int default_ascent;
 380
 381   /* Charset to encode a character code into a glyph code of the font.
 382      -1 means that the font doesn't require this information to encode
 383      a character.  */
 384   int encoding_charset;
 385
 386   /* Charset to check if a character code is supported by the font.
 387      -1 means that the contents of the font must be looked up to
 388      determine it.  */
 389   int repertory_charset;
 390
 391 #endif /* HAVE_WINDOW_SYSTEM */
 392
 393   /* Font-driver for the font.  */
 394   struct font_driver *driver;
 395
 396   /* There are more members in this structure, but they are private
 397      to the font-driver.  */
 398 };
 399
 400 enum font_spacing
 401   {
 402     FONT_SPACING_PROPORTIONAL = 0,
 403     FONT_SPACING_DUAL = 90,
 404     FONT_SPACING_MONO = 100,
 405     FONT_SPACING_CHARCELL = 110
 406   };
 407
 408 struct font_metrics
 409 {
 410   short lbearing, rbearing, width, ascent, descent;
 411 };
 412
 413 struct font_bitmap
 414 {
 415   int bits_per_pixel;
 416   int rows;
 417   int width;
 418   int pitch;
 419   unsigned char *buffer;
 420   int left;
 421   int top;
 422   int advance;
 423 };
 424
 425 /* Predicates to check various font-related objects.  */
 426
 427 /* True iff X is one of font-spec, font-entity, and font-object.  */
 428 #define FONTP(x) PSEUDOVECTORP (x, PVEC_FONT)
 429 /* True iff X is font-spec.  */
 430 #define FONT_SPEC_P(x)  \
 431   (FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_SPEC_MAX)
 432 /* True iff X is font-entity.  */
 433 #define FONT_ENTITY_P(x)        \
 434   (FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_ENTITY_MAX)
 435 /* True iff X is font-object.  */
 436 #define FONT_OBJECT_P(x)        \
 437   (FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_OBJECT_MAX)
 438
 439 /* Check macros for various font-related objects.  */
 440
 441 #define CHECK_FONT(x)   \
 442   do { if (! FONTP (x)) wrong_type_argument (Qfont, x); } while (false)
 443 #define CHECK_FONT_SPEC(x)      \
 444   do { if (! FONT_SPEC_P (x)) wrong_type_argument (Qfont_spec, x); } \
 445   while (false)
 446 #define CHECK_FONT_ENTITY(x)    \
 447   do { if (! FONT_ENTITY_P (x)) wrong_type_argument (Qfont_entity, x); } \
 448   while (false)
 449 #define CHECK_FONT_OBJECT(x)    \
 450   do { if (! FONT_OBJECT_P (x)) wrong_type_argument (Qfont_object, x); } \
 451   while (false)
 452
 453 #define CHECK_FONT_GET_OBJECT(x, font)  \
 454   do {                                  \
 455     CHECK_FONT_OBJECT (x);              \
 456     font = XFONT_OBJECT (x);            \
 457   } while (false)
 458
 459 #define XFONT_SPEC(p)   \
 460   (eassert (FONT_SPEC_P (p)), (struct font_spec *) XUNTAG (p, Lisp_Vectorlike))
 461 #define XFONT_ENTITY(p) \
 462   (eassert (FONT_ENTITY_P (p)), \
 463    (struct font_entity *) XUNTAG (p, Lisp_Vectorlike))
 464 #define XFONT_OBJECT(p) \
 465   (eassert (FONT_OBJECT_P (p)), (struct font *) XUNTAG (p, Lisp_Vectorlike))
 466 #define XSETFONT(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_FONT))
 467
 468 /* Number of pt per inch (from the TeXbook).  */
 469 #define PT_PER_INCH 72.27
 470
 471 /* Return a pixel size (integer) corresponding to POINT size (double)
 472    on resolution DPI.  */
 473 #define POINT_TO_PIXEL(POINT, DPI) ((POINT) * (DPI) / PT_PER_INCH + 0.5)
 474
 475 /* Return a point size corresponding to POINT size (integer)
 476    on resolution DPI.  Note that though point size is a double, we expect
 477    it to be rounded to an int, so we add 0.5 here.  If the desired value
 478    is tenths of points (as in xfld specs), then the pixel size should
 479    be multiplied BEFORE the conversion to avoid magnifying the error.  */
 480 #define PIXEL_TO_POINT(PIXEL, DPI) ((PIXEL) * PT_PER_INCH / (DPI) + 0.5)
 481
 482 /* Ignore the difference of font pixel sizes less than or equal to
 483    this value.  */
 484 #define FONT_PIXEL_SIZE_QUANTUM 1
 485
 486 #define FONT_INVALID_CODE 0xFFFFFFFF
 487
 488 /* Font driver.  Members specified as "optional" can be NULL.  */
 489
 490 struct font_driver
 491 {
 492   /* Symbol indicating the type of the font-driver.  */
 493   Lisp_Object type;
 494
 495   /* True iff the font's foundry, family, and adstyle names are case
 496      sensitive.  */
 497   bool case_sensitive;
 498
 499   /* Return a cache of font-entities on frame F.  The cache must be a
 500      cons whose cdr part is the actual cache area.  */
 501   Lisp_Object (*get_cache) (struct frame *f);
 502
 503   /* List fonts exactly matching with FONT_SPEC on FRAME.  The value
 504      is a list of font-entities.  The font properties to be considered
 505      are: :foundry, :family, :adstyle, :registry, :script, :lang, and
 506      :otf.  See the function `font-spec' for their meanings.  Note
 507      that the last three properties are stored in FONT_EXTRA_INDEX
 508      slot of FONT_SPEC.
 509
 510      The returned value is a list of font-entities.  Each font-entity
 511      has :type property whose value is the same as the above `type'.
 512      It also has these properties if they are available from the
 513      corresponding font; :foundry, :family, :adstyle, :registry,
 514      :weight, :slant, :width, :size, :dpi, :spacing, :avgwidth.  If
 515      the font is scalable, :size and :avgwidth must be 0.
 516
 517      The `open' method of the same font-backend is called with one of
 518      the returned font-entities.  If the backend needs additional
 519      information to be used in `open' method, this method can add any
 520      Lispy value by the property :font-entity to the entities.
 521
 522      This and the following `match' are the only APIs that allocate
 523      font-entities.  */
 524   Lisp_Object (*list) (struct frame *frame, Lisp_Object font_spec);
 525
 526   /* Return a font-entity most closely matching with FONT_SPEC on
 527      FRAME.  Which font property to consider, and how to calculate the
 528      closeness is determined by the font backend, thus
 529      `face-font-selection-order' is ignored here.
 530
 531      The properties that the font-entity has is the same as `list'
 532      method.  */
 533   Lisp_Object (*match) (struct frame *f, Lisp_Object spec);
 534
 535   /* Optional.
 536      List available families.  The value is a list of family names
 537      (symbols).  */
 538   Lisp_Object (*list_family) (struct frame *f);
 539
 540   /* Optional (if FONT_EXTRA_INDEX is not Lisp_Save_Value).
 541      Free FONT_EXTRA_INDEX field of FONT_ENTITY.  */
 542   void (*free_entity) (Lisp_Object font_entity);
 543
 544   /* Open a font specified by FONT_ENTITY on frame F.  If the font is
 545      scalable, open it with PIXEL_SIZE.  */
 546   Lisp_Object (*open) (struct frame *f, Lisp_Object font_entity,
 547                        int pixel_size);
 548
 549   /* Close FONT.  NOTE: this can be called by GC.  */
 550   void (*close) (struct font *font);
 551
 552   /* Prepare FACE for displaying characters by FONT on frame F by
 553      storing some data in FACE->extra.  */
 554   void (*prepare_face) (struct frame *f, struct face *face);
 555
 556   /* Optional.
 557      Done FACE for displaying characters by FACE->font on frame F.  */
 558   void (*done_face) (struct frame *f, struct face *face);
 559
 560   /* Optional.
 561      If FONT (FONT-ENTITY or FONT-OBJECT) has a glyph for character C
 562      (Unicode code point), return 1.  If not, return 0.  If FONT is
 563      FONT-ENTITY and it must be opened to check it, return -1.  */
 564   int (*has_char) (Lisp_Object font, int c);
 565
 566   /* Return a glyph code of FONT for character C (Unicode code point).
 567      If FONT doesn't have such a glyph, return FONT_INVALID_CODE.  */
 568   unsigned (*encode_char) (struct font *font, int c);
 569
 570   /* Compute the total metrics of the NGLYPHS glyphs specified by
 571      the font FONT and the sequence of glyph codes CODE, and store the
 572      result in METRICS.  */
 573   void (*text_extents) (struct font *font,
 574                         unsigned *code, int nglyphs,
 575                         struct font_metrics *metrics);
 576
 577 #ifdef HAVE_WINDOW_SYSTEM
 578
 579   /* Optional.
 580      Draw glyphs between FROM and TO of S->char2b at (X Y) pixel
 581      position of frame F with S->FACE and S->GC.  If WITH_BACKGROUND,
 582      fill the background in advance.  It is assured that WITH_BACKGROUND
 583      is false when (FROM > 0 || TO < S->nchars).  */
 584   int (*draw) (struct glyph_string *s, int from, int to,
 585                int x, int y, bool with_background);
 586
 587   /* Optional.
 588      Store bitmap data for glyph-code CODE of FONT in BITMAP.  It is
 589      intended that this method is called from the other font-driver
 590      for actual drawing.  */
 591   int (*get_bitmap) (struct font *font, unsigned code,
 592                      struct font_bitmap *bitmap,
 593                      int bits_per_pixel);
 594
 595   /* Optional.
 596      Free bitmap data in BITMAP.  */
 597   void (*free_bitmap) (struct font *font, struct font_bitmap *bitmap);
 598
 599 #endif /* HAVE_WINDOW_SYSTEM */
 600
 601   /* Optional.
 602      Get coordinates of the INDEXth anchor point of the glyph whose
 603      code is CODE.  Store the coordinates in *X and *Y.  Return 0 if
 604      the operations was successful.  Otherwise return -1.  */
 605   int (*anchor_point) (struct font *font, unsigned code, int index,
 606                        int *x, int *y);
 607
 608   /* Optional.
 609      Return a list describing which scripts/languages FONT
 610      supports by which GSUB/GPOS features of OpenType tables.  */
 611   Lisp_Object (*otf_capability) (struct font *font);
 612
 613   /* Optional.
 614      Apply FONT's OTF-FEATURES to the glyph string.
 615
 616      FEATURES specifies which OTF features to apply in this format:
 617         (SCRIPT LANGSYS GSUB-FEATURE GPOS-FEATURE)
 618      See the documentation of `font-drive-otf' for the details.
 619
 620      This method applies the specified features to the codes in the
 621      elements of GSTRING-IN (between FROMth and TOth).  The output
 622      codes are stored in GSTRING-OUT at the IDXth element and the
 623      following elements.
 624
 625      Return the number of output codes.  If none of the features are
 626      applicable to the input data, return 0.  If GSTRING-OUT is too
 627      short, return -1.  */
 628   int (*otf_drive) (struct font *font, Lisp_Object features,
 629                     Lisp_Object gstring_in, int from, int to,
 630                     Lisp_Object gstring_out, int idx, bool alternate_subst);
 631
 632   /* Optional.
 633      Make the font driver ready for frame F.  Usually this function
 634      makes some data specific to F and stores it in F by calling
 635      font_put_frame_data ().  */
 636   int (*start_for_frame) (struct frame *f);
 637
 638   /* Optional.
 639      End using the driver for frame F.  Usually this function free
 640      some data stored for F.  */
 641   int (*end_for_frame) (struct frame *f);
 642
 643   /* Optional.
 644
 645      Shape text in GSTRING.  See the docstring of
 646      `composition-get-gstring' for the format of GSTRING.  If the
 647      (N+1)th element of GSTRING is nil, input of shaping is from the
 648      1st to (N)th elements.  In each input glyph, FROM, TO, CHAR, and
 649      CODE are already set.
 650
 651      This function updates all fields of the input glyphs.  If the
 652      output glyphs (M) are more than the input glyphs (N), (N+1)th
 653      through (M)th elements of GSTRING are updated possibly by making
 654      a new glyph object and storing it in GSTRING.  If (M) is greater
 655      than the length of GSTRING, nil should be return.  In that case,
 656      this function is called again with the larger GSTRING.  */
 657   Lisp_Object (*shape) (Lisp_Object lgstring);
 658
 659   /* Optional.
 660
 661      If FONT is usable on frame F, return 0.  Otherwise return -1.
 662      This method is used only for debugging.  If this method is NULL,
 663      Emacs assumes that the font is usable on any frame.  */
 664   int (*check) (struct frame *f, struct font *font);
 665
 666   /* Optional.
 667
 668      Return the number of variation glyphs of character C supported by
 669      FONT.  VARIATIONS is an array of 256 elements.  If the variation
 670      selector N (1..256) defines a glyph, that glyph code is stored in
 671      the (N-1)th element of VARIATIONS.  */
 672   int (*get_variation_glyphs) (struct font *font,
 673                                int c, unsigned variations[256]);
 674
 675   void (*filter_properties) (Lisp_Object font, Lisp_Object properties);
 676
 677   /* Optional.
 678
 679      Return non-zero if FONT_OBJECT can be used as a (cached) font
 680      for ENTITY on frame F.  */
 681   bool (*cached_font_ok) (struct frame *f,
 682                           Lisp_Object font_object,
 683                           Lisp_Object entity);
 684 };
 685
 686
 687 /* Chain of font drivers.  There's one global font driver list
 688    (font_driver_list in font.c).  In addition, each frame has
 689    its own font driver list at F->font_driver_list.  */
 690
 691 struct font_driver_list
 692 {
 693   /* True iff this driver is currently used.  It is ignored in the global
 694      font driver list.*/
 695   bool on;
 696   /* Pointer to the font driver.  */
 697   struct font_driver *driver;
 698   /* Pointer to the next element of the chain.  */
 699   struct font_driver_list *next;
 700 };
 701
 702 extern Lisp_Object copy_font_spec (Lisp_Object);
 703 extern Lisp_Object merge_font_spec (Lisp_Object, Lisp_Object);
 704
 705 extern Lisp_Object font_make_entity (void);
 706 extern Lisp_Object font_make_object (int, Lisp_Object, int);
 707 #if defined (HAVE_XFT) || defined (HAVE_FREETYPE) || defined (HAVE_NS)
 708 extern Lisp_Object font_build_object (int, Lisp_Object, Lisp_Object, double);
 709 #endif
 710
 711 extern Lisp_Object find_font_encoding (Lisp_Object);
 712 extern int font_registry_charsets (Lisp_Object, struct charset **,
 713                                    struct charset **);
 714 extern int font_style_to_value (enum font_property_index prop,
 715                                 Lisp_Object name, bool noerror);
 716 extern Lisp_Object font_style_symbolic (Lisp_Object font,
 717                                         enum font_property_index prop,
 718                                         bool for_face);
 719
 720 extern bool font_match_p (Lisp_Object spec, Lisp_Object font);
 721 extern Lisp_Object font_list_entities (struct frame *, Lisp_Object);
 722
 723 extern Lisp_Object font_get_name (Lisp_Object font_object);
 724 extern Lisp_Object font_spec_from_name (Lisp_Object font_name);
 725 extern Lisp_Object font_get_frame (Lisp_Object font_object);
 726 extern int font_has_char (struct frame *, Lisp_Object, int);
 727
 728 extern void font_clear_prop (Lisp_Object *attrs,
 729                              enum font_property_index prop);
 730 extern Lisp_Object font_find_for_lface (struct frame *f, Lisp_Object *lface,
 731                                         Lisp_Object spec, int c);
 732 extern Lisp_Object font_open_for_lface (struct frame *f, Lisp_Object entity,
 733                                         Lisp_Object *lface,
 734                                         Lisp_Object spec);
 735 extern Lisp_Object font_load_for_lface (struct frame *f, Lisp_Object *lface,
 736                                         Lisp_Object spec);
 737 extern void font_prepare_for_face (struct frame *f, struct face *face);
 738 extern void font_done_for_face (struct frame *f, struct face *face);
 739 extern void clear_font_cache (struct frame *);
 740
 741 extern Lisp_Object font_open_by_spec (struct frame *f, Lisp_Object spec);
 742 extern Lisp_Object font_open_by_name (struct frame *f, Lisp_Object name);
 743
 744 extern Lisp_Object font_intern_prop (const char *str, ptrdiff_t len,
 745                                      bool force_symbol);
 746 extern void font_update_sort_order (int *order);
 747
 748 extern void font_parse_family_registry (Lisp_Object family,
 749                                         Lisp_Object registry,
 750                                         Lisp_Object spec);
 751
 752 extern int font_parse_xlfd (char *name, ptrdiff_t len, Lisp_Object font);
 753 extern ptrdiff_t font_unparse_xlfd (Lisp_Object font, int pixel_size,
 754                                     char *name, int bytes);
 755 extern void register_font_driver (struct font_driver *driver, struct frame *f);
 756 extern void free_font_driver_list (struct frame *f);
 757 #ifdef ENABLE_CHECKING
 758 extern bool valid_font_driver (struct font_driver *);
 759 #else
 760 INLINE bool
 761 valid_font_driver (struct font_driver *d)
 762 {
 763   return true;
 764 }
 765 #endif
 766 extern Lisp_Object font_update_drivers (struct frame *f, Lisp_Object list);
 767 extern Lisp_Object font_range (ptrdiff_t, ptrdiff_t, ptrdiff_t *,
 768                                struct window *, struct face *,
 769                                Lisp_Object);
 770 extern void font_fill_lglyph_metrics (Lisp_Object, Lisp_Object);
 771
 772 extern Lisp_Object font_put_extra (Lisp_Object font, Lisp_Object prop,
 773                                    Lisp_Object val);
 774
 775 #if defined (HAVE_XFT) || defined (HAVE_FREETYPE)
 776 extern void font_put_frame_data (struct frame *, Lisp_Object, void *);
 777 extern void *font_get_frame_data (struct frame *f, Lisp_Object);
 778 #endif /* HAVE_XFT || HAVE_FREETYPE */
 779
 780 extern void font_filter_properties (Lisp_Object font,
 781                                     Lisp_Object alist,
 782                                     const char *const boolean_properties[],
 783                                     const char *const non_boolean_properties[]);
 784
 785 #ifdef HAVE_FREETYPE
 786 extern struct font_driver ftfont_driver;
 787 extern void syms_of_ftfont (void);
 788 #endif  /* HAVE_FREETYPE */
 789 #ifdef HAVE_X_WINDOWS
 790 extern struct font_driver xfont_driver;
 791 extern void syms_of_xfont (void);
 792 extern void syms_of_ftxfont (void);
 793 #ifdef HAVE_XFT
 794 extern Lisp_Object Qxft;
 795 extern struct font_driver xftfont_driver;
 796 extern void syms_of_xftfont (void);
 797 #endif
 798 #if defined HAVE_FREETYPE || defined HAVE_XFT
 799 extern struct font_driver ftxfont_driver;
 800 #endif
 801 #ifdef HAVE_BDFFONT
 802 extern void syms_of_bdffont (void);
 803 #endif  /* HAVE_BDFFONT */
 804 #endif  /* HAVE_X_WINDOWS */
 805 #ifdef HAVE_NTGUI
 806 extern struct font_driver w32font_driver;
 807 extern struct font_driver uniscribe_font_driver;
 808 extern void syms_of_w32font (void);
 809 #endif  /* HAVE_NTGUI */
 810 #ifdef HAVE_NS
 811 extern Lisp_Object Qfontsize;
 812 extern struct font_driver nsfont_driver;
 813 extern void syms_of_nsfont (void);
 814 extern void syms_of_macfont (void);
 815 #endif  /* HAVE_NS */
 816
 817 #ifndef FONT_DEBUG
 818 #define FONT_DEBUG
 819 #endif
 820
 821 extern Lisp_Object QCfoundry;
 822
 823 extern void font_add_log (const char *, Lisp_Object, Lisp_Object);
 824 extern void font_deferred_log (const char *, Lisp_Object, Lisp_Object);
 825
 826 #define FONT_ADD_LOG(ACTION, ARG, RESULT)       \
 827   do {                                          \
 828     if (! EQ (Vfont_log, Qt))                   \
 829       font_add_log ((ACTION), (ARG), (RESULT)); \
 830   } while (false)
 831
 832 #define FONT_DEFERRED_LOG(ACTION, ARG, RESULT)          \
 833   do {                                                  \
 834     if (! EQ (Vfont_log, Qt))                           \
 835       font_deferred_log ((ACTION), (ARG), (RESULT));    \
 836   } while (false)
 837
 838 INLINE_HEADER_END
 839
 840 #endif  /* not EMACS_FONT_H */