Roll HarfBuzz to 1.1.1

third_party/harfbuzz-ng/src/hb-font-private.hh

 /*
  * Copyright © 2009  Red Hat, Inc.
  * Copyright © 2011  Google, Inc.
  *
  *  This is part of HarfBuzz, a text shaping library.
  *
  * Permission is hereby granted, without written agreement and without
  * license or royalty fees, to use, copy, modify, and distribute this
  * software and its documentation for any purpose, provided that the
  * above copyright notice and the following two paragraphs appear in
@@ skipping 43 matching lines @@
   HB_FONT_FUNC_IMPLEMENT (glyph_name) \
   HB_FONT_FUNC_IMPLEMENT (glyph_from_name) \
   /* ^--- Add new callbacks here */
 
 struct hb_font_funcs_t {
   hb_object_header_t header;
   ASSERT_POD ();
 
   hb_bool_t immutable;
 
-  /* Don't access these directly.  Call hb_font_get_*() instead. */
-
-  struct {
-#define HB_FONT_FUNC_IMPLEMENT(name) hb_font_get_##name##_func_t name;
-    HB_FONT_FUNCS_IMPLEMENT_CALLBACKS
-#undef HB_FONT_FUNC_IMPLEMENT
-  } get;
-
   struct {
 #define HB_FONT_FUNC_IMPLEMENT(name) void *name;
     HB_FONT_FUNCS_IMPLEMENT_CALLBACKS
 #undef HB_FONT_FUNC_IMPLEMENT
   } user_data;
 
   struct {
 #define HB_FONT_FUNC_IMPLEMENT(name) hb_destroy_func_t name;
     HB_FONT_FUNCS_IMPLEMENT_CALLBACKS
 #undef HB_FONT_FUNC_IMPLEMENT
   } destroy;
+
+  /* Don't access these directly.  Call font->get_*() instead. */
+  union get_t {
+    struct get_funcs_t {
+#define HB_FONT_FUNC_IMPLEMENT(name) hb_font_get_##name##_func_t name;
+      HB_FONT_FUNCS_IMPLEMENT_CALLBACKS
+#undef HB_FONT_FUNC_IMPLEMENT
+    } f;
+    void (*array[]) (void);
+  } get;
 };
 
 
 
 /*
  * hb_font_t
  */
 
 struct hb_font_t {
   hb_object_header_t header;
@@ skipping 44 matching lines @@
     *y = parent_scale_y_distance (*y);
   }
   inline void parent_scale_position (hb_position_t *x, hb_position_t *y) {
     *x = parent_scale_x_position (*x);
     *y = parent_scale_y_position (*y);
   }
 
 
   /* Public getters */
 
