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 position 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 HB_EXTERN void 491 hb_buffer_set_not_found_variation_selector_glyph (hb_buffer_t *buffer, 492 hb_codepoint_t not_found_variation_selector); 493 494 HB_EXTERN hb_codepoint_t 495 hb_buffer_get_not_found_variation_selector_glyph (const hb_buffer_t *buffer); 496 497 HB_EXTERN void 498 hb_buffer_set_random_state (hb_buffer_t *buffer, 499 unsigned state); 500 501 HB_EXTERN unsigned 502 hb_buffer_get_random_state (const hb_buffer_t *buffer); 503 504 /* 505 * Content API. 506 */ 507 508 HB_EXTERN void 509 hb_buffer_clear_contents (hb_buffer_t *buffer); 510 511 HB_EXTERN hb_bool_t 512 hb_buffer_pre_allocate (hb_buffer_t *buffer, 513 unsigned int size); 514 515 516 HB_EXTERN hb_bool_t 517 hb_buffer_allocation_successful (hb_buffer_t *buffer); 518 519 HB_EXTERN void 520 hb_buffer_reverse (hb_buffer_t *buffer); 521 522 HB_EXTERN void 523 hb_buffer_reverse_range (hb_buffer_t *buffer, 524 unsigned int start, unsigned int end); 525 526 HB_EXTERN void 527 hb_buffer_reverse_clusters (hb_buffer_t *buffer); 528 529 530 /* Filling the buffer in */ 531 532 HB_EXTERN void 533 hb_buffer_add (hb_buffer_t *buffer, 534 hb_codepoint_t codepoint, 535 unsigned int cluster); 536 537 HB_EXTERN void 538 hb_buffer_add_utf8 (hb_buffer_t *buffer, 539 const char *text, 540 int text_length, 541 unsigned int item_offset, 542 int item_length); 543 544 HB_EXTERN void 545 hb_buffer_add_utf16 (hb_buffer_t *buffer, 546 const uint16_t *text, 547 int text_length, 548 unsigned int item_offset, 549 int item_length); 550 551 HB_EXTERN void 552 hb_buffer_add_utf32 (hb_buffer_t *buffer, 553 const uint32_t *text, 554 int text_length, 555 unsigned int item_offset, 556 int item_length); 557 558 HB_EXTERN void 559 hb_buffer_add_latin1 (hb_buffer_t *buffer, 560 const uint8_t *text, 561 int text_length, 562 unsigned int item_offset, 563 int item_length); 564 565 HB_EXTERN void 566 hb_buffer_add_codepoints (hb_buffer_t *buffer, 567 const hb_codepoint_t *text, 568 int text_length, 569 unsigned int item_offset, 570 int item_length); 571 572 HB_EXTERN void 573 hb_buffer_append (hb_buffer_t *buffer, 574 const hb_buffer_t *source, 575 unsigned int start, 576 unsigned int end); 577 578 HB_EXTERN hb_bool_t 579 hb_buffer_set_length (hb_buffer_t *buffer, 580 unsigned int length); 581 582 HB_EXTERN unsigned int 583 hb_buffer_get_length (const hb_buffer_t *buffer); 584 585 /* Getting glyphs out of the buffer */ 586 587 HB_EXTERN hb_glyph_info_t * 588 hb_buffer_get_glyph_infos (hb_buffer_t *buffer, 589 unsigned int *length); 590 591 HB_EXTERN hb_glyph_position_t * 592 hb_buffer_get_glyph_positions (hb_buffer_t *buffer, 593 unsigned int *length); 594 595 HB_EXTERN hb_bool_t 596 hb_buffer_has_positions (hb_buffer_t *buffer); 597 598 599 HB_EXTERN void 600 hb_buffer_normalize_glyphs (hb_buffer_t *buffer); 601 602 603 /* 604 * Serialize 605 */ 606 607 /** 608 * hb_buffer_serialize_flags_t: 609 * @HB_BUFFER_SERIALIZE_FLAG_DEFAULT: serialize glyph names, clusters and positions. 610 * @HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS: do not serialize glyph cluster. 611 * @HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS: do not serialize glyph position information. 612 * @HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES: do no serialize glyph name. 613 * @HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS: serialize glyph extents. 614 * @HB_BUFFER_SERIALIZE_FLAG_GLYPH_FLAGS: serialize glyph flags. Since: 1.5.0 615 * @HB_BUFFER_SERIALIZE_FLAG_NO_ADVANCES: do not serialize glyph advances, 616 * glyph offsets will reflect absolute glyph positions. Since: 1.8.0 617 * @HB_BUFFER_SERIALIZE_FLAG_DEFINED: All currently defined flags. Since: 4.4.0 618 * 619 * Flags that control what glyph information are serialized in hb_buffer_serialize_glyphs(). 620 * 621 * Since: 0.9.20 622 */ 623 typedef enum { /*< flags >*/ 624 HB_BUFFER_SERIALIZE_FLAG_DEFAULT = 0x00000000u, 625 HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS = 0x00000001u, 626 HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS = 0x00000002u, 627 HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES = 0x00000004u, 628 HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS = 0x00000008u, 629 HB_BUFFER_SERIALIZE_FLAG_GLYPH_FLAGS = 0x00000010u, 630 HB_BUFFER_SERIALIZE_FLAG_NO_ADVANCES = 0x00000020u, 631 632 HB_BUFFER_SERIALIZE_FLAG_DEFINED = 0x0000003Fu 633 } hb_buffer_serialize_flags_t; 634 635 /** 636 * hb_buffer_serialize_format_t: 637 * @HB_BUFFER_SERIALIZE_FORMAT_TEXT: a human-readable, plain text format. 638 * @HB_BUFFER_SERIALIZE_FORMAT_JSON: a machine-readable JSON format. 639 * @HB_BUFFER_SERIALIZE_FORMAT_INVALID: invalid format. 640 * 641 * The buffer serialization and de-serialization format used in 642 * hb_buffer_serialize_glyphs() and hb_buffer_deserialize_glyphs(). 643 * 644 * Since: 0.9.2 645 */ 646 typedef enum { 647 HB_BUFFER_SERIALIZE_FORMAT_TEXT = HB_TAG('T','E','X','T'), 648 HB_BUFFER_SERIALIZE_FORMAT_JSON = HB_TAG('J','S','O','N'), 649 HB_BUFFER_SERIALIZE_FORMAT_INVALID = HB_TAG_NONE 650 } hb_buffer_serialize_format_t; 651 652 HB_EXTERN hb_buffer_serialize_format_t 653 hb_buffer_serialize_format_from_string (const char *str, int len); 654 655 HB_EXTERN const char * 656 hb_buffer_serialize_format_to_string (hb_buffer_serialize_format_t format); 657 658 HB_EXTERN const char ** 659 hb_buffer_serialize_list_formats (void); 660 661 HB_EXTERN unsigned int 662 hb_buffer_serialize_glyphs (hb_buffer_t *buffer, 663 unsigned int start, 664 unsigned int end, 665 char *buf, 666 unsigned int buf_size, 667 unsigned int *buf_consumed, 668 hb_font_t *font, 669 hb_buffer_serialize_format_t format, 670 hb_buffer_serialize_flags_t flags); 671 672 HB_EXTERN unsigned int 673 hb_buffer_serialize_unicode (hb_buffer_t *buffer, 674 unsigned int start, 675 unsigned int end, 676 char *buf, 677 unsigned int buf_size, 678 unsigned int *buf_consumed, 679 hb_buffer_serialize_format_t format, 680 hb_buffer_serialize_flags_t flags); 681 682 HB_EXTERN unsigned int 683 hb_buffer_serialize (hb_buffer_t *buffer, 684 unsigned int start, 685 unsigned int end, 686 char *buf, 687 unsigned int buf_size, 688 unsigned int *buf_consumed, 689 hb_font_t *font, 690 hb_buffer_serialize_format_t format, 691 hb_buffer_serialize_flags_t flags); 692 693 HB_EXTERN hb_bool_t 694 hb_buffer_deserialize_glyphs (hb_buffer_t *buffer, 695 const char *buf, 696 int buf_len, 697 const char **end_ptr, 698 hb_font_t *font, 699 hb_buffer_serialize_format_t format); 700 701 HB_EXTERN hb_bool_t 702 hb_buffer_deserialize_unicode (hb_buffer_t *buffer, 703 const char *buf, 704 int buf_len, 705 const char **end_ptr, 706 hb_buffer_serialize_format_t format); 707 708 709 710 /* 711 * Compare buffers 712 */ 713 714 /** 715 * hb_buffer_diff_flags_t: 716 * @HB_BUFFER_DIFF_FLAG_EQUAL: equal buffers. 717 * @HB_BUFFER_DIFF_FLAG_CONTENT_TYPE_MISMATCH: buffers with different 718 * #hb_buffer_content_type_t. 719 * @HB_BUFFER_DIFF_FLAG_LENGTH_MISMATCH: buffers with differing length. 720 * @HB_BUFFER_DIFF_FLAG_NOTDEF_PRESENT: `.notdef` glyph is present in the 721 * reference buffer. 722 * @HB_BUFFER_DIFF_FLAG_DOTTED_CIRCLE_PRESENT: dotted circle glyph is present 723 * in the reference buffer. 724 * @HB_BUFFER_DIFF_FLAG_CODEPOINT_MISMATCH: difference in #hb_glyph_info_t.codepoint 725 * @HB_BUFFER_DIFF_FLAG_CLUSTER_MISMATCH: difference in #hb_glyph_info_t.cluster 726 * @HB_BUFFER_DIFF_FLAG_GLYPH_FLAGS_MISMATCH: difference in #hb_glyph_flags_t. 727 * @HB_BUFFER_DIFF_FLAG_POSITION_MISMATCH: difference in #hb_glyph_position_t. 728 * 729 * Flags from comparing two #hb_buffer_t's. 730 * 731 * Buffer with different #hb_buffer_content_type_t cannot be meaningfully 732 * compared in any further detail. 733 * 734 * For buffers with differing length, the per-glyph comparison is not 735 * attempted, though we do still scan reference buffer for dotted circle and 736 * `.notdef` glyphs. 737 * 738 * If the buffers have the same length, we compare them glyph-by-glyph and 739 * report which aspect(s) of the glyph info/position are different. 740 * 741 * Since: 1.5.0 742 */ 743 typedef enum { /*< flags >*/ 744 HB_BUFFER_DIFF_FLAG_EQUAL = 0x0000, 745 746 /* Buffers with different content_type cannot be meaningfully compared 747 * in any further detail. */ 748 HB_BUFFER_DIFF_FLAG_CONTENT_TYPE_MISMATCH = 0x0001, 749 750 /* For buffers with differing length, the per-glyph comparison is not 751 * attempted, though we do still scan reference for dottedcircle / .notdef 752 * glyphs. */ 753 HB_BUFFER_DIFF_FLAG_LENGTH_MISMATCH = 0x0002, 754 755 /* We want to know if dottedcircle / .notdef glyphs are present in the 756 * reference, as we may not care so much about other differences in this 757 * case. */ 758 HB_BUFFER_DIFF_FLAG_NOTDEF_PRESENT = 0x0004, 759 HB_BUFFER_DIFF_FLAG_DOTTED_CIRCLE_PRESENT = 0x0008, 760 761 /* If the buffers have the same length, we compare them glyph-by-glyph 762 * and report which aspect(s) of the glyph info/position are different. */ 763 HB_BUFFER_DIFF_FLAG_CODEPOINT_MISMATCH = 0x0010, 764 HB_BUFFER_DIFF_FLAG_CLUSTER_MISMATCH = 0x0020, 765 HB_BUFFER_DIFF_FLAG_GLYPH_FLAGS_MISMATCH = 0x0040, 766 HB_BUFFER_DIFF_FLAG_POSITION_MISMATCH = 0x0080 767 768 } hb_buffer_diff_flags_t; 769 770 /* Compare the contents of two buffers, report types of differences. */ 771 HB_EXTERN hb_buffer_diff_flags_t 772 hb_buffer_diff (hb_buffer_t *buffer, 773 hb_buffer_t *reference, 774 hb_codepoint_t dottedcircle_glyph, 775 unsigned int position_fuzz); 776 777 778 /* 779 * Tracing. 780 */ 781 782 /** 783 * hb_buffer_message_func_t: 784 * @buffer: An #hb_buffer_t to work upon 785 * @font: The #hb_font_t the @buffer is shaped with 786 * @message: `NULL`-terminated message passed to the function 787 * @user_data: User data pointer passed by the caller 788 * 789 * A callback method for #hb_buffer_t. The method gets called with the 790 * #hb_buffer_t it was set on, the #hb_font_t the buffer is shaped with and a 791 * message describing what step of the shaping process will be performed. 792 * Returning `false` from this method will skip this shaping step and move to 793 * the next one. 794 * 795 * Return value: `true` to perform the shaping step, `false` to skip it. 796 * 797 * Since: 1.1.3 798 */ 799 typedef hb_bool_t (*hb_buffer_message_func_t) (hb_buffer_t *buffer, 800 hb_font_t *font, 801 const char *message, 802 void *user_data); 803 804 HB_EXTERN void 805 hb_buffer_set_message_func (hb_buffer_t *buffer, 806 hb_buffer_message_func_t func, 807 void *user_data, hb_destroy_func_t destroy); 808 809 810 HB_END_DECLS 811 812 #endif /* HB_BUFFER_H */ 813