src/font.h

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