+  HB_INTERNAL bool has_func (unsigned int i);
+
+  /* has_* ... */
+#define HB_FONT_FUNC_IMPLEMENT(name) \
+  bool \
+  has_##name##_func (void) \
+  { \
+    hb_font_funcs_t *funcs = this->klass; \
+    unsigned int i = offsetof (hb_font_funcs_t::get_t::get_funcs_t, name) / sizeof (funcs->get.array[0]); \
+    return has_func (i); \
+  }
+  HB_FONT_FUNCS_IMPLEMENT_CALLBACKS
+#undef HB_FONT_FUNC_IMPLEMENT
+
   inline hb_bool_t has_glyph (hb_codepoint_t unicode)
   {
     hb_codepoint_t glyph;
     return get_glyph (unicode, 0, &glyph);
   }
 
   inline hb_bool_t get_glyph (hb_codepoint_t unicode, hb_codepoint_t variation_selector,
                               hb_codepoint_t *glyph)
   {
     *glyph = 0;
-    return klass->get.glyph (this, user_data,
-                             unicode, variation_selector, glyph,
-                             klass->user_data.glyph);
+    return klass->get.f.glyph (this, user_data,
+                               unicode, variation_selector, glyph,
+                               klass->user_data.glyph);
   }
 
   inline hb_position_t get_glyph_h_advance (hb_codepoint_t glyph)
   {
-    return klass->get.glyph_h_advance (this, user_data,
-                                       glyph,
-                                       klass->user_data.glyph_h_advance);
+    return klass->get.f.glyph_h_advance (this, user_data,
+                                         glyph,
+                                         klass->user_data.glyph_h_advance);
   }
 
   inline hb_position_t get_glyph_v_advance (hb_codepoint_t glyph)
   {
-    return klass->get.glyph_v_advance (this, user_data,
-                                       glyph,
-                                       klass->user_data.glyph_v_advance);
+    return klass->get.f.glyph_v_advance (this, user_data,
+                                         glyph,
+                                         klass->user_data.glyph_v_advance);
   }
 
   inline hb_bool_t get_glyph_h_origin (hb_codepoint_t glyph,
                                        hb_position_t *x, hb_position_t *y)
   {
     *x = *y = 0;
-    return klass->get.glyph_h_origin (this, user_data,
-                                      glyph, x, y,
-                                      klass->user_data.glyph_h_origin);
+    return klass->get.f.glyph_h_origin (this, user_data,
+                                        glyph, x, y,
+                                        klass->user_data.glyph_h_origin);
   }
 
   inline hb_bool_t get_glyph_v_origin (hb_codepoint_t glyph,
                                        hb_position_t *x, hb_position_t *y)
   {
     *x = *y = 0;
-    return klass->get.glyph_v_origin (this, user_data,
-                                      glyph, x, y,
-                                      klass->user_data.glyph_v_origin);
+    return klass->get.f.glyph_v_origin (this, user_data,
+                                        glyph, x, y,
+                                        klass->user_data.glyph_v_origin);
   }
 
   inline hb_position_t get_glyph_h_kerning (hb_codepoint_t left_glyph, hb_codepoint_t right_glyph)
   {
-    return klass->get.glyph_h_kerning (this, user_data,
-                                       left_glyph, right_glyph,
-                                       klass->user_data.glyph_h_kerning);
+    return klass->get.f.glyph_h_kerning (this, user_data,
+                                         left_glyph, right_glyph,
+                                         klass->user_data.glyph_h_kerning);
   }
 
   inline hb_position_t get_glyph_v_kerning (hb_codepoint_t top_glyph, hb_codepoint_t bottom_glyph)
   {
-    return klass->get.glyph_v_kerning (this, user_data,
-                                       top_glyph, bottom_glyph,
-                                       klass->user_data.glyph_v_kerning);
+    return klass->get.f.glyph_v_kerning (this, user_data,
+                                         top_glyph, bottom_glyph,
+                                         klass->user_data.glyph_v_kerning);
   }
 
   inline hb_bool_t get_glyph_extents (hb_codepoint_t glyph,
                                       hb_glyph_extents_t *extents)
   {
     memset (extents, 0, sizeof (*extents));
-    return klass->get.glyph_extents (this, user_data,
-                                     glyph,
-                                     extents,
-                                     klass->user_data.glyph_extents);
+    return klass->get.f.glyph_extents (this, user_data,
+                                       glyph,
+                                       extents,
+                                       klass->user_data.glyph_extents);
   }
 
   inline hb_bool_t get_glyph_contour_point (hb_codepoint_t glyph, unsigned int point_index,
                                             hb_position_t *x, hb_position_t *y)
   {
     *x = *y = 0;
-    return klass->get.glyph_contour_point (this, user_data,
-                                           glyph, point_index,
-                                           x, y,
-                                           klass->user_data.glyph_contour_point);
+    return klass->get.f.glyph_contour_point (this, user_data,
+                                             glyph, point_index,
+                                             x, y,
+                                             klass->user_data.glyph_contour_point);
   }
 
   inline hb_bool_t get_glyph_name (hb_codepoint_t glyph,
                                    char *name, unsigned int size)
   {
     if (size) *name = '\0';
-    return klass->get.glyph_name (this, user_data,
-                                  glyph,
-                                  name, size,
-                                  klass->user_data.glyph_name);
+    return klass->get.f.glyph_name (this, user_data,
+                                    glyph,
+                                    name, size,
+                                    klass->user_data.glyph_name);
   }
 
   inline hb_bool_t get_glyph_from_name (const char *name, int len, /* -1 means nul-terminated */
                                         hb_codepoint_t *glyph)
   {
     *glyph = 0;
     if (len == -1) len = strlen (name);
-    return klass->get.glyph_from_name (this, user_data,
-                                       name, len,
-                                       glyph,
-                                       klass->user_data.glyph_from_name);
+    return klass->get.f.glyph_from_name (this, user_data,
+                                         name, len,
+                                         glyph,
+                                         klass->user_data.glyph_from_name);
   }
 
 
   /* A bit higher-level, and with fallback */
 
   inline void get_glyph_advance_for_direction (hb_codepoint_t glyph,
                                                hb_direction_t direction,
                                                hb_position_t *x, hb_position_t *y)
   {
     if (likely (HB_DIRECTION_IS_HORIZONTAL (direction))) {
@@ skipping 34 matching lines @@
       if (!get_glyph_v_origin (glyph, x, y) &&
            get_glyph_h_origin (glyph, x, y))
       {
         hb_position_t dx, dy;
         guess_v_origin_minus_h_origin (glyph, &dx, &dy);
         *x += dx; *y += dy;
       }
     }
   }
 
