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