1/* 2 * Copyright �� 2009 Red Hat, Inc. 3 * Copyright �� 2011 Google, Inc. 4 * 5 * This is part of HarfBuzz, a text shaping library. 6 * 7 * Permission is hereby granted, without written agreement and without 8 * license or royalty fees, to use, copy, modify, and distribute this 9 * software and its documentation for any purpose, provided that the 10 * above copyright notice and the following two paragraphs appear in 11 * all copies of this software. 12 * 13 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR 14 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES 15 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN 16 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH 17 * DAMAGE. 18 * 19 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, 20 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 21 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS 22 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO 23 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. 24 * 25 * Red Hat Author(s): Behdad Esfahbod 26 * Google Author(s): Behdad Esfahbod 27 */ 28 29#ifndef HB_FONT_PRIVATE_HH 30#define HB_FONT_PRIVATE_HH 31 32#include "hb-private.hh" 33 34#include "hb-object-private.hh" 35#include "hb-face-private.hh" 36#include "hb-shaper-private.hh" 37 38 39 40/* 41 * hb_font_funcs_t 42 */ 43 44#define HB_FONT_FUNCS_IMPLEMENT_CALLBACKS \ 45 HB_FONT_FUNC_IMPLEMENT (font_h_extents) \ 46 HB_FONT_FUNC_IMPLEMENT (font_v_extents) \ 47 HB_FONT_FUNC_IMPLEMENT (nominal_glyph) \ 48 HB_FONT_FUNC_IMPLEMENT (variation_glyph) \ 49 HB_FONT_FUNC_IMPLEMENT (glyph_h_advance) \ 50 HB_FONT_FUNC_IMPLEMENT (glyph_v_advance) \ 51 HB_FONT_FUNC_IMPLEMENT (glyph_h_origin) \ 52 HB_FONT_FUNC_IMPLEMENT (glyph_v_origin) \ 53 HB_FONT_FUNC_IMPLEMENT (glyph_h_kerning) \ 54 HB_FONT_FUNC_IMPLEMENT (glyph_v_kerning) \ 55 HB_FONT_FUNC_IMPLEMENT (glyph_extents) \ 56 HB_FONT_FUNC_IMPLEMENT (glyph_contour_point) \ 57 HB_FONT_FUNC_IMPLEMENT (glyph_name) \ 58 HB_FONT_FUNC_IMPLEMENT (glyph_from_name) \ 59 /* ^--- Add new callbacks here */ 60 61struct hb_font_funcs_t { 62 hb_object_header_t header; 63 ASSERT_POD (); 64 65 hb_bool_t immutable; 66 67 struct { 68#define HB_FONT_FUNC_IMPLEMENT(name) void *name; 69 HB_FONT_FUNCS_IMPLEMENT_CALLBACKS 70#undef HB_FONT_FUNC_IMPLEMENT 71 } user_data; 72 73 struct { 74#define HB_FONT_FUNC_IMPLEMENT(name) hb_destroy_func_t name; 75 HB_FONT_FUNCS_IMPLEMENT_CALLBACKS 76#undef HB_FONT_FUNC_IMPLEMENT 77 } destroy; 78 79 /* Don't access these directly. Call font->get_*() instead. */ 80 union get_t { 81 struct get_funcs_t { 82#define HB_FONT_FUNC_IMPLEMENT(name) hb_font_get_##name##_func_t name; 83 HB_FONT_FUNCS_IMPLEMENT_CALLBACKS 84#undef HB_FONT_FUNC_IMPLEMENT 85 } f; 86 void (*array[VAR]) (void); 87 } get; 88}; 89 90 91 92/* 93 * hb_font_t 94 */ 95 96struct hb_font_t { 97 hb_object_header_t header; 98 ASSERT_POD (); 99 100 hb_bool_t immutable; 101 102 hb_font_t *parent; 103 hb_face_t *face; 104 105 int x_scale; 106 int y_scale; 107 108 unsigned int x_ppem; 109 unsigned int y_ppem; 110 111 /* Font variation coordinates. */ 112 unsigned int num_coords; 113 int *coords; 114 115 hb_font_funcs_t *klass; 116 void *user_data; 117 hb_destroy_func_t destroy; 118 119 struct hb_shaper_data_t shaper_data; 120 121 122 /* Convert from font-space to user-space */ 123 inline int dir_scale (hb_direction_t direction) 124 { return HB_DIRECTION_IS_VERTICAL(direction) ? y_scale : x_scale; } 125 inline hb_position_t em_scale_x (int16_t v) { return em_scale (v, x_scale); } 126 inline hb_position_t em_scale_y (int16_t v) { return em_scale (v, y_scale); } 127 inline hb_position_t em_scalef_x (float v) { return em_scalef (v, this->x_scale); } 128 inline hb_position_t em_scalef_y (float v) { return em_scalef (v, this->y_scale); } 129 inline hb_position_t em_scale_dir (int16_t v, hb_direction_t direction) 130 { return em_scale (v, dir_scale (direction)); } 131 132 /* Convert from parent-font user-space to our user-space */ 133 inline hb_position_t parent_scale_x_distance (hb_position_t v) { 134 if (unlikely (parent && parent->x_scale != x_scale)) 135 return (hb_position_t) (v * (int64_t) this->x_scale / this->parent->x_scale); 136 return v; 137 } 138 inline hb_position_t parent_scale_y_distance (hb_position_t v) { 139 if (unlikely (parent && parent->y_scale != y_scale)) 140 return (hb_position_t) (v * (int64_t) this->y_scale / this->parent->y_scale); 141 return v; 142 } 143 inline hb_position_t parent_scale_x_position (hb_position_t v) { 144 return parent_scale_x_distance (v); 145 } 146 inline hb_position_t parent_scale_y_position (hb_position_t v) { 147 return parent_scale_y_distance (v); 148 } 149 150 inline void parent_scale_distance (hb_position_t *x, hb_position_t *y) { 151 *x = parent_scale_x_distance (*x); 152 *y = parent_scale_y_distance (*y); 153 } 154 inline void parent_scale_position (hb_position_t *x, hb_position_t *y) { 155 *x = parent_scale_x_position (*x); 156 *y = parent_scale_y_position (*y); 157 } 158 159 160 /* Public getters */ 161 162 HB_INTERNAL bool has_func (unsigned int i); 163 164 /* has_* ... */ 165#define HB_FONT_FUNC_IMPLEMENT(name) \ 166 bool \ 167 has_##name##_func (void) \ 168 { \ 169 hb_font_funcs_t *funcs = this->klass; \ 170 unsigned int i = offsetof (hb_font_funcs_t::get_t::get_funcs_t, name) / sizeof (funcs->get.array[0]); \ 171 return has_func (i); \ 172 } 173 HB_FONT_FUNCS_IMPLEMENT_CALLBACKS 174#undef HB_FONT_FUNC_IMPLEMENT 175 176 inline hb_bool_t get_font_h_extents (hb_font_extents_t *extents) 177 { 178 memset (extents, 0, sizeof (*extents)); 179 return klass->get.f.font_h_extents (this, user_data, 180 extents, 181 klass->user_data.font_h_extents); 182 } 183 inline hb_bool_t get_font_v_extents (hb_font_extents_t *extents) 184 { 185 memset (extents, 0, sizeof (*extents)); 186 return klass->get.f.font_v_extents (this, user_data, 187 extents, 188 klass->user_data.font_v_extents); 189 } 190 191 inline bool has_glyph (hb_codepoint_t unicode) 192 { 193 hb_codepoint_t glyph; 194 return get_nominal_glyph (unicode, &glyph); 195 } 196 197 inline hb_bool_t get_nominal_glyph (hb_codepoint_t unicode, 198 hb_codepoint_t *glyph) 199 { 200 *glyph = 0; 201 return klass->get.f.nominal_glyph (this, user_data, 202 unicode, glyph, 203 klass->user_data.nominal_glyph); 204 } 205 206 inline hb_bool_t get_variation_glyph (hb_codepoint_t unicode, hb_codepoint_t variation_selector, 207 hb_codepoint_t *glyph) 208 { 209 *glyph = 0; 210 return klass->get.f.variation_glyph (this, user_data, 211 unicode, variation_selector, glyph, 212 klass->user_data.variation_glyph); 213 } 214 215 inline hb_position_t get_glyph_h_advance (hb_codepoint_t glyph) 216 { 217 return klass->get.f.glyph_h_advance (this, user_data, 218 glyph, 219 klass->user_data.glyph_h_advance); 220 } 221 222 inline hb_position_t get_glyph_v_advance (hb_codepoint_t glyph) 223 { 224 return klass->get.f.glyph_v_advance (this, user_data, 225 glyph, 226 klass->user_data.glyph_v_advance); 227 } 228 229 inline hb_bool_t get_glyph_h_origin (hb_codepoint_t glyph, 230 hb_position_t *x, hb_position_t *y) 231 { 232 *x = *y = 0; 233 return klass->get.f.glyph_h_origin (this, user_data, 234 glyph, x, y, 235 klass->user_data.glyph_h_origin); 236 } 237 238 inline hb_bool_t get_glyph_v_origin (hb_codepoint_t glyph, 239 hb_position_t *x, hb_position_t *y) 240 { 241 *x = *y = 0; 242 return klass->get.f.glyph_v_origin (this, user_data, 243 glyph, x, y, 244 klass->user_data.glyph_v_origin); 245 } 246 247 inline hb_position_t get_glyph_h_kerning (hb_codepoint_t left_glyph, hb_codepoint_t right_glyph) 248 { 249 return klass->get.f.glyph_h_kerning (this, user_data, 250 left_glyph, right_glyph, 251 klass->user_data.glyph_h_kerning); 252 } 253 254 inline hb_position_t get_glyph_v_kerning (hb_codepoint_t top_glyph, hb_codepoint_t bottom_glyph) 255 { 256 return klass->get.f.glyph_v_kerning (this, user_data, 257 top_glyph, bottom_glyph, 258 klass->user_data.glyph_v_kerning); 259 } 260 261 inline hb_bool_t get_glyph_extents (hb_codepoint_t glyph, 262 hb_glyph_extents_t *extents) 263 { 264 memset (extents, 0, sizeof (*extents)); 265 return klass->get.f.glyph_extents (this, user_data, 266 glyph, 267 extents, 268 klass->user_data.glyph_extents); 269 } 270 271 inline hb_bool_t get_glyph_contour_point (hb_codepoint_t glyph, unsigned int point_index, 272 hb_position_t *x, hb_position_t *y) 273 { 274 *x = *y = 0; 275 return klass->get.f.glyph_contour_point (this, user_data, 276 glyph, point_index, 277 x, y, 278 klass->user_data.glyph_contour_point); 279 } 280 281 inline hb_bool_t get_glyph_name (hb_codepoint_t glyph, 282 char *name, unsigned int size) 283 { 284 if (size) *name = '\0'; 285 return klass->get.f.glyph_name (this, user_data, 286 glyph, 287 name, size, 288 klass->user_data.glyph_name); 289 } 290 291 inline hb_bool_t get_glyph_from_name (const char *name, int len, /* -1 means nul-terminated */ 292 hb_codepoint_t *glyph) 293 { 294 *glyph = 0; 295 if (len == -1) len = strlen (name); 296 return klass->get.f.glyph_from_name (this, user_data, 297 name, len, 298 glyph, 299 klass->user_data.glyph_from_name); 300 } 301 302 303 /* A bit higher-level, and with fallback */ 304 305 inline void get_h_extents_with_fallback (hb_font_extents_t *extents) 306 { 307 if (!get_font_h_extents (extents)) 308 { 309 extents->ascender = y_scale * .8; 310 extents->descender = extents->ascender - y_scale; 311 extents->line_gap = 0; 312 } 313 } 314 inline void get_v_extents_with_fallback (hb_font_extents_t *extents) 315 { 316 if (!get_font_v_extents (extents)) 317 { 318 extents->ascender = x_scale / 2; 319 extents->descender = extents->ascender - x_scale; 320 extents->line_gap = 0; 321 } 322 } 323 324 inline void get_extents_for_direction (hb_direction_t direction, 325 hb_font_extents_t *extents) 326 { 327 if (likely (HB_DIRECTION_IS_HORIZONTAL (direction))) 328 get_h_extents_with_fallback (extents); 329 else 330 get_v_extents_with_fallback (extents); 331 } 332 333 inline void get_glyph_advance_for_direction (hb_codepoint_t glyph, 334 hb_direction_t direction, 335 hb_position_t *x, hb_position_t *y) 336 { 337 if (likely (HB_DIRECTION_IS_HORIZONTAL (direction))) { 338 *x = get_glyph_h_advance (glyph); 339 *y = 0; 340 } else { 341 *x = 0; 342 *y = get_glyph_v_advance (glyph); 343 } 344 } 345 346 inline void guess_v_origin_minus_h_origin (hb_codepoint_t glyph, 347 hb_position_t *x, hb_position_t *y) 348 { 349 *x = get_glyph_h_advance (glyph) / 2; 350 351 /* TODO cache this somehow?! */ 352 hb_font_extents_t extents; 353 get_h_extents_with_fallback (&extents); 354 *y = extents.ascender; 355 } 356 357 inline void get_glyph_h_origin_with_fallback (hb_codepoint_t glyph, 358 hb_position_t *x, hb_position_t *y) 359 { 360 if (!get_glyph_h_origin (glyph, x, y) && 361 get_glyph_v_origin (glyph, x, y)) 362 { 363 hb_position_t dx, dy; 364 guess_v_origin_minus_h_origin (glyph, &dx, &dy); 365 *x -= dx; *y -= dy; 366 } 367 } 368 inline void get_glyph_v_origin_with_fallback (hb_codepoint_t glyph, 369 hb_position_t *x, hb_position_t *y) 370 { 371 if (!get_glyph_v_origin (glyph, x, y) && 372 get_glyph_h_origin (glyph, x, y)) 373 { 374 hb_position_t dx, dy; 375 guess_v_origin_minus_h_origin (glyph, &dx, &dy); 376 *x += dx; *y += dy; 377 } 378 } 379 380 inline void get_glyph_origin_for_direction (hb_codepoint_t glyph, 381 hb_direction_t direction, 382 hb_position_t *x, hb_position_t *y) 383 { 384 if (likely (HB_DIRECTION_IS_HORIZONTAL (direction))) 385 get_glyph_h_origin_with_fallback (glyph, x, y); 386 else 387 get_glyph_v_origin_with_fallback (glyph, x, y); 388 } 389 390 inline void add_glyph_h_origin (hb_codepoint_t glyph, 391 hb_position_t *x, hb_position_t *y) 392 { 393 hb_position_t origin_x, origin_y; 394 395 get_glyph_h_origin_with_fallback (glyph, &origin_x, &origin_y); 396 397 *x += origin_x; 398 *y += origin_y; 399 } 400 inline void add_glyph_v_origin (hb_codepoint_t glyph, 401 hb_position_t *x, hb_position_t *y) 402 { 403 hb_position_t origin_x, origin_y; 404 405 get_glyph_v_origin_with_fallback (glyph, &origin_x, &origin_y); 406 407 *x += origin_x; 408 *y += origin_y; 409 } 410 inline void add_glyph_origin_for_direction (hb_codepoint_t glyph, 411 hb_direction_t direction, 412 hb_position_t *x, hb_position_t *y) 413 { 414 hb_position_t origin_x, origin_y; 415 416 get_glyph_origin_for_direction (glyph, direction, &origin_x, &origin_y); 417 418 *x += origin_x; 419 *y += origin_y; 420 } 421 422 inline void subtract_glyph_h_origin (hb_codepoint_t glyph, 423 hb_position_t *x, hb_position_t *y) 424 { 425 hb_position_t origin_x, origin_y; 426 427 get_glyph_h_origin_with_fallback (glyph, &origin_x, &origin_y); 428 429 *x -= origin_x; 430 *y -= origin_y; 431 } 432 inline void subtract_glyph_v_origin (hb_codepoint_t glyph, 433 hb_position_t *x, hb_position_t *y) 434 { 435 hb_position_t origin_x, origin_y; 436 437 get_glyph_v_origin_with_fallback (glyph, &origin_x, &origin_y); 438 439 *x -= origin_x; 440 *y -= origin_y; 441 } 442 inline void subtract_glyph_origin_for_direction (hb_codepoint_t glyph, 443 hb_direction_t direction, 444 hb_position_t *x, hb_position_t *y) 445 { 446 hb_position_t origin_x, origin_y; 447 448 get_glyph_origin_for_direction (glyph, direction, &origin_x, &origin_y); 449 450 *x -= origin_x; 451 *y -= origin_y; 452 } 453 454 inline void get_glyph_kerning_for_direction (hb_codepoint_t first_glyph, hb_codepoint_t second_glyph, 455 hb_direction_t direction, 456 hb_position_t *x, hb_position_t *y) 457 { 458 if (likely (HB_DIRECTION_IS_HORIZONTAL (direction))) { 459 *x = get_glyph_h_kerning (first_glyph, second_glyph); 460 *y = 0; 461 } else { 462 *x = 0; 463 *y = get_glyph_v_kerning (first_glyph, second_glyph); 464 } 465 } 466 467 inline hb_bool_t get_glyph_extents_for_origin (hb_codepoint_t glyph, 468 hb_direction_t direction, 469 hb_glyph_extents_t *extents) 470 { 471 hb_bool_t ret = get_glyph_extents (glyph, extents); 472 473 if (ret) 474 subtract_glyph_origin_for_direction (glyph, direction, &extents->x_bearing, &extents->y_bearing); 475 476 return ret; 477 } 478 479 inline hb_bool_t get_glyph_contour_point_for_origin (hb_codepoint_t glyph, unsigned int point_index, 480 hb_direction_t direction, 481 hb_position_t *x, hb_position_t *y) 482 { 483 hb_bool_t ret = get_glyph_contour_point (glyph, point_index, x, y); 484 485 if (ret) 486 subtract_glyph_origin_for_direction (glyph, direction, x, y); 487 488 return ret; 489 } 490 491 /* Generates gidDDD if glyph has no name. */ 492 inline void 493 glyph_to_string (hb_codepoint_t glyph, 494 char *s, unsigned int size) 495 { 496 if (get_glyph_name (glyph, s, size)) return; 497 498 if (size && snprintf (s, size, "gid%u", glyph) < 0) 499 *s = '\0'; 500 } 501 502 /* Parses gidDDD and uniUUUU strings automatically. */ 503 inline hb_bool_t 504 glyph_from_string (const char *s, int len, /* -1 means nul-terminated */ 505 hb_codepoint_t *glyph) 506 { 507 if (get_glyph_from_name (s, len, glyph)) return true; 508 509 if (len == -1) len = strlen (s); 510 511 /* Straight glyph index. */ 512 if (hb_codepoint_parse (s, len, 10, glyph)) 513 return true; 514 515 if (len > 3) 516 { 517 /* gidDDD syntax for glyph indices. */ 518 if (0 == strncmp (s, "gid", 3) && 519 hb_codepoint_parse (s + 3, len - 3, 10, glyph)) 520 return true; 521 522 /* uniUUUU and other Unicode character indices. */ 523 hb_codepoint_t unichar; 524 if (0 == strncmp (s, "uni", 3) && 525 hb_codepoint_parse (s + 3, len - 3, 16, &unichar) && 526 get_nominal_glyph (unichar, glyph)) 527 return true; 528 } 529 530 return false; 531 } 532 533 inline hb_position_t em_scale (int16_t v, int scale) 534 { 535 int upem = face->get_upem (); 536 int64_t scaled = v * (int64_t) scale; 537 scaled += scaled >= 0 ? upem/2 : -upem/2; /* Round. */ 538 return (hb_position_t) (scaled / upem); 539 } 540 inline hb_position_t em_scalef (float v, int scale) 541 { 542 return (hb_position_t) (v * scale / face->get_upem ()); 543 } 544}; 545 546#define HB_SHAPER_DATA_CREATE_FUNC_EXTRA_ARGS 547#define HB_SHAPER_IMPLEMENT(shaper) HB_SHAPER_DATA_PROTOTYPE(shaper, font); 548#include "hb-shaper-list.hh" 549#undef HB_SHAPER_IMPLEMENT 550#undef HB_SHAPER_DATA_CREATE_FUNC_EXTRA_ARGS 551 552 553#endif /* HB_FONT_PRIVATE_HH */ 554