1 /* 2 * Copyright © 1998-2004 David Turner and Werner Lemberg 3 * Copyright © 2004,2007,2009 Red Hat, Inc. 4 * Copyright © 2011,2012 Google, Inc. 5 * 6 * This is part of HarfBuzz, a text shaping library. 7 * 8 * Permission is hereby granted, without written agreement and without 9 * license or royalty fees, to use, copy, modify, and distribute this 10 * software and its documentation for any purpose, provided that the 11 * above copyright notice and the following two paragraphs appear in 12 * all copies of this software. 13 * 14 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR 15 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES 16 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN 17 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH 18 * DAMAGE. 19 * 20 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, 21 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 22 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS 23 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO 24 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. 25 * 26 * Red Hat Author(s): Owen Taylor, Behdad Esfahbod 27 * Google Author(s): Behdad Esfahbod 28 */ 29 30 #if !defined(HB_H_IN) && !defined(HB_NO_SINGLE_HEADER_ERROR) 31 #error "Include <hb.h> instead." 32 #endif 33 34 #ifndef HB_BUFFER_H 35 #define HB_BUFFER_H 36 37 #include "hb-common.h" 38 #include "hb-unicode.h" 39 #include "hb-font.h" 40 41 HB_BEGIN_DECLS 42 43 /** 44 * hb_glyph_info_t: 45 * @codepoint: either a Unicode code point (before shaping) or a glyph index 46 * (after shaping). 47 * @cluster: the index of the character in the original text that corresponds 48 * to this #hb_glyph_info_t, or whatever the client passes to 49 * hb_buffer_add(). More than one #hb_glyph_info_t can have the same 50 * @cluster value, if they resulted from the same character (e.g. one 51 * to many glyph substitution), and when more than one character gets 52 * merged in the same glyph (e.g. many to one glyph substitution) the 53 * #hb_glyph_info_t will have the smallest cluster value of them. 54 * By default some characters are merged into the same cluster 55 * (e.g. combining marks have the same cluster as their bases) 56 * even if they are separate glyphs, hb_buffer_set_cluster_level() 57 * allow selecting more fine-grained cluster handling. 58 * 59 * The #hb_glyph_info_t is the structure that holds information about the 60 * glyphs and their relation to input text. 61 */ 62 typedef struct hb_glyph_info_t { 63 hb_codepoint_t codepoint; 64 /*< private >*/ 65 hb_mask_t mask; 66 /*< public >*/ 67 uint32_t cluster; 68 69 /*< private >*/ 70 hb_var_int_t var1; 71 hb_var_int_t var2; 72 } hb_glyph_info_t; 73 74 /** 75 * hb_glyph_flags_t: 76 * @HB_GLYPH_FLAG_UNSAFE_TO_BREAK: Indicates that if input text is broken at the 77 * beginning of the cluster this glyph is part of, 78 * then both sides need to be re-shaped, as the 79 * result might be different. 80 * On the flip side, it means that when this 81 * flag is not present, then it is safe to break 82 * the glyph-run at the beginning of this 83 * cluster, and the two sides will represent the 84 * exact same result one would get if breaking 85 * input text at the beginning of this cluster 86 * and shaping the two sides separately. 87 * This can be used to optimize paragraph 88 * layout, by avoiding re-shaping of each line 89 * after line-breaking. 90 * @HB_GLYPH_FLAG_UNSAFE_TO_CONCAT: Indicates that if input text is changed on one 91 * side of the beginning of the cluster this glyph 92 * is part of, then the shaping results for the 93 * other side might change. 94 * Note that the absence of this flag will NOT by 95 * itself mean that it IS safe to concat text. 96 * Only two pieces of text both of which clear of 97 * this flag can be concatenated safely. 98 * This can be used to optimize paragraph 99 * layout, by avoiding re-shaping of each line 100 * after line-breaking, by limiting the 101 * reshaping to a small piece around the 102 * breaking positin only, even if the breaking 103 * position carries the 104 * #HB_GLYPH_FLAG_UNSAFE_TO_BREAK or when 105 * hyphenation or other text transformation 106 * happens at line-break position, in the following 107 * way: 108 * 1. Iterate back from the line-break position 109 * until the first cluster start position that is 110 * NOT unsafe-to-concat, 2. shape the segment from 111 * there till the end of line, 3. check whether the 112 * resulting glyph-run also is clear of the 113 * unsafe-to-concat at its start-of-text position; 114 * if it is, just splice it into place and the line 115 * is shaped; If not, move on to a position further 116 * back that is clear of unsafe-to-concat and retry 117 * from there, and repeat. 118 * At the start of next line a similar algorithm can 119 * be implemented. That is: 1. Iterate forward from 120 * the line-break position until the first cluster 121 * start position that is NOT unsafe-to-concat, 2. 122 * shape the segment from beginning of the line to 123 * that position, 3. check whether the resulting 124 * glyph-run also is clear of the unsafe-to-concat 125 * at its end-of-text position; if it is, just splice 126 * it into place and the beginning is shaped; If not, 127 * move on to a position further forward that is clear 128 * of unsafe-to-concat and retry up to there, and repeat. 129 * A slight complication will arise in the 130 * implementation of the algorithm above, 131 * because while our buffer API has a way to 132 * return flags for position corresponding to 133 * start-of-text, there is currently no position 134 * corresponding to end-of-text. This limitation 135 * can be alleviated by shaping more text than needed 136 * and looking for unsafe-to-concat flag within text 137 * clusters. 138 * The #HB_GLYPH_FLAG_UNSAFE_TO_BREAK flag will 139 * always imply this flag. 140 * To use this flag, you must enable the buffer flag 141 * @HB_BUFFER_FLAG_PRODUCE_UNSAFE_TO_CONCAT during 142 * shaping, otherwise the buffer flag will not be 143 * reliably produced. 144 * Since: 4.0.0 145 * @HB_GLYPH_FLAG_SAFE_TO_INSERT_TATWEEL: In scripts that use elongation (Arabic, 146 Mongolian, Syriac, etc.), this flag signifies 147 that it is safe to insert a U+0640 TATWEEL 148 character before this cluster for elongation. 149 This flag does not determine the 150 script-specific elongation places, but only 151 when it is safe to do the elongation without 152 interrupting text shaping. 153 Since: 5.1.0 154 * @HB_GLYPH_FLAG_DEFINED: All the currently defined flags. 155 * 156 * Flags for #hb_glyph_info_t. 157 * 158 * Since: 1.5.0 159 */ 160 typedef enum { /*< flags >*/ 161 HB_GLYPH_FLAG_UNSAFE_TO_BREAK = 0x00000001, 162 HB_GLYPH_FLAG_UNSAFE_TO_CONCAT = 0x00000002, 163 HB_GLYPH_FLAG_SAFE_TO_INSERT_TATWEEL = 0x00000004, 164 165 HB_GLYPH_FLAG_DEFINED = 0x00000007 /* OR of all defined flags */ 166 } hb_glyph_flags_t; 167 168 HB_EXTERN hb_glyph_flags_t 169 hb_glyph_info_get_glyph_flags (const hb_glyph_info_t *info); 170 171 #define hb_glyph_info_get_glyph_flags(info) \ 172 ((hb_glyph_flags_t) ((unsigned int) (info)->mask & HB_GLYPH_FLAG_DEFINED)) 173 174 175 /** 176 * hb_glyph_position_t: 177 * @x_advance: how much the line advances after drawing this glyph when setting 178 * text in horizontal direction. 179 * @y_advance: how much the line advances after drawing this glyph when setting 180 * text in vertical direction. 181 * @x_offset: how much the glyph moves on the X-axis before drawing it, this 182 * should not affect how much the line advances. 183 * @y_offset: how much the glyph moves on the Y-axis before drawing it, this 184 * should not affect how much the line advances. 185 * 186 * The #hb_glyph_position_t is the structure that holds the positions of the 187 * glyph in both horizontal and vertical directions. All positions in 188 * #hb_glyph_position_t are relative to the current point. 189 * 190 */ 191 typedef struct hb_glyph_position_t { 192 hb_position_t x_advance; 193 hb_position_t y_advance; 194 hb_position_t x_offset; 195 hb_position_t y_offset; 196 197 /*< private >*/ 198 hb_var_int_t var; 199 } hb_glyph_position_t; 200 201 /** 202 * hb_segment_properties_t: 203 * @direction: the #hb_direction_t of the buffer, see hb_buffer_set_direction(). 204 * @script: the #hb_script_t of the buffer, see hb_buffer_set_script(). 205 * @language: the #hb_language_t of the buffer, see hb_buffer_set_language(). 206 * 207 * The structure that holds various text properties of an #hb_buffer_t. Can be 208 * set and retrieved using hb_buffer_set_segment_properties() and 209 * hb_buffer_get_segment_properties(), respectively. 210 */ 211 typedef struct hb_segment_properties_t { 212 hb_direction_t direction; 213 hb_script_t script; 214 hb_language_t language; 215 /*< private >*/ 216 void *reserved1; 217 void *reserved2; 218 } hb_segment_properties_t; 219 220 /** 221 * HB_SEGMENT_PROPERTIES_DEFAULT: 222 * 223 * The default #hb_segment_properties_t of of freshly created #hb_buffer_t. 224 */ 225 #define HB_SEGMENT_PROPERTIES_DEFAULT {HB_DIRECTION_INVALID, \ 226 HB_SCRIPT_INVALID, \ 227 HB_LANGUAGE_INVALID, \ 228 (void *) 0, \ 229 (void *) 0} 230 231 HB_EXTERN hb_bool_t 232 hb_segment_properties_equal (const hb_segment_properties_t *a, 233 const hb_segment_properties_t *b); 234 235 HB_EXTERN unsigned int 236 hb_segment_properties_hash (const hb_segment_properties_t *p); 237 238 HB_EXTERN void 239 hb_segment_properties_overlay (hb_segment_properties_t *p, 240 const hb_segment_properties_t *src); 241 242 243 /** 244 * hb_buffer_t: 245 * 246 * The main structure holding the input text and its properties before shaping, 247 * and output glyphs and their information after shaping. 248 */ 249 250 typedef struct hb_buffer_t hb_buffer_t; 251 252 HB_EXTERN hb_buffer_t * 253 hb_buffer_create (void); 254 255 HB_EXTERN hb_buffer_t * 256 hb_buffer_create_similar (const hb_buffer_t *src); 257 258 HB_EXTERN void 259 hb_buffer_reset (hb_buffer_t *buffer); 260 261 262 HB_EXTERN hb_buffer_t * 263 hb_buffer_get_empty (void); 264 265 HB_EXTERN hb_buffer_t * 266 hb_buffer_reference (hb_buffer_t *buffer); 267 268 HB_EXTERN void 269 hb_buffer_destroy (hb_buffer_t *buffer); 270 271 HB_EXTERN hb_bool_t 272 hb_buffer_set_user_data (hb_buffer_t *buffer, 273 hb_user_data_key_t *key, 274 void * data, 275 hb_destroy_func_t destroy, 276 hb_bool_t replace); 277 278 HB_EXTERN void * 279 hb_buffer_get_user_data (const hb_buffer_t *buffer, 280 hb_user_data_key_t *key); 281 282 283 /** 284 * hb_buffer_content_type_t: 285 * @HB_BUFFER_CONTENT_TYPE_INVALID: Initial value for new buffer. 286 * @HB_BUFFER_CONTENT_TYPE_UNICODE: The buffer contains input characters (before shaping). 287 * @HB_BUFFER_CONTENT_TYPE_GLYPHS: The buffer contains output glyphs (after shaping). 288 * 289 * The type of #hb_buffer_t contents. 290 */ 291 typedef enum { 292 HB_BUFFER_CONTENT_TYPE_INVALID = 0, 293 HB_BUFFER_CONTENT_TYPE_UNICODE, 294 HB_BUFFER_CONTENT_TYPE_GLYPHS 295 } hb_buffer_content_type_t; 296 297 HB_EXTERN void 298 hb_buffer_set_content_type (hb_buffer_t *buffer, 299 hb_buffer_content_type_t content_type); 300 301 HB_EXTERN hb_buffer_content_type_t 302 hb_buffer_get_content_type (const hb_buffer_t *buffer); 303 304 305 HB_EXTERN void 306 hb_buffer_set_unicode_funcs (hb_buffer_t *buffer, 307 hb_unicode_funcs_t *unicode_funcs); 308 309 HB_EXTERN hb_unicode_funcs_t * 310 hb_buffer_get_unicode_funcs (const hb_buffer_t *buffer); 311 312 HB_EXTERN void 313 hb_buffer_set_direction (hb_buffer_t *buffer, 314 hb_direction_t direction); 315 316 HB_EXTERN hb_direction_t 317 hb_buffer_get_direction (const hb_buffer_t *buffer); 318 319 HB_EXTERN void 320 hb_buffer_set_script (hb_buffer_t *buffer, 321 hb_script_t script); 322 323 HB_EXTERN hb_script_t 324 hb_buffer_get_script (const hb_buffer_t *buffer); 325 326 HB_EXTERN void 327 hb_buffer_set_language (hb_buffer_t *buffer, 328 hb_language_t language); 329 330 331 HB_EXTERN hb_language_t 332 hb_buffer_get_language (const hb_buffer_t *buffer); 333 334 HB_EXTERN void 335 hb_buffer_set_segment_properties (hb_buffer_t *buffer, 336 const hb_segment_properties_t *props); 337 338 HB_EXTERN void 339 hb_buffer_get_segment_properties (const hb_buffer_t *buffer, 340 hb_segment_properties_t *props); 341 342 HB_EXTERN void 343 hb_buffer_guess_segment_properties (hb_buffer_t *buffer); 344 345 346 /** 347 * hb_buffer_flags_t: 348 * @HB_BUFFER_FLAG_DEFAULT: the default buffer flag. 349 * @HB_BUFFER_FLAG_BOT: flag indicating that special handling of the beginning 350 * of text paragraph can be applied to this buffer. Should usually 351 * be set, unless you are passing to the buffer only part 352 * of the text without the full context. 353 * @HB_BUFFER_FLAG_EOT: flag indicating that special handling of the end of text 354 * paragraph can be applied to this buffer, similar to 355 * @HB_BUFFER_FLAG_BOT. 356 * @HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES: 357 * flag indication that character with Default_Ignorable 358 * Unicode property should use the corresponding glyph 359 * from the font, instead of hiding them (done by 360 * replacing them with the space glyph and zeroing the 361 * advance width.) This flag takes precedence over 362 * @HB_BUFFER_FLAG_REMOVE_DEFAULT_IGNORABLES. 363 * @HB_BUFFER_FLAG_REMOVE_DEFAULT_IGNORABLES: 364 * flag indication that character with Default_Ignorable 365 * Unicode property should be removed from glyph string 366 * instead of hiding them (done by replacing them with the 367 * space glyph and zeroing the advance width.) 368 * @HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES takes 369 * precedence over this flag. Since: 1.8.0 370 * @HB_BUFFER_FLAG_DO_NOT_INSERT_DOTTED_CIRCLE: 371 * flag indicating that a dotted circle should 372 * not be inserted in the rendering of incorrect 373 * character sequences (such at <0905 093E>). Since: 2.4.0 374 * @HB_BUFFER_FLAG_VERIFY: 375 * flag indicating that the hb_shape() call and its variants 376 * should perform various verification processes on the results 377 * of the shaping operation on the buffer. If the verification 378 * fails, then either a buffer message is sent, if a message 379 * handler is installed on the buffer, or a message is written 380 * to standard error. In either case, the shaping result might 381 * be modified to show the failed output. Since: 3.4.0 382 * @HB_BUFFER_FLAG_PRODUCE_UNSAFE_TO_CONCAT: 383 * flag indicating that the @HB_GLYPH_FLAG_UNSAFE_TO_CONCAT 384 * glyph-flag should be produced by the shaper. By default 385 * it will not be produced since it incurs a cost. Since: 4.0.0 386 * @HB_BUFFER_FLAG_PRODUCE_SAFE_TO_INSERT_TATWEEL: 387 * flag indicating that the @HB_GLYPH_FLAG_SAFE_TO_INSERT_TATWEEL 388 * glyph-flag should be produced by the shaper. By default 389 * it will not be produced. Since: 5.1.0 390 * @HB_BUFFER_FLAG_DEFINED: All currently defined flags: Since: 4.4.0 391 * 392 * Flags for #hb_buffer_t. 393 * 394 * Since: 0.9.20 395 */ 396 typedef enum { /*< flags >*/ 397 HB_BUFFER_FLAG_DEFAULT = 0x00000000u, 398 HB_BUFFER_FLAG_BOT = 0x00000001u, /* Beginning-of-text */ 399 HB_BUFFER_FLAG_EOT = 0x00000002u, /* End-of-text */ 400 HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES = 0x00000004u, 401 HB_BUFFER_FLAG_REMOVE_DEFAULT_IGNORABLES = 0x00000008u, 402 HB_BUFFER_FLAG_DO_NOT_INSERT_DOTTED_CIRCLE = 0x00000010u, 403 HB_BUFFER_FLAG_VERIFY = 0x00000020u, 404 HB_BUFFER_FLAG_PRODUCE_UNSAFE_TO_CONCAT = 0x00000040u, 405 HB_BUFFER_FLAG_PRODUCE_SAFE_TO_INSERT_TATWEEL = 0x00000080u, 406 407 HB_BUFFER_FLAG_DEFINED = 0x000000FFu 408 } hb_buffer_flags_t; 409 410 HB_EXTERN void 411 hb_buffer_set_flags (hb_buffer_t *buffer, 412 hb_buffer_flags_t flags); 413 414 HB_EXTERN hb_buffer_flags_t 415 hb_buffer_get_flags (const hb_buffer_t *buffer); 416 417 /** 418 * hb_buffer_cluster_level_t: 419 * @HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES: Return cluster values grouped by graphemes into 420 * monotone order. 421 * @HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS: Return cluster values grouped into monotone order. 422 * @HB_BUFFER_CLUSTER_LEVEL_CHARACTERS: Don't group cluster values. 423 * @HB_BUFFER_CLUSTER_LEVEL_DEFAULT: Default cluster level, 424 * equal to @HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES. 425 * 426 * Data type for holding HarfBuzz's clustering behavior options. The cluster level 427 * dictates one aspect of how HarfBuzz will treat non-base characters 428 * during shaping. 429 * 430 * In @HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES, non-base 431 * characters are merged into the cluster of the base character that precedes them. 432 * 433 * In @HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS, non-base characters are initially 434 * assigned their own cluster values, which are not merged into preceding base 435 * clusters. This allows HarfBuzz to perform additional operations like reorder 436 * sequences of adjacent marks. 437 * 438 * @HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES is the default, because it maintains 439 * backward compatibility with older versions of HarfBuzz. New client programs that 440 * do not need to maintain such backward compatibility are recommended to use 441 * @HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS instead of the default. 442 * 443 * Since: 0.9.42 444 */ 445 typedef enum { 446 HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES = 0, 447 HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS = 1, 448 HB_BUFFER_CLUSTER_LEVEL_CHARACTERS = 2, 449 HB_BUFFER_CLUSTER_LEVEL_DEFAULT = HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES 450 } hb_buffer_cluster_level_t; 451 452 HB_EXTERN void 453 hb_buffer_set_cluster_level (hb_buffer_t *buffer, 454 hb_buffer_cluster_level_t cluster_level); 455 456 HB_EXTERN hb_buffer_cluster_level_t 457 hb_buffer_get_cluster_level (const hb_buffer_t *buffer); 458 459 /** 460 * HB_BUFFER_REPLACEMENT_CODEPOINT_DEFAULT: 461 * 462 * The default code point for replacing invalid characters in a given encoding. 463 * Set to U+FFFD REPLACEMENT CHARACTER. 464 * 465 * Since: 0.9.31 466 */ 467 #define HB_BUFFER_REPLACEMENT_CODEPOINT_DEFAULT 0xFFFDu 468 469 HB_EXTERN void 470 hb_buffer_set_replacement_codepoint (hb_buffer_t *buffer, 471 hb_codepoint_t replacement); 472 473 HB_EXTERN hb_codepoint_t 474 hb_buffer_get_replacement_codepoint (const hb_buffer_t *buffer); 475 476 HB_EXTERN void 477 hb_buffer_set_invisible_glyph (hb_buffer_t *buffer, 478 hb_codepoint_t invisible); 479 480 HB_EXTERN hb_codepoint_t 481 hb_buffer_get_invisible_glyph (const hb_buffer_t *buffer); 482 483 HB_EXTERN void 484 hb_buffer_set_not_found_glyph (hb_buffer_t *buffer, 485 hb_codepoint_t not_found); 486 487 HB_EXTERN hb_codepoint_t 488 hb_buffer_get_not_found_glyph (const hb_buffer_t *buffer); 489 490 491 /* 492 * Content API. 493 */ 494 495 HB_EXTERN void 496 hb_buffer_clear_contents (hb_buffer_t *buffer); 497 498 HB_EXTERN hb_bool_t 499 hb_buffer_pre_allocate (hb_buffer_t *buffer, 500 unsigned int size); 501 502 503 HB_EXTERN hb_bool_t 504 hb_buffer_allocation_successful (hb_buffer_t *buffer); 505 506 HB_EXTERN void 507 hb_buffer_reverse (hb_buffer_t *buffer); 508 509 HB_EXTERN void 510 hb_buffer_reverse_range (hb_buffer_t *buffer, 511 unsigned int start, unsigned int end); 512 513 HB_EXTERN void 514 hb_buffer_reverse_clusters (hb_buffer_t *buffer); 515 516 517 /* Filling the buffer in */ 518 519 HB_EXTERN void 520 hb_buffer_add (hb_buffer_t *buffer, 521 hb_codepoint_t codepoint, 522 unsigned int cluster); 523 524 HB_EXTERN void 525 hb_buffer_add_utf8 (hb_buffer_t *buffer, 526 const char *text, 527 int text_length, 528 unsigned int item_offset, 529 int item_length); 530 531 HB_EXTERN void 532 hb_buffer_add_utf16 (hb_buffer_t *buffer, 533 const uint16_t *text, 534 int text_length, 535 unsigned int item_offset, 536 int item_length); 537 538 HB_EXTERN void 539 hb_buffer_add_utf32 (hb_buffer_t *buffer, 540 const uint32_t *text, 541 int text_length, 542 unsigned int item_offset, 543 int item_length); 544 545 HB_EXTERN void 546 hb_buffer_add_latin1 (hb_buffer_t *buffer, 547 const uint8_t *text, 548 int text_length, 549 unsigned int item_offset, 550 int item_length); 551 552 HB_EXTERN void 553 hb_buffer_add_codepoints (hb_buffer_t *buffer, 554 const hb_codepoint_t *text, 555 int text_length, 556 unsigned int item_offset, 557 int item_length); 558 559 HB_EXTERN void 560 hb_buffer_append (hb_buffer_t *buffer, 561 const hb_buffer_t *source, 562 unsigned int start, 563 unsigned int end); 564 565 HB_EXTERN hb_bool_t 566 hb_buffer_set_length (hb_buffer_t *buffer, 567 unsigned int length); 568 569 HB_EXTERN unsigned int 570 hb_buffer_get_length (const hb_buffer_t *buffer); 571 572 /* Getting glyphs out of the buffer */ 573 574 HB_EXTERN hb_glyph_info_t * 575 hb_buffer_get_glyph_infos (hb_buffer_t *buffer, 576 unsigned int *length); 577 578 HB_EXTERN hb_glyph_position_t * 579 hb_buffer_get_glyph_positions (hb_buffer_t *buffer, 580 unsigned int *length); 581 582 HB_EXTERN hb_bool_t 583 hb_buffer_has_positions (hb_buffer_t *buffer); 584 585 586 HB_EXTERN void 587 hb_buffer_normalize_glyphs (hb_buffer_t *buffer); 588 589 590 /* 591 * Serialize 592 */ 593 594 /** 595 * hb_buffer_serialize_flags_t: 596 * @HB_BUFFER_SERIALIZE_FLAG_DEFAULT: serialize glyph names, clusters and positions. 597 * @HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS: do not serialize glyph cluster. 598 * @HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS: do not serialize glyph position information. 599 * @HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES: do no serialize glyph name. 600 * @HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS: serialize glyph extents. 601 * @HB_BUFFER_SERIALIZE_FLAG_GLYPH_FLAGS: serialize glyph flags. Since: 1.5.0 602 * @HB_BUFFER_SERIALIZE_FLAG_NO_ADVANCES: do not serialize glyph advances, 603 * glyph offsets will reflect absolute glyph positions. Since: 1.8.0 604 * @HB_BUFFER_SERIALIZE_FLAG_DEFINED: All currently defined flags. Since: 4.4.0 605 * 606 * Flags that control what glyph information are serialized in hb_buffer_serialize_glyphs(). 607 * 608 * Since: 0.9.20 609 */ 610 typedef enum { /*< flags >*/ 611 HB_BUFFER_SERIALIZE_FLAG_DEFAULT = 0x00000000u, 612 HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS = 0x00000001u, 613 HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS = 0x00000002u, 614 HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES = 0x00000004u, 615 HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS = 0x00000008u, 616 HB_BUFFER_SERIALIZE_FLAG_GLYPH_FLAGS = 0x00000010u, 617 HB_BUFFER_SERIALIZE_FLAG_NO_ADVANCES = 0x00000020u, 618 619 HB_BUFFER_SERIALIZE_FLAG_DEFINED = 0x0000003Fu 620 } hb_buffer_serialize_flags_t; 621 622 /** 623 * hb_buffer_serialize_format_t: 624 * @HB_BUFFER_SERIALIZE_FORMAT_TEXT: a human-readable, plain text format. 625 * @HB_BUFFER_SERIALIZE_FORMAT_JSON: a machine-readable JSON format. 626 * @HB_BUFFER_SERIALIZE_FORMAT_INVALID: invalid format. 627 * 628 * The buffer serialization and de-serialization format used in 629 * hb_buffer_serialize_glyphs() and hb_buffer_deserialize_glyphs(). 630 * 631 * Since: 0.9.2 632 */ 633 typedef enum { 634 HB_BUFFER_SERIALIZE_FORMAT_TEXT = HB_TAG('T','E','X','T'), 635 HB_BUFFER_SERIALIZE_FORMAT_JSON = HB_TAG('J','S','O','N'), 636 HB_BUFFER_SERIALIZE_FORMAT_INVALID = HB_TAG_NONE 637 } hb_buffer_serialize_format_t; 638 639 HB_EXTERN hb_buffer_serialize_format_t 640 hb_buffer_serialize_format_from_string (const char *str, int len); 641 642 HB_EXTERN const char * 643 hb_buffer_serialize_format_to_string (hb_buffer_serialize_format_t format); 644 645 HB_EXTERN const char ** 646 hb_buffer_serialize_list_formats (void); 647 648 HB_EXTERN unsigned int 649 hb_buffer_serialize_glyphs (hb_buffer_t *buffer, 650 unsigned int start, 651 unsigned int end, 652 char *buf, 653 unsigned int buf_size, 654 unsigned int *buf_consumed, 655 hb_font_t *font, 656 hb_buffer_serialize_format_t format, 657 hb_buffer_serialize_flags_t flags); 658 659 HB_EXTERN unsigned int 660 hb_buffer_serialize_unicode (hb_buffer_t *buffer, 661 unsigned int start, 662 unsigned int end, 663 char *buf, 664 unsigned int buf_size, 665 unsigned int *buf_consumed, 666 hb_buffer_serialize_format_t format, 667 hb_buffer_serialize_flags_t flags); 668 669 HB_EXTERN unsigned int 670 hb_buffer_serialize (hb_buffer_t *buffer, 671 unsigned int start, 672 unsigned int end, 673 char *buf, 674 unsigned int buf_size, 675 unsigned int *buf_consumed, 676 hb_font_t *font, 677 hb_buffer_serialize_format_t format, 678 hb_buffer_serialize_flags_t flags); 679 680 HB_EXTERN hb_bool_t 681 hb_buffer_deserialize_glyphs (hb_buffer_t *buffer, 682 const char *buf, 683 int buf_len, 684 const char **end_ptr, 685 hb_font_t *font, 686 hb_buffer_serialize_format_t format); 687 688 HB_EXTERN hb_bool_t 689 hb_buffer_deserialize_unicode (hb_buffer_t *buffer, 690 const char *buf, 691 int buf_len, 692 const char **end_ptr, 693 hb_buffer_serialize_format_t format); 694 695 696 697 /* 698 * Compare buffers 699 */ 700 701 /** 702 * hb_buffer_diff_flags_t: 703 * @HB_BUFFER_DIFF_FLAG_EQUAL: equal buffers. 704 * @HB_BUFFER_DIFF_FLAG_CONTENT_TYPE_MISMATCH: buffers with different 705 * #hb_buffer_content_type_t. 706 * @HB_BUFFER_DIFF_FLAG_LENGTH_MISMATCH: buffers with differing length. 707 * @HB_BUFFER_DIFF_FLAG_NOTDEF_PRESENT: `.notdef` glyph is present in the 708 * reference buffer. 709 * @HB_BUFFER_DIFF_FLAG_DOTTED_CIRCLE_PRESENT: dotted circle glyph is present 710 * in the reference buffer. 711 * @HB_BUFFER_DIFF_FLAG_CODEPOINT_MISMATCH: difference in #hb_glyph_info_t.codepoint 712 * @HB_BUFFER_DIFF_FLAG_CLUSTER_MISMATCH: difference in #hb_glyph_info_t.cluster 713 * @HB_BUFFER_DIFF_FLAG_GLYPH_FLAGS_MISMATCH: difference in #hb_glyph_flags_t. 714 * @HB_BUFFER_DIFF_FLAG_POSITION_MISMATCH: difference in #hb_glyph_position_t. 715 * 716 * Flags from comparing two #hb_buffer_t's. 717 * 718 * Buffer with different #hb_buffer_content_type_t cannot be meaningfully 719 * compared in any further detail. 720 * 721 * For buffers with differing length, the per-glyph comparison is not 722 * attempted, though we do still scan reference buffer for dotted circle and 723 * `.notdef` glyphs. 724 * 725 * If the buffers have the same length, we compare them glyph-by-glyph and 726 * report which aspect(s) of the glyph info/position are different. 727 * 728 * Since: 1.5.0 729 */ 730 typedef enum { /*< flags >*/ 731 HB_BUFFER_DIFF_FLAG_EQUAL = 0x0000, 732 733 /* Buffers with different content_type cannot be meaningfully compared 734 * in any further detail. */ 735 HB_BUFFER_DIFF_FLAG_CONTENT_TYPE_MISMATCH = 0x0001, 736 737 /* For buffers with differing length, the per-glyph comparison is not 738 * attempted, though we do still scan reference for dottedcircle / .notdef 739 * glyphs. */ 740 HB_BUFFER_DIFF_FLAG_LENGTH_MISMATCH = 0x0002, 741 742 /* We want to know if dottedcircle / .notdef glyphs are present in the 743 * reference, as we may not care so much about other differences in this 744 * case. */ 745 HB_BUFFER_DIFF_FLAG_NOTDEF_PRESENT = 0x0004, 746 HB_BUFFER_DIFF_FLAG_DOTTED_CIRCLE_PRESENT = 0x0008, 747 748 /* If the buffers have the same length, we compare them glyph-by-glyph 749 * and report which aspect(s) of the glyph info/position are different. */ 750 HB_BUFFER_DIFF_FLAG_CODEPOINT_MISMATCH = 0x0010, 751 HB_BUFFER_DIFF_FLAG_CLUSTER_MISMATCH = 0x0020, 752 HB_BUFFER_DIFF_FLAG_GLYPH_FLAGS_MISMATCH = 0x0040, 753 HB_BUFFER_DIFF_FLAG_POSITION_MISMATCH = 0x0080 754 755 } hb_buffer_diff_flags_t; 756 757 /* Compare the contents of two buffers, report types of differences. */ 758 HB_EXTERN hb_buffer_diff_flags_t 759 hb_buffer_diff (hb_buffer_t *buffer, 760 hb_buffer_t *reference, 761 hb_codepoint_t dottedcircle_glyph, 762 unsigned int position_fuzz); 763 764 765 /* 766 * Debugging. 767 */ 768 769 /** 770 * hb_buffer_message_func_t: 771 * @buffer: An #hb_buffer_t to work upon 772 * @font: The #hb_font_t the @buffer is shaped with 773 * @message: `NULL`-terminated message passed to the function 774 * @user_data: User data pointer passed by the caller 775 * 776 * A callback method for #hb_buffer_t. The method gets called with the 777 * #hb_buffer_t it was set on, the #hb_font_t the buffer is shaped with and a 778 * message describing what step of the shaping process will be performed. 779 * Returning `false` from this method will skip this shaping step and move to 780 * the next one. 781 * 782 * Return value: `true` to perform the shaping step, `false` to skip it. 783 * 784 * Since: 1.1.3 785 */ 786 typedef hb_bool_t (*hb_buffer_message_func_t) (hb_buffer_t *buffer, 787 hb_font_t *font, 788 const char *message, 789 void *user_data); 790 791 HB_EXTERN void 792 hb_buffer_set_message_func (hb_buffer_t *buffer, 793 hb_buffer_message_func_t func, 794 void *user_data, hb_destroy_func_t destroy); 795 796 797 HB_END_DECLS 798 799 #endif /* HB_BUFFER_H */ 800