1 /* font.h -- Interface definition for font handling.
2 Copyright (C) 2006-2013 Free Software Foundation, Inc.
3 Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
4 National Institute of Advanced Industrial Science and Technology (AIST)
5 Registration Number H13PRO009
7 This file is part of GNU Emacs.
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.
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.
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/>. */
28 /* We have three types of Lisp objects related to font.
32 Pseudo vector (length FONT_SPEC_MAX) of font properties. Some
33 properties can be left unspecified (i.e. nil). Emacs asks
34 font-drivers to find a font by FONT-SPEC. A fontset entry
35 specifies requisite properties whereas a face specifies just
36 preferable properties.
40 Pseudo vector (length FONT_ENTITY_MAX) of fully instantiated
41 font properties that a font-driver returns upon a request of
44 Note: Only the method `list' and `match' of a font-driver can
45 create this object, and it should never be modified by Lisp.
49 Pseudo vector (length FONT_OBJECT_MAX) of an opened font.
51 Lisp object encapsulating "struct font". This corresponds to
54 Note: Only the method `open' of a font-driver can create this
55 object, and it should never be modified by Lisp. */
57 extern Lisp_Object Qfont_spec
, Qfont_entity
, Qfont_object
;
59 /* An enumerator for each font property. This is used as an index to
60 the vector of FONT-SPEC and FONT-ENTITY.
62 Note: The order is important and should not be changed. */
64 enum font_property_index
66 /* FONT-TYPE is a symbol indicating a font backend; currently `x',
67 `xft', and `ftx' are available on X, `uniscribe' and `gdi' on
68 Windows, and `ns' under Cocoa / GNUstep. */
71 /* FONT-FOUNDRY is a foundry name (symbol). */
74 /* FONT-FAMILY is a family name (symbol). */
77 /* FONT-ADSTYLE is an additional style name (symbol). */
80 /* FONT-REGISTRY is a combination of a charset-registry and
81 charset-encoding name (symbol). */
84 /* FONT-WEIGHT is a numeric value of weight (e.g. medium, bold) of
85 the font. The lowest 8 bits is an index determining the
86 symbolic name, and the higher bits is the actual numeric value
87 defined in `font-weight-table'. */
90 /* FONT-SLANT is a numeric value of slant (e.g. r, i, o) of the
91 font. The lowest 8 bits is an index determining the symbolic
92 name, and the higher bits is the actual numeric value defined
93 in `font-slant-table'. */
96 /* FONT-WIDTH is a numeric value of setwidth (e.g. normal) of the
97 font. The lowest 8 bits is an index determining the symbolic
98 name, and the higher bits is the actual numeric value defined
99 `font-width-table'. */
102 /* FONT-SIZE is a size of the font. If integer, it is a pixel
103 size. For a font-spec, the value can be a float specifying
104 the point size. The value zero means that the font is
108 /* FONT-DPI is a resolution (dot per inch) for which the font is
112 /* FONT-SPACING is a spacing (mono, proportional, charcell) of the
113 font (integer; one of enum font_spacing). */
116 /* FONT-AVGWIDTH is an average width (1/10 pixel unit) of the
121 /* The following two members are to substitute for the above 6
122 members (FONT_WEIGHT_INDEX to FONT_AVGWIDTH_INDEX excluding
123 FONT_SIZE_INDEX) if it is found that font-entities consumes too
126 /* FONT-STYLE is a 24-bit integer containing indices for
127 style-related properties WEIGHT, SLANT, and WIDTH. The lowest
128 8 bits is an index to the weight table AREF (font_style_table,
129 0), the next 8 bits is an index to the slant table AREF
130 (font_style_table, 1), the highest 8 bits is an index to the
131 slant table AREF (font_style_table, 2). The index 0 indicates
132 that the corresponding style is not specified. This way, we
133 can represent at most 255 different names for each style, which
134 is surely sufficient. */
137 /* FONT-METRICS is a 27-bit integer containing metrics-related
138 properties DPI, AVGWIDTH, SPACING. The lowest 12 bits is for
139 DPI, the next 12 bits is for AVGWIDTH, the highest 3 bits is for
140 SPACING. In each bit field, the highest bit indicates that the
141 corresponding value is set or not. This way, we can represent
142 DPI by 11-bit (0 to 2047), AVGWIDTH by 11-bit (0 to 2047),
143 SPACING by 3-bit (0 for proportional, 1 for dual, 2 for mono, 3
144 for charcell), which is surely sufficient. */
148 /* In a font-spec, the value is an alist of extra information of a
149 font such as name, OpenType features, and language coverage.
150 In addition, in a font-entity, the value may contain a pair
151 (font-entity . INFO) where INFO is extra information to identify
152 a font (font-driver dependent). */
153 FONT_EXTRA_INDEX
, /* alist alist */
155 /* This value is the length of font-spec vector. */
158 /* The followings are used only for a font-entity and a font-object. */
160 /* List of font-objects opened from the font-entity. */
161 FONT_OBJLIST_INDEX
= FONT_SPEC_MAX
,
163 /* Font-entity from which the font-object is opened. */
164 FONT_ENTITY_INDEX
= FONT_SPEC_MAX
,
166 /* This value is the length of font-entity vector. */
169 /* The followings are used only for a font-object. */
171 /* XLFD name of the font (string). */
172 FONT_NAME_INDEX
= FONT_ENTITY_MAX
,
174 /* Full name of the font (string). It is the name extracted from
175 the opened font, and may be different from the above. It may be
176 nil if the opened font doesn't give a name. */
179 /* File name of the font or nil if a file associated with the font
183 /* Format of the font (symbol) or nil if unknown. */
186 /* This value is the length of font-object vector. */
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)
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)
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)))
237 #define FONT_WIDTH(f) ((f)->max_width)
238 #define FONT_HEIGHT(f) ((f)->height)
239 #define FONT_BASE(f) ((f)->ascent)
240 #define FONT_DESCENT(f) ((f)->descent)
242 extern Lisp_Object QCspacing
, QCdpi
, QCscalable
, QCotf
, QClang
, QCscript
;
243 extern Lisp_Object QCavgwidth
, QCantialias
, QCfont_entity
;
244 extern Lisp_Object Qp
;
247 /* Important character set symbols. */
248 extern Lisp_Object Qascii_0
;
249 extern Lisp_Object Qiso8859_1
, Qiso10646_1
, Qunicode_bmp
, Qunicode_sip
;
251 /* Special ADSTYLE properties to avoid fonts used for Latin characters. */
252 extern Lisp_Object Qja
, Qko
;
254 /* Structure for a font-spec. */
258 struct vectorlike_header header
;
259 Lisp_Object props
[FONT_SPEC_MAX
];
262 /* Structure for a font-entity. */
266 struct vectorlike_header header
;
267 Lisp_Object props
[FONT_ENTITY_MAX
];
269 struct font_driver
*driver
;
273 /* A value which may appear in the member `encoding' of struct font
274 indicating that a font itself doesn't tell which encoding to be
276 #define FONT_ENCODING_NOT_DECIDED 255
278 /* Structure for a font-object. */
282 struct vectorlike_header header
;
284 /* All Lisp_Object components must come first.
285 That ensures they are all aligned normally. */
287 Lisp_Object props
[FONT_OBJECT_MAX
];
289 /* Beyond here, there should be no more Lisp_Object components. */
291 /* Minimum and maximum glyph widths, in pixels. Some font backends,
292 such as xft, lack the information to easily compute minimum and
293 maximum widths over all characters; in that case, these values
298 /* By which pixel size the font is opened. */
301 /* Height of the font. On X window, this is the same as
302 (font->ascent + font->descent). */
305 /* Width of the space glyph of the font. If the font doesn't have a
306 SPACE glyph, the value is 0. */
309 /* Average width of glyphs in the font. If the font itself doesn't
310 have that information but has glyphs of ASCII characters, the
311 value is the average width of those glyphs. Otherwise, the value
315 /* Ascent and descent of the font (in pixels). */
318 /* The following members makes sense on graphic displays only. */
320 #if defined (HAVE_WINDOW_SYSTEM)
322 /* The frame where the font was opened. */
325 /* Vertical pixel width of the underline. If is zero if that
326 information is not in the font. */
327 int underline_thickness
;
329 /* Vertical pixel position (relative to the baseline) of the
330 underline. If it is positive, it is below the baseline. It is
331 negative if that information is not in the font. */
332 int underline_position
;
334 /* True if `vertical-centering-font-regexp' matches this font name.
335 In this case, we render characters at vertical center positions
337 bool vertical_centering
;
339 /* The baseline position of a font is normally `ascent' value of the
340 font. However, there exist many fonts which don't set `ascent' to
341 an appropriate value to be used as baseline position. This is
342 typical in such ASCII fonts which are designed to be used with
343 Chinese, Japanese, Korean characters. When we use mixture of
344 such fonts and normal fonts (having correct `ascent' value), a
345 display line gets very ugly. Since we have no way to fix it
346 automatically, it is user's responsibility to supply well designed
347 fonts or correct `ascent' value of fonts. But, the latter
348 requires heavy work (modifying all bitmap data in BDF files).
349 So, Emacs accepts a private font property
350 `_MULE_BASELINE_OFFSET'. If a font has this property, we
351 calculate the baseline position by subtracting the value from
352 `ascent'. In other words, the value indicates how many pixels
353 higher than normal ASCII text we should draw a character of the
354 font for better appearance.
356 We also have to consider the fact that the concept of `baseline'
357 differs among scripts to which each character belongs. For
358 instance, baseline should be at the bottom-most position of all
359 glyphs for Chinese, Japanese, and Korean. But, many of existing
360 fonts for those characters don't have correct `ascent' values
361 because they are designed to be used with ASCII fonts. To
362 display characters of different language on the same line, the
363 best way will be to arrange them in the middle of the line. So,
364 in such a case, again, we utilize the font property
365 `_MULE_BASELINE_OFFSET'. If the value is larger than `ascent' we
366 calculate baseline so that a character is arranged in the middle
370 /* Non-zero means a character should be composed at a position
371 relative to the height (or depth) of previous glyphs in the
373 (1) The bottom of the character is higher than this value. In
374 this case, the character is drawn above the previous glyphs.
375 (2) The top of the character is lower than 0 (i.e. baseline
376 height). In this case, the character is drawn below the
379 This value is taken from a private font property
380 `_MULE_RELATIVE_COMPOSE' which is introduced by Emacs. */
381 int relative_compose
;
383 /* Non-zero means an ascent value to be used for a character
384 registered in char-table `use-default-ascent'. */
387 /* Charset to encode a character code into a glyph code of the font.
388 -1 means that the font doesn't require this information to encode
390 int encoding_charset
;
392 /* Charset to check if a character code is supported by the font.
393 -1 means that the contents of the font must be looked up to
395 int repertory_charset
;
397 #endif /* HAVE_WINDOW_SYSTEM */
399 /* Font-driver for the font. */
400 struct font_driver
*driver
;
402 /* There are more members in this structure, but they are private
403 to the font-driver. */
408 FONT_SPACING_PROPORTIONAL
= 0,
409 FONT_SPACING_DUAL
= 90,
410 FONT_SPACING_MONO
= 100,
411 FONT_SPACING_CHARCELL
= 110
416 short lbearing
, rbearing
, width
, ascent
, descent
;
425 unsigned char *buffer
;
431 /* Predicates to check various font-related objects. */
433 /* 1 iff X is one of font-spec, font-entity, and font-object. */
434 #define FONTP(x) PSEUDOVECTORP (x, PVEC_FONT)
435 /* 1 iff X is font-spec. */
436 #define FONT_SPEC_P(x) \
437 (FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_SPEC_MAX)
438 /* 1 iff X is font-entity. */
439 #define FONT_ENTITY_P(x) \
440 (FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_ENTITY_MAX)
441 /* 1 iff X is font-object. */
442 #define FONT_OBJECT_P(x) \
443 (FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_OBJECT_MAX)
445 /* 1 iff ENTITY can't be loaded. */
446 #define FONT_ENTITY_NOT_LOADABLE(entity) \
447 EQ (AREF (entity, FONT_OBJLIST_INDEX), Qt)
449 /* Flag ENTITY not loadable. */
450 #define FONT_ENTITY_SET_NOT_LOADABLE(entity) \
451 ASET (entity, FONT_OBJLIST_INDEX, Qt)
454 /* Check macros for various font-related objects. */
456 #define CHECK_FONT(x) \
457 do { if (! FONTP (x)) wrong_type_argument (Qfont, x); } while (0)
458 #define CHECK_FONT_SPEC(x) \
459 do { if (! FONT_SPEC_P (x)) wrong_type_argument (Qfont_spec, x); } while (0)
460 #define CHECK_FONT_ENTITY(x) \
461 do { if (! FONT_ENTITY_P (x)) wrong_type_argument (Qfont_entity, x); } while (0)
462 #define CHECK_FONT_OBJECT(x) \
463 do { if (! FONT_OBJECT_P (x)) wrong_type_argument (Qfont_object, x); } while (0)
465 #define CHECK_FONT_GET_OBJECT(x, font) \
467 CHECK_FONT_OBJECT (x); \
468 font = XFONT_OBJECT (x); \
471 #define XFONT_SPEC(p) \
472 (eassert (FONT_SPEC_P (p)), (struct font_spec *) XUNTAG (p, Lisp_Vectorlike))
473 #define XFONT_ENTITY(p) \
474 (eassert (FONT_ENTITY_P (p)), \
475 (struct font_entity *) XUNTAG (p, Lisp_Vectorlike))
476 #define XFONT_OBJECT(p) \
477 (eassert (FONT_OBJECT_P (p)), (struct font *) XUNTAG (p, Lisp_Vectorlike))
478 #define XSETFONT(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_FONT))
480 /* Number of pt per inch (from the TeXbook). */
481 #define PT_PER_INCH 72.27
483 /* Return a pixel size (integer) corresponding to POINT size (double)
484 on resolution DPI. */
485 #define POINT_TO_PIXEL(POINT, DPI) ((POINT) * (DPI) / PT_PER_INCH + 0.5)
487 /* Return a point size corresponding to POINT size (integer)
488 on resolution DPI. Note that though point size is a double, we expect
489 it to be rounded to an int, so we add 0.5 here. If the desired value
490 is tenths of points (as in xfld specs), then the pixel size should
491 be multiplied BEFORE the conversion to avoid magnifying the error. */
492 #define PIXEL_TO_POINT(PIXEL, DPI) ((PIXEL) * PT_PER_INCH / (DPI) + 0.5)
494 /* Ignore the difference of font pixel sizes less than or equal to
496 #define FONT_PIXEL_SIZE_QUANTUM 1
498 #define FONT_INVALID_CODE 0xFFFFFFFF
500 /* Font driver. Members specified as "optional" can be NULL. */
504 /* Symbol indicating the type of the font-driver. */
507 /* True iff the font's foundry, family, and adstyle names are case
511 /* Return a cache of font-entities on frame F. The cache must be a
512 cons whose cdr part is the actual cache area. */
513 Lisp_Object (*get_cache
) (struct frame
*f
);
515 /* List fonts exactly matching with FONT_SPEC on FRAME. The value
516 is a list of font-entities. The font properties to be considered
517 are: :foundry, :family, :adstyle, :registry, :script, :lang, and
518 :otf. See the function `font-spec' for their meanings. Note
519 that the last three properties are stored in FONT_EXTRA_INDEX
522 The returned value is a list of font-entities. Each font-entity
523 has :type property whose value is the same as the above `type'.
524 It also has these properties if they are available from the
525 corresponding font; :foundry, :family, :adstyle, :registry,
526 :weight, :slant, :width, :size, :dpi, :spacing, :avgwidth. If
527 the font is scalable, :size and :avgwidth must be 0.
529 The `open' method of the same font-backend is called with one of
530 the returned font-entities. If the backend needs additional
531 information to be used in `open' method, this method can add any
532 Lispy value by the property :font-entity to the entities.
534 This and the following `match' are the only APIs that allocate
536 Lisp_Object (*list
) (struct frame
*frame
, Lisp_Object font_spec
);
538 /* Return a font-entity most closely matching with FONT_SPEC on
539 FRAME. Which font property to consider, and how to calculate the
540 closeness is determined by the font backend, thus
541 `face-font-selection-order' is ignored here.
543 The properties that the font-entity has is the same as `list'
545 Lisp_Object (*match
) (struct frame
*f
, Lisp_Object spec
);
548 List available families. The value is a list of family names
550 Lisp_Object (*list_family
) (struct frame
*f
);
552 /* Optional (if FONT_EXTRA_INDEX is not Lisp_Save_Value).
553 Free FONT_EXTRA_INDEX field of FONT_ENTITY. */
554 void (*free_entity
) (Lisp_Object font_entity
);
556 /* Open a font specified by FONT_ENTITY on frame F. If the font is
557 scalable, open it with PIXEL_SIZE. */
558 Lisp_Object (*open
) (struct frame
*f
, Lisp_Object font_entity
,
561 /* Close FONT. NOTE: this can be called by GC. */
562 void (*close
) (struct font
*font
);
564 /* Optional (if FACE->extra is not used).
565 Prepare FACE for displaying characters by FONT on frame F by
566 storing some data in FACE->extra. If successful, return 0.
567 Otherwise, return -1. */
568 int (*prepare_face
) (struct frame
*f
, struct face
*face
);
571 Done FACE for displaying characters by FACE->font on frame F. */
572 void (*done_face
) (struct frame
*f
, struct face
*face
);
575 If FONT (FONT-ENTITY or FONT-OBJECT) has a glyph for character C
576 (Unicode code point), return 1. If not, return 0. If FONT is
577 FONT-ENTITY and it must be opened to check it, return -1. */
578 int (*has_char
) (Lisp_Object font
, int c
);
580 /* Return a glyph code of FONT for character C (Unicode code point).
581 If FONT doesn't have such a glyph, return FONT_INVALID_CODE. */
582 unsigned (*encode_char
) (struct font
*font
, int c
);
584 /* Compute the total metrics of the NGLYPHS glyphs specified by
585 the font FONT and the sequence of glyph codes CODE, and store the
586 result in METRICS. */
587 int (*text_extents
) (struct font
*font
,
588 unsigned *code
, int nglyphs
,
589 struct font_metrics
*metrics
);
591 #ifdef HAVE_WINDOW_SYSTEM
594 Draw glyphs between FROM and TO of S->char2b at (X Y) pixel
595 position of frame F with S->FACE and S->GC. If WITH_BACKGROUND,
596 fill the background in advance. It is assured that WITH_BACKGROUND
597 is false when (FROM > 0 || TO < S->nchars). */
598 int (*draw
) (struct glyph_string
*s
, int from
, int to
,
599 int x
, int y
, bool with_background
);
602 Store bitmap data for glyph-code CODE of FONT in BITMAP. It is
603 intended that this method is called from the other font-driver
604 for actual drawing. */
605 int (*get_bitmap
) (struct font
*font
, unsigned code
,
606 struct font_bitmap
*bitmap
,
610 Free bitmap data in BITMAP. */
611 void (*free_bitmap
) (struct font
*font
, struct font_bitmap
*bitmap
);
613 #endif /* HAVE_WINDOW_SYSTEM */
616 Return an outline data for glyph-code CODE of FONT. The format
617 of the outline data depends on the font-driver. */
618 void *(*get_outline
) (struct font
*font
, unsigned code
);
621 Free OUTLINE (that is obtained by the above method). */
622 void (*free_outline
) (struct font
*font
, void *outline
);
625 Get coordinates of the INDEXth anchor point of the glyph whose
626 code is CODE. Store the coordinates in *X and *Y. Return 0 if
627 the operations was successful. Otherwise return -1. */
628 int (*anchor_point
) (struct font
*font
, unsigned code
, int index
,
632 Return a list describing which scripts/languages FONT
633 supports by which GSUB/GPOS features of OpenType tables. */
634 Lisp_Object (*otf_capability
) (struct font
*font
);
637 Apply FONT's OTF-FEATURES to the glyph string.
639 FEATURES specifies which OTF features to apply in this format:
640 (SCRIPT LANGSYS GSUB-FEATURE GPOS-FEATURE)
641 See the documentation of `font-drive-otf' for the details.
643 This method applies the specified features to the codes in the
644 elements of GSTRING-IN (between FROMth and TOth). The output
645 codes are stored in GSTRING-OUT at the IDXth element and the
648 Return the number of output codes. If none of the features are
649 applicable to the input data, return 0. If GSTRING-OUT is too
651 int (*otf_drive
) (struct font
*font
, Lisp_Object features
,
652 Lisp_Object gstring_in
, int from
, int to
,
653 Lisp_Object gstring_out
, int idx
, bool alternate_subst
);
656 Make the font driver ready for frame F. Usually this function
657 makes some data specific to F and stores it in F by calling
658 font_put_frame_data (). */
659 int (*start_for_frame
) (struct frame
*f
);
662 End using the driver for frame F. Usually this function free
663 some data stored for F. */
664 int (*end_for_frame
) (struct frame
*f
);
668 Shape text in GSTRING. See the docstring of
669 `composition-get-gstring' for the format of GSTRING. If the
670 (N+1)th element of GSTRING is nil, input of shaping is from the
671 1st to (N)th elements. In each input glyph, FROM, TO, CHAR, and
672 CODE are already set.
674 This function updates all fields of the input glyphs. If the
675 output glyphs (M) are more than the input glyphs (N), (N+1)th
676 through (M)th elements of GSTRING are updated possibly by making
677 a new glyph object and storing it in GSTRING. If (M) is greater
678 than the length of GSTRING, nil should be return. In that case,
679 this function is called again with the larger GSTRING. */
680 Lisp_Object (*shape
) (Lisp_Object lgstring
);
684 If FONT is usable on frame F, return 0. Otherwise return -1.
685 This method is used only for debugging. If this method is NULL,
686 Emacs assumes that the font is usable on any frame. */
687 int (*check
) (struct frame
*f
, struct font
*font
);
691 Return the number of variation glyphs of character C supported by
692 FONT. VARIATIONS is an array of 256 elements. If the variation
693 selector N (1..256) defines a glyph, that glyph code is stored in
694 the (N-1)th element of VARIATIONS. */
695 int (*get_variation_glyphs
) (struct font
*font
,
696 int c
, unsigned variations
[256]);
698 void (*filter_properties
) (Lisp_Object font
, Lisp_Object properties
);
702 Return non-zero if FONT_OBJECT can be used as a (cached) font
703 for ENTITY on frame F. */
704 bool (*cached_font_ok
) (struct frame
*f
,
705 Lisp_Object font_object
,
710 /* Chain of font drivers. There's one global font driver list
711 (font_driver_list in font.c). In addition, each frame has
712 its own font driver list at F->font_driver_list. */
714 struct font_driver_list
716 /* True iff this driver is currently used. It is ignored in the global
719 /* Pointer to the font driver. */
720 struct font_driver
*driver
;
721 /* Pointer to the next element of the chain. */
722 struct font_driver_list
*next
;
726 /* Chain of arbitrary data specific to each font driver.
727 Each frame has its own font data list at F->font_data_list. */
729 struct font_data_list
731 /* Pointer to the font driver. */
732 struct font_driver
*driver
;
733 /* Data specific to the font driver. */
735 /* Pointer to the next element of the chain. */
736 struct font_data_list
*next
;
739 extern Lisp_Object
copy_font_spec (Lisp_Object
);
740 extern Lisp_Object
merge_font_spec (Lisp_Object
, Lisp_Object
);
742 extern Lisp_Object
font_make_entity (void);
743 extern Lisp_Object
font_make_object (int, Lisp_Object
, int);
744 extern void font_close_object (Lisp_Object
);
746 extern Lisp_Object
find_font_encoding (Lisp_Object
);
747 extern int font_registry_charsets (Lisp_Object
, struct charset
**,
749 extern int font_style_to_value (enum font_property_index prop
,
750 Lisp_Object name
, bool noerror
);
751 extern Lisp_Object
font_style_symbolic (Lisp_Object font
,
752 enum font_property_index prop
,
755 extern bool font_match_p (Lisp_Object spec
, Lisp_Object font
);
756 extern Lisp_Object
font_list_entities (struct frame
*, Lisp_Object
);
758 extern Lisp_Object
font_get_name (Lisp_Object font_object
);
759 extern Lisp_Object
font_spec_from_name (Lisp_Object font_name
);
760 extern Lisp_Object
font_get_frame (Lisp_Object font_object
);
761 extern int font_has_char (struct frame
*, Lisp_Object
, int);
763 extern void font_clear_prop (Lisp_Object
*attrs
,
764 enum font_property_index prop
);
765 extern Lisp_Object
font_find_for_lface (struct frame
*f
, Lisp_Object
*lface
,
766 Lisp_Object spec
, int c
);
767 extern Lisp_Object
font_open_for_lface (struct frame
*f
, Lisp_Object entity
,
770 extern Lisp_Object
font_load_for_lface (struct frame
*f
, Lisp_Object
*lface
,
772 extern void font_prepare_for_face (struct frame
*f
, struct face
*face
);
773 extern void font_done_for_face (struct frame
*f
, struct face
*face
);
774 extern void clear_font_cache (struct frame
*);
776 extern Lisp_Object
font_open_by_spec (struct frame
*f
, Lisp_Object spec
);
777 extern Lisp_Object
font_open_by_name (struct frame
*f
, Lisp_Object name
);
779 extern Lisp_Object
font_intern_prop (const char *str
, ptrdiff_t len
,
781 extern void font_update_sort_order (int *order
);
783 extern void font_parse_family_registry (Lisp_Object family
,
784 Lisp_Object registry
,
787 extern int font_parse_xlfd (char *name
, ptrdiff_t len
, Lisp_Object font
);
788 extern ptrdiff_t font_unparse_xlfd (Lisp_Object font
, int pixel_size
,
789 char *name
, int bytes
);
790 extern int font_unparse_fcname (Lisp_Object font
, int pixel_size
,
791 char *name
, int bytes
);
792 extern void register_font_driver (struct font_driver
*driver
, struct frame
*f
);
793 extern void free_font_driver_list (struct frame
*f
);
794 extern Lisp_Object
font_update_drivers (struct frame
*f
, Lisp_Object list
);
795 extern Lisp_Object
font_range (ptrdiff_t, ptrdiff_t, ptrdiff_t *,
796 struct window
*, struct face
*,
798 extern void font_fill_lglyph_metrics (Lisp_Object
, Lisp_Object
);
800 extern Lisp_Object
font_put_extra (Lisp_Object font
, Lisp_Object prop
,
803 extern int font_put_frame_data (struct frame
*f
,
804 struct font_driver
*driver
,
806 extern void *font_get_frame_data (struct frame
*f
,
807 struct font_driver
*driver
);
809 extern void font_filter_properties (Lisp_Object font
,
811 const char *const boolean_properties
[],
812 const char *const non_boolean_properties
[]);
815 extern struct font_driver ftfont_driver
;
816 extern void syms_of_ftfont (void);
817 #endif /* HAVE_FREETYPE */
818 #ifdef HAVE_X_WINDOWS
819 extern struct font_driver xfont_driver
;
820 extern void syms_of_xfont (void);
821 extern void syms_of_ftxfont (void);
823 extern Lisp_Object Qxft
;
824 extern struct font_driver xftfont_driver
;
825 extern void syms_of_xftfont (void);
826 #elif defined HAVE_FREETYPE
827 extern struct font_driver ftxfont_driver
;
830 extern void syms_of_bdffont (void);
831 #endif /* HAVE_BDFFONT */
832 #endif /* HAVE_X_WINDOWS */
834 extern struct font_driver w32font_driver
;
835 extern struct font_driver uniscribe_font_driver
;
836 extern void syms_of_w32font (void);
837 #endif /* HAVE_NTGUI */
839 extern Lisp_Object Qfontsize
;
840 extern struct font_driver nsfont_driver
;
841 extern void syms_of_nsfont (void);
842 extern void syms_of_macfont (void);
849 extern Lisp_Object QCfoundry
;
851 extern void font_add_log (const char *, Lisp_Object
, Lisp_Object
);
852 extern void font_deferred_log (const char *, Lisp_Object
, Lisp_Object
);
854 #define FONT_ADD_LOG(ACTION, ARG, RESULT) \
856 if (! EQ (Vfont_log, Qt)) \
857 font_add_log ((ACTION), (ARG), (RESULT)); \
860 #define FONT_DEFERRED_LOG(ACTION, ARG, RESULT) \
862 if (! EQ (Vfont_log, Qt)) \
863 font_deferred_log ((ACTION), (ARG), (RESULT)); \
866 #endif /* not EMACS_FONT_H */