src/font.h

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