From 8b5bc141cd3a6bfcea3c91a882a630426876ceb3 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Wed, 24 Feb 2016 19:05:23 +0900 Subject: [PATCH] Add get_nominal_glyph() and get_variation_glyph() instead of get_glyph() New API: - hb_font_get_nominal_glyph_func_t - hb_font_get_variation_glyph_func_t - hb_font_funcs_set_nominal_glyph_func() - hb_font_funcs_set_variation_glyph_func() - hb_font_get_nominal_glyph() - hb_font_get_variation_glyph() Deprecated API: - hb_font_get_glyph_func_t - hb_font_funcs_set_glyph_func() Clients that implement their own font-funcs are encouraged to replace their get_glyph() implementation with a get_nominal_glyph() and get_variation_glyph() pair. The variation version can assume that variation_selector argument is not zero. --- src/hb-deprecated.h | 10 ++ src/hb-fallback-shape.cc | 4 +- src/hb-font-private.hh | 26 ++-- src/hb-font.cc | 203 +++++++++++++++++++++++++++-- src/hb-font.h | 55 ++++++-- src/hb-ft.cc | 38 ++++-- src/hb-ot-font.cc | 57 +++++--- src/hb-ot-shape-complex-indic.cc | 8 +- src/hb-ot-shape-complex-myanmar.cc | 2 +- src/hb-ot-shape-complex-use.cc | 2 +- src/hb-ot-shape-fallback.cc | 6 +- src/hb-ot-shape-normalize.cc | 18 +-- src/hb-ot-shape.cc | 6 +- 13 files changed, 344 insertions(+), 91 deletions(-) diff --git a/src/hb-deprecated.h b/src/hb-deprecated.h index 30ae4b1ca..0398dfae6 100644 --- a/src/hb-deprecated.h +++ b/src/hb-deprecated.h @@ -44,6 +44,16 @@ HB_BEGIN_DECLS #define HB_BUFFER_FLAGS_DEFAULT HB_BUFFER_FLAG_DEFAULT #define HB_BUFFER_SERIALIZE_FLAGS_DEFAULT HB_BUFFER_SERIALIZE_FLAG_DEFAULT +typedef hb_bool_t (*hb_font_get_glyph_func_t) (hb_font_t *font, void *font_data, + hb_codepoint_t unicode, hb_codepoint_t variation_selector, + hb_codepoint_t *glyph, + void *user_data); + +HB_EXTERN void +hb_font_funcs_set_glyph_func (hb_font_funcs_t *ffuncs, + hb_font_get_glyph_func_t func, + void *user_data, hb_destroy_func_t destroy); + #endif HB_END_DECLS diff --git a/src/hb-fallback-shape.cc b/src/hb-fallback-shape.cc index b5ebfc046..e2ad24001 100644 --- a/src/hb-fallback-shape.cc +++ b/src/hb-fallback-shape.cc @@ -106,7 +106,7 @@ _hb_fallback_shape (hb_shape_plan_t *shape_plan HB_UNUSED, */ hb_codepoint_t space; - bool has_space = (bool) font->get_glyph (' ', 0, &space); + bool has_space = (bool) font->get_nominal_glyph (' ', &space); buffer->clear_positions (); @@ -123,7 +123,7 @@ _hb_fallback_shape (hb_shape_plan_t *shape_plan HB_UNUSED, pos[i].y_advance = 0; continue; } - font->get_glyph (info[i].codepoint, 0, &info[i].codepoint); + font->get_nominal_glyph (info[i].codepoint, &info[i].codepoint); font->get_glyph_advance_for_direction (info[i].codepoint, direction, &pos[i].x_advance, diff --git a/src/hb-font-private.hh b/src/hb-font-private.hh index 9138c236d..8da40a992 100644 --- a/src/hb-font-private.hh +++ b/src/hb-font-private.hh @@ -44,7 +44,8 @@ #define HB_FONT_FUNCS_IMPLEMENT_CALLBACKS \ HB_FONT_FUNC_IMPLEMENT (font_h_extents) \ HB_FONT_FUNC_IMPLEMENT (font_v_extents) \ - HB_FONT_FUNC_IMPLEMENT (glyph) \ + HB_FONT_FUNC_IMPLEMENT (nominal_glyph) \ + HB_FONT_FUNC_IMPLEMENT (variation_glyph) \ HB_FONT_FUNC_IMPLEMENT (glyph_h_advance) \ HB_FONT_FUNC_IMPLEMENT (glyph_v_advance) \ HB_FONT_FUNC_IMPLEMENT (glyph_h_origin) \ @@ -180,16 +181,25 @@ struct hb_font_t { inline bool has_glyph (hb_codepoint_t unicode) { hb_codepoint_t glyph; - return get_glyph (unicode, 0, &glyph); + return get_nominal_glyph (unicode, &glyph); } - inline hb_bool_t get_glyph (hb_codepoint_t unicode, hb_codepoint_t variation_selector, - hb_codepoint_t *glyph) + inline hb_bool_t get_nominal_glyph (hb_codepoint_t unicode, + hb_codepoint_t *glyph) { *glyph = 0; - return klass->get.f.glyph (this, user_data, - unicode, variation_selector, glyph, - klass->user_data.glyph); + return klass->get.f.nominal_glyph (this, user_data, + unicode, glyph, + klass->user_data.nominal_glyph); + } + + inline hb_bool_t get_variation_glyph (hb_codepoint_t unicode, hb_codepoint_t variation_selector, + hb_codepoint_t *glyph) + { + *glyph = 0; + return klass->get.f.variation_glyph (this, user_data, + unicode, variation_selector, glyph, + klass->user_data.variation_glyph); } inline hb_position_t get_glyph_h_advance (hb_codepoint_t glyph) @@ -487,7 +497,7 @@ struct hb_font_t { hb_codepoint_t unichar; if (0 == strncmp (s, "uni", 3) && hb_codepoint_parse (s + 3, len - 3, 16, &unichar) && - get_glyph (unichar, 0, glyph)) + get_nominal_glyph (unichar, glyph)) return true; } diff --git a/src/hb-font.cc b/src/hb-font.cc index c038b1087..6742b4992 100644 --- a/src/hb-font.cc +++ b/src/hb-font.cc @@ -93,27 +93,48 @@ hb_font_get_font_v_extents_parent (hb_font_t *font, } static hb_bool_t -hb_font_get_glyph_nil (hb_font_t *font HB_UNUSED, - void *font_data HB_UNUSED, - hb_codepoint_t unicode, - hb_codepoint_t variation_selector, - hb_codepoint_t *glyph, - void *user_data HB_UNUSED) +hb_font_get_nominal_glyph_nil (hb_font_t *font HB_UNUSED, + void *font_data HB_UNUSED, + hb_codepoint_t unicode, + hb_codepoint_t *glyph, + void *user_data HB_UNUSED) { *glyph = 0; return false; } static hb_bool_t -hb_font_get_glyph_parent (hb_font_t *font, - void *font_data HB_UNUSED, - hb_codepoint_t unicode, - hb_codepoint_t variation_selector, - hb_codepoint_t *glyph, - void *user_data HB_UNUSED) +hb_font_get_nominal_glyph_parent (hb_font_t *font, + void *font_data HB_UNUSED, + hb_codepoint_t unicode, + hb_codepoint_t *glyph, + void *user_data HB_UNUSED) { - return font->parent->get_glyph (unicode, variation_selector, glyph); + return font->parent->get_nominal_glyph (unicode, glyph); } +static hb_bool_t +hb_font_get_variation_glyph_nil (hb_font_t *font HB_UNUSED, + void *font_data HB_UNUSED, + hb_codepoint_t unicode, + hb_codepoint_t variation_selector, + hb_codepoint_t *glyph, + void *user_data HB_UNUSED) +{ + *glyph = 0; + return false; +} +static hb_bool_t +hb_font_get_variation_glyph_parent (hb_font_t *font, + void *font_data HB_UNUSED, + hb_codepoint_t unicode, + hb_codepoint_t variation_selector, + hb_codepoint_t *glyph, + void *user_data HB_UNUSED) +{ + return font->parent->get_variation_glyph (unicode, variation_selector, glyph); +} + + static hb_position_t hb_font_get_glyph_h_advance_nil (hb_font_t *font HB_UNUSED, void *font_data HB_UNUSED, @@ -622,7 +643,50 @@ hb_font_get_glyph (hb_font_t *font, hb_codepoint_t unicode, hb_codepoint_t variation_selector, hb_codepoint_t *glyph) { - return font->get_glyph (unicode, variation_selector, glyph); + if (unlikely (variation_selector)) + return font->get_variation_glyph (unicode, variation_selector, glyph); + return font->get_nominal_glyph (unicode, glyph); +} + +/** + * hb_font_get_nominal_glyph: + * @font: a font. + * @unicode: + * @glyph: (out): + * + * + * + * Return value: + * + * Since: 1.2.3 + **/ +hb_bool_t +hb_font_get_nominal_glyph (hb_font_t *font, + hb_codepoint_t unicode, + hb_codepoint_t *glyph) +{ + return font->get_nominal_glyph (unicode, glyph); +} + +/** + * hb_font_get_variation_glyph: + * @font: a font. + * @unicode: + * @variation_selector: + * @glyph: (out): + * + * + * + * Return value: + * + * Since: 1.2.3 + **/ +hb_bool_t +hb_font_get_variation_glyph (hb_font_t *font, + hb_codepoint_t unicode, hb_codepoint_t variation_selector, + hb_codepoint_t *glyph) +{ + return font->get_variation_glyph (unicode, variation_selector, glyph); } /** @@ -1472,3 +1536,114 @@ hb_font_get_ppem (hb_font_t *font, if (x_ppem) *x_ppem = font->x_ppem; if (y_ppem) *y_ppem = font->y_ppem; } + + +/* + * Deprecated get_glyph_func(): + */ + +struct hb_trampoline_closure_t +{ + void *user_data; + hb_destroy_func_t destroy; +}; + +template +struct hb_trampoline_t +{ + hb_trampoline_closure_t closure; /* Must be first. */ + FuncType func; +}; + +template +static hb_trampoline_t * +trampoline_create (FuncType func, + void *user_data, + hb_destroy_func_t destroy) +{ + typedef hb_trampoline_t trampoline_t; + + trampoline_t *trampoline = (trampoline_t *) calloc (1, sizeof (trampoline_t)); + + if (unlikely (!trampoline)) + { + if (destroy) + destroy (user_data); + return NULL; + } + + trampoline->closure.user_data = user_data; + trampoline->closure.destroy = destroy; + trampoline->func = func; + + return trampoline; +} + +static void +trampoline_destroy (void *user_data) +{ + hb_trampoline_closure_t *closure = (hb_trampoline_closure_t *) user_data; + if (closure->destroy) + closure->destroy (closure->user_data); + free (closure); +} + +typedef hb_trampoline_t hb_font_get_glyph_trampoline_t; + +static hb_bool_t +hb_font_get_nominal_glyph_trampoline (hb_font_t *font, + void *font_data, + hb_codepoint_t unicode, + hb_codepoint_t *glyph, + void *user_data) +{ + hb_font_get_glyph_trampoline_t *trampoline = (hb_font_get_glyph_trampoline_t *) user_data; + return trampoline->func (font, font_data, unicode, 0, glyph, trampoline->closure.user_data); +} + +static hb_bool_t +hb_font_get_variation_glyph_trampoline (hb_font_t *font, + void *font_data, + hb_codepoint_t unicode, + hb_codepoint_t variation_selector, + hb_codepoint_t *glyph, + void *user_data) +{ + hb_font_get_glyph_trampoline_t *trampoline = (hb_font_get_glyph_trampoline_t *) user_data; + return trampoline->func (font, font_data, unicode, variation_selector, glyph, trampoline->closure.user_data); +} + +/** + * hb_font_funcs_set_glyph_func: + * @ffuncs: font functions. + * @func: (closure user_data) (destroy destroy) (scope notified): + * @user_data: + * @destroy: + * + * Deprecated. Use hb_font_funcs_set_nominal_glyph_func() and + * hb_font_funcs_set_variation_glyph_func() instead. + * + * Since: 0.9.2 + * Deprecated: 1.2.3 + **/ +void +hb_font_funcs_set_glyph_func (hb_font_funcs_t *ffuncs, + hb_font_get_glyph_func_t func, + void *user_data, hb_destroy_func_t destroy) +{ + hb_font_get_glyph_trampoline_t *trampoline; + + trampoline = trampoline_create (func, user_data, destroy); + if (likely (trampoline)) + hb_font_funcs_set_nominal_glyph_func (ffuncs, + hb_font_get_nominal_glyph_trampoline, + trampoline, + trampoline_destroy); + + trampoline = trampoline_create (func, user_data, destroy); + if (likely (trampoline)) + hb_font_funcs_set_variation_glyph_func (ffuncs, + hb_font_get_variation_glyph_trampoline, + trampoline, + trampoline_destroy); +} diff --git a/src/hb-font.h b/src/hb-font.h index 82d056c01..2b6ab5088 100644 --- a/src/hb-font.h +++ b/src/hb-font.h @@ -116,10 +116,14 @@ typedef hb_font_get_font_extents_func_t hb_font_get_font_h_extents_func_t; typedef hb_font_get_font_extents_func_t hb_font_get_font_v_extents_func_t; -typedef hb_bool_t (*hb_font_get_glyph_func_t) (hb_font_t *font, void *font_data, - hb_codepoint_t unicode, hb_codepoint_t variation_selector, - hb_codepoint_t *glyph, - void *user_data); +typedef hb_bool_t (*hb_font_get_nominal_glyph_func_t) (hb_font_t *font, void *font_data, + hb_codepoint_t unicode, + hb_codepoint_t *glyph, + void *user_data); +typedef hb_bool_t (*hb_font_get_variation_glyph_func_t) (hb_font_t *font, void *font_data, + hb_codepoint_t unicode, hb_codepoint_t variation_selector, + hb_codepoint_t *glyph, + void *user_data); typedef hb_position_t (*hb_font_get_glyph_advance_func_t) (hb_font_t *font, void *font_data, @@ -197,7 +201,7 @@ hb_font_funcs_set_font_v_extents_func (hb_font_funcs_t *ffuncs, void *user_data, hb_destroy_func_t destroy); /** - * hb_font_funcs_set_glyph_func: + * hb_font_funcs_set_nominal_glyph_func: * @ffuncs: font functions. * @func: (closure user_data) (destroy destroy) (scope notified): * @user_data: @@ -205,12 +209,28 @@ hb_font_funcs_set_font_v_extents_func (hb_font_funcs_t *ffuncs, * * * - * Since: 0.9.2 + * Since: 1.2.3 **/ HB_EXTERN void -hb_font_funcs_set_glyph_func (hb_font_funcs_t *ffuncs, - hb_font_get_glyph_func_t func, - void *user_data, hb_destroy_func_t destroy); +hb_font_funcs_set_nominal_glyph_func (hb_font_funcs_t *ffuncs, + hb_font_get_nominal_glyph_func_t func, + void *user_data, hb_destroy_func_t destroy); + +/** + * hb_font_funcs_set_variation_glyph_func: + * @ffuncs: font functions. + * @func: (closure user_data) (destroy destroy) (scope notified): + * @user_data: + * @destroy: + * + * + * + * Since: 1.2.3 + **/ +HB_EXTERN void +hb_font_funcs_set_variation_glyph_func (hb_font_funcs_t *ffuncs, + hb_font_get_variation_glyph_func_t func, + void *user_data, hb_destroy_func_t destroy); /** * hb_font_funcs_set_glyph_h_advance_func: @@ -382,9 +402,13 @@ hb_font_get_v_extents (hb_font_t *font, hb_font_extents_t *extents); HB_EXTERN hb_bool_t -hb_font_get_glyph (hb_font_t *font, - hb_codepoint_t unicode, hb_codepoint_t variation_selector, - hb_codepoint_t *glyph); +hb_font_get_nominal_glyph (hb_font_t *font, + hb_codepoint_t unicode, + hb_codepoint_t *glyph); +HB_EXTERN hb_bool_t +hb_font_get_variation_glyph (hb_font_t *font, + hb_codepoint_t unicode, hb_codepoint_t variation_selector, + hb_codepoint_t *glyph); HB_EXTERN hb_position_t hb_font_get_glyph_h_advance (hb_font_t *font, @@ -431,6 +455,13 @@ hb_font_get_glyph_from_name (hb_font_t *font, /* high-level funcs, with fallback */ +/* Calls either hb_font_get_nominal_glyph() if variation_selector is 0, + * otherwise callse hb_font_get_variation_glyph(). */ +HB_EXTERN hb_bool_t +hb_font_get_glyph (hb_font_t *font, + hb_codepoint_t unicode, hb_codepoint_t variation_selector, + hb_codepoint_t *glyph); + HB_EXTERN void hb_font_get_extents_for_direction (hb_font_t *font, hb_direction_t direction, diff --git a/src/hb-ft.cc b/src/hb-ft.cc index eed1787da..2cad8c264 100644 --- a/src/hb-ft.cc +++ b/src/hb-ft.cc @@ -155,21 +155,32 @@ hb_ft_font_get_face (hb_font_t *font) static hb_bool_t -hb_ft_get_glyph (hb_font_t *font HB_UNUSED, - void *font_data, - hb_codepoint_t unicode, - hb_codepoint_t variation_selector, - hb_codepoint_t *glyph, - void *user_data HB_UNUSED) - +hb_ft_get_nominal_glyph (hb_font_t *font HB_UNUSED, + void *font_data, + hb_codepoint_t unicode, + hb_codepoint_t *glyph, + void *user_data HB_UNUSED) { const hb_ft_font_t *ft_font = (const hb_ft_font_t *) font_data; - unsigned int g; + unsigned int g = FT_Get_Char_Index (ft_font->ft_face, unicode); - if (likely (!variation_selector)) - g = FT_Get_Char_Index (ft_font->ft_face, unicode); - else - g = FT_Face_GetCharVariantIndex (ft_font->ft_face, unicode, variation_selector); + if (unlikely (!g)) + return false; + + *glyph = g; + return true; +} + +static hb_bool_t +hb_ft_get_variation_glyph (hb_font_t *font HB_UNUSED, + void *font_data, + hb_codepoint_t unicode, + hb_codepoint_t variation_selector, + hb_codepoint_t *glyph, + void *user_data HB_UNUSED) +{ + const hb_ft_font_t *ft_font = (const hb_ft_font_t *) font_data; + unsigned int g = FT_Face_GetCharVariantIndex (ft_font->ft_face, unicode, variation_selector); if (unlikely (!g)) return false; @@ -408,7 +419,8 @@ retry: hb_font_funcs_set_font_h_extents_func (funcs, hb_ft_get_font_h_extents, NULL, NULL); //hb_font_funcs_set_font_v_extents_func (funcs, hb_ft_get_font_v_extents, NULL, NULL); - hb_font_funcs_set_glyph_func (funcs, hb_ft_get_glyph, NULL, NULL); + hb_font_funcs_set_nominal_glyph_func (funcs, hb_ft_get_nominal_glyph, NULL, NULL); + hb_font_funcs_set_variation_glyph_func (funcs, hb_ft_get_variation_glyph, NULL, NULL); hb_font_funcs_set_glyph_h_advance_func (funcs, hb_ft_get_glyph_h_advance, NULL, NULL); hb_font_funcs_set_glyph_v_advance_func (funcs, hb_ft_get_glyph_v_advance, NULL, NULL); //hb_font_funcs_set_glyph_h_origin_func (funcs, hb_ft_get_glyph_h_origin, NULL, NULL); diff --git a/src/hb-ot-font.cc b/src/hb-ot-font.cc index e7b57b88a..bba613271 100644 --- a/src/hb-ot-font.cc +++ b/src/hb-ot-font.cc @@ -242,23 +242,26 @@ struct hb_ot_face_cmap_accelerator_t hb_blob_destroy (this->blob); } - inline bool get_glyph (hb_codepoint_t unicode, - hb_codepoint_t variation_selector, - hb_codepoint_t *glyph) const + inline bool get_nominal_glyph (hb_codepoint_t unicode, + hb_codepoint_t *glyph) const { - if (unlikely (variation_selector)) + return this->table->get_glyph (unicode, glyph); + } + + inline bool get_variation_glyph (hb_codepoint_t unicode, + hb_codepoint_t variation_selector, + hb_codepoint_t *glyph) const + { + switch (this->uvs_table->get_glyph_variant (unicode, + variation_selector, + glyph)) { - switch (this->uvs_table->get_glyph_variant (unicode, - variation_selector, - glyph)) - { - case OT::GLYPH_VARIANT_NOT_FOUND: return false; - case OT::GLYPH_VARIANT_FOUND: return true; - case OT::GLYPH_VARIANT_USE_DEFAULT: break; - } + case OT::GLYPH_VARIANT_NOT_FOUND: return false; + case OT::GLYPH_VARIANT_FOUND: return true; + case OT::GLYPH_VARIANT_USE_DEFAULT: break; } - return this->table->get_glyph (unicode, glyph); + return get_nominal_glyph (unicode, glyph); } }; @@ -301,16 +304,27 @@ _hb_ot_font_destroy (hb_ot_font_t *ot_font) static hb_bool_t -hb_ot_get_glyph (hb_font_t *font HB_UNUSED, - void *font_data, - hb_codepoint_t unicode, - hb_codepoint_t variation_selector, - hb_codepoint_t *glyph, - void *user_data HB_UNUSED) +hb_ot_get_nominal_glyph (hb_font_t *font HB_UNUSED, + void *font_data, + hb_codepoint_t unicode, + hb_codepoint_t *glyph, + void *user_data HB_UNUSED) { const hb_ot_font_t *ot_font = (const hb_ot_font_t *) font_data; - return ot_font->cmap.get_glyph (unicode, variation_selector, glyph); + return ot_font->cmap.get_nominal_glyph (unicode, glyph); +} + +static hb_bool_t +hb_ot_get_variation_glyph (hb_font_t *font HB_UNUSED, + void *font_data, + hb_codepoint_t unicode, + hb_codepoint_t variation_selector, + hb_codepoint_t *glyph, + void *user_data HB_UNUSED) +{ + const hb_ot_font_t *ot_font = (const hb_ot_font_t *) font_data; + return ot_font->cmap.get_variation_glyph (unicode, variation_selector, glyph); } static hb_position_t @@ -397,7 +411,8 @@ retry: hb_font_funcs_set_font_h_extents_func (funcs, hb_ot_get_font_h_extents, NULL, NULL); hb_font_funcs_set_font_v_extents_func (funcs, hb_ot_get_font_v_extents, NULL, NULL); - hb_font_funcs_set_glyph_func (funcs, hb_ot_get_glyph, NULL, NULL); + hb_font_funcs_set_nominal_glyph_func (funcs, hb_ot_get_nominal_glyph, NULL, NULL); + hb_font_funcs_set_variation_glyph_func (funcs, hb_ot_get_variation_glyph, NULL, NULL); hb_font_funcs_set_glyph_h_advance_func (funcs, hb_ot_get_glyph_h_advance, NULL, NULL); hb_font_funcs_set_glyph_v_advance_func (funcs, hb_ot_get_glyph_v_advance, NULL, NULL); //hb_font_funcs_set_glyph_h_origin_func (funcs, hb_ot_get_glyph_h_origin, NULL, NULL); diff --git a/src/hb-ot-shape-complex-indic.cc b/src/hb-ot-shape-complex-indic.cc index 21256dec5..c8fc2b5b6 100644 --- a/src/hb-ot-shape-complex-indic.cc +++ b/src/hb-ot-shape-complex-indic.cc @@ -493,12 +493,12 @@ struct indic_shape_plan_t hb_codepoint_t glyph = virama_glyph; if (unlikely (virama_glyph == (hb_codepoint_t) -1)) { - if (!config->virama || !font->get_glyph (config->virama, 0, &glyph)) + if (!config->virama || !font->get_nominal_glyph (config->virama, &glyph)) glyph = 0; /* Technically speaking, the spec says we should apply 'locl' to virama too. * Maybe one day... */ - /* Our get_glyph() function needs a font, so we can't get the virama glyph + /* Our get_nominal_glyph() function needs a font, so we can't get the virama glyph * during shape planning... Instead, overwrite it here. It's safe. Don't worry! */ (const_cast (this))->virama_glyph = glyph; } @@ -1219,7 +1219,7 @@ insert_dotted_circles (const hb_ot_shape_plan_t *plan HB_UNUSED, hb_codepoint_t dottedcircle_glyph; - if (!font->get_glyph (0x25CCu, 0, &dottedcircle_glyph)) + if (!font->get_nominal_glyph (0x25CCu, &dottedcircle_glyph)) return; hb_glyph_info_t dottedcircle = {0}; @@ -1803,7 +1803,7 @@ decompose_indic (const hb_ot_shape_normalize_context_t *c, hb_codepoint_t glyph; if (hb_options ().uniscribe_bug_compatible || - (c->font->get_glyph (ab, 0, &glyph) && + (c->font->get_nominal_glyph (ab, &glyph) && indic_plan->pstf.would_substitute (&glyph, 1, c->font->face))) { /* Ok, safe to use Uniscribe-style decomposition. */ diff --git a/src/hb-ot-shape-complex-myanmar.cc b/src/hb-ot-shape-complex-myanmar.cc index 7b043440e..545765d5f 100644 --- a/src/hb-ot-shape-complex-myanmar.cc +++ b/src/hb-ot-shape-complex-myanmar.cc @@ -439,7 +439,7 @@ insert_dotted_circles (const hb_ot_shape_plan_t *plan HB_UNUSED, hb_codepoint_t dottedcircle_glyph; - if (!font->get_glyph (0x25CCu, 0, &dottedcircle_glyph)) + if (!font->get_nominal_glyph (0x25CCu, &dottedcircle_glyph)) return; hb_glyph_info_t dottedcircle = {0}; diff --git a/src/hb-ot-shape-complex-use.cc b/src/hb-ot-shape-complex-use.cc index 6fbfe2b5e..d2b6e63bd 100644 --- a/src/hb-ot-shape-complex-use.cc +++ b/src/hb-ot-shape-complex-use.cc @@ -499,7 +499,7 @@ insert_dotted_circles (const hb_ot_shape_plan_t *plan HB_UNUSED, return; hb_glyph_info_t dottedcircle = {0}; - if (!font->get_glyph (0x25CCu, 0, &dottedcircle.codepoint)) + if (!font->get_nominal_glyph (0x25CCu, &dottedcircle.codepoint)) return; dottedcircle.use_category() = hb_use_get_categories (0x25CC); diff --git a/src/hb-ot-shape-fallback.cc b/src/hb-ot-shape-fallback.cc index c9cf737f4..ea8312b22 100644 --- a/src/hb-ot-shape-fallback.cc +++ b/src/hb-ot-shape-fallback.cc @@ -526,7 +526,7 @@ _hb_ot_shape_fallback_spaces (const hb_ot_shape_plan_t *plan, case t::SPACE_FIGURE: for (char u = '0'; u <= '9'; u++) - if (font->get_glyph (u, 0, &glyph)) + if (font->get_nominal_glyph (u, &glyph)) { pos[i].x_advance = font->get_glyph_h_advance (glyph); break; @@ -534,9 +534,9 @@ _hb_ot_shape_fallback_spaces (const hb_ot_shape_plan_t *plan, break; case t::SPACE_PUNCTUATION: - if (font->get_glyph ('.', 0, &glyph)) + if (font->get_nominal_glyph ('.', &glyph)) pos[i].x_advance = font->get_glyph_h_advance (glyph); - else if (font->get_glyph (',', 0, &glyph)) + else if (font->get_nominal_glyph (',', &glyph)) pos[i].x_advance = font->get_glyph_h_advance (glyph); break; diff --git a/src/hb-ot-shape-normalize.cc b/src/hb-ot-shape-normalize.cc index 3f00b8ee6..107617e81 100644 --- a/src/hb-ot-shape-normalize.cc +++ b/src/hb-ot-shape-normalize.cc @@ -91,7 +91,7 @@ compose_unicode (const hb_ot_shape_normalize_context_t *c, static inline void set_glyph (hb_glyph_info_t &info, hb_font_t *font) { - font->get_glyph (info.codepoint, 0, &info.glyph_index()); + font->get_nominal_glyph (info.codepoint, &info.glyph_index()); } static inline void @@ -124,10 +124,10 @@ decompose (const hb_ot_shape_normalize_context_t *c, bool shortest, hb_codepoint hb_font_t * const font = c->font; if (!c->decompose (c, ab, &a, &b) || - (b && !font->get_glyph (b, 0, &b_glyph))) + (b && !font->get_nominal_glyph (b, &b_glyph))) return 0; - bool has_a = (bool) font->get_glyph (a, 0, &a_glyph); + bool has_a = (bool) font->get_nominal_glyph (a, &a_glyph); if (shortest && has_a) { /* Output a and b */ output_char (buffer, a, a_glyph); @@ -166,7 +166,7 @@ decompose_current_character (const hb_ot_shape_normalize_context_t *c, bool shor hb_codepoint_t u = buffer->cur().codepoint; hb_codepoint_t glyph; - if (shortest && c->font->get_glyph (u, 0, &glyph)) + if (shortest && c->font->get_nominal_glyph (u, &glyph)) { next_char (buffer, glyph); return; @@ -178,7 +178,7 @@ decompose_current_character (const hb_ot_shape_normalize_context_t *c, bool shor return; } - if (!shortest && c->font->get_glyph (u, 0, &glyph)) + if (!shortest && c->font->get_nominal_glyph (u, &glyph)) { next_char (buffer, glyph); return; @@ -188,7 +188,7 @@ decompose_current_character (const hb_ot_shape_normalize_context_t *c, bool shor { hb_codepoint_t space_glyph; hb_unicode_funcs_t::space_t space_type = buffer->unicode->space_fallback_type (u); - if (space_type != hb_unicode_funcs_t::NOT_SPACE && c->font->get_glyph (0x0020u, 0, &space_glyph)) + if (space_type != hb_unicode_funcs_t::NOT_SPACE && c->font->get_nominal_glyph (0x0020u, &space_glyph)) { _hb_glyph_info_set_unicode_space_fallback_type (&buffer->cur(), space_type); next_char (buffer, space_glyph); @@ -202,7 +202,7 @@ decompose_current_character (const hb_ot_shape_normalize_context_t *c, bool shor /* U+2011 is the only sensible character that is a no-break version of another character * and not a space. The space ones are handled already. Handle this lone one. */ hb_codepoint_t other_glyph; - if (c->font->get_glyph (0x2010u, 0, &other_glyph)) + if (c->font->get_nominal_glyph (0x2010u, &other_glyph)) { next_char (buffer, other_glyph); return; @@ -221,7 +221,7 @@ handle_variation_selector_cluster (const hb_ot_shape_normalize_context_t *c, uns for (; buffer->idx < end - 1 && !buffer->in_error;) { if (unlikely (buffer->unicode->is_variation_selector (buffer->cur(+1).codepoint))) { /* The next two lines are some ugly lines... But work. */ - if (font->get_glyph (buffer->cur().codepoint, buffer->cur(+1).codepoint, &buffer->cur().glyph_index())) + if (font->get_variation_glyph (buffer->cur().codepoint, buffer->cur(+1).codepoint, &buffer->cur().glyph_index())) { buffer->replace_glyphs (2, 1, &buffer->cur().codepoint); } @@ -388,7 +388,7 @@ _hb_ot_shape_normalize (const hb_ot_shape_plan_t *plan, buffer->cur().codepoint, &composed) && /* And the font has glyph for the composite. */ - font->get_glyph (composed, 0, &glyph)) + font->get_nominal_glyph (composed, &glyph)) { /* Composes. */ buffer->next_glyph (); /* Copy to out-buffer. */ diff --git a/src/hb-ot-shape.cc b/src/hb-ot-shape.cc index 42b921c6e..2ba9b78a3 100644 --- a/src/hb-ot-shape.cc +++ b/src/hb-ot-shape.cc @@ -456,7 +456,7 @@ hb_ot_hide_default_ignorables (hb_ot_shape_context_t *c) return; hb_codepoint_t space; - if (c->font->get_glyph (' ', 0, &space)) + if (c->font->get_nominal_glyph (' ', &space)) { /* Replace default-ignorables with a zero-advance space glyph. */ for (/*continue*/; i < count; i++) @@ -848,12 +848,12 @@ add_char (hb_font_t *font, hb_set_t *glyphs) { hb_codepoint_t glyph; - if (font->get_glyph (u, 0, &glyph)) + if (font->get_nominal_glyph (u, &glyph)) glyphs->add (glyph); if (mirror) { hb_codepoint_t m = unicode->mirroring (u); - if (m != u && font->get_glyph (m, 0, &glyph)) + if (m != u && font->get_nominal_glyph (m, &glyph)) glyphs->add (glyph); } }