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-font.h" 35#include "hb-object-private.hh" 36#include "hb-shaper-private.hh" 37#include "hb-shape-plan-private.hh" 38 39 40 41/* 42 * hb_font_funcs_t 43 */ 44 45#define HB_FONT_FUNCS_IMPLEMENT_CALLBACKS \ 46 HB_FONT_FUNC_IMPLEMENT (glyph) \ 47 HB_FONT_FUNC_IMPLEMENT (glyph_h_advance) \ 48 HB_FONT_FUNC_IMPLEMENT (glyph_v_advance) \ 49 HB_FONT_FUNC_IMPLEMENT (glyph_h_origin) \ 50 HB_FONT_FUNC_IMPLEMENT (glyph_v_origin) \ 51 HB_FONT_FUNC_IMPLEMENT (glyph_h_kerning) \ 52 HB_FONT_FUNC_IMPLEMENT (glyph_v_kerning) \ 53 HB_FONT_FUNC_IMPLEMENT (glyph_extents) \ 54 HB_FONT_FUNC_IMPLEMENT (glyph_contour_point) \ 55 HB_FONT_FUNC_IMPLEMENT (glyph_name) \ 56 HB_FONT_FUNC_IMPLEMENT (glyph_from_name) \ 57 /* ^--- Add new callbacks here */ 58 59struct hb_font_funcs_t { 60 hb_object_header_t header; 61 ASSERT_POD (); 62 63 hb_bool_t immutable; 64 65 /* Don't access these directly. Call hb_font_get_*() instead. */ 66 67 struct { 68#define HB_FONT_FUNC_IMPLEMENT(name) hb_font_get_##name##_func_t name; 69 HB_FONT_FUNCS_IMPLEMENT_CALLBACKS 70#undef HB_FONT_FUNC_IMPLEMENT 71 } get; 72 73 struct { 74#define HB_FONT_FUNC_IMPLEMENT(name) void *name; 75 HB_FONT_FUNCS_IMPLEMENT_CALLBACKS 76#undef HB_FONT_FUNC_IMPLEMENT 77 } user_data; 78 79 struct { 80#define HB_FONT_FUNC_IMPLEMENT(name) hb_destroy_func_t name; 81 HB_FONT_FUNCS_IMPLEMENT_CALLBACKS 82#undef HB_FONT_FUNC_IMPLEMENT 83 } destroy; 84}; 85 86 87/* 88 * hb_face_t 89 */ 90 91struct hb_face_t { 92 hb_object_header_t header; 93 ASSERT_POD (); 94 95 hb_bool_t immutable; 96 97 hb_reference_table_func_t reference_table_func; 98 void *user_data; 99 hb_destroy_func_t destroy; 100 101 unsigned int index; 102 mutable unsigned int upem; 103 mutable unsigned int num_glyphs; 104 105 struct hb_shaper_data_t shaper_data; 106 107 struct plan_node_t { 108 hb_shape_plan_t *shape_plan; 109 plan_node_t *next; 110 } *shape_plans; 111 112 113 inline hb_blob_t *reference_table (hb_tag_t tag) const 114 { 115 hb_blob_t *blob; 116 117 if (unlikely (!this || !reference_table_func)) 118 return hb_blob_get_empty (); 119 120 blob = reference_table_func (/*XXX*/const_cast<hb_face_t *> (this), tag, user_data); 121 if (unlikely (!blob)) 122 return hb_blob_get_empty (); 123 124 return blob; 125 } 126 127 inline unsigned int get_upem (void) const 128 { 129 if (unlikely (!upem)) 130 load_upem (); 131 return upem; 132 } 133 134 inline unsigned int get_num_glyphs (void) const 135 { 136 if (unlikely (num_glyphs == (unsigned int) -1)) 137 load_num_glyphs (); 138 return num_glyphs; 139 } 140 141 private: 142 HB_INTERNAL void load_upem (void) const; 143 HB_INTERNAL void load_num_glyphs (void) const; 144}; 145 146#define HB_SHAPER_DATA_CREATE_FUNC_EXTRA_ARGS 147#define HB_SHAPER_IMPLEMENT(shaper) HB_SHAPER_DATA_PROTOTYPE(shaper, face); 148#include "hb-shaper-list.hh" 149#undef HB_SHAPER_IMPLEMENT 150#undef HB_SHAPER_DATA_CREATE_FUNC_EXTRA_ARGS 151 152 153/* 154 * hb_font_t 155 */ 156 157struct hb_font_t { 158 hb_object_header_t header; 159 ASSERT_POD (); 160 161 hb_bool_t immutable; 162 163 hb_font_t *parent; 164 hb_face_t *face; 165 166 int x_scale; 167 int y_scale; 168 169 unsigned int x_ppem; 170 unsigned int y_ppem; 171 172 hb_font_funcs_t *klass; 173 void *user_data; 174 hb_destroy_func_t destroy; 175 176 struct hb_shaper_data_t shaper_data; 177 178 179 /* Convert from font-space to user-space */ 180 inline hb_position_t em_scale_x (int16_t v) { return em_scale (v, this->x_scale); } 181 inline hb_position_t em_scale_y (int16_t v) { return em_scale (v, this->y_scale); } 182 183 /* Convert from parent-font user-space to our user-space */ 184 inline hb_position_t parent_scale_x_distance (hb_position_t v) { 185 if (unlikely (parent && parent->x_scale != x_scale)) 186 return v * (int64_t) this->x_scale / this->parent->x_scale; 187 return v; 188 } 189 inline hb_position_t parent_scale_y_distance (hb_position_t v) { 190 if (unlikely (parent && parent->y_scale != y_scale)) 191 return v * (int64_t) this->y_scale / this->parent->y_scale; 192 return v; 193 } 194 inline hb_position_t parent_scale_x_position (hb_position_t v) { 195 return parent_scale_x_distance (v); 196 } 197 inline hb_position_t parent_scale_y_position (hb_position_t v) { 198 return parent_scale_y_distance (v); 199 } 200 201 inline void parent_scale_distance (hb_position_t *x, hb_position_t *y) { 202 *x = parent_scale_x_distance (*x); 203 *y = parent_scale_y_distance (*y); 204 } 205 inline void parent_scale_position (hb_position_t *x, hb_position_t *y) { 206 *x = parent_scale_x_position (*x); 207 *y = parent_scale_y_position (*y); 208 } 209 210 211 /* Public getters */ 212 213 inline hb_bool_t get_glyph (hb_codepoint_t unicode, hb_codepoint_t variation_selector, 214 hb_codepoint_t *glyph) 215 { 216 *glyph = 0; 217 return klass->get.glyph (this, user_data, 218 unicode, variation_selector, glyph, 219 klass->user_data.glyph); 220 } 221 222 inline hb_position_t get_glyph_h_advance (hb_codepoint_t glyph) 223 { 224 return klass->get.glyph_h_advance (this, user_data, 225 glyph, 226 klass->user_data.glyph_h_advance); 227 } 228 229 inline hb_position_t get_glyph_v_advance (hb_codepoint_t glyph) 230 { 231 return klass->get.glyph_v_advance (this, user_data, 232 glyph, 233 klass->user_data.glyph_v_advance); 234 } 235 236 inline hb_bool_t get_glyph_h_origin (hb_codepoint_t glyph, 237 hb_position_t *x, hb_position_t *y) 238 { 239 *x = *y = 0; 240 return klass->get.glyph_h_origin (this, user_data, 241 glyph, x, y, 242 klass->user_data.glyph_h_origin); 243 } 244 245 inline hb_bool_t get_glyph_v_origin (hb_codepoint_t glyph, 246 hb_position_t *x, hb_position_t *y) 247 { 248 *x = *y = 0; 249 return klass->get.glyph_v_origin (this, user_data, 250 glyph, x, y, 251 klass->user_data.glyph_v_origin); 252 } 253 254 inline hb_position_t get_glyph_h_kerning (hb_codepoint_t left_glyph, hb_codepoint_t right_glyph) 255 { 256 return klass->get.glyph_h_kerning (this, user_data, 257 left_glyph, right_glyph, 258 klass->user_data.glyph_h_kerning); 259 } 260 261 inline hb_position_t get_glyph_v_kerning (hb_codepoint_t left_glyph, hb_codepoint_t right_glyph) 262 { 263 return klass->get.glyph_v_kerning (this, user_data, 264 left_glyph, right_glyph, 265 klass->user_data.glyph_v_kerning); 266 } 267 268 inline hb_bool_t get_glyph_extents (hb_codepoint_t glyph, 269 hb_glyph_extents_t *extents) 270 { 271 memset (extents, 0, sizeof (*extents)); 272 return klass->get.glyph_extents (this, user_data, 273 glyph, 274 extents, 275 klass->user_data.glyph_extents); 276 } 277 278 inline hb_bool_t get_glyph_contour_point (hb_codepoint_t glyph, unsigned int point_index, 279 hb_position_t *x, hb_position_t *y) 280 { 281 *x = *y = 0; 282 return klass->get.glyph_contour_point (this, user_data, 283 glyph, point_index, 284 x, y, 285 klass->user_data.glyph_contour_point); 286 } 287 288 inline hb_bool_t get_glyph_name (hb_codepoint_t glyph, 289 char *name, unsigned int size) 290 { 291 if (size) *name = '\0'; 292 return klass->get.glyph_name (this, user_data, 293 glyph, 294 name, size, 295 klass->user_data.glyph_name); 296 } 297 298 inline hb_bool_t get_glyph_from_name (const char *name, int len, /* -1 means nul-terminated */ 299 hb_codepoint_t *glyph) 300 { 301 *glyph = 0; 302 if (len == -1) len = strlen (name); 303 return klass->get.glyph_from_name (this, user_data, 304 name, len, 305 glyph, 306 klass->user_data.glyph_from_name); 307 } 308 309 310 /* A bit higher-level, and with fallback */ 311 312 inline void get_glyph_advance_for_direction (hb_codepoint_t glyph, 313 hb_direction_t direction, 314 hb_position_t *x, hb_position_t *y) 315 { 316 if (likely (HB_DIRECTION_IS_HORIZONTAL (direction))) { 317 *x = get_glyph_h_advance (glyph); 318 *y = 0; 319 } else { 320 *x = 0; 321 *y = get_glyph_v_advance (glyph); 322 } 323 } 324 325 /* Internal only */ 326 inline void guess_v_origin_minus_h_origin (hb_codepoint_t glyph, 327 hb_position_t *x, hb_position_t *y) 328 { 329 *x = get_glyph_h_advance (glyph) / 2; 330 331 /* TODO use font_metics.ascent */ 332 *y = y_scale; 333 } 334 335 inline void get_glyph_origin_for_direction (hb_codepoint_t glyph, 336 hb_direction_t direction, 337 hb_position_t *x, hb_position_t *y) 338 { 339 if (likely (HB_DIRECTION_IS_HORIZONTAL (direction))) { 340 hb_bool_t ret = get_glyph_h_origin (glyph, x, y); 341 if (!ret && (ret = get_glyph_v_origin (glyph, x, y))) { 342 hb_position_t dx, dy; 343 guess_v_origin_minus_h_origin (glyph, &dx, &dy); 344 *x -= dx; *y -= dy; 345 } 346 } else { 347 hb_bool_t ret = get_glyph_v_origin (glyph, x, y); 348 if (!ret && (ret = get_glyph_h_origin (glyph, x, y))) { 349 hb_position_t dx, dy; 350 guess_v_origin_minus_h_origin (glyph, &dx, &dy); 351 *x += dx; *y += dy; 352 } 353 } 354 } 355 356 inline void add_glyph_origin_for_direction (hb_codepoint_t glyph, 357 hb_direction_t direction, 358 hb_position_t *x, hb_position_t *y) 359 { 360 hb_position_t origin_x, origin_y; 361 362 get_glyph_origin_for_direction (glyph, direction, &origin_x, &origin_y); 363 364 *x += origin_x; 365 *y += origin_y; 366 } 367 368 inline void subtract_glyph_origin_for_direction (hb_codepoint_t glyph, 369 hb_direction_t direction, 370 hb_position_t *x, hb_position_t *y) 371 { 372 hb_position_t origin_x, origin_y; 373 374 get_glyph_origin_for_direction (glyph, direction, &origin_x, &origin_y); 375 376 *x -= origin_x; 377 *y -= origin_y; 378 } 379 380 inline void get_glyph_kerning_for_direction (hb_codepoint_t first_glyph, hb_codepoint_t second_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 *x = get_glyph_h_kerning (first_glyph, second_glyph); 386 *y = 0; 387 } else { 388 *x = 0; 389 *y = get_glyph_v_kerning (first_glyph, second_glyph); 390 } 391 } 392 393 inline hb_bool_t get_glyph_extents_for_origin (hb_codepoint_t glyph, 394 hb_direction_t direction, 395 hb_glyph_extents_t *extents) 396 { 397 hb_bool_t ret = get_glyph_extents (glyph, extents); 398 399 if (ret) 400 subtract_glyph_origin_for_direction (glyph, direction, &extents->x_bearing, &extents->y_bearing); 401 402 return ret; 403 } 404 405 inline hb_bool_t get_glyph_contour_point_for_origin (hb_codepoint_t glyph, unsigned int point_index, 406 hb_direction_t direction, 407 hb_position_t *x, hb_position_t *y) 408 { 409 hb_bool_t ret = get_glyph_contour_point (glyph, point_index, x, y); 410 411 if (ret) 412 subtract_glyph_origin_for_direction (glyph, direction, x, y); 413 414 return ret; 415 } 416 417 /* Generates gidDDD if glyph has no name. */ 418 inline void 419 glyph_to_string (hb_codepoint_t glyph, 420 char *s, unsigned int size) 421 { 422 if (get_glyph_name (glyph, s, size)) return; 423 424 snprintf (s, size, "gid%u", glyph); 425 } 426 427 /* Parses gidDDD and uniUUUU strings automatically. */ 428 inline hb_bool_t 429 glyph_from_string (const char *s, int len, /* -1 means nul-terminated */ 430 hb_codepoint_t *glyph) 431 { 432 if (get_glyph_from_name (s, len, glyph)) return true; 433 434 if (len == -1) len = strlen (s); 435 436 /* Straight glyph index. */ 437 if (hb_codepoint_parse (s, len, 10, glyph)) 438 return true; 439 440 if (len > 3) 441 { 442 /* gidDDD syntax for glyph indices. */ 443 if (0 == strncmp (s, "gid", 3) && 444 hb_codepoint_parse (s + 3, len - 3, 10, glyph)) 445 return true; 446 447 /* uniUUUU and other Unicode character indices. */ 448 hb_codepoint_t unichar; 449 if (0 == strncmp (s, "uni", 3) && 450 hb_codepoint_parse (s + 3, len - 3, 16, &unichar) && 451 get_glyph (unichar, 0, glyph)) 452 return true; 453 } 454 455 return false; 456 } 457 458 private: 459 inline hb_position_t em_scale (int16_t v, int scale) { return v * (int64_t) scale / hb_face_get_upem (this->face); } 460}; 461 462#define HB_SHAPER_DATA_CREATE_FUNC_EXTRA_ARGS 463#define HB_SHAPER_IMPLEMENT(shaper) HB_SHAPER_DATA_PROTOTYPE(shaper, font); 464#include "hb-shaper-list.hh" 465#undef HB_SHAPER_IMPLEMENT 466#undef HB_SHAPER_DATA_CREATE_FUNC_EXTRA_ARGS 467 468 469#endif /* HB_FONT_PRIVATE_HH */ 470