src/font.h

   1 /* font.h -- Interface definition for font handling.
   2    Copyright (C) 2006, 2007, 2008 Free Software Foundation, Inc.
   3    Copyright (C) 2006, 2007, 2008
   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
  62 /* An enumerator for each font property.  This is used as an index to
  63    the vector of FONT-SPEC and FONT-ENTITY.
  64
  65    Note: The order is important and should not be changed.  */
  66
  67 enum font_property_index
  68   {
  69     /* FONT-TYPE is a symbol indicating a font backend; currently `x',
  70        `xft', `ftx' are available on X and gdi on Windows.
  71        For Windows, `bdf' and `uniscribe' backends are in progress.
  72        For Mac OS X, we need `atm'.  */
  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 an extra infomation to
 156        identify 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).  */
 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 Qiso8859_1, Qiso10646_1, Qunicode_bmp, Qunicode_sip;
 241
 242 /* Structure for a font-spec.  */
 243
 244 struct font_spec
 245 {
 246   EMACS_UINT size;
 247   struct Lisp_Vector *next;
 248   Lisp_Object props[FONT_SPEC_MAX];
 249 };
 250
 251 /* Structure for a font-entity.  */
 252
 253 struct font_entity
 254 {
 255   EMACS_UINT size;
 256   struct Lisp_Vector *next;
 257   Lisp_Object props[FONT_ENTITY_MAX];
 258 };
 259
 260 /* A value which may appear in the member `encoding' of struct font
 261    indicating that a font itself doesn't tell which encoding to be
 262    used.  */
 263 #define FONT_ENCODING_NOT_DECIDED 255
 264
 265 /* Structure for a font-object.  */
 266
 267 struct font
 268 {
 269   EMACS_UINT size;
 270   struct Lisp_Vector *next;
 271
 272   /* All Lisp_Object components must come first.
 273      That ensures they are all aligned normally.  */
 274
 275   Lisp_Object props[FONT_OBJECT_MAX];
 276
 277   /* Beyond here, there should be no more Lisp_Object components.  */
 278
 279   /* Maximum bound width over all existing characters of the font.  On
 280      X window, this is same as (font->max_bounds.width).  */
 281   int max_width;
 282
 283   /* By which pixel size the font is opened.  */
 284   int pixel_size;
 285
 286   /* Height of the font.  On X window, this is the same as
 287      (font->ascent + font->descent).  */
 288   int height;
 289
 290   /* Width of the space glyph of the font.  If the font doesn't have a
 291      SPACE glyph, the value is 0.  */
 292   int space_width;
 293
 294   /* Average width of glyphs in the font.  If the font itself doesn't
 295      have that information but has glyphs of ASCII character, the
 296      value is the average with of those glyphs.  Otherwise, the value
 297      is 0.  */
 298   int average_width;
 299
 300   /* Minimum glyph width (in pixels).  */
 301   int min_width;
 302
 303   /* Ascent and descent of the font (in pixels).  */
 304   int ascent, descent;
 305
 306   /* Vertical pixel width of the underline.  If is zero if that
 307      information is not in the font.  */
 308   int underline_thickness;
 309
 310   /* Vertical pixel position (relative to the baseline) of the
 311      underline.  If it is positive, it is below the baseline.  It is
 312      negative if that information is not in the font.  */
 313   int underline_position;
 314
 315   /* 1 if `vertical-centering-font-regexp' matches this font name.
 316      In this case, we render characters at vartical center positions
 317      of lines.  */
 318   int vertical_centering;
 319
 320   /* Encoding type of the font.  The value is one of
 321      0, 1, 2, or 3:
 322         0: code points 0x20..0x7F or 0x2020..0x7F7F are used
 323         1: code points 0xA0..0xFF or 0xA0A0..0xFFFF are used
 324         2: code points 0x20A0..0x7FFF are used
 325         3: code points 0xA020..0xFF7F are used
 326      If the member `font_encoder' is not NULL, this member is ignored.  */
 327   unsigned char encoding_type;
 328
 329   /* The baseline position of a font is normally `ascent' value of the
 330      font.  However, there exists many fonts which don't set `ascent'
 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 users 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 bits
 343      higher we should draw a character of the font than normal ASCII
 344      text for a better looking.
 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 doesn'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 beneath 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 will be more to this structure, but they are private to a
 394      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 *) XPNTR (p))
 465 #define XFONT_ENTITY(p) \
 466   (eassert (FONT_ENTITY_P(p)), (struct font_entity *) XPNTR (p))
 467 #define XFONT_OBJECT(p) \
 468   (eassert (FONT_OBJECT_P(p)), (struct font *) XPNTR (p))
 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 (double) corresponding to POINT size (integer)
 479    on resolution DPI.  */
 480 #define PIXEL_TO_POINT(PIXEL, DPI) ((PIXEL) * PT_PER_INCH / (DPI) + 0.5)
 481
 482 /* Ignore the difference of font pixel sizes less than or equal to
 483    this value.  */
 484 #define FONT_PIXEL_SIZE_QUANTUM 1
 485
 486 struct face;
 487 struct composition;
 488
 489 /* Macros for lispy glyph-string.  */
 490 enum lgstring_indices
 491   {
 492     LGSTRING_IX_FONT, LGSTRING_IX_WIDTH,
 493     LGSTRING_IX_LBEARING, LGSTRING_IX_RBEARING,
 494     LGSTRING_IX_ASCENT, LGSTRING_IX_DESCENT
 495   };
 496 #define LGSTRING_SLOT(lgs, ix) AREF (AREF ((lgs), 0), ix)
 497 #define LGSTRING_FONT(lgs) LGSTRING_SLOT (lgs, LGSTRING_IX_FONT)
 498 #define LGSTRING_WIDTH(lgs) XINT (LGSTRING_SLOT (lgs, LGSTRING_IX_WIDTH))
 499 #define LGSTRING_LBEARING(lgs) XINT (LGSTRING_SLOT (lgs, LGSTRING_IX_LBEARING))
 500 #define LGSTRING_RBEARING(lgs) XINT (LGSTRING_SLOT (lgs, LGSTRING_IX_RBEARING))
 501 #define LGSTRING_ASCENT(lgs) XINT (LGSTRING_SLOT (lgs, LGSTRING_IX_ASCENT))
 502 #define LGSTRING_DESCENT(lgs) XINT (LGSTRING_SLOT (lgs, LGSTRING_IX_DESCENT))
 503 #define LGSTRING_SET_SLOT(lgs, ix, val) ASET (AREF ((lgs), 0), ix, (val))
 504 #define LGSTRING_SET_FONT(lgs, val)     \
 505   LGSTRING_SET_SLOT(lgs, LGSTRING_IX_FONT, (val))
 506 #define LGSTRING_SET_WIDTH(lgs, val)    \
 507   LGSTRING_SET_SLOT(lgs, LGSTRING_IX_WIDTH, make_number (val))
 508 #define LGSTRING_SET_LBEARING(lgs, val) \
 509   LGSTRING_SET_SLOT(lgs, LGSTRING_IX_LBEARING, make_number (val))
 510 #define LGSTRING_SET_RBEARING(lgs, val) \
 511   LGSTRING_SET_SLOT(lgs, LGSTRING_IX_RBEARING, make_number (val))
 512 #define LGSTRING_SET_ASCENT(lgs, val)   \
 513   LGSTRING_SET_SLOT(lgs, LGSTRING_IX_ASCENT, make_number (val))
 514 #define LGSTRING_SET_DESCENT(lgs, val)  \
 515   LGSTRING_SET_SLOT(lgs, LGSTRING_IX_DESCENT, make_number (val))
 516
 517 #define LGSTRING_LENGTH(lgs) (ASIZE ((lgs)) - 1)
 518 #define LGSTRING_GLYPH(lgs, idx) AREF ((lgs), (idx) + 1)
 519 #define LGSTRING_SET_GLYPH(lgs, idx, val) ASET ((lgs), (idx) + 1, (val))
 520
 521 /* Vector size of Lispy glyph.  */
 522 enum lglyph_indices
 523   {
 524     LGLYPH_IX_FROM, LGLYPH_IX_TO,  LGLYPH_IX_CHAR, LGLYPH_IX_CODE,
 525     LGLYPH_IX_WIDTH, LGLYPH_IX_LBEARING, LGLYPH_IX_RBEARING,
 526     LGLYPH_IX_ASCENT, LGLYPH_IX_DESCENT, LGLYPH_IX_ADJUSTMENT,
 527     /* Not an index.  */
 528     LGLYPH_SIZE
 529   };
 530 #define LGLYPH_FROM(g) XINT (AREF ((g), LGLYPH_IX_FROM))
 531 #define LGLYPH_TO(g) XINT (AREF ((g), LGLYPH_IX_TO))
 532 #define LGLYPH_CHAR(g) XINT (AREF ((g), LGLYPH_IX_CHAR))
 533 #define LGLYPH_CODE(g) XUINT (AREF ((g), LGLYPH_IX_CODE))
 534 #define LGLYPH_WIDTH(g) XINT (AREF ((g), LGLYPH_IX_WIDTH))
 535 #define LGLYPH_LBEARING(g) XINT (AREF ((g), LGLYPH_IX_LBEARING))
 536 #define LGLYPH_RBEARING(g) XINT (AREF ((g), LGLYPH_IX_RBEARING))
 537 #define LGLYPH_ASCENT(g) XINT (AREF ((g), LGLYPH_IX_ASCENT))
 538 #define LGLYPH_DESCENT(g) XINT (AREF ((g), LGLYPH_IX_DESCENT))
 539 #define LGLYPH_ADJUSTMENT(g) AREF ((g), LGLYPH_IX_ADJUSTMENT)
 540 #define LGLYPH_SET_FROM(g, val) ASET ((g), LGLYPH_IX_FROM, make_number (val))
 541 #define LGLYPH_SET_TO(g, val) ASET ((g), LGLYPH_IX_TO, make_number (val))
 542 #define LGLYPH_SET_CHAR(g, val) ASET ((g), LGLYPH_IX_CHAR, make_number (val))
 543 /* FIXME: we should use make_uint_number here.  */
 544 #define LGLYPH_SET_CODE(g, val) ASET ((g), LGLYPH_IX_CODE, make_number (val))
 545 #define LGLYPH_SET_WIDTH(g, val) ASET ((g), LGLYPH_IX_WIDTH, make_number (val))
 546 #define LGLYPH_SET_LBEARING(g, val) ASET ((g), LGLYPH_IX_RBEARING, make_number (val))
 547 #define LGLYPH_SET_RBEARING(g, val) ASET ((g), LGLYPH_IX_LBEARING, make_number (val))
 548 #define LGLYPH_SET_ASCENT(g, val) ASET ((g), LGLYPH_IX_ASCENT, make_number (val))
 549 #define LGLYPH_SET_DESCENT(g, val) ASET ((g), LGLYPH_IX_DESCENT, make_number (val))
 550 #define LGLYPH_SET_ADJUSTMENT(g, val) ASET ((g), LGLYPH_IX_ADJUSTMENT, (val))
 551
 552 #define LGLYPH_XOFF(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
 553                         ? XINT (AREF (LGLYPH_ADJUSTMENT (g), 0)) : 0)
 554 #define LGLYPH_YOFF(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
 555                         ? XINT (AREF (LGLYPH_ADJUSTMENT (g), 1)) : 0)
 556 #define LGLYPH_WADJUST(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
 557                            ? XINT (AREF (LGLYPH_ADJUSTMENT (g), 2)) : 0)
 558
 559 #define FONT_INVALID_CODE 0xFFFFFFFF
 560
 561 /* Font driver.  Members specified as "optional" can be NULL.  */
 562
 563 struct font_driver
 564 {
 565   /* Symbol indicating the type of the font-driver.  */
 566   Lisp_Object type;
 567
 568   /* 1 iff the font's foundary, family, and adstyle names are case
 569      sensitve.  */
 570   int case_sensitive;
 571
 572   /* Return a cache of font-entities on frame F.  The cache must be a
 573      cons whose cdr part is the actual cache area.  */
 574   Lisp_Object (*get_cache) P_ ((FRAME_PTR F));
 575
 576   /* List fonts exactly matching with FONT_SPEC on FRAME.  The value
 577      is a list of font-entities.  It is assured that the properties
 578      WEIGHT to AVGWIDTH are all nil (i.e. not specified) in FONT_SPEC.
 579      This and the following `match' are the only APIs that allocate
 580      font-entities.  */
 581   Lisp_Object (*list) P_ ((Lisp_Object frame, Lisp_Object font_spec));
 582
 583   /* Return a font entity most closely maching with FONT_SPEC on
 584      FRAME.  The closeness is detemined by the font backend, thus
 585      `face-font-selection-order' is ignored here.  */
 586   Lisp_Object (*match) P_ ((Lisp_Object frame, Lisp_Object font_spec));
 587
 588   /* Optional.
 589      List available families.  The value is a list of family names
 590      (symbols).  */
 591   Lisp_Object (*list_family) P_ ((Lisp_Object frame));
 592
 593   /* Optional (if FONT_EXTRA_INDEX is not Lisp_Save_Value).
 594      Free FONT_EXTRA_INDEX field of FONT_ENTITY.  */
 595   void (*free_entity) P_ ((Lisp_Object font_entity));
 596
 597   /* Open a font specified by FONT_ENTITY on frame F.  If the font is
 598      scalable, open it with PIXEL_SIZE.  */
 599   Lisp_Object (*open) P_ ((FRAME_PTR f, Lisp_Object font_entity,
 600                            int pixel_size));
 601
 602   /* Close FONT on frame F.  */
 603   void (*close) P_ ((FRAME_PTR f, struct font *font));
 604
 605   /* Optional (if FACE->extra is not used).
 606      Prepare FACE for displaying characters by FONT on frame F by
 607      storing some data in FACE->extra.  If successful, return 0.
 608      Otherwise, return -1.  */
 609   int (*prepare_face) P_ ((FRAME_PTR f, struct face *face));
 610
 611   /* Optional.
 612      Done FACE for displaying characters by FACE->font on frame F.  */
 613   void (*done_face) P_ ((FRAME_PTR f, struct face *face));
 614
 615   /* Optional.
 616      If FONT_ENTITY has a glyph for character C (Unicode code point),
 617      return 1.  If not, return 0.  If a font must be opened to check
 618      it, return -1.  */
 619   int (*has_char) P_ ((Lisp_Object entity, int c));
 620
 621   /* Return a glyph code of FONT for characer C (Unicode code point).
 622      If FONT doesn't have such a glyph, return FONT_INVALID_CODE.  */
 623   unsigned (*encode_char) P_ ((struct font *font, int c));
 624
 625   /* Computate the total metrics of the NGLYPHS glyphs specified by
 626      the font FONT and the sequence of glyph codes CODE, and store the
 627      result in METRICS.  */
 628   int (*text_extents) P_ ((struct font *font,
 629                            unsigned *code, int nglyphs,
 630                            struct font_metrics *metrics));
 631
 632   /* Optional.
 633      Draw glyphs between FROM and TO of S->char2b at (X Y) pixel
 634      position of frame F with S->FACE and S->GC.  If WITH_BACKGROUND
 635      is nonzero, fill the background in advance.  It is assured that
 636      WITH_BACKGROUND is zero when (FROM > 0 || TO < S->nchars).  */
 637   int (*draw) P_ ((struct glyph_string *s, int from, int to,
 638                    int x, int y, int with_background));
 639
 640   /* Optional.
 641      Store bitmap data for glyph-code CODE of FONT in BITMAP.  It is
 642      intended that this method is callled from the other font-driver
 643      for actual drawing.  */
 644   int (*get_bitmap) P_ ((struct font *font, unsigned code,
 645                          struct font_bitmap *bitmap,
 646                          int bits_per_pixel));
 647
 648   /* Optional.
 649      Free bitmap data in BITMAP.  */
 650   void (*free_bitmap) P_ ((struct font *font, struct font_bitmap *bitmap));
 651
 652   /* Optional.
 653      Return an outline data for glyph-code CODE of FONT.  The format
 654      of the outline data depends on the font-driver.  */
 655   void *(*get_outline) P_ ((struct font *font, unsigned code));
 656
 657   /* Optional.
 658      Free OUTLINE (that is obtained by the above method).  */
 659   void (*free_outline) P_ ((struct font *font, void *outline));
 660
 661   /* Optional.
 662      Get coordinates of the INDEXth anchor point of the glyph whose
 663      code is CODE.  Store the coordinates in *X and *Y.  Return 0 if
 664      the operations was successfull.  Otherwise return -1.  */
 665   int (*anchor_point) P_ ((struct font *font, unsigned code, int index,
 666                            int *x, int *y));
 667
 668   /* Optional.
 669      Return a list describing which scripts/languages FONT
 670      supports by which GSUB/GPOS features of OpenType tables.  */
 671   Lisp_Object (*otf_capability) P_ ((struct font *font));
 672
 673   /* Optional.
 674      Apply FONT's OTF-FEATURES to the glyph string.
 675
 676      FEATURES specifies which OTF features to apply in this format:
 677         (SCRIPT LANGSYS GSUB-FEATURE GPOS-FEATURE)
 678      See the documentation of `font-drive-otf' for the detail.
 679
 680      This method applies the specified features to the codes in the
 681      elements of GSTRING-IN (between FROMth and TOth).  The output
 682      codes are stored in GSTRING-OUT at the IDXth element and the
 683      following elements.
 684
 685      Return the number of output codes.  If none of the features are
 686      applicable to the input data, return 0.  If GSTRING-OUT is too
 687      short, return -1.  */
 688   int (*otf_drive) P_ ((struct font *font, Lisp_Object features,
 689                        Lisp_Object gstring_in, int from, int to,
 690                        Lisp_Object gstring_out, int idx, int alternate_subst));
 691
 692   /* Optional.
 693      Make the font driver ready for frame F.  Usually this function
 694      makes some data specific to F and store it in F by calling
 695      font_put_frame_data ().  */
 696   int (*start_for_frame) P_ ((FRAME_PTR f));
 697
 698   /* Optional.
 699      End using the driver for frame F.  Usually this function free
 700      some data stored for F.  */
 701   int (*end_for_frame) P_ ((FRAME_PTR f));
 702
 703   /* Optional.
 704
 705      Shape text in LGSTRING.  See the docstring of `font-make-gstring'
 706      for the format of LGSTRING.  If the (N+1)th element of LGSTRING
 707      is nil, input of shaping is from the 1st to (N)th elements.  In
 708      each input glyph, FROM, TO, CHAR, and CODE are already set.
 709
 710      This function updates all fields of the input glyphs.  If the
 711      output glyphs (M) are more than the input glyphs (N), (N+1)th
 712      through (M)th elements of LGSTRING are updated possibly by making
 713      a new glyph object and storing it in LGSTRING.  If (M) is greater
 714      than the length of LGSTRING, nil should be return.  In that case,
 715      this function is called again with the larger LGSTRING.  */
 716   Lisp_Object (*shape) P_ ((Lisp_Object lgstring));
 717
 718   /* Optional.
 719
 720      If FONT is usable on frame F, return 0.  Otherwise return -1.
 721    */
 722   int (*check) P_ ((FRAME_PTR F, struct font *font));
 723 };
 724
 725
 726 /* Chain of font drivers.  There's one global font driver list
 727    (font_driver_list in font.c).  In addition, each frame has it's own
 728    font driver list at FRAME_PTR->font_driver_list.  */
 729
 730 struct font_driver_list
 731 {
 732   /* 1 iff this driver is currently used.  It is igonred in the global
 733      font driver list.*/
 734   int on;
 735   /* Pointer to the font driver.  */
 736   struct font_driver *driver;
 737   /* Pointer to the next element of the chain.  */
 738   struct font_driver_list *next;
 739 };
 740
 741
 742 /* Chain of arbitrary data specific to each font driver.  Each frame
 743    has it's own font data list at FRAME_PTR->font_data_list.  */
 744
 745 struct font_data_list
 746 {
 747   /* Pointer to the font driver.  */
 748   struct font_driver *driver;
 749   /* Data specific to the font driver.  */
 750   void *data;
 751   /* Pointer to the next element of the chain.  */
 752   struct font_data_list *next;
 753 };
 754
 755 EXFUN (Ffont_spec, MANY);
 756 EXFUN (Fcopy_font_spec, 1);
 757 EXFUN (Fmerge_font_spec, 2);
 758 EXFUN (Ffont_get, 2);
 759 EXFUN (Ffont_put, 3);
 760 EXFUN (Flist_fonts, 4);
 761 EXFUN (Ffont_family_list, 1);
 762 EXFUN (Fclear_font_cache, 0);
 763 EXFUN (Ffont_xlfd_name, 1);
 764
 765 extern Lisp_Object font_make_spec P_ ((void));
 766 extern Lisp_Object font_make_entity P_ ((void));
 767 extern Lisp_Object font_make_object P_ ((int));
 768
 769 extern int font_registry_charsets P_ ((Lisp_Object, struct charset **,
 770                                        struct charset **));
 771 extern int font_style_to_value P_ ((enum font_property_index prop,
 772                                     Lisp_Object name, int noerror));
 773 extern Lisp_Object font_style_symbolic P_ ((Lisp_Object font,
 774                                             enum font_property_index prop,
 775                                             int for_face));
 776
 777 extern int font_match_p P_ ((Lisp_Object spec, Lisp_Object entity));
 778 extern Lisp_Object font_list_entities P_ ((Lisp_Object frame,
 779                                            Lisp_Object spec));
 780
 781 extern Lisp_Object font_get_name P_ ((Lisp_Object font_object));
 782 extern Lisp_Object font_spec_from_name P_ ((Lisp_Object font_name));
 783 extern Lisp_Object font_get_frame P_ ((Lisp_Object font_object));
 784 extern int font_has_char P_ ((FRAME_PTR, Lisp_Object, int));
 785 extern unsigned font_encode_char P_ ((Lisp_Object, int));
 786
 787 extern void font_clear_prop P_ ((Lisp_Object *attrs,
 788                                  enum font_property_index prop));
 789 extern void font_update_lface P_ ((FRAME_PTR f, Lisp_Object *attrs));
 790 extern Lisp_Object font_find_for_lface P_ ((FRAME_PTR f, Lisp_Object *lface,
 791                                             Lisp_Object spec, int c));
 792 extern Lisp_Object font_open_for_lface P_ ((FRAME_PTR f, Lisp_Object entity,
 793                                             Lisp_Object *lface,
 794                                             Lisp_Object spec));
 795 extern Lisp_Object font_load_for_lface P_ ((FRAME_PTR f, Lisp_Object *lface,
 796                                             Lisp_Object spec));
 797 extern void font_prepare_for_face P_ ((FRAME_PTR f, struct face *face));
 798 extern void font_done_for_face P_ ((FRAME_PTR f, struct face *face));
 799
 800 extern Lisp_Object font_open_by_name P_ ((FRAME_PTR f, char *name));
 801 extern void font_close_object (FRAME_PTR f, Lisp_Object font_object);
 802
 803 extern Lisp_Object font_intern_prop P_ ((char *str, int len));
 804 extern void font_update_sort_order P_ ((int *order));
 805
 806 extern void font_parse_family_registry P_ ((Lisp_Object family,
 807                                             Lisp_Object registry,
 808                                             Lisp_Object spec));
 809 extern Lisp_Object font_spec_from_family_registry P_ ((Lisp_Object family,
 810                                                        Lisp_Object registry));
 811
 812 extern int font_parse_xlfd P_ ((char *name, Lisp_Object font));
 813 extern int font_unparse_xlfd P_ ((Lisp_Object font, int pixel_size,
 814                                   char *name, int bytes));
 815 extern int font_parse_fcname P_ ((char *name, Lisp_Object font));
 816 extern int font_unparse_fcname P_ ((Lisp_Object font, int pixel_size,
 817                                   char *name, int bytes));
 818 extern void register_font_driver P_ ((struct font_driver *driver, FRAME_PTR f));
 819 extern void free_font_driver_list P_ ((FRAME_PTR f));
 820 extern Lisp_Object font_update_drivers P_ ((FRAME_PTR f, Lisp_Object list));
 821 extern Lisp_Object font_at P_ ((int c, EMACS_INT pos, struct face *face,
 822                                 struct window *w, Lisp_Object object));
 823 extern EMACS_INT font_range P_ ((EMACS_INT pos, EMACS_INT limit,
 824                                  struct face *face, FRAME_PTR f,
 825                                  Lisp_Object object));
 826
 827 extern struct font *font_prepare_composition P_ ((struct composition *cmp,
 828                                                   FRAME_PTR f));
 829
 830 extern Lisp_Object font_put_extra P_ ((Lisp_Object font, Lisp_Object prop,
 831                                        Lisp_Object val));
 832
 833 extern int font_put_frame_data P_ ((FRAME_PTR f,
 834                                     struct font_driver *driver,
 835                                     void *data));
 836 extern void *font_get_frame_data P_ ((FRAME_PTR f,
 837                                       struct font_driver *driver));
 838
 839 #ifdef HAVE_FREETYPE
 840 extern struct font_driver ftfont_driver;
 841 #endif  /* HAVE_FREETYPE */
 842 #ifdef HAVE_X_WINDOWS
 843 extern struct font_driver xfont_driver;
 844 extern struct font_driver ftxfont_driver;
 845 #ifdef HAVE_XFT
 846 extern struct font_driver xftfont_driver;
 847 #endif  /* HAVE_XFT */
 848 #endif  /* HAVE_X_WINDOWS */
 849 #ifdef WINDOWSNT
 850 extern struct font_driver w32font_driver;
 851 extern struct font_driver uniscribe_font_driver;
 852 #endif  /* WINDOWSNT */
 853 #ifdef MAC_OS
 854 extern struct font_driver atmfont_driver;
 855 #endif  /* MAC_OS */
 856
 857 #endif  /* not EMACS_FONT_H */
 858
 859 /* arch-tag: 3b7260c3-5bec-4d6b-a0db-95c1b431b1a2
 860    (do not change this comment) */