Backport Bug#9990 fix from trunk
[emacs.git] / src / font.h
blob7471464bb9b2f85e80d2afa1dc54f6cba18f4915
1 /* font.h -- Interface definition for font handling.
2 Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 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/>. */
22 #ifndef EMACS_FONT_H
23 #define EMACS_FONT_H
25 #include "ccl.h"
27 /* We have three types of Lisp objects related to font.
29 FONT-SPEC
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.
37 FONT-ENTITY
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.
43 Note: Only the method `list' and `match' of a font-driver can
44 create this object, and should never be modified by Lisp.
46 FONT-OBJECT
48 Pseudo vector (length FONT_OBJECT_MAX) of a opend font.
50 Lisp object encapsulating "struct font". This corresponds to
51 an opened font.
53 Note: Only the method `open' of a font-driver can create this
54 object, and should never be modified by Lisp. */
56 extern Lisp_Object Qfont_spec, Qfont_entity, Qfont_object;
59 struct font_driver;
60 struct font;
61 struct glyph_string;
63 /* An enumerator for each font property. This is used as an index to
64 the vector of FONT-SPEC and FONT-ENTITY.
66 Note: The order is important and should not be changed. */
68 enum font_property_index
70 /* FONT-TYPE is a symbol indicating a font backend; currently `x',
71 `xft', `ftx' are available on X, `uniscribe' and `gdi' on
72 Windows, and `ns' under Cocoa / GNUstep. */
73 FONT_TYPE_INDEX,
75 /* FONT-FOUNDRY is a foundry name (symbol). */
76 FONT_FOUNDRY_INDEX,
78 /* FONT-FAMILY is a family name (symbol). */
79 FONT_FAMILY_INDEX,
81 /* FONT-ADSTYLE is an additional style name (symbol). */
82 FONT_ADSTYLE_INDEX,
84 /* FONT-REGISTRY is a combination of a charset-registry and
85 charset-encoding name (symbol). */
86 FONT_REGISTRY_INDEX,
88 /* FONT-WEIGHT is a numeric value of weight (e.g. medium, bold) of
89 the font. The lowest 8-bit is an index determining the
90 symbolic name, and the higher bits is the actual numeric value
91 defined in `font-weight-table'. */
92 FONT_WEIGHT_INDEX,
94 /* FONT-SLANT is a numeric value of slant (e.g. r, i, o) of the
95 font. The lowest 8-bit is an index determining the symbolic
96 name, and the higher bits is the actual numeric value defined
97 in `font-slant-table'. */
98 FONT_SLANT_INDEX,
100 /* FONT-WIDTH is a numeric value of setwidth (e.g. normal) of the
101 font. The lowest 8-bit is an index determining the symbolic
102 name, and the higher bits is the actual numeric value defined
103 `font-width-table'. */
104 FONT_WIDTH_INDEX,
106 /* FONT-SIZE is a size of the font. If integer, it is a pixel
107 size. For a font-spec, the value can be float specifying a
108 point size. The value zero means that the font is
109 scalable. */
110 FONT_SIZE_INDEX,
112 /* FONT-DPI is a resolution (dot per inch) for which the font is
113 designed. */
114 FONT_DPI_INDEX,
116 /* FONT-SPACING is a spacing (mono, proportional, charcell) of the
117 font (integer; one of enum font_spacing). */
118 FONT_SPACING_INDEX,
120 /* FONT-AVGWIDTH is an average width (1/10 pixel unit) of the
121 font. */
122 FONT_AVGWIDTH_INDEX,
124 #if 0
125 /* The following two members are to substitute for the above 6
126 members (FONT_WEIGHT_INDEX to FONT_AVGWIDTH_INDEX excluding
127 FONT_SIZE_INDEX) if it is found that font-entities consumes too
128 much memory. */
130 /* FONT-STYLE is a 24-bit integer containing indices for
131 style-related properties WEIGHT, SLANT, and WIDTH. The lowest
132 8-bit is an indice to the weight table AREF (font_style_table,
133 0), the next 8-bit is an indice to the slant table AREF
134 (font_style_table, 1), the highest 8-bit is an indice to the
135 slant table AREF (font_style_table, 2). The indice 0 indicates
136 that the corresponding style is not specified. This way, we
137 can represent at most 255 different names for each style, which
138 is surely sufficient. */
139 FONT_STYLE_INDEX,
141 /* FONT-METRICS is a 27-bit integer containing metrics-related
142 properties DPI, AVGWIDTH, SPACING. The lowest 12-bit is for
143 DPI, the next 12-bit is for AVGWIDTH, the highest 3-bit is for
144 SPACING. In each bit field, the highest bit indicates that the
145 corresponding value is set or not. This way, we can represent
146 DPI by 11-bit (0 to 2047), AVGWIDTH by 11-bit (0 to 2047),
147 SPACING by 3-bit (0 for proportional, 1 for dual, 2 for mono, 3
148 for charcell), which is surely sufficient. */
149 FONT_METRICS_INDEX,
150 #endif
152 /* In a font-spec, the value is an alist of extra information of a
153 font such as name, OpenType features, and language coverage.
154 In addition, in a font-entity, the value may contain a pair
155 (font-entity . INFO) where INFO is extra information to identify
156 a font (font-driver dependent). */
157 FONT_EXTRA_INDEX, /* alist alist */
159 /* This value is the length of font-spec vector. */
160 FONT_SPEC_MAX,
162 /* The followings are used only for a font-entity. */
164 /* List of font-objects opened from the font-entity. */
165 FONT_OBJLIST_INDEX = FONT_SPEC_MAX,
167 /* This value is the length of font-entity vector. */
168 FONT_ENTITY_MAX,
170 /* XLFD name of the font (string). */
171 FONT_NAME_INDEX = FONT_ENTITY_MAX,
173 /* Full name of the font (string). It is the name extracted from
174 the opend font, and may be different from the above. It may be
175 nil if the opened font doesn't give a name. */
176 FONT_FULLNAME_INDEX,
178 /* File name of the font or nil if a file associated with the font
179 is not available. */
180 FONT_FILE_INDEX,
182 /* Format of the font (symbol) or nil if unknown. */
183 FONT_FORMAT_INDEX,
185 /* This value is the length of font-object vector. */
186 FONT_OBJECT_MAX
189 /* Return the numeric weight value of FONT. */
190 #define FONT_WEIGHT_NUMERIC(font) \
191 (INTEGERP (AREF ((font), FONT_WEIGHT_INDEX)) \
192 ? (XINT (AREF ((font), FONT_WEIGHT_INDEX)) >> 8) : -1)
193 /* Return the numeric slant value of FONT. */
194 #define FONT_SLANT_NUMERIC(font) \
195 (INTEGERP (AREF ((font), FONT_SLANT_INDEX)) \
196 ? (XINT (AREF ((font), FONT_SLANT_INDEX)) >> 8) : -1)
197 /* Return the numeric width value of FONT. */
198 #define FONT_WIDTH_NUMERIC(font) \
199 (INTEGERP (AREF ((font), FONT_WIDTH_INDEX)) \
200 ? (XINT (AREF ((font), FONT_WIDTH_INDEX)) >> 8) : -1)
201 /* Return the symbolic weight value of FONT. */
202 #define FONT_WEIGHT_SYMBOLIC(font) \
203 font_style_symbolic (font, FONT_WEIGHT_INDEX, 0)
204 /* Return the symbolic slant value of FONT. */
205 #define FONT_SLANT_SYMBOLIC(font) \
206 font_style_symbolic (font, FONT_SLANT_INDEX, 0)
207 /* Return the symbolic width value of FONT. */
208 #define FONT_WIDTH_SYMBOLIC(font) \
209 font_style_symbolic (font, FONT_WIDTH_INDEX, 0)
210 /* Return the face-weight corresponding to the weight of FONT. */
211 #define FONT_WEIGHT_FOR_FACE(font) \
212 font_style_symbolic (font, FONT_WEIGHT_INDEX, 1)
213 /* Return the face-slant corresponding to the slant of FONT. */
214 #define FONT_SLANT_FOR_FACE(font) \
215 font_style_symbolic (font, FONT_SLANT_INDEX, 1)
216 /* Return the face-swidth corresponding to the slant of FONT. */
217 #define FONT_WIDTH_FOR_FACE(font) \
218 font_style_symbolic (font, FONT_WIDTH_INDEX, 1)
220 /* Return the numeric weight value corresponding ot the symbol NAME. */
221 #define FONT_WEIGHT_NAME_NUMERIC(name) \
222 (font_style_to_value (FONT_WEIGHT_INDEX, (name), 0) >> 8)
223 /* Return the numeric slant value corresponding ot the symbol NAME. */
224 #define FONT_SLANT_NAME_NUMERIC(name) \
225 (font_style_to_value (FONT_SLANT_INDEX, (name), 0) >> 8)
226 /* Return the numeric width value corresponding ot the symbol NAME. */
227 #define FONT_WIDTH_NAME_NUMERIC(name) \
228 (font_style_to_value (FONT_WIDTH_INDEX, (name), 0) >> 8)
230 /* Set the font property PROP of FONT to VAL. PROP is one of
231 style-related font property index (FONT_WEIGHT/SLANT/WIDTH_INDEX).
232 VAL (integer or symbol) is the numeric or symbolic style value. */
233 #define FONT_SET_STYLE(font, prop, val) \
234 ASET ((font), prop, make_number (font_style_to_value (prop, val, 1)))
236 extern Lisp_Object QCspacing, QCdpi, QCscalable, QCotf, QClang, QCscript;
237 extern Lisp_Object QCavgwidth, QCfont_entity, QCfc_unknown_spec;
239 /* Important character set symbols. */
240 extern Lisp_Object Qascii_0;
241 extern Lisp_Object Qiso8859_1, Qiso10646_1, Qunicode_bmp, Qunicode_sip;
243 /* Special ADSTYLE properties to avoid fonts used for Latin characters. */
244 extern Lisp_Object Qja, Qko;
246 /* Structure for a font-spec. */
248 struct font_spec
250 struct vectorlike_header header;
251 Lisp_Object props[FONT_SPEC_MAX];
254 /* Structure for a font-entity. */
256 struct font_entity
258 struct vectorlike_header header;
259 Lisp_Object props[FONT_ENTITY_MAX];
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
267 /* Structure for a font-object. */
269 struct font
271 struct vectorlike_header header;
273 /* All Lisp_Object components must come first.
274 That ensures they are all aligned normally. */
276 Lisp_Object props[FONT_OBJECT_MAX];
278 /* Beyond here, there should be no more Lisp_Object components. */
280 /* Maximum bound width over all existing characters of the font. On
281 X window, this is same as (font->max_bounds.width). */
282 int max_width;
284 /* By which pixel size the font is opened. */
285 int pixel_size;
287 /* Height of the font. On X window, this is the same as
288 (font->ascent + font->descent). */
289 int height;
291 /* Width of the space glyph of the font. If the font doesn't have a
292 SPACE glyph, the value is 0. */
293 int space_width;
295 /* Average width of glyphs in the font. If the font itself doesn't
296 have that information but has glyphs of ASCII character, the
297 value is the average with of those glyphs. Otherwise, the value
298 is 0. */
299 int average_width;
301 /* Minimum glyph width (in pixels). */
302 int min_width;
304 /* Ascent and descent of the font (in pixels). */
305 int ascent, descent;
307 /* Vertical pixel width of the underline. If is zero if that
308 information is not in the font. */
309 int underline_thickness;
311 /* Vertical pixel position (relative to the baseline) of the
312 underline. If it is positive, it is below the baseline. It is
313 negative if that information is not in the font. */
314 int underline_position;
316 /* 1 if `vertical-centering-font-regexp' matches this font name.
317 In this case, we render characters at vartical center positions
318 of lines. */
319 int vertical_centering;
321 /* Encoding type of the font. The value is one of
322 0, 1, 2, or 3:
323 0: code points 0x20..0x7F or 0x2020..0x7F7F are used
324 1: code points 0xA0..0xFF or 0xA0A0..0xFFFF are used
325 2: code points 0x20A0..0x7FFF are used
326 3: code points 0xA020..0xFF7F are used
327 If the member `font_encoder' is not NULL, this member is ignored. */
328 unsigned char encoding_type;
330 /* The baseline position of a font is normally `ascent' value of the
331 font. However, there exists many fonts which don't set `ascent'
332 an appropriate value to be used as baseline position. This is
333 typical in such ASCII fonts which are designed to be used with
334 Chinese, Japanese, Korean characters. When we use mixture of
335 such fonts and normal fonts (having correct `ascent' value), a
336 display line gets very ugly. Since we have no way to fix it
337 automatically, it is users responsibility to supply well designed
338 fonts or correct `ascent' value of fonts. But, the latter
339 requires heavy work (modifying all bitmap data in BDF files).
340 So, Emacs accepts a private font property
341 `_MULE_BASELINE_OFFSET'. If a font has this property, we
342 calculate the baseline position by subtracting the value from
343 `ascent'. In other words, the value indicates how many bits
344 higher we should draw a character of the font than normal ASCII
345 text for a better looking.
347 We also have to consider the fact that the concept of `baseline'
348 differs among scripts to which each character belongs. For
349 instance, baseline should be at the bottom most position of all
350 glyphs for Chinese, Japanese, and Korean. But, many of existing
351 fonts for those characters doesn't have correct `ascent' values
352 because they are designed to be used with ASCII fonts. To
353 display characters of different language on the same line, the
354 best way will be to arrange them in the middle of the line. So,
355 in such a case, again, we utilize the font property
356 `_MULE_BASELINE_OFFSET'. If the value is larger than `ascent' we
357 calculate baseline so that a character is arranged in the middle
358 of a line. */
359 int baseline_offset;
361 /* Non zero means a character should be composed at a position
362 relative to the height (or depth) of previous glyphs in the
363 following cases:
364 (1) The bottom of the character is higher than this value. In
365 this case, the character is drawn above the previous glyphs.
366 (2) The top of the character is lower than 0 (i.e. baseline
367 height). In this case, the character is drawn beneath the
368 previous glyphs.
370 This value is taken from a private font property
371 `_MULE_RELATIVE_COMPOSE' which is introduced by Emacs. */
372 int relative_compose;
374 /* Non zero means an ascent value to be used for a character
375 registered in char-table `use-default-ascent'. */
376 int default_ascent;
378 /* CCL program to calculate code points of the font. */
379 struct ccl_program *font_encoder;
381 /* Font-driver for the font. */
382 struct font_driver *driver;
384 /* Charset to encode a character code into a glyph code of the font.
385 -1 means that the font doesn't require this information to encode
386 a character. */
387 int encoding_charset;
389 /* Charset to check if a character code is supported by the font.
390 -1 means that the contents of the font must be looked up to
391 determine it. */
392 int repertory_charset;
394 /* There will be more to this structure, but they are private to a
395 font-driver. */
398 enum font_spacing
400 FONT_SPACING_PROPORTIONAL = 0,
401 FONT_SPACING_DUAL = 90,
402 FONT_SPACING_MONO = 100,
403 FONT_SPACING_CHARCELL = 110
406 struct font_metrics
408 short lbearing, rbearing, width, ascent, descent;
411 struct font_bitmap
413 int bits_per_pixel;
414 int rows;
415 int width;
416 int pitch;
417 unsigned char *buffer;
418 int left;
419 int top;
420 int advance;
421 void *extra;
424 /* Predicates to check various font-related objects. */
426 /* 1 iff X is one of font-spec, font-entity, and font-object. */
427 #define FONTP(x) PSEUDOVECTORP (x, PVEC_FONT)
428 /* 1 iff X is font-spec. */
429 #define FONT_SPEC_P(x) \
430 (FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_SPEC_MAX)
431 /* 1 iff X is font-entity. */
432 #define FONT_ENTITY_P(x) \
433 (FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_ENTITY_MAX)
434 /* 1 iff X is font-object. */
435 #define FONT_OBJECT_P(x) \
436 (FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_OBJECT_MAX)
438 /* 1 iff ENTITY can't be loaded. */
439 #define FONT_ENTITY_NOT_LOADABLE(entity) \
440 EQ (AREF (entity, FONT_OBJLIST_INDEX), Qt)
442 /* Flag ENTITY not loadable. */
443 #define FONT_ENTITY_SET_NOT_LOADABLE(entity) \
444 ASET (entity, FONT_OBJLIST_INDEX, Qt)
447 /* Check macros for various font-related objects. */
449 #define CHECK_FONT(x) \
450 do { if (! FONTP (x)) wrong_type_argument (Qfont, x); } while (0)
451 #define CHECK_FONT_SPEC(x) \
452 do { if (! FONT_SPEC_P (x)) wrong_type_argument (Qfont_spec, x); } while (0)
453 #define CHECK_FONT_ENTITY(x) \
454 do { if (! FONT_ENTITY_P (x)) wrong_type_argument (Qfont_entity, x); } while (0)
455 #define CHECK_FONT_OBJECT(x) \
456 do { if (! FONT_OBJECT_P (x)) wrong_type_argument (Qfont_object, x); } while (0)
458 #define CHECK_FONT_GET_OBJECT(x, font) \
459 do { \
460 CHECK_FONT_OBJECT (x); \
461 font = XFONT_OBJECT (x); \
462 } while (0)
464 #define XFONT_SPEC(p) \
465 (eassert (FONT_SPEC_P(p)), (struct font_spec *) XPNTR (p))
466 #define XFONT_ENTITY(p) \
467 (eassert (FONT_ENTITY_P(p)), (struct font_entity *) XPNTR (p))
468 #define XFONT_OBJECT(p) \
469 (eassert (FONT_OBJECT_P(p)), (struct font *) XPNTR (p))
470 #define XSETFONT(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_FONT))
472 /* Number of pt per inch (from the TeXbook). */
473 #define PT_PER_INCH 72.27
475 /* Return a pixel size (integer) corresponding to POINT size (double)
476 on resolution DPI. */
477 #define POINT_TO_PIXEL(POINT, DPI) ((POINT) * (DPI) / PT_PER_INCH + 0.5)
479 /* Return a point size corresponding to POINT size (integer)
480 on resolution DPI. Note that though point size is a double, we expect
481 it to be rounded to an int, so we add 0.5 here. If the desired value
482 is tenths of points (as in xfld specs), then the pixel size should
483 be multiplied BEFORE the conversion to avoid magnifying the error. */
484 #define PIXEL_TO_POINT(PIXEL, DPI) ((PIXEL) * PT_PER_INCH / (DPI) + 0.5)
486 /* Ignore the difference of font pixel sizes less than or equal to
487 this value. */
488 #define FONT_PIXEL_SIZE_QUANTUM 1
490 struct face;
492 #define FONT_INVALID_CODE 0xFFFFFFFF
494 /* Font driver. Members specified as "optional" can be NULL. */
496 struct font_driver
498 /* Symbol indicating the type of the font-driver. */
499 Lisp_Object type;
501 /* 1 iff the font's foundry, family, and adstyle names are case
502 sensitve. */
503 int case_sensitive;
505 /* Return a cache of font-entities on frame F. The cache must be a
506 cons whose cdr part is the actual cache area. */
507 Lisp_Object (*get_cache) P_ ((FRAME_PTR F));
509 /* List fonts exactly matching with FONT_SPEC on FRAME. The value
510 is a list of font-entities. The font properties to be considered
511 are: :foundry, :family, :adstyle, :registry, :script, :lang, and
512 :otf. See the function `font-spec' for their meanings. Note
513 that the last three properties are stored in FONT_EXTRA_INDEX
514 slot of FONT_SPEC.
516 The returned value is a list of font-entities. Each font-entity
517 has :type property whose value is the same as the above `type'.
518 It also has these properties if they are available from the
519 corresponding font; :foundry, :family, :adstyle, :registry,
520 :weight, :slant, :width, :size, :dpi, :spacing, :avgwidth. If
521 the font is scalable, :size and :avgwidth must be 0.
523 The `open' method of the same font-backend is called with one of
524 the returned font-entities. If the backend needs additional
525 information to be used in `open' method, this method can add any
526 Lispy value by the property :font-entity to the entities.
528 This and the following `match' are the only APIs that allocate
529 font-entities. */
530 Lisp_Object (*list) P_ ((Lisp_Object frame, Lisp_Object font_spec));
532 /* Return a font-entity most closely matching with FONT_SPEC on
533 FRAME. Which font property to consider, and how to calculate the
534 closeness is determined by the font backend, thus
535 `face-font-selection-order' is ignored here.
537 The properties that the font-entity has is the same as `list'
538 method. */
539 Lisp_Object (*match) P_ ((Lisp_Object frame, Lisp_Object font_spec));
541 /* Optional.
542 List available families. The value is a list of family names
543 (symbols). */
544 Lisp_Object (*list_family) P_ ((Lisp_Object frame));
546 /* Optional (if FONT_EXTRA_INDEX is not Lisp_Save_Value).
547 Free FONT_EXTRA_INDEX field of FONT_ENTITY. */
548 void (*free_entity) P_ ((Lisp_Object font_entity));
550 /* Open a font specified by FONT_ENTITY on frame F. If the font is
551 scalable, open it with PIXEL_SIZE. */
552 Lisp_Object (*open) P_ ((FRAME_PTR f, Lisp_Object font_entity,
553 int pixel_size));
555 /* Close FONT on frame F. */
556 void (*close) P_ ((FRAME_PTR f, struct font *font));
558 /* Optional (if FACE->extra is not used).
559 Prepare FACE for displaying characters by FONT on frame F by
560 storing some data in FACE->extra. If successful, return 0.
561 Otherwise, return -1. */
562 int (*prepare_face) P_ ((FRAME_PTR f, struct face *face));
564 /* Optional.
565 Done FACE for displaying characters by FACE->font on frame F. */
566 void (*done_face) P_ ((FRAME_PTR f, struct face *face));
568 /* Optional.
569 If FONT (FONT-ENTITY or FONT-OBJECT) has a glyph for character C
570 (Unicode code point), return 1. If not, return 0. If FONT is
571 FONT-ENTITY and it must be opened to check it, return -1. */
572 int (*has_char) P_ ((Lisp_Object font, int c));
574 /* Return a glyph code of FONT for character C (Unicode code point).
575 If FONT doesn't have such a glyph, return FONT_INVALID_CODE. */
576 unsigned (*encode_char) P_ ((struct font *font, int c));
578 /* Computate the total metrics of the NGLYPHS glyphs specified by
579 the font FONT and the sequence of glyph codes CODE, and store the
580 result in METRICS. */
581 int (*text_extents) P_ ((struct font *font,
582 unsigned *code, int nglyphs,
583 struct font_metrics *metrics));
585 /* Optional.
586 Draw glyphs between FROM and TO of S->char2b at (X Y) pixel
587 position of frame F with S->FACE and S->GC. If WITH_BACKGROUND
588 is nonzero, fill the background in advance. It is assured that
589 WITH_BACKGROUND is zero when (FROM > 0 || TO < S->nchars). */
590 int (*draw) P_ ((struct glyph_string *s, int from, int to,
591 int x, int y, int with_background));
593 /* Optional.
594 Store bitmap data for glyph-code CODE of FONT in BITMAP. It is
595 intended that this method is callled from the other font-driver
596 for actual drawing. */
597 int (*get_bitmap) P_ ((struct font *font, unsigned code,
598 struct font_bitmap *bitmap,
599 int bits_per_pixel));
601 /* Optional.
602 Free bitmap data in BITMAP. */
603 void (*free_bitmap) P_ ((struct font *font, struct font_bitmap *bitmap));
605 /* Optional.
606 Return an outline data for glyph-code CODE of FONT. The format
607 of the outline data depends on the font-driver. */
608 void *(*get_outline) P_ ((struct font *font, unsigned code));
610 /* Optional.
611 Free OUTLINE (that is obtained by the above method). */
612 void (*free_outline) P_ ((struct font *font, void *outline));
614 /* Optional.
615 Get coordinates of the INDEXth anchor point of the glyph whose
616 code is CODE. Store the coordinates in *X and *Y. Return 0 if
617 the operations was successfull. Otherwise return -1. */
618 int (*anchor_point) P_ ((struct font *font, unsigned code, int index,
619 int *x, int *y));
621 /* Optional.
622 Return a list describing which scripts/languages FONT
623 supports by which GSUB/GPOS features of OpenType tables. */
624 Lisp_Object (*otf_capability) P_ ((struct font *font));
626 /* Optional.
627 Apply FONT's OTF-FEATURES to the glyph string.
629 FEATURES specifies which OTF features to apply in this format:
630 (SCRIPT LANGSYS GSUB-FEATURE GPOS-FEATURE)
631 See the documentation of `font-drive-otf' for the detail.
633 This method applies the specified features to the codes in the
634 elements of GSTRING-IN (between FROMth and TOth). The output
635 codes are stored in GSTRING-OUT at the IDXth element and the
636 following elements.
638 Return the number of output codes. If none of the features are
639 applicable to the input data, return 0. If GSTRING-OUT is too
640 short, return -1. */
641 int (*otf_drive) P_ ((struct font *font, Lisp_Object features,
642 Lisp_Object gstring_in, int from, int to,
643 Lisp_Object gstring_out, int idx, int alternate_subst));
645 /* Optional.
646 Make the font driver ready for frame F. Usually this function
647 makes some data specific to F and stores it in F by calling
648 font_put_frame_data (). */
649 int (*start_for_frame) P_ ((FRAME_PTR f));
651 /* Optional.
652 End using the driver for frame F. Usually this function free
653 some data stored for F. */
654 int (*end_for_frame) P_ ((FRAME_PTR f));
656 /* Optional.
658 Shape text in GSTRING. See the docstring of
659 `composition-get-gstring' for the format of GSTRING. If the
660 (N+1)th element of GSTRING is nil, input of shaping is from the
661 1st to (N)th elements. In each input glyph, FROM, TO, CHAR, and
662 CODE are already set.
664 This function updates all fields of the input glyphs. If the
665 output glyphs (M) are more than the input glyphs (N), (N+1)th
666 through (M)th elements of GSTRING are updated possibly by making
667 a new glyph object and storing it in GSTRING. If (M) is greater
668 than the length of GSTRING, nil should be return. In that case,
669 this function is called again with the larger GSTRING. */
670 Lisp_Object (*shape) P_ ((Lisp_Object lgstring));
672 /* Optional.
674 If FONT is usable on frame F, return 0. Otherwise return -1.
675 This method is used only for debugging. If this method is NULL,
676 Emacs assumes that the font is usable on any frame. */
677 int (*check) P_ ((FRAME_PTR F, struct font *font));
679 /* Optional.
681 Return the number of variation glyphs of character C supported by
682 FONT. VARIATIONS is an array of 256 elements. If the variation
683 selector N (1..256) defines a glyph, that glyph code is stored in
684 the (N-1)th element of VARIATIONS. */
685 int (*get_variation_glyphs) P_ ((struct font *font,
686 int c, unsigned variations[256]));
688 void (*filter_properties) P_ ((Lisp_Object font, Lisp_Object properties));
690 /* Optional.
692 Return non-zero if FONT_OBJECT can be used as a (cached) font
693 for ENTITY on frame F. */
694 int (*cached_font_ok) P_ ((struct frame *f,
695 Lisp_Object font_object,
696 Lisp_Object entity));
700 /* Chain of font drivers. There's one global font driver list
701 (font_driver_list in font.c). In addition, each frame has it's own
702 font driver list at FRAME_PTR->font_driver_list. */
704 struct font_driver_list
706 /* 1 iff this driver is currently used. It is igonred in the global
707 font driver list.*/
708 int on;
709 /* Pointer to the font driver. */
710 struct font_driver *driver;
711 /* Pointer to the next element of the chain. */
712 struct font_driver_list *next;
716 /* Chain of arbitrary data specific to each font driver. Each frame
717 has it's own font data list at FRAME_PTR->font_data_list. */
719 struct font_data_list
721 /* Pointer to the font driver. */
722 struct font_driver *driver;
723 /* Data specific to the font driver. */
724 void *data;
725 /* Pointer to the next element of the chain. */
726 struct font_data_list *next;
729 EXFUN (Ffont_spec, MANY);
730 EXFUN (Fcopy_font_spec, 1);
731 EXFUN (Fmerge_font_spec, 2);
732 EXFUN (Ffont_get, 2);
733 EXFUN (Ffont_put, 3);
734 EXFUN (Flist_fonts, 4);
735 EXFUN (Ffont_family_list, 1);
736 EXFUN (Fclear_font_cache, 0);
737 EXFUN (Ffont_xlfd_name, 2);
739 extern Lisp_Object font_make_spec P_ ((void));
740 extern Lisp_Object font_make_entity P_ ((void));
741 extern Lisp_Object font_make_object P_ ((int, Lisp_Object, int));
743 extern Lisp_Object find_font_encoding P_ ((Lisp_Object));
744 extern int font_registry_charsets P_ ((Lisp_Object, struct charset **,
745 struct charset **));
746 extern int font_style_to_value P_ ((enum font_property_index prop,
747 Lisp_Object name, int noerror));
748 extern Lisp_Object font_style_symbolic P_ ((Lisp_Object font,
749 enum font_property_index prop,
750 int for_face));
752 extern int font_match_p P_ ((Lisp_Object spec, Lisp_Object font));
753 extern Lisp_Object font_list_entities P_ ((Lisp_Object frame,
754 Lisp_Object spec));
756 extern Lisp_Object font_get_name P_ ((Lisp_Object font_object));
757 extern Lisp_Object font_spec_from_name P_ ((Lisp_Object font_name));
758 extern Lisp_Object font_get_frame P_ ((Lisp_Object font_object));
759 extern int font_has_char P_ ((FRAME_PTR, Lisp_Object, int));
760 extern unsigned font_encode_char P_ ((Lisp_Object, int));
762 extern void font_clear_prop P_ ((Lisp_Object *attrs,
763 enum font_property_index prop));
764 extern void font_update_lface P_ ((FRAME_PTR f, Lisp_Object *attrs));
765 extern Lisp_Object font_find_for_lface P_ ((FRAME_PTR f, Lisp_Object *lface,
766 Lisp_Object spec, int c));
767 extern Lisp_Object font_open_for_lface P_ ((FRAME_PTR f, Lisp_Object entity,
768 Lisp_Object *lface,
769 Lisp_Object spec));
770 extern Lisp_Object font_load_for_lface P_ ((FRAME_PTR f, Lisp_Object *lface,
771 Lisp_Object spec));
772 extern void font_prepare_for_face P_ ((FRAME_PTR f, struct face *face));
773 extern void font_done_for_face P_ ((FRAME_PTR f, struct face *face));
775 extern Lisp_Object font_open_by_spec P_ ((FRAME_PTR f, Lisp_Object spec));
776 extern Lisp_Object font_open_by_name P_ ((FRAME_PTR f, char *name));
777 extern void font_close_object (FRAME_PTR f, Lisp_Object font_object);
779 extern Lisp_Object font_intern_prop P_ ((char *str, int len, int force_symbol));
780 extern void font_update_sort_order P_ ((int *order));
782 extern void font_parse_family_registry P_ ((Lisp_Object family,
783 Lisp_Object registry,
784 Lisp_Object spec));
785 extern Lisp_Object font_spec_from_family_registry P_ ((Lisp_Object family,
786 Lisp_Object registry));
788 extern int font_parse_xlfd P_ ((char *name, Lisp_Object font));
789 extern int font_unparse_xlfd P_ ((Lisp_Object font, int pixel_size,
790 char *name, int bytes));
791 extern int font_parse_fcname P_ ((char *name, Lisp_Object font));
792 extern int font_unparse_fcname P_ ((Lisp_Object font, int pixel_size,
793 char *name, int bytes));
794 extern int font_unparse_gtkname P_ ((Lisp_Object, struct frame *, char *, int));
795 extern void register_font_driver P_ ((struct font_driver *driver, FRAME_PTR f));
796 extern void free_font_driver_list P_ ((FRAME_PTR f));
797 extern Lisp_Object font_update_drivers P_ ((FRAME_PTR f, Lisp_Object list));
798 extern Lisp_Object font_at P_ ((int c, EMACS_INT pos, struct face *face,
799 struct window *w, Lisp_Object object));
800 extern Lisp_Object font_range (EMACS_INT, EMACS_INT *,
801 struct window *, struct face *,
802 Lisp_Object);
803 extern void font_fill_lglyph_metrics P_ ((Lisp_Object, Lisp_Object));
805 extern Lisp_Object font_put_extra P_ ((Lisp_Object font, Lisp_Object prop,
806 Lisp_Object val));
808 extern int font_put_frame_data P_ ((FRAME_PTR f,
809 struct font_driver *driver,
810 void *data));
811 extern void *font_get_frame_data P_ ((FRAME_PTR f,
812 struct font_driver *driver));
814 extern void font_filter_properties (Lisp_Object font,
815 Lisp_Object alist,
816 const char *boolean_properties[],
817 const char *non_boolean_properties[]);
819 #ifdef HAVE_FREETYPE
820 extern struct font_driver ftfont_driver;
821 #endif /* HAVE_FREETYPE */
822 #ifdef HAVE_X_WINDOWS
823 extern struct font_driver xfont_driver;
824 extern struct font_driver ftxfont_driver;
825 #ifdef HAVE_XFT
826 extern struct font_driver xftfont_driver;
827 #endif /* HAVE_XFT */
828 #endif /* HAVE_X_WINDOWS */
829 #ifdef WINDOWSNT
830 extern struct font_driver w32font_driver;
831 extern struct font_driver uniscribe_font_driver;
832 #endif /* WINDOWSNT */
833 #ifdef HAVE_NS
834 extern struct font_driver nsfont_driver;
835 #endif /* HAVE_NS */
837 #ifndef FONT_DEBUG
838 #define FONT_DEBUG
839 #endif
841 extern Lisp_Object Vfont_log;
842 extern void font_add_log P_ ((char *, Lisp_Object, Lisp_Object));
843 extern void font_deferred_log P_ ((char *, Lisp_Object, Lisp_Object));
845 #define FONT_ADD_LOG(ACTION, ARG, RESULT) \
846 do { \
847 if (! EQ (Vfont_log, Qt)) \
848 font_add_log ((ACTION), (ARG), (RESULT)); \
849 } while (0)
851 #define FONT_DEFERRED_LOG(ACTION, ARG, RESULT) \
852 do { \
853 if (! EQ (Vfont_log, Qt)) \
854 font_deferred_log ((ACTION), (ARG), (RESULT)); \
855 } while (0)
857 #ifdef FONT_DEBUG
858 #define font_assert(X) do {if (!(X)) abort ();} while (0)
859 #else /* not FONT_DEBUG */
860 #define font_assert(X) (void) 0
861 #endif /* not FONT_DEBUG */
863 #endif /* not EMACS_FONT_H */
865 /* arch-tag: 3b7260c3-5bec-4d6b-a0db-95c1b431b1a2
866 (do not change this comment) */