src/hb-font.hh

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