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 #ifndef HB_H_IN 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 { 64 hb_codepoint_t codepoint; 65 /*< private >*/ 66 hb_mask_t mask; 67 /*< public >*/ 68 uint32_t cluster; 69 70 /*< private >*/ 71 hb_var_int_t var1; 72 hb_var_int_t var2; 73 } hb_glyph_info_t; 74 75 /** 76 * hb_glyph_flags_t: 77 * @HB_GLYPH_FLAG_UNSAFE_TO_BREAK: Indicates that if input text is broken at the 78 * beginning of the cluster this glyph is part of, 79 * then both sides need to be re-shaped, as the 80 * result might be different. On the flip side, 81 * it means that when this flag is not present, 82 * then it's safe to break the glyph-run at the 83 * beginning of this cluster, and the two sides 84 * represent the exact same result one would get 85 * if breaking input text at the beginning of 86 * this cluster and shaping the two sides 87 * separately. This can be used to optimize 88 * paragraph layout, by avoiding re-shaping 89 * of each line after line-breaking, or limiting 90 * the reshaping to a small piece around the 91 * breaking point only. 92 * @HB_GLYPH_FLAG_DEFINED: All the currently defined flags. 93 * 94 * Since: 1.5.0 95 */ 96 typedef enum { /*< flags >*/ 97 HB_GLYPH_FLAG_UNSAFE_TO_BREAK = 0x00000001, 98 99 HB_GLYPH_FLAG_DEFINED = 0x00000001 /* OR of all defined flags */ 100 } hb_glyph_flags_t; 101 102 HB_EXTERN hb_glyph_flags_t 103 hb_glyph_info_get_glyph_flags (const hb_glyph_info_t *info); 104 105 #define hb_glyph_info_get_glyph_flags(info) \ 106 ((hb_glyph_flags_t) ((unsigned int) (info)->mask & HB_GLYPH_FLAG_DEFINED)) 107 108 109 /** 110 * hb_glyph_position_t: 111 * @x_advance: how much the line advances after drawing this glyph when setting 112 * text in horizontal direction. 113 * @y_advance: how much the line advances after drawing this glyph when setting 114 * text in vertical direction. 115 * @x_offset: how much the glyph moves on the X-axis before drawing it, this 116 * should not affect how much the line advances. 117 * @y_offset: how much the glyph moves on the Y-axis before drawing it, this 118 * should not affect how much the line advances. 119 * 120 * The #hb_glyph_position_t is the structure that holds the positions of the 121 * glyph in both horizontal and vertical directions. All positions in 122 * #hb_glyph_position_t are relative to the current point. 123 * 124 */ 125 typedef struct hb_glyph_position_t { 126 hb_position_t x_advance; 127 hb_position_t y_advance; 128 hb_position_t x_offset; 129 hb_position_t y_offset; 130 131 /*< private >*/ 132 hb_var_int_t var; 133 } hb_glyph_position_t; 134 135 /** 136 * hb_segment_properties_t: 137 * @direction: the #hb_direction_t of the buffer, see hb_buffer_set_direction(). 138 * @script: the #hb_script_t of the buffer, see hb_buffer_set_script(). 139 * @language: the #hb_language_t of the buffer, see hb_buffer_set_language(). 140 * 141 * The structure that holds various text properties of an #hb_buffer_t. Can be 142 * set and retrieved using hb_buffer_set_segment_properties() and 143 * hb_buffer_get_segment_properties(), respectively. 144 */ 145 typedef struct hb_segment_properties_t { 146 hb_direction_t direction; 147 hb_script_t script; 148 hb_language_t language; 149 /*< private >*/ 150 void *reserved1; 151 void *reserved2; 152 } hb_segment_properties_t; 153 154 #define HB_SEGMENT_PROPERTIES_DEFAULT {HB_DIRECTION_INVALID, \ 155 HB_SCRIPT_INVALID, \ 156 HB_LANGUAGE_INVALID, \ 157 (void *) 0, \ 158 (void *) 0} 159 160 HB_EXTERN hb_bool_t 161 hb_segment_properties_equal (const hb_segment_properties_t *a, 162 const hb_segment_properties_t *b); 163 164 HB_EXTERN unsigned int 165 hb_segment_properties_hash (const hb_segment_properties_t *p); 166 167 168 169 /** 170 * hb_buffer_t: 171 * 172 * The main structure holding the input text and its properties before shaping, 173 * and output glyphs and their information after shaping. 174 */ 175 176 typedef struct hb_buffer_t hb_buffer_t; 177 178 HB_EXTERN hb_buffer_t * 179 hb_buffer_create (void); 180 181 HB_EXTERN hb_buffer_t * 182 hb_buffer_get_empty (void); 183 184 HB_EXTERN hb_buffer_t * 185 hb_buffer_reference (hb_buffer_t *buffer); 186 187 HB_EXTERN void 188 hb_buffer_destroy (hb_buffer_t *buffer); 189 190 HB_EXTERN hb_bool_t 191 hb_buffer_set_user_data (hb_buffer_t *buffer, 192 hb_user_data_key_t *key, 193 void * data, 194 hb_destroy_func_t destroy, 195 hb_bool_t replace); 196 197 HB_EXTERN void * 198 hb_buffer_get_user_data (hb_buffer_t *buffer, 199 hb_user_data_key_t *key); 200 201 202 /** 203 * hb_buffer_content_type_t: 204 * @HB_BUFFER_CONTENT_TYPE_INVALID: Initial value for new buffer. 205 * @HB_BUFFER_CONTENT_TYPE_UNICODE: The buffer contains input characters (before shaping). 206 * @HB_BUFFER_CONTENT_TYPE_GLYPHS: The buffer contains output glyphs (after shaping). 207 */ 208 typedef enum { 209 HB_BUFFER_CONTENT_TYPE_INVALID = 0, 210 HB_BUFFER_CONTENT_TYPE_UNICODE, 211 HB_BUFFER_CONTENT_TYPE_GLYPHS 212 } hb_buffer_content_type_t; 213 214 HB_EXTERN void 215 hb_buffer_set_content_type (hb_buffer_t *buffer, 216 hb_buffer_content_type_t content_type); 217 218 HB_EXTERN hb_buffer_content_type_t 219 hb_buffer_get_content_type (hb_buffer_t *buffer); 220 221 222 HB_EXTERN void 223 hb_buffer_set_unicode_funcs (hb_buffer_t *buffer, 224 hb_unicode_funcs_t *unicode_funcs); 225 226 HB_EXTERN hb_unicode_funcs_t * 227 hb_buffer_get_unicode_funcs (hb_buffer_t *buffer); 228 229 HB_EXTERN void 230 hb_buffer_set_direction (hb_buffer_t *buffer, 231 hb_direction_t direction); 232 233 HB_EXTERN hb_direction_t 234 hb_buffer_get_direction (hb_buffer_t *buffer); 235 236 HB_EXTERN void 237 hb_buffer_set_script (hb_buffer_t *buffer, 238 hb_script_t script); 239 240 HB_EXTERN hb_script_t 241 hb_buffer_get_script (hb_buffer_t *buffer); 242 243 HB_EXTERN void 244 hb_buffer_set_language (hb_buffer_t *buffer, 245 hb_language_t language); 246 247 248 HB_EXTERN hb_language_t 249 hb_buffer_get_language (hb_buffer_t *buffer); 250 251 HB_EXTERN void 252 hb_buffer_set_segment_properties (hb_buffer_t *buffer, 253 const hb_segment_properties_t *props); 254 255 HB_EXTERN void 256 hb_buffer_get_segment_properties (hb_buffer_t *buffer, 257 hb_segment_properties_t *props); 258 259 HB_EXTERN void 260 hb_buffer_guess_segment_properties (hb_buffer_t *buffer); 261 262 263 /** 264 * hb_buffer_flags_t: 265 * @HB_BUFFER_FLAG_DEFAULT: the default buffer flag. 266 * @HB_BUFFER_FLAG_BOT: flag indicating that special handling of the beginning 267 * of text paragraph can be applied to this buffer. Should usually 268 * be set, unless you are passing to the buffer only part 269 * of the text without the full context. 270 * @HB_BUFFER_FLAG_EOT: flag indicating that special handling of the end of text 271 * paragraph can be applied to this buffer, similar to 272 * @HB_BUFFER_FLAG_BOT. 273 * @HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES: 274 * flag indication that character with Default_Ignorable 275 * Unicode property should use the corresponding glyph 276 * from the font, instead of hiding them (done by 277 * replacing them with the space glyph and zeroing the 278 * advance width.) This flag takes precedence over 279 * @HB_BUFFER_FLAG_REMOVE_DEFAULT_IGNORABLES. 280 * @HB_BUFFER_FLAG_REMOVE_DEFAULT_IGNORABLES: 281 * flag indication that character with Default_Ignorable 282 * Unicode property should be removed from glyph string 283 * instead of hiding them (done by replacing them with the 284 * space glyph and zeroing the advance width.) 285 * @HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES takes 286 * precedence over this flag. Since: 1.8.0 287 * @HB_BUFFER_FLAG_DO_NOT_INSERT_DOTTED_CIRCLE: 288 * flag indicating that a dotted circle should 289 * not be inserted in the rendering of incorrect 290 * character sequences (such at <0905 093E>). Since: 2.4 291 * 292 * Since: 0.9.20 293 */ 294 typedef enum { /*< flags >*/ 295 HB_BUFFER_FLAG_DEFAULT = 0x00000000u, 296 HB_BUFFER_FLAG_BOT = 0x00000001u, /* Beginning-of-text */ 297 HB_BUFFER_FLAG_EOT = 0x00000002u, /* End-of-text */ 298 HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES = 0x00000004u, 299 HB_BUFFER_FLAG_REMOVE_DEFAULT_IGNORABLES = 0x00000008u, 300 HB_BUFFER_FLAG_DO_NOT_INSERT_DOTTED_CIRCLE = 0x00000010u 301 } hb_buffer_flags_t; 302 303 HB_EXTERN void 304 hb_buffer_set_flags (hb_buffer_t *buffer, 305 hb_buffer_flags_t flags); 306 307 HB_EXTERN hb_buffer_flags_t 308 hb_buffer_get_flags (hb_buffer_t *buffer); 309 310 /** 311 * hb_buffer_cluster_level_t: 312 * @HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES: Return cluster values grouped by graphemes into 313 * monotone order. 314 * @HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS: Return cluster values grouped into monotone order. 315 * @HB_BUFFER_CLUSTER_LEVEL_CHARACTERS: Don't group cluster values. 316 * @HB_BUFFER_CLUSTER_LEVEL_DEFAULT: Default cluster level, 317 * equal to @HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES. 318 * 319 * Since: 0.9.42 320 */ 321 typedef enum { 322 HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES = 0, 323 HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS = 1, 324 HB_BUFFER_CLUSTER_LEVEL_CHARACTERS = 2, 325 HB_BUFFER_CLUSTER_LEVEL_DEFAULT = HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES 326 } hb_buffer_cluster_level_t; 327 328 HB_EXTERN void 329 hb_buffer_set_cluster_level (hb_buffer_t *buffer, 330 hb_buffer_cluster_level_t cluster_level); 331 332 HB_EXTERN hb_buffer_cluster_level_t 333 hb_buffer_get_cluster_level (hb_buffer_t *buffer); 334 335 /** 336 * HB_BUFFER_REPLACEMENT_CODEPOINT_DEFAULT: 337 * 338 * The default code point for replacing invalid characters in a given encoding. 339 * Set to U+FFFD REPLACEMENT CHARACTER. 340 * 341 * Since: 0.9.31 342 */ 343 #define HB_BUFFER_REPLACEMENT_CODEPOINT_DEFAULT 0xFFFDu 344 345 HB_EXTERN void 346 hb_buffer_set_replacement_codepoint (hb_buffer_t *buffer, 347 hb_codepoint_t replacement); 348 349 HB_EXTERN hb_codepoint_t 350 hb_buffer_get_replacement_codepoint (hb_buffer_t *buffer); 351 352 HB_EXTERN void 353 hb_buffer_set_invisible_glyph (hb_buffer_t *buffer, 354 hb_codepoint_t invisible); 355 356 HB_EXTERN hb_codepoint_t 357 hb_buffer_get_invisible_glyph (hb_buffer_t *buffer); 358 359 360 HB_EXTERN void 361 hb_buffer_reset (hb_buffer_t *buffer); 362 363 HB_EXTERN void 364 hb_buffer_clear_contents (hb_buffer_t *buffer); 365 366 HB_EXTERN hb_bool_t 367 hb_buffer_pre_allocate (hb_buffer_t *buffer, 368 unsigned int size); 369 370 371 HB_EXTERN hb_bool_t 372 hb_buffer_allocation_successful (hb_buffer_t *buffer); 373 374 HB_EXTERN void 375 hb_buffer_reverse (hb_buffer_t *buffer); 376 377 HB_EXTERN void 378 hb_buffer_reverse_range (hb_buffer_t *buffer, 379 unsigned int start, unsigned int end); 380 381 HB_EXTERN void 382 hb_buffer_reverse_clusters (hb_buffer_t *buffer); 383 384 385 /* Filling the buffer in */ 386 387 HB_EXTERN void 388 hb_buffer_add (hb_buffer_t *buffer, 389 hb_codepoint_t codepoint, 390 unsigned int cluster); 391 392 HB_EXTERN void 393 hb_buffer_add_utf8 (hb_buffer_t *buffer, 394 const char *text, 395 int text_length, 396 unsigned int item_offset, 397 int item_length); 398 399 HB_EXTERN void 400 hb_buffer_add_utf16 (hb_buffer_t *buffer, 401 const uint16_t *text, 402 int text_length, 403 unsigned int item_offset, 404 int item_length); 405 406 HB_EXTERN void 407 hb_buffer_add_utf32 (hb_buffer_t *buffer, 408 const uint32_t *text, 409 int text_length, 410 unsigned int item_offset, 411 int item_length); 412 413 HB_EXTERN void 414 hb_buffer_add_latin1 (hb_buffer_t *buffer, 415 const uint8_t *text, 416 int text_length, 417 unsigned int item_offset, 418 int item_length); 419 420 HB_EXTERN void 421 hb_buffer_add_codepoints (hb_buffer_t *buffer, 422 const hb_codepoint_t *text, 423 int text_length, 424 unsigned int item_offset, 425 int item_length); 426 427 HB_EXTERN void 428 hb_buffer_append (hb_buffer_t *buffer, 429 hb_buffer_t *source, 430 unsigned int start, 431 unsigned int end); 432 433 HB_EXTERN hb_bool_t 434 hb_buffer_set_length (hb_buffer_t *buffer, 435 unsigned int length); 436 437 HB_EXTERN unsigned int 438 hb_buffer_get_length (hb_buffer_t *buffer); 439 440 /* Getting glyphs out of the buffer */ 441 442 HB_EXTERN hb_glyph_info_t * 443 hb_buffer_get_glyph_infos (hb_buffer_t *buffer, 444 unsigned int *length); 445 446 HB_EXTERN hb_glyph_position_t * 447 hb_buffer_get_glyph_positions (hb_buffer_t *buffer, 448 unsigned int *length); 449 450 451 HB_EXTERN void 452 hb_buffer_normalize_glyphs (hb_buffer_t *buffer); 453 454 455 /* 456 * Serialize 457 */ 458 459 /** 460 * hb_buffer_serialize_flags_t: 461 * @HB_BUFFER_SERIALIZE_FLAG_DEFAULT: serialize glyph names, clusters and positions. 462 * @HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS: do not serialize glyph cluster. 463 * @HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS: do not serialize glyph position information. 464 * @HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES: do no serialize glyph name. 465 * @HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS: serialize glyph extents. 466 * @HB_BUFFER_SERIALIZE_FLAG_GLYPH_FLAGS: serialize glyph flags. Since: 1.5.0 467 * @HB_BUFFER_SERIALIZE_FLAG_NO_ADVANCES: do not serialize glyph advances, 468 * glyph offsets will reflect absolute glyph positions. Since: 1.8.0 469 * 470 * Flags that control what glyph information are serialized in hb_buffer_serialize_glyphs(). 471 * 472 * Since: 0.9.20 473 */ 474 typedef enum { /*< flags >*/ 475 HB_BUFFER_SERIALIZE_FLAG_DEFAULT = 0x00000000u, 476 HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS = 0x00000001u, 477 HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS = 0x00000002u, 478 HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES = 0x00000004u, 479 HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS = 0x00000008u, 480 HB_BUFFER_SERIALIZE_FLAG_GLYPH_FLAGS = 0x00000010u, 481 HB_BUFFER_SERIALIZE_FLAG_NO_ADVANCES = 0x00000020u 482 } hb_buffer_serialize_flags_t; 483 484 /** 485 * hb_buffer_serialize_format_t: 486 * @HB_BUFFER_SERIALIZE_FORMAT_TEXT: a human-readable, plain text format. 487 * @HB_BUFFER_SERIALIZE_FORMAT_JSON: a machine-readable JSON format. 488 * @HB_BUFFER_SERIALIZE_FORMAT_INVALID: invalid format. 489 * 490 * The buffer serialization and de-serialization format used in 491 * hb_buffer_serialize_glyphs() and hb_buffer_deserialize_glyphs(). 492 * 493 * Since: 0.9.2 494 */ 495 typedef enum { 496 HB_BUFFER_SERIALIZE_FORMAT_TEXT = HB_TAG('T','E','X','T'), 497 HB_BUFFER_SERIALIZE_FORMAT_JSON = HB_TAG('J','S','O','N'), 498 HB_BUFFER_SERIALIZE_FORMAT_INVALID = HB_TAG_NONE 499 } hb_buffer_serialize_format_t; 500 501 HB_EXTERN hb_buffer_serialize_format_t 502 hb_buffer_serialize_format_from_string (const char *str, int len); 503 504 HB_EXTERN const char * 505 hb_buffer_serialize_format_to_string (hb_buffer_serialize_format_t format); 506 507 HB_EXTERN const char ** 508 hb_buffer_serialize_list_formats (void); 509 510 HB_EXTERN unsigned int 511 hb_buffer_serialize_glyphs (hb_buffer_t *buffer, 512 unsigned int start, 513 unsigned int end, 514 char *buf, 515 unsigned int buf_size, 516 unsigned int *buf_consumed, 517 hb_font_t *font, 518 hb_buffer_serialize_format_t format, 519 hb_buffer_serialize_flags_t flags); 520 521 HB_EXTERN hb_bool_t 522 hb_buffer_deserialize_glyphs (hb_buffer_t *buffer, 523 const char *buf, 524 int buf_len, 525 const char **end_ptr, 526 hb_font_t *font, 527 hb_buffer_serialize_format_t format); 528 529 530 /* 531 * Compare buffers 532 */ 533 534 typedef enum { /*< flags >*/ 535 HB_BUFFER_DIFF_FLAG_EQUAL = 0x0000, 536 537 /* Buffers with different content_type cannot be meaningfully compared 538 * in any further detail. */ 539 HB_BUFFER_DIFF_FLAG_CONTENT_TYPE_MISMATCH = 0x0001, 540 541 /* For buffers with differing length, the per-glyph comparison is not 542 * attempted, though we do still scan reference for dottedcircle / .notdef 543 * glyphs. */ 544 HB_BUFFER_DIFF_FLAG_LENGTH_MISMATCH = 0x0002, 545 546 /* We want to know if dottedcircle / .notdef glyphs are present in the 547 * reference, as we may not care so much about other differences in this 548 * case. */ 549 HB_BUFFER_DIFF_FLAG_NOTDEF_PRESENT = 0x0004, 550 HB_BUFFER_DIFF_FLAG_DOTTED_CIRCLE_PRESENT = 0x0008, 551 552 /* If the buffers have the same length, we compare them glyph-by-glyph 553 * and report which aspect(s) of the glyph info/position are different. */ 554 HB_BUFFER_DIFF_FLAG_CODEPOINT_MISMATCH = 0x0010, 555 HB_BUFFER_DIFF_FLAG_CLUSTER_MISMATCH = 0x0020, 556 HB_BUFFER_DIFF_FLAG_GLYPH_FLAGS_MISMATCH = 0x0040, 557 HB_BUFFER_DIFF_FLAG_POSITION_MISMATCH = 0x0080 558 559 } hb_buffer_diff_flags_t; 560 561 /* Compare the contents of two buffers, report types of differences. */ 562 HB_EXTERN hb_buffer_diff_flags_t 563 hb_buffer_diff (hb_buffer_t *buffer, 564 hb_buffer_t *reference, 565 hb_codepoint_t dottedcircle_glyph, 566 unsigned int position_fuzz); 567 568 569 /* 570 * Debugging. 571 */ 572 573 typedef hb_bool_t (*hb_buffer_message_func_t) (hb_buffer_t *buffer, 574 hb_font_t *font, 575 const char *message, 576 void *user_data); 577 578 HB_EXTERN void 579 hb_buffer_set_message_func (hb_buffer_t *buffer, 580 hb_buffer_message_func_t func, 581 void *user_data, hb_destroy_func_t destroy); 582 583 584 HB_END_DECLS 585 586 #endif /* HB_BUFFER_H */ 587