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 |
|
61 struct 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[0 |
|
87 #define HB_FONT_FUNC_IMPLEMENT(name) +1 |
|
88 HB_FONT_FUNCS_IMPLEMENT_CALLBACKS |
|
89 #undef HB_FONT_FUNC_IMPLEMENT |
|
90 ]) (void); |
|
91 } get; |
|
92 }; |
|
93 |
|
94 |
|
95 |
|
96 /* |
|
97 * hb_font_t |
|
98 */ |
|
99 |
|
100 struct hb_font_t { |
|
101 hb_object_header_t header; |
|
102 ASSERT_POD (); |
|
103 |
|
104 hb_bool_t immutable; |
|
105 |
|
106 hb_font_t *parent; |
|
107 hb_face_t *face; |
|
108 |
|
109 int x_scale; |
|
110 int y_scale; |
|
111 |
|
112 unsigned int x_ppem; |
|
113 unsigned int y_ppem; |
|
114 |
|
115 float ptem; |
|
116 |
|
117 /* Font variation coordinates. */ |
|
118 unsigned int num_coords; |
|
119 int *coords; |
|
120 |
|
121 hb_font_funcs_t *klass; |
|
122 void *user_data; |
|
123 hb_destroy_func_t destroy; |
|
124 |
|
125 struct hb_shaper_data_t shaper_data; |
|
126 |
|
127 |
|
128 /* Convert from font-space to user-space */ |
|
129 inline int dir_scale (hb_direction_t direction) |
|
130 { return HB_DIRECTION_IS_VERTICAL(direction) ? y_scale : x_scale; } |
|
131 inline hb_position_t em_scale_x (int16_t v) { return em_scale (v, x_scale); } |
|
132 inline hb_position_t em_scale_y (int16_t v) { return em_scale (v, y_scale); } |
|
133 inline hb_position_t em_scalef_x (float v) { return em_scalef (v, this->x_scale); } |
|
134 inline hb_position_t em_scalef_y (float v) { return em_scalef (v, this->y_scale); } |
|
135 inline float em_fscale_x (int16_t v) { return em_fscale (v, x_scale); } |
|
136 inline float em_fscale_y (int16_t v) { return em_fscale (v, y_scale); } |
|
137 inline hb_position_t em_scale_dir (int16_t v, hb_direction_t direction) |
|
138 { return em_scale (v, dir_scale (direction)); } |
|
139 |
|
140 /* Convert from parent-font user-space to our user-space */ |
|
141 inline hb_position_t parent_scale_x_distance (hb_position_t v) { |
|
142 if (unlikely (parent && parent->x_scale != x_scale)) |
|
143 return (hb_position_t) (v * (int64_t) this->x_scale / this->parent->x_scale); |
|
144 return v; |
|
145 } |
|
146 inline hb_position_t parent_scale_y_distance (hb_position_t v) { |
|
147 if (unlikely (parent && parent->y_scale != y_scale)) |
|
148 return (hb_position_t) (v * (int64_t) this->y_scale / this->parent->y_scale); |
|
149 return v; |
|
150 } |
|
151 inline hb_position_t parent_scale_x_position (hb_position_t v) { |
|
152 return parent_scale_x_distance (v); |
|
153 } |
|
154 inline hb_position_t parent_scale_y_position (hb_position_t v) { |
|
155 return parent_scale_y_distance (v); |
|
156 } |
|
157 |
|
158 inline void parent_scale_distance (hb_position_t *x, hb_position_t *y) { |
|
159 *x = parent_scale_x_distance (*x); |
|
160 *y = parent_scale_y_distance (*y); |
|
161 } |
|
162 inline void parent_scale_position (hb_position_t *x, hb_position_t *y) { |
|
163 *x = parent_scale_x_position (*x); |
|
164 *y = parent_scale_y_position (*y); |
|
165 } |
|
166 |
|
167 |
|
168 /* Public getters */ |
|
169 |
|
170 HB_INTERNAL bool has_func (unsigned int i); |
|
171 |
|
172 /* has_* ... */ |
|
173 #define HB_FONT_FUNC_IMPLEMENT(name) \ |
|
174 bool \ |
|
175 has_##name##_func (void) \ |
|
176 { \ |
|
177 hb_font_funcs_t *funcs = this->klass; \ |
|
178 unsigned int i = offsetof (hb_font_funcs_t::get_t::get_funcs_t, name) / sizeof (funcs->get.array[0]); \ |
|
179 return has_func (i); \ |
|
180 } |
|
181 HB_FONT_FUNCS_IMPLEMENT_CALLBACKS |
|
182 #undef HB_FONT_FUNC_IMPLEMENT |
|
183 |
|
184 inline hb_bool_t get_font_h_extents (hb_font_extents_t *extents) |
|
185 { |
|
186 memset (extents, 0, sizeof (*extents)); |
|
187 return klass->get.f.font_h_extents (this, user_data, |
|
188 extents, |
|
189 klass->user_data.font_h_extents); |
|
190 } |
|
191 inline hb_bool_t get_font_v_extents (hb_font_extents_t *extents) |
|
192 { |
|
193 memset (extents, 0, sizeof (*extents)); |
|
194 return klass->get.f.font_v_extents (this, user_data, |
|
195 extents, |
|
196 klass->user_data.font_v_extents); |
|
197 } |
|
198 |
|
199 inline bool has_glyph (hb_codepoint_t unicode) |
|
200 { |
|
201 hb_codepoint_t glyph; |
|
202 return get_nominal_glyph (unicode, &glyph); |
|
203 } |
|
204 |
|
205 inline hb_bool_t get_nominal_glyph (hb_codepoint_t unicode, |
|
206 hb_codepoint_t *glyph) |
|
207 { |
|
208 *glyph = 0; |
|
209 return klass->get.f.nominal_glyph (this, user_data, |
|
210 unicode, glyph, |
|
211 klass->user_data.nominal_glyph); |
|
212 } |
|
213 |
|
214 inline hb_bool_t get_variation_glyph (hb_codepoint_t unicode, hb_codepoint_t variation_selector, |
|
215 hb_codepoint_t *glyph) |
|
216 { |
|
217 *glyph = 0; |
|
218 return klass->get.f.variation_glyph (this, user_data, |
|
219 unicode, variation_selector, glyph, |
|
220 klass->user_data.variation_glyph); |
|
221 } |
|
222 |
|
223 inline hb_position_t get_glyph_h_advance (hb_codepoint_t glyph) |
|
224 { |
|
225 return klass->get.f.glyph_h_advance (this, user_data, |
|
226 glyph, |
|
227 klass->user_data.glyph_h_advance); |
|
228 } |
|
229 |
|
230 inline hb_position_t get_glyph_v_advance (hb_codepoint_t glyph) |
|
231 { |
|
232 return klass->get.f.glyph_v_advance (this, user_data, |
|
233 glyph, |
|
234 klass->user_data.glyph_v_advance); |
|
235 } |
|
236 |
|
237 inline hb_bool_t get_glyph_h_origin (hb_codepoint_t glyph, |
|
238 hb_position_t *x, hb_position_t *y) |
|
239 { |
|
240 *x = *y = 0; |
|
241 return klass->get.f.glyph_h_origin (this, user_data, |
|
242 glyph, x, y, |
|
243 klass->user_data.glyph_h_origin); |
|
244 } |
|
245 |
|
246 inline hb_bool_t get_glyph_v_origin (hb_codepoint_t glyph, |
|
247 hb_position_t *x, hb_position_t *y) |
|
248 { |
|
249 *x = *y = 0; |
|
250 return klass->get.f.glyph_v_origin (this, user_data, |
|
251 glyph, x, y, |
|
252 klass->user_data.glyph_v_origin); |
|
253 } |
|
254 |
|
255 inline hb_position_t get_glyph_h_kerning (hb_codepoint_t left_glyph, hb_codepoint_t right_glyph) |
|
256 { |
|
257 return klass->get.f.glyph_h_kerning (this, user_data, |
|
258 left_glyph, right_glyph, |
|
259 klass->user_data.glyph_h_kerning); |
|
260 } |
|
261 |
|
262 inline hb_position_t get_glyph_v_kerning (hb_codepoint_t top_glyph, hb_codepoint_t bottom_glyph) |
|
263 { |
|
264 return klass->get.f.glyph_v_kerning (this, user_data, |
|
265 top_glyph, bottom_glyph, |
|
266 klass->user_data.glyph_v_kerning); |
|
267 } |
|
268 |
|
269 inline hb_bool_t get_glyph_extents (hb_codepoint_t glyph, |
|
270 hb_glyph_extents_t *extents) |
|
271 { |
|
272 memset (extents, 0, sizeof (*extents)); |
|
273 return klass->get.f.glyph_extents (this, user_data, |
|
274 glyph, |
|
275 extents, |
|
276 klass->user_data.glyph_extents); |
|
277 } |
|
278 |
|
279 inline hb_bool_t get_glyph_contour_point (hb_codepoint_t glyph, unsigned int point_index, |
|
280 hb_position_t *x, hb_position_t *y) |
|
281 { |
|
282 *x = *y = 0; |
|
283 return klass->get.f.glyph_contour_point (this, user_data, |
|
284 glyph, point_index, |
|
285 x, y, |
|
286 klass->user_data.glyph_contour_point); |
|
287 } |
|
288 |
|
289 inline hb_bool_t get_glyph_name (hb_codepoint_t glyph, |
|
290 char *name, unsigned int size) |
|
291 { |
|
292 if (size) *name = '\0'; |
|
293 return klass->get.f.glyph_name (this, user_data, |
|
294 glyph, |
|
295 name, size, |
|
296 klass->user_data.glyph_name); |
|
297 } |
|
298 |
|
299 inline hb_bool_t get_glyph_from_name (const char *name, int len, /* -1 means nul-terminated */ |
|
300 hb_codepoint_t *glyph) |
|
301 { |
|
302 *glyph = 0; |
|
303 if (len == -1) len = strlen (name); |
|
304 return klass->get.f.glyph_from_name (this, user_data, |
|
305 name, len, |
|
306 glyph, |
|
307 klass->user_data.glyph_from_name); |
|
308 } |
|
309 |
|
310 |
|
311 /* A bit higher-level, and with fallback */ |
|
312 |
|
313 inline void get_h_extents_with_fallback (hb_font_extents_t *extents) |
|
314 { |
|
315 if (!get_font_h_extents (extents)) |
|
316 { |
|
317 extents->ascender = y_scale * .8; |
|
318 extents->descender = extents->ascender - y_scale; |
|
319 extents->line_gap = 0; |
|
320 } |
|
321 } |
|
322 inline void get_v_extents_with_fallback (hb_font_extents_t *extents) |
|
323 { |
|
324 if (!get_font_v_extents (extents)) |
|
325 { |
|
326 extents->ascender = x_scale / 2; |
|
327 extents->descender = extents->ascender - x_scale; |
|
328 extents->line_gap = 0; |
|
329 } |
|
330 } |
|
331 |
|
332 inline void get_extents_for_direction (hb_direction_t direction, |
|
333 hb_font_extents_t *extents) |
|
334 { |
|
335 if (likely (HB_DIRECTION_IS_HORIZONTAL (direction))) |
|
336 get_h_extents_with_fallback (extents); |
|
337 else |
|
338 get_v_extents_with_fallback (extents); |
|
339 } |
|
340 |
|
341 inline void get_glyph_advance_for_direction (hb_codepoint_t glyph, |
|
342 hb_direction_t direction, |
|
343 hb_position_t *x, hb_position_t *y) |
|
344 { |
|
345 if (likely (HB_DIRECTION_IS_HORIZONTAL (direction))) { |
|
346 *x = get_glyph_h_advance (glyph); |
|
347 *y = 0; |
|
348 } else { |
|
349 *x = 0; |
|
350 *y = get_glyph_v_advance (glyph); |
|
351 } |
|
352 } |
|
353 |
|
354 inline void guess_v_origin_minus_h_origin (hb_codepoint_t glyph, |
|
355 hb_position_t *x, hb_position_t *y) |
|
356 { |
|
357 *x = get_glyph_h_advance (glyph) / 2; |
|
358 |
|
359 /* TODO cache this somehow?! */ |
|
360 hb_font_extents_t extents; |
|
361 get_h_extents_with_fallback (&extents); |
|
362 *y = extents.ascender; |
|
363 } |
|
364 |
|
365 inline void get_glyph_h_origin_with_fallback (hb_codepoint_t glyph, |
|
366 hb_position_t *x, hb_position_t *y) |
|
367 { |
|
368 if (!get_glyph_h_origin (glyph, x, y) && |
|
369 get_glyph_v_origin (glyph, x, y)) |
|
370 { |
|
371 hb_position_t dx, dy; |
|
372 guess_v_origin_minus_h_origin (glyph, &dx, &dy); |
|
373 *x -= dx; *y -= dy; |
|
374 } |
|
375 } |
|
376 inline void get_glyph_v_origin_with_fallback (hb_codepoint_t glyph, |
|
377 hb_position_t *x, hb_position_t *y) |
|
378 { |
|
379 if (!get_glyph_v_origin (glyph, x, y) && |
|
380 get_glyph_h_origin (glyph, x, y)) |
|
381 { |
|
382 hb_position_t dx, dy; |
|
383 guess_v_origin_minus_h_origin (glyph, &dx, &dy); |
|
384 *x += dx; *y += dy; |
|
385 } |
|
386 } |
|
387 |
|
388 inline void get_glyph_origin_for_direction (hb_codepoint_t glyph, |
|
389 hb_direction_t direction, |
|
390 hb_position_t *x, hb_position_t *y) |
|
391 { |
|
392 if (likely (HB_DIRECTION_IS_HORIZONTAL (direction))) |
|
393 get_glyph_h_origin_with_fallback (glyph, x, y); |
|
394 else |
|
395 get_glyph_v_origin_with_fallback (glyph, x, y); |
|
396 } |
|
397 |
|
398 inline void add_glyph_h_origin (hb_codepoint_t glyph, |
|
399 hb_position_t *x, hb_position_t *y) |
|
400 { |
|
401 hb_position_t origin_x, origin_y; |
|
402 |
|
403 get_glyph_h_origin_with_fallback (glyph, &origin_x, &origin_y); |
|
404 |
|
405 *x += origin_x; |
|
406 *y += origin_y; |
|
407 } |
|
408 inline void add_glyph_v_origin (hb_codepoint_t glyph, |
|
409 hb_position_t *x, hb_position_t *y) |
|
410 { |
|
411 hb_position_t origin_x, origin_y; |
|
412 |
|
413 get_glyph_v_origin_with_fallback (glyph, &origin_x, &origin_y); |
|
414 |
|
415 *x += origin_x; |
|
416 *y += origin_y; |
|
417 } |
|
418 inline void add_glyph_origin_for_direction (hb_codepoint_t glyph, |
|
419 hb_direction_t direction, |
|
420 hb_position_t *x, hb_position_t *y) |
|
421 { |
|
422 hb_position_t origin_x, origin_y; |
|
423 |
|
424 get_glyph_origin_for_direction (glyph, direction, &origin_x, &origin_y); |
|
425 |
|
426 *x += origin_x; |
|
427 *y += origin_y; |
|
428 } |
|
429 |
|
430 inline void subtract_glyph_h_origin (hb_codepoint_t glyph, |
|
431 hb_position_t *x, hb_position_t *y) |
|
432 { |
|
433 hb_position_t origin_x, origin_y; |
|
434 |
|
435 get_glyph_h_origin_with_fallback (glyph, &origin_x, &origin_y); |
|
436 |
|
437 *x -= origin_x; |
|
438 *y -= origin_y; |
|
439 } |
|
440 inline void subtract_glyph_v_origin (hb_codepoint_t glyph, |
|
441 hb_position_t *x, hb_position_t *y) |
|
442 { |
|
443 hb_position_t origin_x, origin_y; |
|
444 |
|
445 get_glyph_v_origin_with_fallback (glyph, &origin_x, &origin_y); |
|
446 |
|
447 *x -= origin_x; |
|
448 *y -= origin_y; |
|
449 } |
|
450 inline void subtract_glyph_origin_for_direction (hb_codepoint_t glyph, |
|
451 hb_direction_t direction, |
|
452 hb_position_t *x, hb_position_t *y) |
|
453 { |
|
454 hb_position_t origin_x, origin_y; |
|
455 |
|
456 get_glyph_origin_for_direction (glyph, direction, &origin_x, &origin_y); |
|
457 |
|
458 *x -= origin_x; |
|
459 *y -= origin_y; |
|
460 } |
|
461 |
|
462 inline void get_glyph_kerning_for_direction (hb_codepoint_t first_glyph, hb_codepoint_t second_glyph, |
|
463 hb_direction_t direction, |
|
464 hb_position_t *x, hb_position_t *y) |
|
465 { |
|
466 if (likely (HB_DIRECTION_IS_HORIZONTAL (direction))) { |
|
467 *x = get_glyph_h_kerning (first_glyph, second_glyph); |
|
468 *y = 0; |
|
469 } else { |
|
470 *x = 0; |
|
471 *y = get_glyph_v_kerning (first_glyph, second_glyph); |
|
472 } |
|
473 } |
|
474 |
|
475 inline hb_bool_t get_glyph_extents_for_origin (hb_codepoint_t glyph, |
|
476 hb_direction_t direction, |
|
477 hb_glyph_extents_t *extents) |
|
478 { |
|
479 hb_bool_t ret = get_glyph_extents (glyph, extents); |
|
480 |
|
481 if (ret) |
|
482 subtract_glyph_origin_for_direction (glyph, direction, &extents->x_bearing, &extents->y_bearing); |
|
483 |
|
484 return ret; |
|
485 } |
|
486 |
|
487 inline hb_bool_t get_glyph_contour_point_for_origin (hb_codepoint_t glyph, unsigned int point_index, |
|
488 hb_direction_t direction, |
|
489 hb_position_t *x, hb_position_t *y) |
|
490 { |
|
491 hb_bool_t ret = get_glyph_contour_point (glyph, point_index, x, y); |
|
492 |
|
493 if (ret) |
|
494 subtract_glyph_origin_for_direction (glyph, direction, x, y); |
|
495 |
|
496 return ret; |
|
497 } |
|
498 |
|
499 /* Generates gidDDD if glyph has no name. */ |
|
500 inline void |
|
501 glyph_to_string (hb_codepoint_t glyph, |
|
502 char *s, unsigned int size) |
|
503 { |
|
504 if (get_glyph_name (glyph, s, size)) return; |
|
505 |
|
506 if (size && snprintf (s, size, "gid%u", glyph) < 0) |
|
507 *s = '\0'; |
|
508 } |
|
509 |
|
510 /* Parses gidDDD and uniUUUU strings automatically. */ |
|
511 inline hb_bool_t |
|
512 glyph_from_string (const char *s, int len, /* -1 means nul-terminated */ |
|
513 hb_codepoint_t *glyph) |
|
514 { |
|
515 if (get_glyph_from_name (s, len, glyph)) return true; |
|
516 |
|
517 if (len == -1) len = strlen (s); |
|
518 |
|
519 /* Straight glyph index. */ |
|
520 if (hb_codepoint_parse (s, len, 10, glyph)) |
|
521 return true; |
|
522 |
|
523 if (len > 3) |
|
524 { |
|
525 /* gidDDD syntax for glyph indices. */ |
|
526 if (0 == strncmp (s, "gid", 3) && |
|
527 hb_codepoint_parse (s + 3, len - 3, 10, glyph)) |
|
528 return true; |
|
529 |
|
530 /* uniUUUU and other Unicode character indices. */ |
|
531 hb_codepoint_t unichar; |
|
532 if (0 == strncmp (s, "uni", 3) && |
|
533 hb_codepoint_parse (s + 3, len - 3, 16, &unichar) && |
|
534 get_nominal_glyph (unichar, glyph)) |
|
535 return true; |
|
536 } |
|
537 |
|
538 return false; |
|
539 } |
|
540 |
|
541 inline hb_position_t em_scale (int16_t v, int scale) |
|
542 { |
|
543 int upem = face->get_upem (); |
|
544 int64_t scaled = v * (int64_t) scale; |
|
545 scaled += scaled >= 0 ? upem/2 : -upem/2; /* Round. */ |
|
546 return (hb_position_t) (scaled / upem); |
|
547 } |
|
548 inline hb_position_t em_scalef (float v, int scale) |
|
549 { |
|
550 return (hb_position_t) round (v * scale / face->get_upem ()); |
|
551 } |
|
552 inline float em_fscale (int16_t v, int scale) |
|
553 { |
|
554 return (float) v * scale / face->get_upem (); |
|
555 } |
|
556 }; |
|
557 |
|
558 #define HB_SHAPER_DATA_CREATE_FUNC_EXTRA_ARGS |
|
559 #define HB_SHAPER_IMPLEMENT(shaper) HB_SHAPER_DATA_PROTOTYPE(shaper, font); |
|
560 #include "hb-shaper-list.hh" |
|
561 #undef HB_SHAPER_IMPLEMENT |
|
562 #undef HB_SHAPER_DATA_CREATE_FUNC_EXTRA_ARGS |
|
563 |
|
564 |
|
565 #endif /* HB_FONT_PRIVATE_HH */ |
|