src/font.h

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