src/hb-face.cc

   1 /*
   2  * Copyright © 2009  Red Hat, Inc.
   3  * Copyright © 2012  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 #include "hb-private.hh"
  30
  31 #include "hb-face-private.hh"
  32 #include "hb-open-file-private.hh"
  33 #include "hb-ot-head-table.hh"
  34 #include "hb-ot-maxp-table.hh"
  35
  36
  37 /*
  38  * hb_face_t
  39  */
  40
  41 const hb_face_t _hb_face_nil = {
  42   HB_OBJECT_HEADER_STATIC,
  43
  44   true, /* immutable */
  45
  46   NULL, /* reference_table_func */
  47   NULL, /* user_data */
  48   NULL, /* destroy */
  49
  50   0,    /* index */
  51   1000, /* upem */
  52   0,    /* num_glyphs */
  53
  54   hb_face_t::NOTHING, /* dirty */
  55
  56   {
  57 #define HB_SHAPER_IMPLEMENT(shaper) HB_SHAPER_DATA_INVALID,
  58 #include "hb-shaper-list.hh"
  59 #undef HB_SHAPER_IMPLEMENT
  60   },
  61
  62   NULL, /* shape_plans */
  63 };
  64
  65
  66 /**
  67  * hb_face_create_for_tables:
  68  * @reference_table_func: (closure user_data) (destroy destroy) (scope notified):
  69  * @user_data:
  70  * @destroy:
  71  *
  72  *
  73  *
  74  * Return value: (transfer full)
  75  *
  76  * Since: 0.9.2
  77  **/
  78 hb_face_t *
  79 hb_face_create_for_tables (hb_reference_table_func_t  reference_table_func,
  80                            void                      *user_data,
  81                            hb_destroy_func_t          destroy)
  82 {
  83   hb_face_t *face;
  84
  85   if (!reference_table_func || !(face = hb_object_create<hb_face_t> ())) {
  86     if (destroy)
  87       destroy (user_data);
  88     return hb_face_get_empty ();
  89   }
  90
  91   face->reference_table_func = reference_table_func;
  92   face->user_data = user_data;
  93   face->destroy = destroy;
  94
  95   face->upem = 0;
  96   face->num_glyphs = (unsigned int) -1;
  97
  98   return face;
  99 }
 100
 101
 102 typedef struct hb_face_for_data_closure_t {
 103   hb_blob_t *blob;
 104   unsigned int  index;
 105 } hb_face_for_data_closure_t;
 106
 107 static hb_face_for_data_closure_t *
 108 _hb_face_for_data_closure_create (hb_blob_t *blob, unsigned int index)
 109 {
 110   hb_face_for_data_closure_t *closure;
 111
 112   closure = (hb_face_for_data_closure_t *) calloc (1, sizeof (hb_face_for_data_closure_t));
 113   if (unlikely (!closure))
 114     return NULL;
 115
 116   closure->blob = blob;
 117   closure->index = index;
 118
 119   return closure;
 120 }
 121
 122 static void
 123 _hb_face_for_data_closure_destroy (hb_face_for_data_closure_t *closure)
 124 {
 125   hb_blob_destroy (closure->blob);
 126   free (closure);
 127 }
 128
 129 static hb_blob_t *
 130 _hb_face_for_data_reference_table (hb_face_t *face HB_UNUSED, hb_tag_t tag, void *user_data)
 131 {
 132   hb_face_for_data_closure_t *data = (hb_face_for_data_closure_t *) user_data;
 133
 134   if (tag == HB_TAG_NONE)
 135     return hb_blob_reference (data->blob);
 136
 137   const OT::OpenTypeFontFile &ot_file = *OT::Sanitizer<OT::OpenTypeFontFile>::lock_instance (data->blob);
 138   const OT::OpenTypeFontFace &ot_face = ot_file.get_face (data->index);
 139
 140   const OT::OpenTypeTable &table = ot_face.get_table_by_tag (tag);
 141
 142   hb_blob_t *blob = hb_blob_create_sub_blob (data->blob, table.offset, table.length);
 143
 144   return blob;
 145 }
 146
 147 /**
 148  * hb_face_create: (Xconstructor)
 149  * @blob:
 150  * @index:
 151  *
 152  *
 153  *
 154  * Return value: (transfer full):
 155  *
 156  * Since: 0.9.2
 157  **/
 158 hb_face_t *
 159 hb_face_create (hb_blob_t    *blob,
 160                 unsigned int  index)
 161 {
 162   hb_face_t *face;
 163
 164   if (unlikely (!blob))
 165     blob = hb_blob_get_empty ();
 166
 167   hb_face_for_data_closure_t *closure = _hb_face_for_data_closure_create (OT::Sanitizer<OT::OpenTypeFontFile>::sanitize (hb_blob_reference (blob)), index);
 168
 169   if (unlikely (!closure))
 170     return hb_face_get_empty ();
 171
 172   face = hb_face_create_for_tables (_hb_face_for_data_reference_table,
 173                                     closure,
 174                                     (hb_destroy_func_t) _hb_face_for_data_closure_destroy);
 175
 176   face->index = index;
 177
 178   return face;
 179 }
 180
 181 /**
 182  * hb_face_get_empty:
 183  *
 184  *
 185  *
 186  * Return value: (transfer full)
 187  *
 188  * Since: 0.9.2
 189  **/
 190 hb_face_t *
 191 hb_face_get_empty (void)
 192 {
 193   return const_cast<hb_face_t *> (&_hb_face_nil);
 194 }
 195
 196
 197 /**
 198  * hb_face_reference: (skip)
 199  * @face: a face.
 200  *
 201  *
 202  *
 203  * Return value:
 204  *
 205  * Since: 0.9.2
 206  **/
 207 hb_face_t *
 208 hb_face_reference (hb_face_t *face)
 209 {
 210   return hb_object_reference (face);
 211 }
 212
 213 /**
 214  * hb_face_destroy: (skip)
 215  * @face: a face.
 216  *
 217  *
 218  *
 219  * Since: 0.9.2
 220  **/
 221 void
 222 hb_face_destroy (hb_face_t *face)
 223 {
 224   if (!hb_object_destroy (face)) return;
 225
 226   for (hb_face_t::plan_node_t *node = face->shape_plans; node; )
 227   {
 228     hb_face_t::plan_node_t *next = node->next;
 229     hb_shape_plan_destroy (node->shape_plan);
 230     free (node);
 231     node = next;
 232   }
 233
 234 #define HB_SHAPER_IMPLEMENT(shaper) HB_SHAPER_DATA_DESTROY(shaper, face);
 235 #include "hb-shaper-list.hh"
 236 #undef HB_SHAPER_IMPLEMENT
 237
 238   if (face->destroy)
 239     face->destroy (face->user_data);
 240
 241   free (face);
 242 }
 243
 244 /**
 245  * hb_face_set_user_data: (skip)
 246  * @face: a face.
 247  * @key:
 248  * @data:
 249  * @destroy:
 250  * @replace:
 251  *
 252  *
 253  *
 254  * Return value:
 255  *
 256  * Since: 0.9.2
 257  **/
 258 hb_bool_t
 259 hb_face_set_user_data (hb_face_t          *face,
 260                        hb_user_data_key_t *key,
 261                        void *              data,
 262                        hb_destroy_func_t   destroy,
 263                        hb_bool_t           replace)
 264 {
 265   return hb_object_set_user_data (face, key, data, destroy, replace);
 266 }
 267
 268 /**
 269  * hb_face_get_user_data: (skip)
 270  * @face: a face.
 271  * @key:
 272  *
 273  *
 274  *
 275  * Return value: (transfer none):
 276  *
 277  * Since: 0.9.2
 278  **/
 279 void *
 280 hb_face_get_user_data (hb_face_t          *face,
 281                        hb_user_data_key_t *key)
 282 {
 283   return hb_object_get_user_data (face, key);
 284 }
 285
 286 /**
 287  * hb_face_make_immutable:
 288  * @face: a face.
 289  *
 290  *
 291  *
 292  * Since: 0.9.2
 293  **/
 294 void
 295 hb_face_make_immutable (hb_face_t *face)
 296 {
 297   if (unlikely (hb_object_is_inert (face)))
 298     return;
 299
 300   face->immutable = true;
 301 }
 302
 303 /**
 304  * hb_face_is_immutable:
 305  * @face: a face.
 306  *
 307  *
 308  *
 309  * Return value:
 310  *
 311  * Since: 0.9.2
 312  **/
 313 hb_bool_t
 314 hb_face_is_immutable (hb_face_t *face)
 315 {
 316   return face->immutable;
 317 }
 318
 319
 320 /**
 321  * hb_face_reference_table:
 322  * @face: a face.
 323  * @tag:
 324  *
 325  *
 326  *
 327  * Return value: (transfer full):
 328  *
 329  * Since: 0.9.2
 330  **/
 331 hb_blob_t *
 332 hb_face_reference_table (hb_face_t *face,
 333                          hb_tag_t   tag)
 334 {
 335   return face->reference_table (tag);
 336 }
 337
 338 /**
 339  * hb_face_reference_blob:
 340  * @face: a face.
 341  *
 342  *
 343  *
 344  * Return value: (transfer full):
 345  *
 346  * Since: 0.9.2
 347  **/
 348 hb_blob_t *
 349 hb_face_reference_blob (hb_face_t *face)
 350 {
 351   return face->reference_table (HB_TAG_NONE);
 352 }
 353
 354 /**
 355  * hb_face_set_index:
 356  * @face: a face.
 357  * @index:
 358  *
 359  *
 360  *
 361  * Since: 0.9.2
 362  **/
 363 void
 364 hb_face_set_index (hb_face_t    *face,
 365                    unsigned int  index)
 366 {
 367   if (face->immutable)
 368     return;
 369
 370   if (face->index == index)
 371     return;
 372
 373   face->dirty |= face->INDEX;
 374
 375   face->index = index;
 376 }
 377
 378 /**
 379  * hb_face_get_index:
 380  * @face: a face.
 381  *
 382  *
 383  *
 384  * Return value:
 385  *
 386  * Since: 0.9.2
 387  **/
 388 unsigned int
 389 hb_face_get_index (hb_face_t    *face)
 390 {
 391   return face->index;
 392 }
 393
 394 /**
 395  * hb_face_set_upem:
 396  * @face: a face.
 397  * @upem:
 398  *
 399  *
 400  *
 401  * Since: 0.9.2
 402  **/
 403 void
 404 hb_face_set_upem (hb_face_t    *face,
 405                   unsigned int  upem)
 406 {
 407   if (face->immutable)
 408     return;
 409
 410   if (face->upem == upem)
 411     return;
 412
 413   face->dirty |= face->UPEM;
 414
 415   face->upem = upem;
 416 }
 417
 418 /**
 419  * hb_face_get_upem:
 420  * @face: a face.
 421  *
 422  *
 423  *
 424  * Return value:
 425  *
 426  * Since: 0.9.2
 427  **/
 428 unsigned int
 429 hb_face_get_upem (hb_face_t *face)
 430 {
 431   return face->get_upem ();
 432 }
 433
 434 void
 435 hb_face_t::load_upem (void) const
 436 {
 437   hb_blob_t *head_blob = OT::Sanitizer<OT::head>::sanitize (reference_table (HB_OT_TAG_head));
 438   const OT::head *head_table = OT::Sanitizer<OT::head>::lock_instance (head_blob);
 439   upem = head_table->get_upem ();
 440   hb_blob_destroy (head_blob);
 441 }
 442
 443 /**
 444  * hb_face_set_glyph_count:
 445  * @face: a face.
 446  * @glyph_count:
 447  *
 448  *
 449  *
 450  * Since: 0.9.7
 451  **/
 452 void
 453 hb_face_set_glyph_count (hb_face_t    *face,
 454                          unsigned int  glyph_count)
 455 {
 456   if (face->immutable)
 457     return;
 458
 459   if (face->num_glyphs == glyph_count)
 460     return;
 461
 462   face->dirty |= face->NUM_GLYPHS;
 463
 464   face->num_glyphs = glyph_count;
 465 }
 466
 467 /**
 468  * hb_face_get_glyph_count:
 469  * @face: a face.
 470  *
 471  *
 472  *
 473  * Return value:
 474  *
 475  * Since: 0.9.7
 476  **/
 477 unsigned int
 478 hb_face_get_glyph_count (hb_face_t *face)
 479 {
 480   return face->get_num_glyphs ();
 481 }
 482
 483 void
 484 hb_face_t::load_num_glyphs (void) const
 485 {
 486   hb_blob_t *maxp_blob = OT::Sanitizer<OT::maxp>::sanitize (reference_table (HB_OT_TAG_maxp));
 487   const OT::maxp *maxp_table = OT::Sanitizer<OT::maxp>::lock_instance (maxp_blob);
 488   num_glyphs = maxp_table->get_num_glyphs ();
 489   hb_blob_destroy (maxp_blob);
 490 }
 491
 492