| 1 | /* font.h -- Interface definition for font handling. |
| 2 | Copyright (C) 2006-2014 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 |
| 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 | #include "frame.h" |
| 27 | |
| 28 | INLINE_HEADER_BEGIN |
| 29 | |
| 30 | /* We have three types of Lisp objects related to font. |
| 31 | |
| 32 | FONT-SPEC |
| 33 | |
| 34 | Pseudo vector (length FONT_SPEC_MAX) of font properties. Some |
| 35 | properties can be left unspecified (i.e. nil). Emacs asks |
| 36 | font-drivers to find a font by FONT-SPEC. A fontset entry |
| 37 | specifies requisite properties whereas a face specifies just |
| 38 | preferable properties. |
| 39 | |
| 40 | FONT-ENTITY |
| 41 | |
| 42 | Pseudo vector (length FONT_ENTITY_MAX) of fully instantiated |
| 43 | font properties that a font-driver returns upon a request of |
| 44 | FONT-SPEC. |
| 45 | |
| 46 | Note: Only the method `list' and `match' of a font-driver can |
| 47 | create this object, and it should never be modified by Lisp. |
| 48 | |
| 49 | FONT-OBJECT |
| 50 | |
| 51 | Pseudo vector (length FONT_OBJECT_MAX) of an opened font. |
| 52 | |
| 53 | Lisp object encapsulating "struct font". This corresponds to |
| 54 | an opened font. |
| 55 | |
| 56 | Note: Only the method `open' of a font-driver can create this |
| 57 | object, and it should never be modified by Lisp. */ |
| 58 | |
| 59 | extern Lisp_Object Qfont_spec, Qfont_entity, Qfont_object; |
| 60 | |
| 61 | /* An enumerator for each font property. This is used as an index to |
| 62 | the vector of FONT-SPEC and FONT-ENTITY. |
| 63 | |
| 64 | Note: The order is important and should not be changed. */ |
| 65 | |
| 66 | enum font_property_index |
| 67 | { |
| 68 | /* FONT-TYPE is a symbol indicating a font backend; currently `x', |
| 69 | `xft', and `ftx' are available on X, `uniscribe' and `gdi' on |
| 70 | Windows, and `ns' under Cocoa / GNUstep. */ |
| 71 | FONT_TYPE_INDEX, |
| 72 | |
| 73 | /* FONT-FOUNDRY is a foundry name (symbol). */ |
| 74 | FONT_FOUNDRY_INDEX, |
| 75 | |
| 76 | /* FONT-FAMILY is a family name (symbol). */ |
| 77 | FONT_FAMILY_INDEX, |
| 78 | |
| 79 | /* FONT-ADSTYLE is an additional style name (symbol). */ |
| 80 | FONT_ADSTYLE_INDEX, |
| 81 | |
| 82 | /* FONT-REGISTRY is a combination of a charset-registry and |
| 83 | charset-encoding name (symbol). */ |
| 84 | FONT_REGISTRY_INDEX, |
| 85 | |
| 86 | /* FONT-WEIGHT is a numeric value of weight (e.g. medium, bold) of |
| 87 | the font. The lowest 8 bits is an index determining the |
| 88 | symbolic name, and the higher bits is the actual numeric value |
| 89 | defined in `font-weight-table'. */ |
| 90 | FONT_WEIGHT_INDEX, |
| 91 | |
| 92 | /* FONT-SLANT is a numeric value of slant (e.g. r, i, o) of the |
| 93 | font. The lowest 8 bits is an index determining the symbolic |
| 94 | name, and the higher bits is the actual numeric value defined |
| 95 | in `font-slant-table'. */ |
| 96 | FONT_SLANT_INDEX, |
| 97 | |
| 98 | /* FONT-WIDTH is a numeric value of setwidth (e.g. normal) of the |
| 99 | font. The lowest 8 bits is an index determining the symbolic |
| 100 | name, and the higher bits is the actual numeric value defined |
| 101 | `font-width-table'. */ |
| 102 | FONT_WIDTH_INDEX, |
| 103 | |
| 104 | /* FONT-SIZE is a size of the font. If integer, it is a pixel |
| 105 | size. For a font-spec, the value can be a float specifying |
| 106 | the point size. The value zero means that the font is |
| 107 | scalable. */ |
| 108 | FONT_SIZE_INDEX, |
| 109 | |
| 110 | /* FONT-DPI is a resolution (dot per inch) for which the font is |
| 111 | designed. */ |
| 112 | FONT_DPI_INDEX, |
| 113 | |
| 114 | /* FONT-SPACING is a spacing (mono, proportional, charcell) of the |
| 115 | font (integer; one of enum font_spacing). */ |
| 116 | FONT_SPACING_INDEX, |
| 117 | |
| 118 | /* FONT-AVGWIDTH is an average width (1/10 pixel unit) of the |
| 119 | font. */ |
| 120 | FONT_AVGWIDTH_INDEX, |
| 121 | |
| 122 | #if false |
| 123 | /* The following two members are to substitute for the above 6 |
| 124 | members (FONT_WEIGHT_INDEX to FONT_AVGWIDTH_INDEX excluding |
| 125 | FONT_SIZE_INDEX) if it is found that font-entities consumes too |
| 126 | much memory. */ |
| 127 | |
| 128 | /* FONT-STYLE is a 24-bit integer containing indices for |
| 129 | style-related properties WEIGHT, SLANT, and WIDTH. The lowest |
| 130 | 8 bits is an index to the weight table AREF (font_style_table, |
| 131 | 0), the next 8 bits is an index to the slant table AREF |
| 132 | (font_style_table, 1), the highest 8 bits is an index to the |
| 133 | slant table AREF (font_style_table, 2). The index 0 indicates |
| 134 | that the corresponding style is not specified. This way, we |
| 135 | can represent at most 255 different names for each style, which |
| 136 | is surely sufficient. */ |
| 137 | FONT_STYLE_INDEX, |
| 138 | |
| 139 | /* FONT-METRICS is a 27-bit integer containing metrics-related |
| 140 | properties DPI, AVGWIDTH, SPACING. The lowest 12 bits is for |
| 141 | DPI, the next 12 bits is for AVGWIDTH, the highest 3 bits is for |
| 142 | SPACING. In each bit field, the highest bit indicates that the |
| 143 | corresponding value is set or not. This way, we can represent |
| 144 | DPI by 11-bit (0 to 2047), AVGWIDTH by 11-bit (0 to 2047), |
| 145 | SPACING by 3-bit (0 for proportional, 1 for dual, 2 for mono, 3 |
| 146 | for charcell), which is surely sufficient. */ |
| 147 | FONT_METRICS_INDEX, |
| 148 | #endif |
| 149 | |
| 150 | /* In a font-spec, the value is an alist of extra information of a |
| 151 | font such as name, OpenType features, and language coverage. |
| 152 | In addition, in a font-entity, the value may contain a pair |
| 153 | (font-entity . INFO) where INFO is extra information to identify |
| 154 | a font (font-driver dependent). */ |
| 155 | FONT_EXTRA_INDEX, /* alist alist */ |
| 156 | |
| 157 | /* This value is the length of font-spec vector. */ |
| 158 | FONT_SPEC_MAX, |
| 159 | |
| 160 | /* The followings are used only for a font-entity and a font-object. */ |
| 161 | |
| 162 | /* List of font-objects opened from the font-entity. */ |
| 163 | FONT_OBJLIST_INDEX = FONT_SPEC_MAX, |
| 164 | |
| 165 | /* Font-entity from which the font-object is opened. */ |
| 166 | FONT_ENTITY_INDEX = FONT_SPEC_MAX, |
| 167 | |
| 168 | /* This value is the length of font-entity vector. */ |
| 169 | FONT_ENTITY_MAX, |
| 170 | |
| 171 | /* The followings are used only for a font-object. */ |
| 172 | |
| 173 | /* XLFD name of the font (string). */ |
| 174 | FONT_NAME_INDEX = FONT_ENTITY_MAX, |
| 175 | |
| 176 | /* Full name of the font (string). It is the name extracted from |
| 177 | the opened font, and may be different from the above. It may be |
| 178 | nil if the opened font doesn't give a name. */ |
| 179 | FONT_FULLNAME_INDEX, |
| 180 | |
| 181 | /* File name of the font or nil if a file associated with the font |
| 182 | is not available. */ |
| 183 | FONT_FILE_INDEX, |
| 184 | |
| 185 | /* Format of the font (symbol) or nil if unknown. */ |
| 186 | FONT_FORMAT_INDEX, |
| 187 | |
| 188 | /* This value is the length of font-object vector. */ |
| 189 | FONT_OBJECT_MAX |
| 190 | }; |
| 191 | |
| 192 | /* Return the numeric weight value of FONT. */ |
| 193 | #define FONT_WEIGHT_NUMERIC(font) \ |
| 194 | (INTEGERP (AREF ((font), FONT_WEIGHT_INDEX)) \ |
| 195 | ? (XINT (AREF ((font), FONT_WEIGHT_INDEX)) >> 8) : -1) |
| 196 | /* Return the numeric slant value of FONT. */ |
| 197 | #define FONT_SLANT_NUMERIC(font) \ |
| 198 | (INTEGERP (AREF ((font), FONT_SLANT_INDEX)) \ |
| 199 | ? (XINT (AREF ((font), FONT_SLANT_INDEX)) >> 8) : -1) |
| 200 | /* Return the numeric width value of FONT. */ |
| 201 | #define FONT_WIDTH_NUMERIC(font) \ |
| 202 | (INTEGERP (AREF ((font), FONT_WIDTH_INDEX)) \ |
| 203 | ? (XINT (AREF ((font), FONT_WIDTH_INDEX)) >> 8) : -1) |
| 204 | /* Return the symbolic weight value of FONT. */ |
| 205 | #define FONT_WEIGHT_SYMBOLIC(font) \ |
| 206 | font_style_symbolic (font, FONT_WEIGHT_INDEX, false) |
| 207 | /* Return the symbolic slant value of FONT. */ |
| 208 | #define FONT_SLANT_SYMBOLIC(font) \ |
| 209 | font_style_symbolic (font, FONT_SLANT_INDEX, false) |
| 210 | /* Return the symbolic width value of FONT. */ |
| 211 | #define FONT_WIDTH_SYMBOLIC(font) \ |
| 212 | font_style_symbolic (font, FONT_WIDTH_INDEX, false) |
| 213 | /* Return the face-weight corresponding to the weight of FONT. */ |
| 214 | #define FONT_WEIGHT_FOR_FACE(font) \ |
| 215 | font_style_symbolic (font, FONT_WEIGHT_INDEX, true) |
| 216 | /* Return the face-slant corresponding to the slant of FONT. */ |
| 217 | #define FONT_SLANT_FOR_FACE(font) \ |
| 218 | font_style_symbolic (font, FONT_SLANT_INDEX, true) |
| 219 | /* Return the face-swidth corresponding to the slant of FONT. */ |
| 220 | #define FONT_WIDTH_FOR_FACE(font) \ |
| 221 | font_style_symbolic (font, FONT_WIDTH_INDEX, true) |
| 222 | |
| 223 | /* Return the numeric weight value corresponding ot the symbol NAME. */ |
| 224 | #define FONT_WEIGHT_NAME_NUMERIC(name) \ |
| 225 | (font_style_to_value (FONT_WEIGHT_INDEX, (name), false) >> 8) |
| 226 | /* Return the numeric slant value corresponding ot the symbol NAME. */ |
| 227 | #define FONT_SLANT_NAME_NUMERIC(name) \ |
| 228 | (font_style_to_value (FONT_SLANT_INDEX, (name), false) >> 8) |
| 229 | /* Return the numeric width value corresponding ot the symbol NAME. */ |
| 230 | #define FONT_WIDTH_NAME_NUMERIC(name) \ |
| 231 | (font_style_to_value (FONT_WIDTH_INDEX, (name), false) >> 8) |
| 232 | |
| 233 | /* Set the font property PROP of FONT to VAL. PROP is one of |
| 234 | style-related font property index (FONT_WEIGHT/SLANT/WIDTH_INDEX). |
| 235 | VAL (integer or symbol) is the numeric or symbolic style value. */ |
| 236 | #define FONT_SET_STYLE(font, prop, val) \ |
| 237 | ASET ((font), prop, make_number (font_style_to_value (prop, val, true))) |
| 238 | |
| 239 | #ifndef MSDOS |
| 240 | #define FONT_WIDTH(f) ((f)->max_width) |
| 241 | #else |
| 242 | #define FONT_WIDTH(f) 1 |
| 243 | #endif |
| 244 | #define FONT_HEIGHT(f) ((f)->height) |
| 245 | #define FONT_BASE(f) ((f)->ascent) |
| 246 | #define FONT_DESCENT(f) ((f)->descent) |
| 247 | |
| 248 | extern Lisp_Object QCspacing, QCdpi, QCscalable, QCotf, QClang, QCscript; |
| 249 | extern Lisp_Object QCavgwidth, QCantialias, QCfont_entity; |
| 250 | extern Lisp_Object Qp; |
| 251 | |
| 252 | |
| 253 | /* Important character set symbols. */ |
| 254 | extern Lisp_Object Qascii_0; |
| 255 | extern Lisp_Object Qiso8859_1, Qiso10646_1, Qunicode_bmp, Qunicode_sip; |
| 256 | |
| 257 | /* Special ADSTYLE properties to avoid fonts used for Latin characters. */ |
| 258 | extern Lisp_Object Qja, Qko; |
| 259 | |
| 260 | /* Structure for a font-spec. */ |
| 261 | |
| 262 | struct font_spec |
| 263 | { |
| 264 | struct vectorlike_header header; |
| 265 | Lisp_Object props[FONT_SPEC_MAX]; |
| 266 | }; |
| 267 | |
| 268 | /* Structure for a font-entity. */ |
| 269 | |
| 270 | struct font_entity |
| 271 | { |
| 272 | struct vectorlike_header header; |
| 273 | Lisp_Object props[FONT_ENTITY_MAX]; |
| 274 | }; |
| 275 | |
| 276 | /* A value which may appear in the member `encoding' of struct font |
| 277 | indicating that a font itself doesn't tell which encoding to be |
| 278 | used. */ |
| 279 | #define FONT_ENCODING_NOT_DECIDED 255 |
| 280 | |
| 281 | /* Structure for a font-object. */ |
| 282 | |
| 283 | struct font |
| 284 | { |
| 285 | struct vectorlike_header header; |
| 286 | |
| 287 | /* All Lisp_Object components must come first. |
| 288 | That ensures they are all aligned normally. */ |
| 289 | |
| 290 | Lisp_Object props[FONT_OBJECT_MAX]; |
| 291 | |
| 292 | /* Beyond here, there should be no more Lisp_Object components. */ |
| 293 | |
| 294 | /* Minimum and maximum glyph widths, in pixels. Some font backends, |
| 295 | such as xft, lack the information to easily compute minimum and |
| 296 | maximum widths over all characters; in that case, these values |
| 297 | are approximate. */ |
| 298 | int min_width; |
| 299 | int max_width; |
| 300 | |
| 301 | /* By which pixel size the font is opened. */ |
| 302 | int pixel_size; |
| 303 | |
| 304 | /* Height of the font. On X window, this is the same as |
| 305 | (font->ascent + font->descent). */ |
| 306 | int height; |
| 307 | |
| 308 | /* Width of the space glyph of the font. If the font doesn't have a |
| 309 | SPACE glyph, the value is 0. */ |
| 310 | int space_width; |
| 311 | |
| 312 | /* Average width of glyphs in the font. If the font itself doesn't |
| 313 | have that information but has glyphs of ASCII characters, the |
| 314 | value is the average width of those glyphs. Otherwise, the value |
| 315 | is 0. */ |
| 316 | int average_width; |
| 317 | |
| 318 | /* Ascent and descent of the font (in pixels). */ |
| 319 | int ascent, descent; |
| 320 | |
| 321 | /* The following members makes sense on graphic displays only. */ |
| 322 | |
| 323 | #if defined (HAVE_WINDOW_SYSTEM) |
| 324 | |
| 325 | /* Vertical pixel width of the underline. If is zero if that |
| 326 | information is not in the font. */ |
| 327 | int underline_thickness; |
| 328 | |
| 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; |
| 333 | |
| 334 | /* True if `vertical-centering-font-regexp' matches this font name. |
| 335 | In this case, we render characters at vertical center positions |
| 336 | of lines. */ |
| 337 | bool vertical_centering; |
| 338 | |
| 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. |
| 355 | |
| 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 |
| 367 | of a line. */ |
| 368 | int baseline_offset; |
| 369 | |
| 370 | /* Non-zero means a character should be composed at a position |
| 371 | relative to the height (or depth) of previous glyphs in the |
| 372 | following cases: |
| 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 |
| 377 | previous glyphs. |
| 378 | |
| 379 | This value is taken from a private font property |
| 380 | `_MULE_RELATIVE_COMPOSE' which is introduced by Emacs. */ |
| 381 | int relative_compose; |
| 382 | |
| 383 | /* Non-zero means an ascent value to be used for a character |
| 384 | registered in char-table `use-default-ascent'. */ |
| 385 | int default_ascent; |
| 386 | |
| 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 |
| 389 | a character. */ |
| 390 | int encoding_charset; |
| 391 | |
| 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 |
| 394 | determine it. */ |
| 395 | int repertory_charset; |
| 396 | |
| 397 | #endif /* HAVE_WINDOW_SYSTEM */ |
| 398 | |
| 399 | /* Font-driver for the font. */ |
| 400 | struct font_driver *driver; |
| 401 | |
| 402 | /* There are more members in this structure, but they are private |
| 403 | to the font-driver. */ |
| 404 | }; |
| 405 | |
| 406 | enum font_spacing |
| 407 | { |
| 408 | FONT_SPACING_PROPORTIONAL = 0, |
| 409 | FONT_SPACING_DUAL = 90, |
| 410 | FONT_SPACING_MONO = 100, |
| 411 | FONT_SPACING_CHARCELL = 110 |
| 412 | }; |
| 413 | |
| 414 | struct font_metrics |
| 415 | { |
| 416 | short lbearing, rbearing, width, ascent, descent; |
| 417 | }; |
| 418 | |
| 419 | struct font_bitmap |
| 420 | { |
| 421 | int bits_per_pixel; |
| 422 | int rows; |
| 423 | int width; |
| 424 | int pitch; |
| 425 | unsigned char *buffer; |
| 426 | int left; |
| 427 | int top; |
| 428 | int advance; |
| 429 | }; |
| 430 | |
| 431 | /* Predicates to check various font-related objects. */ |
| 432 | |
| 433 | /* True iff X is one of font-spec, font-entity, and font-object. */ |
| 434 | #define FONTP(x) PSEUDOVECTORP (x, PVEC_FONT) |
| 435 | /* True iff X is font-spec. */ |
| 436 | #define FONT_SPEC_P(x) \ |
| 437 | (FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_SPEC_MAX) |
| 438 | /* True iff X is font-entity. */ |
| 439 | #define FONT_ENTITY_P(x) \ |
| 440 | (FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_ENTITY_MAX) |
| 441 | /* True iff X is font-object. */ |
| 442 | #define FONT_OBJECT_P(x) \ |
| 443 | (FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_OBJECT_MAX) |
| 444 | |
| 445 | /* True iff ENTITY can't be loaded. */ |
| 446 | #define FONT_ENTITY_NOT_LOADABLE(entity) \ |
| 447 | EQ (AREF (entity, FONT_OBJLIST_INDEX), Qt) |
| 448 | |
| 449 | /* Flag ENTITY not loadable. */ |
| 450 | #define FONT_ENTITY_SET_NOT_LOADABLE(entity) \ |
| 451 | ASET (entity, FONT_OBJLIST_INDEX, Qt) |
| 452 | |
| 453 | |
| 454 | /* Check macros for various font-related objects. */ |
| 455 | |
| 456 | #define CHECK_FONT(x) \ |
| 457 | do { if (! FONTP (x)) wrong_type_argument (Qfont, x); } while (false) |
| 458 | #define CHECK_FONT_SPEC(x) \ |
| 459 | do { if (! FONT_SPEC_P (x)) wrong_type_argument (Qfont_spec, x); } \ |
| 460 | while (false) |
| 461 | #define CHECK_FONT_ENTITY(x) \ |
| 462 | do { if (! FONT_ENTITY_P (x)) wrong_type_argument (Qfont_entity, x); } \ |
| 463 | while (false) |
| 464 | #define CHECK_FONT_OBJECT(x) \ |
| 465 | do { if (! FONT_OBJECT_P (x)) wrong_type_argument (Qfont_object, x); } \ |
| 466 | while (false) |
| 467 | |
| 468 | #define CHECK_FONT_GET_OBJECT(x, font) \ |
| 469 | do { \ |
| 470 | CHECK_FONT_OBJECT (x); \ |
| 471 | font = XFONT_OBJECT (x); \ |
| 472 | } while (false) |
| 473 | |
| 474 | #define XFONT_SPEC(p) \ |
| 475 | (eassert (FONT_SPEC_P (p)), (struct font_spec *) SCM_SMOB_DATA (p)) |
| 476 | #define XFONT_ENTITY(p) \ |
| 477 | (eassert (FONT_ENTITY_P (p)), \ |
| 478 | (struct font_entity *) SCM_SMOB_DATA (p)) |
| 479 | #define XFONT_OBJECT(p) \ |
| 480 | (eassert (FONT_OBJECT_P (p)), (struct font *) SCM_SMOB_DATA (p)) |
| 481 | #define XSETFONT(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_FONT)) |
| 482 | |
| 483 | /* Number of pt per inch (from the TeXbook). */ |
| 484 | #define PT_PER_INCH 72.27 |
| 485 | |
| 486 | /* Return a pixel size (integer) corresponding to POINT size (double) |
| 487 | on resolution DPI. */ |
| 488 | #define POINT_TO_PIXEL(POINT, DPI) ((POINT) * (DPI) / PT_PER_INCH + 0.5) |
| 489 | |
| 490 | /* Return a point size corresponding to POINT size (integer) |
| 491 | on resolution DPI. Note that though point size is a double, we expect |
| 492 | it to be rounded to an int, so we add 0.5 here. If the desired value |
| 493 | is tenths of points (as in xfld specs), then the pixel size should |
| 494 | be multiplied BEFORE the conversion to avoid magnifying the error. */ |
| 495 | #define PIXEL_TO_POINT(PIXEL, DPI) ((PIXEL) * PT_PER_INCH / (DPI) + 0.5) |
| 496 | |
| 497 | /* Ignore the difference of font pixel sizes less than or equal to |
| 498 | this value. */ |
| 499 | #define FONT_PIXEL_SIZE_QUANTUM 1 |
| 500 | |
| 501 | #define FONT_INVALID_CODE 0xFFFFFFFF |
| 502 | |
| 503 | /* Font driver. Members specified as "optional" can be NULL. */ |
| 504 | |
| 505 | struct font_driver |
| 506 | { |
| 507 | /* Symbol indicating the type of the font-driver. */ |
| 508 | Lisp_Object type; |
| 509 | |
| 510 | /* True iff the font's foundry, family, and adstyle names are case |
| 511 | sensitive. */ |
| 512 | bool case_sensitive; |
| 513 | |
| 514 | /* Return a cache of font-entities on frame F. The cache must be a |
| 515 | cons whose cdr part is the actual cache area. */ |
| 516 | Lisp_Object (*get_cache) (struct frame *f); |
| 517 | |
| 518 | /* List fonts exactly matching with FONT_SPEC on FRAME. The value |
| 519 | is a list of font-entities. The font properties to be considered |
| 520 | are: :foundry, :family, :adstyle, :registry, :script, :lang, and |
| 521 | :otf. See the function `font-spec' for their meanings. Note |
| 522 | that the last three properties are stored in FONT_EXTRA_INDEX |
| 523 | slot of FONT_SPEC. |
| 524 | |
| 525 | The returned value is a list of font-entities. Each font-entity |
| 526 | has :type property whose value is the same as the above `type'. |
| 527 | It also has these properties if they are available from the |
| 528 | corresponding font; :foundry, :family, :adstyle, :registry, |
| 529 | :weight, :slant, :width, :size, :dpi, :spacing, :avgwidth. If |
| 530 | the font is scalable, :size and :avgwidth must be 0. |
| 531 | |
| 532 | The `open' method of the same font-backend is called with one of |
| 533 | the returned font-entities. If the backend needs additional |
| 534 | information to be used in `open' method, this method can add any |
| 535 | Lispy value by the property :font-entity to the entities. |
| 536 | |
| 537 | This and the following `match' are the only APIs that allocate |
| 538 | font-entities. */ |
| 539 | Lisp_Object (*list) (struct frame *frame, Lisp_Object font_spec); |
| 540 | |
| 541 | /* Return a font-entity most closely matching with FONT_SPEC on |
| 542 | FRAME. Which font property to consider, and how to calculate the |
| 543 | closeness is determined by the font backend, thus |
| 544 | `face-font-selection-order' is ignored here. |
| 545 | |
| 546 | The properties that the font-entity has is the same as `list' |
| 547 | method. */ |
| 548 | Lisp_Object (*match) (struct frame *f, Lisp_Object spec); |
| 549 | |
| 550 | /* Optional. |
| 551 | List available families. The value is a list of family names |
| 552 | (symbols). */ |
| 553 | Lisp_Object (*list_family) (struct frame *f); |
| 554 | |
| 555 | /* Optional (if FONT_EXTRA_INDEX is not Lisp_Save_Value). |
| 556 | Free FONT_EXTRA_INDEX field of FONT_ENTITY. */ |
| 557 | void (*free_entity) (Lisp_Object font_entity); |
| 558 | |
| 559 | /* Open a font specified by FONT_ENTITY on frame F. If the font is |
| 560 | scalable, open it with PIXEL_SIZE. */ |
| 561 | Lisp_Object (*open) (struct frame *f, Lisp_Object font_entity, |
| 562 | int pixel_size); |
| 563 | |
| 564 | /* Close FONT. NOTE: this can be called by GC. */ |
| 565 | void (*close) (struct font *font); |
| 566 | |
| 567 | /* Prepare FACE for displaying characters by FONT on frame F by |
| 568 | storing some data in FACE->extra. */ |
| 569 | void (*prepare_face) (struct frame *f, struct face *face); |
| 570 | |
| 571 | /* Optional. |
| 572 | Done FACE for displaying characters by FACE->font on frame F. */ |
| 573 | void (*done_face) (struct frame *f, struct face *face); |
| 574 | |
| 575 | /* Optional. |
| 576 | If FONT (FONT-ENTITY or FONT-OBJECT) has a glyph for character C |
| 577 | (Unicode code point), return 1. If not, return 0. If FONT is |
| 578 | FONT-ENTITY and it must be opened to check it, return -1. */ |
| 579 | int (*has_char) (Lisp_Object font, int c); |
| 580 | |
| 581 | /* Return a glyph code of FONT for character C (Unicode code point). |
| 582 | If FONT doesn't have such a glyph, return FONT_INVALID_CODE. */ |
| 583 | unsigned (*encode_char) (struct font *font, int c); |
| 584 | |
| 585 | /* Compute the total metrics of the NGLYPHS glyphs specified by |
| 586 | the font FONT and the sequence of glyph codes CODE, and store the |
| 587 | result in METRICS. */ |
| 588 | int (*text_extents) (struct font *font, |
| 589 | unsigned *code, int nglyphs, |
| 590 | struct font_metrics *metrics); |
| 591 | |
| 592 | #ifdef HAVE_WINDOW_SYSTEM |
| 593 | |
| 594 | /* Optional. |
| 595 | Draw glyphs between FROM and TO of S->char2b at (X Y) pixel |
| 596 | position of frame F with S->FACE and S->GC. If WITH_BACKGROUND, |
| 597 | fill the background in advance. It is assured that WITH_BACKGROUND |
| 598 | is false when (FROM > 0 || TO < S->nchars). */ |
| 599 | int (*draw) (struct glyph_string *s, int from, int to, |
| 600 | int x, int y, bool with_background); |
| 601 | |
| 602 | /* Optional. |
| 603 | Store bitmap data for glyph-code CODE of FONT in BITMAP. It is |
| 604 | intended that this method is called from the other font-driver |
| 605 | for actual drawing. */ |
| 606 | int (*get_bitmap) (struct font *font, unsigned code, |
| 607 | struct font_bitmap *bitmap, |
| 608 | int bits_per_pixel); |
| 609 | |
| 610 | /* Optional. |
| 611 | Free bitmap data in BITMAP. */ |
| 612 | void (*free_bitmap) (struct font *font, struct font_bitmap *bitmap); |
| 613 | |
| 614 | #endif /* HAVE_WINDOW_SYSTEM */ |
| 615 | |
| 616 | /* Optional. |
| 617 | Return an outline data for glyph-code CODE of FONT. The format |
| 618 | of the outline data depends on the font-driver. */ |
| 619 | void *(*get_outline) (struct font *font, unsigned code); |
| 620 | |
| 621 | /* Optional. |
| 622 | Free OUTLINE (that is obtained by the above method). */ |
| 623 | void (*free_outline) (struct font *font, void *outline); |
| 624 | |
| 625 | /* Optional. |
| 626 | Get coordinates of the INDEXth anchor point of the glyph whose |
| 627 | code is CODE. Store the coordinates in *X and *Y. Return 0 if |
| 628 | the operations was successful. Otherwise return -1. */ |
| 629 | int (*anchor_point) (struct font *font, unsigned code, int index, |
| 630 | int *x, int *y); |
| 631 | |
| 632 | /* Optional. |
| 633 | Return a list describing which scripts/languages FONT |
| 634 | supports by which GSUB/GPOS features of OpenType tables. */ |
| 635 | Lisp_Object (*otf_capability) (struct font *font); |
| 636 | |
| 637 | /* Optional. |
| 638 | Apply FONT's OTF-FEATURES to the glyph string. |
| 639 | |
| 640 | FEATURES specifies which OTF features to apply in this format: |
| 641 | (SCRIPT LANGSYS GSUB-FEATURE GPOS-FEATURE) |
| 642 | See the documentation of `font-drive-otf' for the details. |
| 643 | |
| 644 | This method applies the specified features to the codes in the |
| 645 | elements of GSTRING-IN (between FROMth and TOth). The output |
| 646 | codes are stored in GSTRING-OUT at the IDXth element and the |
| 647 | following elements. |
| 648 | |
| 649 | Return the number of output codes. If none of the features are |
| 650 | applicable to the input data, return 0. If GSTRING-OUT is too |
| 651 | short, return -1. */ |
| 652 | int (*otf_drive) (struct font *font, Lisp_Object features, |
| 653 | Lisp_Object gstring_in, int from, int to, |
| 654 | Lisp_Object gstring_out, int idx, bool alternate_subst); |
| 655 | |
| 656 | /* Optional. |
| 657 | Make the font driver ready for frame F. Usually this function |
| 658 | makes some data specific to F and stores it in F by calling |
| 659 | font_put_frame_data (). */ |
| 660 | int (*start_for_frame) (struct frame *f); |
| 661 | |
| 662 | /* Optional. |
| 663 | End using the driver for frame F. Usually this function free |
| 664 | some data stored for F. */ |
| 665 | int (*end_for_frame) (struct frame *f); |
| 666 | |
| 667 | /* Optional. |
| 668 | |
| 669 | Shape text in GSTRING. See the docstring of |
| 670 | `composition-get-gstring' for the format of GSTRING. If the |
| 671 | (N+1)th element of GSTRING is nil, input of shaping is from the |
| 672 | 1st to (N)th elements. In each input glyph, FROM, TO, CHAR, and |
| 673 | CODE are already set. |
| 674 | |
| 675 | This function updates all fields of the input glyphs. If the |
| 676 | output glyphs (M) are more than the input glyphs (N), (N+1)th |
| 677 | through (M)th elements of GSTRING are updated possibly by making |
| 678 | a new glyph object and storing it in GSTRING. If (M) is greater |
| 679 | than the length of GSTRING, nil should be return. In that case, |
| 680 | this function is called again with the larger GSTRING. */ |
| 681 | Lisp_Object (*shape) (Lisp_Object lgstring); |
| 682 | |
| 683 | /* Optional. |
| 684 | |
| 685 | If FONT is usable on frame F, return 0. Otherwise return -1. |
| 686 | This method is used only for debugging. If this method is NULL, |
| 687 | Emacs assumes that the font is usable on any frame. */ |
| 688 | int (*check) (struct frame *f, struct font *font); |
| 689 | |
| 690 | /* Optional. |
| 691 | |
| 692 | Return the number of variation glyphs of character C supported by |
| 693 | FONT. VARIATIONS is an array of 256 elements. If the variation |
| 694 | selector N (1..256) defines a glyph, that glyph code is stored in |
| 695 | the (N-1)th element of VARIATIONS. */ |
| 696 | int (*get_variation_glyphs) (struct font *font, |
| 697 | int c, unsigned variations[256]); |
| 698 | |
| 699 | void (*filter_properties) (Lisp_Object font, Lisp_Object properties); |
| 700 | |
| 701 | /* Optional. |
| 702 | |
| 703 | Return non-zero if FONT_OBJECT can be used as a (cached) font |
| 704 | for ENTITY on frame F. */ |
| 705 | bool (*cached_font_ok) (struct frame *f, |
| 706 | Lisp_Object font_object, |
| 707 | Lisp_Object entity); |
| 708 | }; |
| 709 | |
| 710 | |
| 711 | /* Chain of font drivers. There's one global font driver list |
| 712 | (font_driver_list in font.c). In addition, each frame has |
| 713 | its own font driver list at F->font_driver_list. */ |
| 714 | |
| 715 | struct font_driver_list |
| 716 | { |
| 717 | /* True iff this driver is currently used. It is ignored in the global |
| 718 | font driver list.*/ |
| 719 | bool on; |
| 720 | /* Pointer to the font driver. */ |
| 721 | struct font_driver *driver; |
| 722 | /* Pointer to the next element of the chain. */ |
| 723 | struct font_driver_list *next; |
| 724 | }; |
| 725 | |
| 726 | |
| 727 | /* Chain of arbitrary data specific to each font driver. |
| 728 | Each frame has its own font data list at F->font_data_list. */ |
| 729 | |
| 730 | struct font_data_list |
| 731 | { |
| 732 | /* Pointer to the font driver. */ |
| 733 | struct font_driver *driver; |
| 734 | /* Data specific to the font driver. */ |
| 735 | void *data; |
| 736 | /* Pointer to the next element of the chain. */ |
| 737 | struct font_data_list *next; |
| 738 | }; |
| 739 | |
| 740 | extern Lisp_Object copy_font_spec (Lisp_Object); |
| 741 | extern Lisp_Object merge_font_spec (Lisp_Object, Lisp_Object); |
| 742 | |
| 743 | extern Lisp_Object font_make_entity (void); |
| 744 | extern Lisp_Object font_make_object (int, Lisp_Object, int); |
| 745 | |
| 746 | extern Lisp_Object find_font_encoding (Lisp_Object); |
| 747 | extern int font_registry_charsets (Lisp_Object, struct charset **, |
| 748 | 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, |
| 753 | bool for_face); |
| 754 | |
| 755 | extern bool font_match_p (Lisp_Object spec, Lisp_Object font); |
| 756 | extern Lisp_Object font_list_entities (struct frame *, Lisp_Object); |
| 757 | |
| 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); |
| 762 | |
| 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, |
| 768 | Lisp_Object *lface, |
| 769 | Lisp_Object spec); |
| 770 | extern Lisp_Object font_load_for_lface (struct frame *f, Lisp_Object *lface, |
| 771 | Lisp_Object spec); |
| 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 *); |
| 775 | |
| 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); |
| 778 | |
| 779 | extern Lisp_Object font_intern_prop (const char *str, ptrdiff_t len, |
| 780 | bool force_symbol); |
| 781 | extern void font_update_sort_order (int *order); |
| 782 | |
| 783 | extern void font_parse_family_registry (Lisp_Object family, |
| 784 | Lisp_Object registry, |
| 785 | Lisp_Object spec); |
| 786 | |
| 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 | #ifdef ENABLE_CHECKING |
| 795 | extern bool valid_font_driver (struct font_driver *); |
| 796 | #else |
| 797 | INLINE bool |
| 798 | valid_font_driver (struct font_driver *d) |
| 799 | { |
| 800 | return true; |
| 801 | } |
| 802 | #endif |
| 803 | extern Lisp_Object font_update_drivers (struct frame *f, Lisp_Object list); |
| 804 | extern Lisp_Object font_range (ptrdiff_t, ptrdiff_t, ptrdiff_t *, |
| 805 | struct window *, struct face *, |
| 806 | Lisp_Object); |
| 807 | extern void font_fill_lglyph_metrics (Lisp_Object, Lisp_Object); |
| 808 | |
| 809 | extern Lisp_Object font_put_extra (Lisp_Object font, Lisp_Object prop, |
| 810 | Lisp_Object val); |
| 811 | |
| 812 | extern int font_put_frame_data (struct frame *f, |
| 813 | struct font_driver *driver, |
| 814 | void *data); |
| 815 | extern void *font_get_frame_data (struct frame *f, |
| 816 | struct font_driver *driver); |
| 817 | |
| 818 | extern void font_filter_properties (Lisp_Object font, |
| 819 | Lisp_Object alist, |
| 820 | const char *const boolean_properties[], |
| 821 | const char *const non_boolean_properties[]); |
| 822 | |
| 823 | #ifdef HAVE_FREETYPE |
| 824 | extern struct font_driver ftfont_driver; |
| 825 | extern void syms_of_ftfont (void); |
| 826 | #endif /* HAVE_FREETYPE */ |
| 827 | #ifdef HAVE_X_WINDOWS |
| 828 | extern struct font_driver xfont_driver; |
| 829 | extern void syms_of_xfont (void); |
| 830 | extern void syms_of_ftxfont (void); |
| 831 | #ifdef HAVE_XFT |
| 832 | extern Lisp_Object Qxft; |
| 833 | extern struct font_driver xftfont_driver; |
| 834 | extern void syms_of_xftfont (void); |
| 835 | #endif |
| 836 | #if defined HAVE_FREETYPE || defined HAVE_XFT |
| 837 | extern struct font_driver ftxfont_driver; |
| 838 | #endif |
| 839 | #ifdef HAVE_BDFFONT |
| 840 | extern void syms_of_bdffont (void); |
| 841 | #endif /* HAVE_BDFFONT */ |
| 842 | #endif /* HAVE_X_WINDOWS */ |
| 843 | #ifdef HAVE_NTGUI |
| 844 | extern struct font_driver w32font_driver; |
| 845 | extern struct font_driver uniscribe_font_driver; |
| 846 | extern void syms_of_w32font (void); |
| 847 | #endif /* HAVE_NTGUI */ |
| 848 | #ifdef HAVE_NS |
| 849 | extern Lisp_Object Qfontsize; |
| 850 | extern struct font_driver nsfont_driver; |
| 851 | extern void syms_of_nsfont (void); |
| 852 | extern void syms_of_macfont (void); |
| 853 | #endif /* HAVE_NS */ |
| 854 | |
| 855 | #ifndef FONT_DEBUG |
| 856 | #define FONT_DEBUG |
| 857 | #endif |
| 858 | |
| 859 | extern Lisp_Object QCfoundry; |
| 860 | |
| 861 | extern void font_add_log (const char *, Lisp_Object, Lisp_Object); |
| 862 | extern void font_deferred_log (const char *, Lisp_Object, Lisp_Object); |
| 863 | |
| 864 | #define FONT_ADD_LOG(ACTION, ARG, RESULT) \ |
| 865 | do { \ |
| 866 | if (! EQ (Vfont_log, Qt)) \ |
| 867 | font_add_log ((ACTION), (ARG), (RESULT)); \ |
| 868 | } while (false) |
| 869 | |
| 870 | #define FONT_DEFERRED_LOG(ACTION, ARG, RESULT) \ |
| 871 | do { \ |
| 872 | if (! EQ (Vfont_log, Qt)) \ |
| 873 | font_deferred_log ((ACTION), (ARG), (RESULT)); \ |
| 874 | } while (false) |
| 875 | |
| 876 | INLINE_HEADER_END |
| 877 | |
| 878 | #endif /* not EMACS_FONT_H */ |