code.delx.au - gnu-emacs/blob - src/font.h

   1 /* font.h -- Interface definition for font handling.
   2    Copyright (C) 2006 Free Software Foundation, Inc.
   3    Copyright (C) 2006
   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 2, or (at your option)
  12 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; see the file COPYING.  If not, write to
  21 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22 Boston, MA 02110-1301, USA.  */
  23
  24 #ifndef EMACS_FONT_H
  25 #define EMACS_FONT_H
  26
  27 #include "ccl.h"
  28
  29 /* We have three types of Lisp objects related to font.
  30
  31    FONT-SPEC
  32
  33         Vector (length FONT_SPEC_MAX) of font properties.  Some
  34         properties can be left unspecified (i.e. nil).  Emacs asks
  35         font-drivers to find a font by FONT-SPEC.  A fontset entry
  36         specifies requisite properties whereas a face specifies just
  37         preferable properties.  This object is fully modifiable by
  38         Lisp.
  39
  40    FONT-ENTITY
  41
  42         Vector (length FONT_ENTITY_MAX) of fully specified font
  43         properties that a font-driver returns upon a request of
  44         FONT-SPEC.
  45
  46         Note: Only the method `list' of a font-driver can create this
  47         object, and should never be modified by Lisp.  In that sense,
  48         it may be cleaner to implement it as a Lisp object of a new
  49         type (e.g. struct Lisp_Font).
  50
  51    FONT-OBJECT
  52
  53         Lisp object of type Lisp_Misc_Save_Value encapsulating a
  54         pointer to "struct font".  This corresponds to an opened font.
  55
  56         Note: The note for FONT-ENTITY also applies to this.
  57 */
  58
  59
  60 struct font_driver;
  61 struct font;
  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', `freetype' are available.  For windows, we need
  72        `bdf' and `windows'.  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        charset0encoding 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 value is what defined by FC_WEIGHT_* in
  90        fontconfig. */
  91     FONT_WEIGHT_INDEX,
  92
  93     /* FONT-SLANT is a numeric value of slant (e.g. r, i, o) of the
  94        font.  The value is what defined by FC_SLANT_* in
  95        fontconfig plus 100. */
  96     FONT_SLANT_INDEX,
  97
  98     /* FONT-WIDTH is a numeric value of setwidth (e.g. normal,
  99        condensed) of the font.  The value is what defined by
 100        FC_WIDTH_* in fontconfig. */
 101     FONT_WIDTH_INDEX,
 102
 103     /* FONT-SIZE is a size of the font.  If integer, it is a pixel
 104        size.  For a font-spec, the value can be float specifying a
 105        point size.  For a font-entity, the value can be zero meaning
 106        that the font is scalable.  */
 107     FONT_SIZE_INDEX,
 108
 109     /* In a font-spec, the value is an alist of extra information of a
 110        font such as name, OpenType features, and language coverage.
 111        In a font-entity, the value is an extra infomation for
 112        identifying a font (font-driver dependent).  */
 113     FONT_EXTRA_INDEX,           /* alist                alist */
 114
 115     /* This value is the length of font-spec vector.  */
 116     FONT_SPEC_MAX,
 117
 118     /* The followings are used only for a font-entity.  */
 119
 120     /* Frame on which the font is found.  The value is nil if the font
 121        can be opend on any frame.  */
 122     FONT_FRAME_INDEX = FONT_SPEC_MAX,
 123
 124     /* List of font-objects opened from the font-entity.  */
 125     FONT_OBJLIST_INDEX,
 126
 127     /* This value is the length of font-entity vector.  */
 128     FONT_ENTITY_MAX
 129   };
 130
 131 extern Lisp_Object QCspacing, QCdpi, QCscalable, QCotf, QClanguage, QCscript;
 132
 133 /* Important character set symbols.  */
 134 extern Lisp_Object Qiso8859_1, Qiso10646_1, Qunicode_bmp;
 135
 136 extern Lisp_Object null_string;
 137 extern Lisp_Object null_vector;
 138
 139 /* Structure for an opened font.  We can safely cast this structure to
 140    "struft font_info".  */
 141
 142 struct font
 143 {
 144   struct font_info font;
 145
 146   /* From which font-entity the font is opened.  */
 147   Lisp_Object entity;
 148
 149   /* By which pixel size the font is opened.  */
 150   int pixel_size;
 151
 152   /* Font-driver for the font.  */
 153   struct font_driver *driver;
 154
 155   /* File name of the font, or NULL if the font is not associated with
 156      a file.  */
 157   char *file_name;
 158
 159   /* Charset to encode a character code into a glyph code of the font.
 160      -1 means that the font doesn't require this information to encode
 161      a character.  */
 162   int encoding_charset;
 163
 164   /* Charset to check if a character code is supported by the font.
 165      -1 means that the contents of the font must be looked up to
 166      determine it.  */
 167   int repertory_charset;
 168
 169   /* Minimum glyph width (in pixels).  */
 170   int min_width;
 171
 172   /* Ascent and descent of the font (in pixels).  */
 173   int ascent, descent;
 174
 175   /* 1 iff the font is scalable.  */
 176   int scalable;
 177
 178   /* There will be more to this structure, but they are private to a
 179      font-driver.  */
 180 };
 181
 182 enum font_spacing
 183   {
 184     FONT_SPACING_PROPORTIONAL = 0,
 185     FONT_SPACING_DUAL = 90,
 186     FONT_SPACING_MONO = 100,
 187     FONT_SPACING_CHARCELL = 110
 188   };
 189
 190 struct font_metrics
 191 {
 192   short lbearing, rbearing, width, ascent, descent;
 193 };
 194
 195 struct font_bitmap
 196 {
 197   int rows;
 198   int width;
 199   int pitch;
 200   unsigned char *buffer;
 201   int left;
 202   int top;
 203   int advance;
 204   void *extra;
 205 };
 206
 207 /* Predicates to check various font-related objects.  */
 208
 209 #define FONTP(x)        \
 210   (VECTORP (x) && (ASIZE (x) == FONT_SPEC_MAX || ASIZE (x) == FONT_ENTITY_MAX))
 211 #define FONT_SPEC_P(x)  \
 212   (VECTORP (x) && ASIZE (x) == FONT_SPEC_MAX)
 213 #define FONT_ENTITY_P(x)        \
 214   (VECTORP (x) && ASIZE (x) == FONT_ENTITY_MAX)
 215 #define FONT_OBJECT_P(x)        \
 216   (XTYPE (x) == Lisp_Misc && XMISCTYPE (x) == Lisp_Misc_Save_Value)
 217
 218
 219 /* Check macros for various font-related objects.  */
 220
 221 #define CHECK_FONT(x)   \
 222   do { if (! FONTP (x)) x = wrong_type_argument (Qfont, x); } while (0)
 223 #define CHECK_FONT_SPEC(x)      \
 224   do { if (! FONT_SPEC_P (x)) x = wrong_type_argument (Qfont, x); } while (0)
 225 #define CHECK_FONT_ENTITY(x)    \
 226   do { if (! FONT_ENTITY_P (x)) x = wrong_type_argument (Qfont, x); } while (0)
 227 #define CHECK_FONT_OBJECT(x)    \
 228   do { if (! FONT_OBJECT_P (x)) x = wrong_type_argument (Qfont, x); } while (0)
 229
 230 #define CHECK_FONT_GET_OBJECT(x, font)                                  \
 231   do {                                                                  \
 232     if (! FONT_OBJECT_P (x)) x = wrong_type_argument (Qfont, x);        \
 233     if (! XSAVE_VALUE (x)->pointer) error ("Font already closed");      \
 234     font = XSAVE_VALUE (x)->pointer;                                    \
 235   } while (0)
 236
 237 /* Ignore the difference of font pixel sizes less than or equal to
 238    this value.  */
 239 #define FONT_PIXEL_SIZE_QUANTUM 1
 240
 241 struct face;
 242 struct composition;
 243
 244 /* Macros for lispy glyph-string.  */
 245 #define LGSTRING_FONT(lgs) AREF (AREF ((lgs), 0), 0)
 246 #define LGSTRING_LBEARING(lgs) AREF (AREF ((lgs), 0), 1)
 247 #define LGSTRING_RBEARING(lgs) AREF (AREF ((lgs), 0), 2)
 248 #define LGSTRING_WIDTH(lgs) AREF (AREF ((lgs), 0), 3)
 249 #define LGSTRING_ASCENT(lgs) AREF (AREF ((lgs), 0), 4)
 250 #define LGSTRING_DESCENT(lgs) AREF (AREF ((lgs), 0), 5)
 251 #define LGSTRING_SET_FONT(lgs, val) ASET (AREF ((lgs), 0), 0, (val))
 252 #define LGSTRING_SET_LBEARING(lgs, val) ASET (AREF ((lgs), 0), 1, (val))
 253 #define LGSTRING_SET_RBEARING(lgs, val) ASET (AREF ((lgs), 0), 2, (val))
 254 #define LGSTRING_SET_WIDTH(lgs, val) ASET (AREF ((lgs), 0), 3, (val))
 255 #define LGSTRING_SET_ASCENT(lgs, val) ASET (AREF ((lgs), 0), 4, (val))
 256 #define LGSTRING_SET_DESCENT(lgs, val) ASET (AREF ((lgs), 0), 5, (val))
 257
 258 #define LGSTRING_LENGTH(lgs) (ASIZE ((lgs)) - 1)
 259 #define LGSTRING_GLYPH(lgs, idx) AREF ((lgs), (idx) + 1)
 260
 261 #define LGLYPH_FROM(g) AREF ((g), 0)
 262 #define LGLYPH_TO(g) AREF ((g), 1)
 263 #define LGLYPH_CHAR(g) AREF ((g), 2)
 264 #define LGLYPH_CODE(g) AREF ((g), 3)
 265 #define LGLYPH_WIDTH(g) AREF ((g), 4)
 266 #define LGLYPH_ADJUSTMENT(g) AREF ((g), 5)
 267 #define LGLYPH_SET_FROM(g, val) ASET ((g), 0, (val))
 268 #define LGLYPH_SET_TO(g, val) ASET ((g), 1, (val))
 269 #define LGLYPH_SET_CHAR(g, val) ASET ((g), 2, (val))
 270 #define LGLYPH_SET_CODE(g, val) ASET ((g), 3, (val))
 271 #define LGLYPH_SET_WIDTH(g, val) ASET ((g), 4, (val))
 272 #define LGLYPH_SET_ADJUSTMENT(g, val) ASET ((g), 5, (val))
 273
 274 #define LGLYPH_XOFF(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
 275                         ? XINT (AREF (LGLYPH_ADJUSTMENT (g), 0)) : 0)
 276 #define LGLYPH_YOFF(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
 277                         ? XINT (AREF (LGLYPH_ADJUSTMENT (g), 1)) : 0)
 278 #define LGLYPH_WADJUST(g) (VECTORP (LGLYPH_ADJUSTMENT (g)) \
 279                            ? XINT (AREF (LGLYPH_ADJUSTMENT (g), 2)) : 0)
 280
 281 #define FONT_INVALID_CODE 0xFFFFFFFF
 282
 283 /* Font driver.  Members specified as "optional" can be NULL.  */
 284
 285 struct font_driver
 286 {
 287   /* Symbol indicating the type of the font-driver.  */
 288   Lisp_Object type;
 289
 290   /* Return a cache of font-entities on FRAME.  The cache must be a
 291      cons whose cdr part is the actual cache area.  */
 292   Lisp_Object (*get_cache) P_ ((Lisp_Object frame));
 293
 294   /* List fonts exactly matching with FONT_SPEC on FRAME.  The value
 295      is a vector of font-entities.  This is the sole API that
 296      allocates font-entities.  */
 297   Lisp_Object (*list) P_ ((Lisp_Object frame, Lisp_Object font_spec));
 298
 299   /* Return a font entity most closely maching with FONT_SPEC on
 300      FRAME.  The closeness is detemined by the font backend, thus
 301      `face-font-selection-order' is ignored here.  */
 302   Lisp_Object (*match) P_ ((Lisp_Object frame, Lisp_Object font_spec));
 303
 304   /* Optional.
 305      List available families.  The value is a list of family names
 306      (symbols).  */
 307   Lisp_Object (*list_family) P_ ((Lisp_Object frame));
 308
 309   /* Optional (if FONT_EXTRA_INDEX is not Lisp_Save_Value).
 310      Free FONT_EXTRA_INDEX field of FONT_ENTITY.  */
 311   void (*free_entity) P_ ((Lisp_Object font_entity));
 312
 313   /* Open a font specified by FONT_ENTITY on frame F.  If the font is
 314      scalable, open it with PIXEL_SIZE.  */
 315   struct font *(*open) P_ ((FRAME_PTR f, Lisp_Object font_entity,
 316                             int pixel_size));
 317
 318   /* Close FONT on frame F.  */
 319   void (*close) P_ ((FRAME_PTR f, struct font *font));
 320
 321   /* Optional (if FACE->extra is not used).
 322      Prepare FACE for displaying characters by FONT on frame F by
 323      storing some data in FACE->extra.  If successful, return 0.
 324      Otherwise, return -1.  */
 325   int (*prepare_face) P_ ((FRAME_PTR f, struct face *face));
 326
 327   /* Optional.
 328      Done FACE for displaying characters by FACE->font on frame F.  */
 329   void (*done_face) P_ ((FRAME_PTR f, struct face *face));
 330
 331   /* Optional.
 332      If FONT_ENTITY has a glyph for character C (Unicode code point),
 333      return 1.  If not, return 0.  If a font must be opened to check
 334      it, return -1.  */
 335   int (*has_char) P_ ((Lisp_Object entity, int c));
 336
 337   /* Return a glyph code of FONT for characer C (Unicode code point).
 338      If FONT doesn't have such a glyph, return FONT_INVALID_CODE.  */
 339   unsigned (*encode_char) P_ ((struct font *font, int c));
 340
 341   /* Perform the size computation of glyphs of FONT and fillin members
 342      of METRICS.  The glyphs are specified by their glyph codes in
 343      CODE (length NGLYPHS).  */
 344   int (*text_extents) P_ ((struct font *font,
 345                            unsigned *code, int nglyphs,
 346                            struct font_metrics *metrics));
 347
 348   /* Optional.
 349      Draw glyphs between FROM and TO of S->char2b at (X Y) pixel
 350      position of frame F with S->FACE and S->GC.  If WITH_BACKGROUND
 351      is nonzero, fill the background in advance.  It is assured that
 352      WITH_BACKGROUND is zero when (FROM > 0 || TO < S->nchars).  */
 353   int (*draw) P_ ((struct glyph_string *s, int from, int to,
 354                    int x, int y, int with_background));
 355
 356   /* Optional.
 357      Store bitmap data for glyph-code CODE of FONT in BITMAP.  It is
 358      intended that this method is callled from the other font-driver
 359      for actual drawing.  */
 360   int (*get_bitmap) P_ ((struct font *font, unsigned code,
 361                          struct font_bitmap *bitmap,
 362                          int bits_per_pixel));
 363
 364   /* Optional.
 365      Free bitmap data in BITMAP.  */
 366   void (*free_bitmap) P_ ((struct font *font, struct font_bitmap *bitmap));
 367
 368   /* Optional.
 369      Return an outline data for glyph-code CODE of FONT.  The format
 370      of the outline data depends on the font-driver.  */
 371   void *(*get_outline) P_ ((struct font *font, unsigned code));
 372
 373   /* Optional.
 374      Free OUTLINE (that is obtained by the above method).  */
 375   void (*free_outline) P_ ((struct font *font, void *outline));
 376
 377   /* Optional.
 378      Get coordinates of the INDEXth anchor point of the glyph whose
 379      code is CODE.  Store the coordinates in *X and *Y.  Return 0 if
 380      the operations was successfull.  Otherwise return -1.  */
 381   int (*anchor_point) P_ ((struct font *font, unsigned code, int index,
 382                            int *x, int *y));
 383
 384   /* Optional.
 385      Return a list describing which scripts/languages FONT
 386      supports by which GSUB/GPOS features of OpenType tables.  */
 387   Lisp_Object (*otf_capability) P_ ((struct font *font));
 388
 389   /* Optional.
 390      Drive FONT's OTF GSUB features according to GSUB_SPEC.
 391
 392      GSUB_SPEC is in this format (all elements are symbols):
 393         (SCRIPT LANGSYS GSUB-FEATURE ...)
 394      If one of GSUB-FEATURE is nil, apply all gsub features except for
 395      already applied and listed later.  For instance, if the font has
 396      GSUB features nukt, haln, rphf, blwf, and half,
 397         (deva nil nukt haln nil rphf)
 398      applies nukt and haln in this order, then applies blwf and half
 399      in the order apearing in the font.  The features are of the
 400      default langsys of `deva' script.
 401
 402      This method applies the specified features to the codes in the
 403      elements of GSTRING-IN (between FROMth and TOth).  The output
 404      codes are stored in GSTRING-OUT at the IDXth element and the
 405      following elements.
 406
 407      Return the number of output codes.  If none of the features are
 408      applicable to the input data, return 0.  If GSTRING-OUT is too
 409      short, return -1.  */
 410   int (*otf_gsub) P_ ((struct font *font, Lisp_Object gsub_spec,
 411                        Lisp_Object gstring_in, int from, int to,
 412                        Lisp_Object gstring_out, int idx, int alternate_subst));
 413
 414   /* Optional.
 415      Drive FONT's OTF GPOS features according to GPOS_SPEC.
 416
 417      GPOS_SPEC is in this format (all elements are symbols):
 418         (SCRIPT LANGSYS GPOS-FEATURE ...)
 419      The meaning is the same as GSUB_SPEC above.
 420
 421      This method applies the specified features to the codes in the
 422      elements of GSTRING (between FROMth and TOth).  The resulting
 423      positioning information (x-offset and y-offset) is stored in the
 424      slots of the elements.
 425
 426      Return 1 if at least one glyph has nonzero x-offset or y-offset.
 427      Otherwise return 0.  */
 428   int (*otf_gpos) P_ ((struct font *font, Lisp_Object gpos_spec,
 429                        Lisp_Object gstring, int from, int to));
 430 };
 431
 432
 433 struct font_driver_list
 434 {
 435   /* 1 iff this driver is currently used.  */
 436   int on;
 437   struct font_driver *driver;
 438   struct font_driver_list *next;
 439 };
 440
 441 extern int enable_font_backend;
 442
 443 EXFUN (Ffont_spec, MANY);
 444 EXFUN (Flist_fonts, 4);
 445 EXFUN (Fclear_font_cache, 0);
 446
 447 extern Lisp_Object font_symbolic_weight P_ ((Lisp_Object font));
 448 extern Lisp_Object font_symbolic_slant P_ ((Lisp_Object font));
 449 extern Lisp_Object font_symbolic_width P_ ((Lisp_Object font));
 450
 451 extern int font_match_p P_ ((Lisp_Object spec, Lisp_Object entity));
 452
 453 extern Lisp_Object font_find_object P_ ((struct font *font));
 454 extern Lisp_Object font_get_name P_ ((Lisp_Object font_object));
 455 extern Lisp_Object font_get_spec P_ ((Lisp_Object font_object));
 456 extern Lisp_Object font_get_frame P_ ((Lisp_Object font_object));
 457 extern int font_has_char P_ ((FRAME_PTR, Lisp_Object, int));
 458 extern unsigned font_encode_char P_ ((Lisp_Object, int));
 459
 460 extern int font_set_lface_from_name P_ ((FRAME_PTR f,
 461                                          Lisp_Object lface,
 462                                          Lisp_Object fontname,
 463                                          int force_p, int may_fail_p));
 464 extern Lisp_Object font_find_for_lface P_ ((FRAME_PTR f, Lisp_Object *lface,
 465                                             Lisp_Object spec));
 466 extern Lisp_Object font_open_for_lface P_ ((FRAME_PTR f, Lisp_Object *lface,
 467                                             Lisp_Object entity));
 468 extern void font_load_for_face P_ ((FRAME_PTR f, struct face *face));
 469 extern void font_prepare_for_face P_ ((FRAME_PTR f, struct face *face));
 470 extern Lisp_Object font_open_by_name P_ ((FRAME_PTR f, char *name));
 471 extern void font_close_object (FRAME_PTR f, Lisp_Object font_object);
 472
 473 extern Lisp_Object intern_downcase P_ ((char *str, int len));
 474 extern void font_update_sort_order P_ ((int *order));
 475
 476 extern void font_merge_old_spec P_ ((Lisp_Object name, Lisp_Object family,
 477                                      Lisp_Object registry, Lisp_Object spec));
 478
 479
 480 extern int font_parse_xlfd P_ ((char *name, Lisp_Object font));
 481 extern int font_unparse_xlfd P_ ((Lisp_Object font, int pixel_size,
 482                                   char *name, int bytes));
 483 extern int font_parse_fcname P_ ((char *name, Lisp_Object font));
 484 extern int font_unparse_fcname P_ ((Lisp_Object font, int pixel_size,
 485                                   char *name, int bytes));
 486 extern void register_font_driver P_ ((struct font_driver *driver, FRAME_PTR f));
 487 extern void free_font_driver_list P_ ((FRAME_PTR f));
 488 extern Lisp_Object font_update_drivers P_ ((FRAME_PTR f, Lisp_Object list));
 489 extern Lisp_Object font_at P_ ((int c, EMACS_INT pos, struct face *face,
 490                                 struct window *w, Lisp_Object object));
 491
 492 extern struct font *font_prepare_composition P_ ((struct composition *cmp));
 493
 494
 495 #ifdef HAVE_LIBOTF
 496 /* This can be used as `otf_capability' method of a font-driver.  */
 497 extern Lisp_Object font_otf_capability P_ ((struct font *font));
 498 /* This can be used as `otf_gsub' method of a font-driver.  */
 499 extern int font_otf_gsub P_ ((struct font *font, Lisp_Object gsub_spec,
 500                               Lisp_Object gstring_in, int from, int to,
 501                               Lisp_Object gstring_out, int idx,
 502                               int alternate_subst));
 503 /* This can be used as `otf_gpos' method of a font-driver.  */
 504 extern int font_otf_gpos P_ ((struct font *font, Lisp_Object gpos_spec,
 505                               Lisp_Object gstring, int from, int to));
 506 #endif  /* HAVE_LIBOTF */
 507
 508 #ifdef HAVE_FREETYPE
 509 extern struct font_driver ftfont_driver;
 510 #endif  /* HAVE_FREETYPE */
 511 #ifdef HAVE_X_WINDOWS
 512 extern struct font_driver xfont_driver;
 513 extern struct font_driver ftxfont_driver;
 514 #ifdef HAVE_XFT
 515 extern struct font_driver xftfont_driver;
 516 #endif  /* HAVE_XFT */
 517 #endif  /* HAVE_X_WINDOWS */
 518 #ifdef WINDOWSNT
 519 extern struct font_driver w32font_driver;
 520 #endif  /* WINDOWSNT */
 521 #ifdef MAC_OS
 522 extern struct font_driver atmfont_driver;
 523 #endif  /* MAC_OS */
 524
 525 #endif  /* not EMACS_FONT_H */
 526
 527 /* arch-tag: 3b7260c3-5bec-4d6b-a0db-95c1b431b1a2
 528    (do not change this comment) */