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
  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 instantiated
  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 it should never be modified by Lisp.
  45
  46    FONT-OBJECT
  47
  48         Pseudo vector (length FONT_OBJECT_MAX) of an opened 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 it 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', and `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 bits 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 bits 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 bits 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 a float specifying
 108        the 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 bits is an index to the weight table AREF (font_style_table,
 133        0), the next 8 bits is an index to the slant table AREF
 134        (font_style_table, 1), the highest 8 bits is an index to the
 135        slant table AREF (font_style_table, 2).  The index 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 bits is for
 143        DPI, the next 12 bits is for AVGWIDTH, the highest 3 bits 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 opened 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;
 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   struct vectorlike_header header;
 258   Lisp_Object props[FONT_SPEC_MAX];
 259 };
 260
 261 /* Structure for a font-entity.  */
 262
 263 struct font_entity
 264 {
 265   struct vectorlike_header header;
 266   Lisp_Object props[FONT_ENTITY_MAX];
 267 };
 268
 269 /* A value which may appear in the member `encoding' of struct font
 270    indicating that a font itself doesn't tell which encoding to be
 271    used.  */
 272 #define FONT_ENCODING_NOT_DECIDED 255
 273
 274 /* Structure for a font-object.  */
 275
 276 struct font
 277 {
 278   struct vectorlike_header header;
 279
 280   /* All Lisp_Object components must come first.
 281      That ensures they are all aligned normally.  */
 282
 283   Lisp_Object props[FONT_OBJECT_MAX];
 284
 285   /* Beyond here, there should be no more Lisp_Object components.  */
 286
 287   /* Minimum and maximum glyph widths, in pixels.  Some font backends,
 288      such as xft, lack the information to easily compute minimum and
 289      maximum widths over all characters; in that case, these values
 290      are approximate.  */
 291   int min_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 characters, the
 307      value is the average width of those glyphs.  Otherwise, the value
 308      is 0.  */
 309   int average_width;
 310
 311   /* Ascent and descent of the font (in pixels).  */
 312   int ascent, descent;
 313
 314   /* Vertical pixel width of the underline.  If is zero if that
 315      information is not in the font.  */
 316   int underline_thickness;
 317
 318   /* Vertical pixel position (relative to the baseline) of the
 319      underline.  If it is positive, it is below the baseline.  It is
 320      negative if that information is not in the font.  */
 321   int underline_position;
 322
 323   /* True if `vertical-centering-font-regexp' matches this font name.
 324      In this case, we render characters at vertical center positions
 325      of lines.  */
 326   bool vertical_centering;
 327
 328   /* The baseline position of a font is normally `ascent' value of the
 329      font.  However, there exist many fonts which don't set `ascent' to
 330      an appropriate value to be used as baseline position.  This is
 331      typical in such ASCII fonts which are designed to be used with
 332      Chinese, Japanese, Korean characters.  When we use mixture of
 333      such fonts and normal fonts (having correct `ascent' value), a
 334      display line gets very ugly.  Since we have no way to fix it
 335      automatically, it is user's responsibility to supply well designed
 336      fonts or correct `ascent' value of fonts.  But, the latter
 337      requires heavy work (modifying all bitmap data in BDF files).
 338      So, Emacs accepts a private font property
 339      `_MULE_BASELINE_OFFSET'.  If a font has this property, we
 340      calculate the baseline position by subtracting the value from
 341      `ascent'.  In other words, the value indicates how many pixels
 342      higher than normal ASCII text we should draw a character of the
 343      font for better appearance.
 344
 345      We also have to consider the fact that the concept of `baseline'
 346      differs among scripts to which each character belongs.  For
 347      instance, baseline should be at the bottom-most position of all
 348      glyphs for Chinese, Japanese, and Korean.  But, many of existing
 349      fonts for those characters don't have correct `ascent' values
 350      because they are designed to be used with ASCII fonts.  To
 351      display characters of different language on the same line, the
 352      best way will be to arrange them in the middle of the line.  So,
 353      in such a case, again, we utilize the font property
 354      `_MULE_BASELINE_OFFSET'.  If the value is larger than `ascent' we
 355      calculate baseline so that a character is arranged in the middle
 356      of a line.  */
 357   int baseline_offset;
 358
 359   /* Non-zero means a character should be composed at a position
 360      relative to the height (or depth) of previous glyphs in the
 361      following cases:
 362         (1) The bottom of the character is higher than this value.  In
 363         this case, the character is drawn above the previous glyphs.
 364         (2) The top of the character is lower than 0 (i.e. baseline
 365         height).  In this case, the character is drawn below the
 366         previous glyphs.
 367
 368      This value is taken from a private font property
 369      `_MULE_RELATIVE_COMPOSE' which is introduced by Emacs.  */
 370   int relative_compose;
 371
 372   /* Non-zero means an ascent value to be used for a character
 373      registered in char-table `use-default-ascent'.  */
 374   int default_ascent;
 375
 376   /* CCL program to calculate code points of the font.  */
 377   struct ccl_program *font_encoder;
 378
 379   /* Font-driver for the font.  */
 380   struct font_driver *driver;
 381
 382   /* Charset to encode a character code into a glyph code of the font.
 383      -1 means that the font doesn't require this information to encode
 384      a character.  */
 385   int encoding_charset;
 386
 387   /* Charset to check if a character code is supported by the font.
 388      -1 means that the contents of the font must be looked up to
 389      determine it.  */
 390   int repertory_charset;
 391
 392   /* There are more members in this structure, but they are private
 393      to the font-driver.  */
 394 };
 395
 396 enum font_spacing
 397   {
 398     FONT_SPACING_PROPORTIONAL = 0,
 399     FONT_SPACING_DUAL = 90,
 400     FONT_SPACING_MONO = 100,
 401     FONT_SPACING_CHARCELL = 110
 402   };
 403
 404 struct font_metrics
 405 {
 406   short lbearing, rbearing, width, ascent, descent;
 407 };
 408
 409 struct font_bitmap
 410 {
 411   int bits_per_pixel;
 412   int rows;
 413   int width;
 414   int pitch;
 415   unsigned char *buffer;
 416   int left;
 417   int top;
 418   int advance;
 419   void *extra;
 420 };
 421
 422 /* Predicates to check various font-related objects.  */
 423
 424 /* 1 iff X is one of font-spec, font-entity, and font-object.  */
 425 #define FONTP(x) PSEUDOVECTORP (x, PVEC_FONT)
 426 /* 1 iff X is font-spec.  */
 427 #define FONT_SPEC_P(x)  \
 428   (FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_SPEC_MAX)
 429 /* 1 iff X is font-entity.  */
 430 #define FONT_ENTITY_P(x)        \
 431   (FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_ENTITY_MAX)
 432 /* 1 iff X is font-object.  */
 433 #define FONT_OBJECT_P(x)        \
 434   (FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_OBJECT_MAX)
 435
 436 /* 1 iff ENTITY can't be loaded.  */
 437 #define FONT_ENTITY_NOT_LOADABLE(entity)        \
 438   EQ (AREF (entity, FONT_OBJLIST_INDEX), Qt)
 439
 440 /* Flag ENTITY not loadable.  */
 441 #define FONT_ENTITY_SET_NOT_LOADABLE(entity)    \
 442   ASET (entity, FONT_OBJLIST_INDEX, Qt)
 443
 444
 445 /* Check macros for various font-related objects.  */
 446
 447 #define CHECK_FONT(x)   \
 448   do { if (! FONTP (x)) wrong_type_argument (Qfont, x); } while (0)
 449 #define CHECK_FONT_SPEC(x)      \
 450   do { if (! FONT_SPEC_P (x)) wrong_type_argument (Qfont_spec, x); } while (0)
 451 #define CHECK_FONT_ENTITY(x)    \
 452   do { if (! FONT_ENTITY_P (x)) wrong_type_argument (Qfont_entity, x); } while (0)
 453 #define CHECK_FONT_OBJECT(x)    \
 454   do { if (! FONT_OBJECT_P (x)) wrong_type_argument (Qfont_object, x); } while (0)
 455
 456 #define CHECK_FONT_GET_OBJECT(x, font)  \
 457   do {                                  \
 458     CHECK_FONT_OBJECT (x);              \
 459     font = XFONT_OBJECT (x);            \
 460   } while (0)
 461
 462 #define XFONT_SPEC(p)   \
 463   (eassert (FONT_SPEC_P (p)), (struct font_spec *) XUNTAG (p, Lisp_Vectorlike))
 464 #define XFONT_ENTITY(p) \
 465   (eassert (FONT_ENTITY_P (p)), \
 466    (struct font_entity *) XUNTAG (p, Lisp_Vectorlike))
 467 #define XFONT_OBJECT(p) \
 468   (eassert (FONT_OBJECT_P (p)), (struct font *) XUNTAG (p, Lisp_Vectorlike))
 469 #define XSETFONT(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_FONT))
 470
 471 /* Number of pt per inch (from the TeXbook).  */
 472 #define PT_PER_INCH 72.27
 473
 474 /* Return a pixel size (integer) corresponding to POINT size (double)
 475    on resolution DPI.  */
 476 #define POINT_TO_PIXEL(POINT, DPI) ((POINT) * (DPI) / PT_PER_INCH + 0.5)
 477
 478 /* Return a point size corresponding to POINT size (integer)
 479    on resolution DPI.  Note that though point size is a double, we expect
 480    it to be rounded to an int, so we add 0.5 here.  If the desired value
 481    is tenths of points (as in xfld specs), then the pixel size should
 482    be multiplied BEFORE the conversion to avoid magnifying the error.  */
 483 #define PIXEL_TO_POINT(PIXEL, DPI) ((PIXEL) * PT_PER_INCH / (DPI) + 0.5)
 484
 485 /* Ignore the difference of font pixel sizes less than or equal to
 486    this value.  */
 487 #define FONT_PIXEL_SIZE_QUANTUM 1
 488
 489 struct face;
 490
 491 #define FONT_INVALID_CODE 0xFFFFFFFF
 492
 493 /* Font driver.  Members specified as "optional" can be NULL.  */
 494
 495 struct font_driver
 496 {
 497   /* Symbol indicating the type of the font-driver.  */
 498   Lisp_Object type;
 499
 500   /* True iff the font's foundry, family, and adstyle names are case
 501      sensitive.  */
 502   bool case_sensitive;
 503
 504   /* Return a cache of font-entities on frame F.  The cache must be a
 505      cons whose cdr part is the actual cache area.  */
 506   Lisp_Object (*get_cache) (FRAME_PTR F);
 507
 508   /* List fonts exactly matching with FONT_SPEC on FRAME.  The value
 509      is a list of font-entities.  The font properties to be considered
 510      are: :foundry, :family, :adstyle, :registry, :script, :lang, and
 511      :otf.  See the function `font-spec' for their meanings.  Note
 512      that the last three properties are stored in FONT_EXTRA_INDEX
 513      slot of FONT_SPEC.
 514
 515      The returned value is a list of font-entities.  Each font-entity
 516      has :type property whose value is the same as the above `type'.
 517      It also has these properties if they are available from the
 518      corresponding font; :foundry, :family, :adstyle, :registry,
 519      :weight, :slant, :width, :size, :dpi, :spacing, :avgwidth.  If
 520      the font is scalable, :size and :avgwidth must be 0.
 521
 522      The `open' method of the same font-backend is called with one of
 523      the returned font-entities.  If the backend needs additional
 524      information to be used in `open' method, this method can add any
 525      Lispy value by the property :font-entity to the entities.
 526
 527      This and the following `match' are the only APIs that allocate
 528      font-entities.  */
 529   Lisp_Object (*list) (Lisp_Object frame, Lisp_Object font_spec);
 530
 531   /* Return a font-entity most closely matching with FONT_SPEC on
 532      FRAME.  Which font property to consider, and how to calculate the
 533      closeness is determined by the font backend, thus
 534      `face-font-selection-order' is ignored here.
 535
 536      The properties that the font-entity has is the same as `list'
 537      method.  */
 538   Lisp_Object (*match) (Lisp_Object frame, Lisp_Object font_spec);
 539
 540   /* Optional.
 541      List available families.  The value is a list of family names
 542      (symbols).  */
 543   Lisp_Object (*list_family) (Lisp_Object frame);
 544
 545   /* Optional (if FONT_EXTRA_INDEX is not Lisp_Save_Value).
 546      Free FONT_EXTRA_INDEX field of FONT_ENTITY.  */
 547   void (*free_entity) (Lisp_Object font_entity);
 548
 549   /* Open a font specified by FONT_ENTITY on frame F.  If the font is
 550      scalable, open it with PIXEL_SIZE.  */
 551   Lisp_Object (*open) (FRAME_PTR f, Lisp_Object font_entity,
 552                        int pixel_size);
 553
 554   /* Close FONT on frame F.  */
 555   void (*close) (FRAME_PTR f, struct font *font);
 556
 557   /* Optional (if FACE->extra is not used).
 558      Prepare FACE for displaying characters by FONT on frame F by
 559      storing some data in FACE->extra.  If successful, return 0.
 560      Otherwise, return -1.  */
 561   int (*prepare_face) (FRAME_PTR f, struct face *face);
 562
 563   /* Optional.
 564      Done FACE for displaying characters by FACE->font on frame F.  */
 565   void (*done_face) (FRAME_PTR f, struct face *face);
 566
 567   /* Optional.
 568      If FONT (FONT-ENTITY or FONT-OBJECT) has a glyph for character C
 569      (Unicode code point), return 1.  If not, return 0.  If FONT is
 570      FONT-ENTITY and it must be opened to check it, return -1.  */
 571   int (*has_char) (Lisp_Object font, int c);
 572
 573   /* Return a glyph code of FONT for character C (Unicode code point).
 574      If FONT doesn't have such a glyph, return FONT_INVALID_CODE.  */
 575   unsigned (*encode_char) (struct font *font, int c);
 576
 577   /* Compute the total metrics of the NGLYPHS glyphs specified by
 578      the font FONT and the sequence of glyph codes CODE, and store the
 579      result in METRICS.  */
 580   int (*text_extents) (struct font *font,
 581                        unsigned *code, int nglyphs,
 582                        struct font_metrics *metrics);
 583
 584   /* Optional.
 585      Draw glyphs between FROM and TO of S->char2b at (X Y) pixel
 586      position of frame F with S->FACE and S->GC.  If WITH_BACKGROUND,
 587      fill the background in advance.  It is assured that WITH_BACKGROUND
 588      is false when (FROM > 0 || TO < S->nchars).  */
 589   int (*draw) (struct glyph_string *s, int from, int to,
 590                int x, int y, bool with_background);
 591
 592   /* Optional.
 593      Store bitmap data for glyph-code CODE of FONT in BITMAP.  It is
 594      intended that this method is called from the other font-driver
 595      for actual drawing.  */
 596   int (*get_bitmap) (struct font *font, unsigned code,
 597                      struct font_bitmap *bitmap,
 598                      int bits_per_pixel);
 599
 600   /* Optional.
 601      Free bitmap data in BITMAP.  */
 602   void (*free_bitmap) (struct font *font, struct font_bitmap *bitmap);
 603
 604   /* Optional.
 605      Return an outline data for glyph-code CODE of FONT.  The format
 606      of the outline data depends on the font-driver.  */
 607   void *(*get_outline) (struct font *font, unsigned code);
 608
 609   /* Optional.
 610      Free OUTLINE (that is obtained by the above method).  */
 611   void (*free_outline) (struct font *font, void *outline);
 612
 613   /* Optional.
 614      Get coordinates of the INDEXth anchor point of the glyph whose
 615      code is CODE.  Store the coordinates in *X and *Y.  Return 0 if
 616      the operations was successful.  Otherwise return -1.  */
 617   int (*anchor_point) (struct font *font, unsigned code, int index,
 618                        int *x, int *y);
 619
 620   /* Optional.
 621      Return a list describing which scripts/languages FONT
 622      supports by which GSUB/GPOS features of OpenType tables.  */
 623   Lisp_Object (*otf_capability) (struct font *font);
 624
 625   /* Optional.
 626      Apply FONT's OTF-FEATURES to the glyph string.
 627
 628      FEATURES specifies which OTF features to apply in this format:
 629         (SCRIPT LANGSYS GSUB-FEATURE GPOS-FEATURE)
 630      See the documentation of `font-drive-otf' for the details.
 631
 632      This method applies the specified features to the codes in the
 633      elements of GSTRING-IN (between FROMth and TOth).  The output
 634      codes are stored in GSTRING-OUT at the IDXth element and the
 635      following elements.
 636
 637      Return the number of output codes.  If none of the features are
 638      applicable to the input data, return 0.  If GSTRING-OUT is too
 639      short, return -1.  */
 640   int (*otf_drive) (struct font *font, Lisp_Object features,
 641                     Lisp_Object gstring_in, int from, int to,
 642                     Lisp_Object gstring_out, int idx, bool alternate_subst);
 643
 644   /* Optional.
 645      Make the font driver ready for frame F.  Usually this function
 646      makes some data specific to F and stores it in F by calling
 647      font_put_frame_data ().  */
 648   int (*start_for_frame) (FRAME_PTR f);
 649
 650   /* Optional.
 651      End using the driver for frame F.  Usually this function free
 652      some data stored for F.  */
 653   int (*end_for_frame) (FRAME_PTR f);
 654
 655   /* Optional.
 656
 657      Shape text in GSTRING.  See the docstring of
 658      `composition-get-gstring' for the format of GSTRING.  If the
 659      (N+1)th element of GSTRING is nil, input of shaping is from the
 660      1st to (N)th elements.  In each input glyph, FROM, TO, CHAR, and
 661      CODE are already set.
 662
 663      This function updates all fields of the input glyphs.  If the
 664      output glyphs (M) are more than the input glyphs (N), (N+1)th
 665      through (M)th elements of GSTRING are updated possibly by making
 666      a new glyph object and storing it in GSTRING.  If (M) is greater
 667      than the length of GSTRING, nil should be return.  In that case,
 668      this function is called again with the larger GSTRING.  */
 669   Lisp_Object (*shape) (Lisp_Object lgstring);
 670
 671   /* Optional.
 672
 673      If FONT is usable on frame F, return 0.  Otherwise return -1.
 674      This method is used only for debugging.  If this method is NULL,
 675      Emacs assumes that the font is usable on any frame.  */
 676   int (*check) (FRAME_PTR F, struct font *font);
 677
 678   /* Optional.
 679
 680      Return the number of variation glyphs of character C supported by
 681      FONT.  VARIATIONS is an array of 256 elements.  If the variation
 682      selector N (1..256) defines a glyph, that glyph code is stored in
 683      the (N-1)th element of VARIATIONS.  */
 684   int (*get_variation_glyphs) (struct font *font,
 685                                int c, unsigned variations[256]);
 686
 687   void (*filter_properties) (Lisp_Object font, Lisp_Object properties);
 688
 689   /* Optional.
 690
 691      Return non-zero if FONT_OBJECT can be used as a (cached) font
 692      for ENTITY on frame F.  */
 693   bool (*cached_font_ok) (struct frame *f,
 694                           Lisp_Object font_object,
 695                           Lisp_Object entity);
 696 };
 697
 698
 699 /* Chain of font drivers.  There's one global font driver list
 700    (font_driver_list in font.c).  In addition, each frame has its own
 701    font driver list at FRAME_PTR->font_driver_list.  */
 702
 703 struct font_driver_list
 704 {
 705   /* True iff this driver is currently used.  It is ignored in the global
 706      font driver list.*/
 707   bool on;
 708   /* Pointer to the font driver.  */
 709   struct font_driver *driver;
 710   /* Pointer to the next element of the chain.  */
 711   struct font_driver_list *next;
 712 };
 713
 714
 715 /* Chain of arbitrary data specific to each font driver.  Each frame
 716    has its own font data list at FRAME_PTR->font_data_list.  */
 717
 718 struct font_data_list
 719 {
 720   /* Pointer to the font driver.  */
 721   struct font_driver *driver;
 722   /* Data specific to the font driver.  */
 723   void *data;
 724   /* Pointer to the next element of the chain.  */
 725   struct font_data_list *next;
 726 };
 727
 728 extern Lisp_Object copy_font_spec (Lisp_Object);
 729 extern Lisp_Object merge_font_spec (Lisp_Object, Lisp_Object);
 730
 731 extern Lisp_Object font_make_entity (void);
 732 extern Lisp_Object font_make_object (int, Lisp_Object, int);
 733
 734 extern Lisp_Object find_font_encoding (Lisp_Object);
 735 extern int font_registry_charsets (Lisp_Object, struct charset **,
 736                                    struct charset **);
 737 extern int font_style_to_value (enum font_property_index prop,
 738                                 Lisp_Object name, bool noerror);
 739 extern Lisp_Object font_style_symbolic (Lisp_Object font,
 740                                         enum font_property_index prop,
 741                                         bool for_face);
 742
 743 extern bool font_match_p (Lisp_Object spec, Lisp_Object font);
 744 extern Lisp_Object font_list_entities (Lisp_Object frame,
 745                                        Lisp_Object spec);
 746
 747 extern Lisp_Object font_get_name (Lisp_Object font_object);
 748 extern Lisp_Object font_spec_from_name (Lisp_Object font_name);
 749 extern Lisp_Object font_get_frame (Lisp_Object font_object);
 750 extern int font_has_char (FRAME_PTR, Lisp_Object, int);
 751
 752 extern void font_clear_prop (Lisp_Object *attrs,
 753                              enum font_property_index prop);
 754 extern Lisp_Object font_find_for_lface (FRAME_PTR f, Lisp_Object *lface,
 755                                         Lisp_Object spec, int c);
 756 extern Lisp_Object font_open_for_lface (FRAME_PTR f, Lisp_Object entity,
 757                                         Lisp_Object *lface,
 758                                         Lisp_Object spec);
 759 extern Lisp_Object font_load_for_lface (FRAME_PTR f, Lisp_Object *lface,
 760                                         Lisp_Object spec);
 761 extern void font_prepare_for_face (FRAME_PTR f, struct face *face);
 762 extern void font_done_for_face (FRAME_PTR f, struct face *face);
 763
 764 extern Lisp_Object font_open_by_spec (FRAME_PTR f, Lisp_Object spec);
 765 extern Lisp_Object font_open_by_name (FRAME_PTR f, Lisp_Object name);
 766
 767 extern Lisp_Object font_intern_prop (const char *str, ptrdiff_t len,
 768                                      bool force_symbol);
 769 extern void font_update_sort_order (int *order);
 770
 771 extern void font_parse_family_registry (Lisp_Object family,
 772                                         Lisp_Object registry,
 773                                         Lisp_Object spec);
 774
 775 extern int font_parse_xlfd (char *name, ptrdiff_t len, Lisp_Object font);
 776 extern ptrdiff_t font_unparse_xlfd (Lisp_Object font, int pixel_size,
 777                                     char *name, int bytes);
 778 extern int font_unparse_fcname (Lisp_Object font, int pixel_size,
 779                                 char *name, int bytes);
 780 extern void register_font_driver (struct font_driver *driver, FRAME_PTR f);
 781 extern void free_font_driver_list (FRAME_PTR f);
 782 extern Lisp_Object font_update_drivers (FRAME_PTR f, Lisp_Object list);
 783 extern Lisp_Object font_range (ptrdiff_t, ptrdiff_t *,
 784                                struct window *, struct face *,
 785                                Lisp_Object);
 786 extern void font_fill_lglyph_metrics (Lisp_Object, Lisp_Object);
 787
 788 extern Lisp_Object font_put_extra (Lisp_Object font, Lisp_Object prop,
 789                                    Lisp_Object val);
 790
 791 extern int font_put_frame_data (FRAME_PTR f,
 792                                 struct font_driver *driver,
 793                                 void *data);
 794 extern void *font_get_frame_data (FRAME_PTR f,
 795                                   struct font_driver *driver);
 796
 797 extern void font_filter_properties (Lisp_Object font,
 798                                     Lisp_Object alist,
 799                                     const char *const boolean_properties[],
 800                                     const char *const non_boolean_properties[]);
 801
 802 #ifdef HAVE_FREETYPE
 803 extern struct font_driver ftfont_driver;
 804 extern void syms_of_ftfont (void);
 805 #endif  /* HAVE_FREETYPE */
 806 #ifdef HAVE_X_WINDOWS
 807 extern struct font_driver xfont_driver;
 808 extern void syms_of_xfont (void);
 809 extern void syms_of_ftxfont (void);
 810 #ifdef HAVE_XFT
 811 extern Lisp_Object Qxft;
 812 extern struct font_driver xftfont_driver;
 813 extern void syms_of_xftfont (void);
 814 #elif defined HAVE_FREETYPE
 815 extern struct font_driver ftxfont_driver;
 816 #endif
 817 #ifdef HAVE_BDFFONT
 818 extern void syms_of_bdffont (void);
 819 #endif  /* HAVE_BDFFONT */
 820 #endif  /* HAVE_X_WINDOWS */
 821 #ifdef WINDOWSNT
 822 extern struct font_driver w32font_driver;
 823 extern struct font_driver uniscribe_font_driver;
 824 extern void syms_of_w32font (void);
 825 #endif  /* WINDOWSNT */
 826 #ifdef HAVE_NS
 827 extern Lisp_Object Qfontsize;
 828 extern struct font_driver nsfont_driver;
 829 extern void syms_of_nsfont (void);
 830 #endif  /* HAVE_NS */
 831
 832 #ifndef FONT_DEBUG
 833 #define FONT_DEBUG
 834 #endif
 835
 836 extern Lisp_Object QCfoundry;
 837
 838 extern void font_add_log (const char *, Lisp_Object, Lisp_Object);
 839 extern void font_deferred_log (const char *, Lisp_Object, Lisp_Object);
 840
 841 #define FONT_ADD_LOG(ACTION, ARG, RESULT)       \
 842   do {                                          \
 843     if (! EQ (Vfont_log, Qt))                   \
 844       font_add_log ((ACTION), (ARG), (RESULT)); \
 845   } while (0)
 846
 847 #define FONT_DEFERRED_LOG(ACTION, ARG, RESULT)          \
 848   do {                                                  \
 849     if (! EQ (Vfont_log, Qt))                           \
 850       font_deferred_log ((ACTION), (ARG), (RESULT));    \
 851   } while (0)
 852
 853 #endif  /* not EMACS_FONT_H */