+  inline void add_glyph_h_origin (hb_codepoint_t glyph,
+                                  hb_position_t *x, hb_position_t *y)
+  {
+    hb_position_t origin_x, origin_y;
+
+    get_glyph_h_origin (glyph, &origin_x, &origin_y);
+
+    *x += origin_x;
+    *y += origin_y;
+  }
+  inline void add_glyph_v_origin (hb_codepoint_t glyph,
+                                  hb_position_t *x, hb_position_t *y)
+  {
+    hb_position_t origin_x, origin_y;
+
+    get_glyph_v_origin (glyph, &origin_x, &origin_y);
+
+    *x += origin_x;
+    *y += origin_y;
+  }
   inline void add_glyph_origin_for_direction (hb_codepoint_t glyph,
                                               hb_direction_t direction,
                                               hb_position_t *x, hb_position_t *y)
   {
     hb_position_t origin_x, origin_y;
 
     get_glyph_origin_for_direction (glyph, direction, &origin_x, &origin_y);
 
     *x += origin_x;
     *y += origin_y;
   }
 
+  inline void subtract_glyph_h_origin (hb_codepoint_t glyph,
+                                       hb_position_t *x, hb_position_t *y)
+  {
+    hb_position_t origin_x, origin_y;
+
+    get_glyph_h_origin (glyph, &origin_x, &origin_y);
+
+    *x -= origin_x;
+    *y -= origin_y;
+  }
+  inline void subtract_glyph_v_origin (hb_codepoint_t glyph,
+                                       hb_position_t *x, hb_position_t *y)
+  {
+    hb_position_t origin_x, origin_y;
+
+    get_glyph_v_origin (glyph, &origin_x, &origin_y);
+
+    *x -= origin_x;
+    *y -= origin_y;
+  }
   inline void subtract_glyph_origin_for_direction (hb_codepoint_t glyph,
                                                    hb_direction_t direction,
                                                    hb_position_t *x, hb_position_t *y)
   {
     hb_position_t origin_x, origin_y;
 
     get_glyph_origin_for_direction (glyph, direction, &origin_x, &origin_y);
 
     *x -= origin_x;
     *y -= origin_y;
@@ skipping 83 matching lines @@
 };
 
 #define HB_SHAPER_DATA_CREATE_FUNC_EXTRA_ARGS
 #define HB_SHAPER_IMPLEMENT(shaper) HB_SHAPER_DATA_PROTOTYPE(shaper, font);
 #include "hb-shaper-list.hh"
 #undef HB_SHAPER_IMPLEMENT
 #undef HB_SHAPER_DATA_CREATE_FUNC_EXTRA_ARGS
 
 
 #endif /* HB_FONT_PRIVATE_HH */