1 /*

     2  * Copyright © 2009,2010  Red Hat, Inc.

     3  * Copyright © 2010,2011,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 #define HB_SHAPER ot

    30 #define hb_ot_shaper_face_data_t hb_ot_layout_t

    31 #define hb_ot_shaper_shape_plan_data_t hb_ot_shape_plan_t

    32 #include "hb-shaper-impl-private.hh"

    33 

    34 #include "hb-ot-shape-private.hh"

    35 #include "hb-ot-shape-complex-private.hh"

    36 #include "hb-ot-shape-fallback-private.hh"

    37 #include "hb-ot-shape-normalize-private.hh"

    38 

    39 #include "hb-ot-layout-private.hh"

    40 #include "hb-unicode-private.hh"

    41 #include "hb-set-private.hh"

    42 

    43 

    44 static hb_tag_t common_features[] = {

    45   HB_TAG('c','c','m','p'),

    46   HB_TAG('l','o','c','l'),

    47   HB_TAG('m','a','r','k'),

    48   HB_TAG('m','k','m','k'),

    49   HB_TAG('r','l','i','g'),

    50 };

    51 

    52 

    53 static hb_tag_t horizontal_features[] = {

    54   HB_TAG('c','a','l','t'),

    55   HB_TAG('c','l','i','g'),

    56   HB_TAG('c','u','r','s'),

    57   HB_TAG('k','e','r','n'),

    58   HB_TAG('l','i','g','a'),

    59   HB_TAG('r','c','l','t'),

    60 };

    61 

    62 

    63 

    64 static void

    65 hb_ot_shape_collect_features (hb_ot_shape_planner_t          *planner,

    66                               const hb_segment_properties_t  *props,

    67                               const hb_feature_t             *user_features,

    68                               unsigned int                    num_user_features)

    69 {

    70   hb_ot_map_builder_t *map = &planner->map;

    71 

    72   switch (props->direction) {

    73     case HB_DIRECTION_LTR:

    74       map->add_global_bool_feature (HB_TAG ('l','t','r','a'));

    75       map->add_global_bool_feature (HB_TAG ('l','t','r','m'));

    76       break;

    77     case HB_DIRECTION_RTL:

    78       map->add_global_bool_feature (HB_TAG ('r','t','l','a'));

    79       map->add_feature (HB_TAG ('r','t','l','m'), 1, F_NONE);

    80       break;

    81     case HB_DIRECTION_TTB:

    82     case HB_DIRECTION_BTT:

    83     case HB_DIRECTION_INVALID:

    84     default:

    85       break;

    86   }

    87 

    88   map->add_feature (HB_TAG ('f','r','a','c'), 1, F_NONE);

    89   map->add_feature (HB_TAG ('n','u','m','r'), 1, F_NONE);

    90   map->add_feature (HB_TAG ('d','n','o','m'), 1, F_NONE);

    91 

    92   if (planner->shaper->collect_features)

    93     planner->shaper->collect_features (planner);

    94 

    95   for (unsigned int i = 0; i < ARRAY_LENGTH (common_features); i++)

    96     map->add_global_bool_feature (common_features[i]);

    97 

    98   if (HB_DIRECTION_IS_HORIZONTAL (props->direction))

    99     for (unsigned int i = 0; i < ARRAY_LENGTH (horizontal_features); i++)

   100       map->add_feature (horizontal_features[i], 1, F_GLOBAL |

   101                         (horizontal_features[i] == HB_TAG('k','e','r','n') ?

   102                          F_HAS_FALLBACK : F_NONE));

   103   else

   104   {

   105     /* We really want to find a 'vert' feature if there's any in the font, no

   106      * matter which script/langsys it is listed (or not) under.

   107      * See various bugs referenced from:

   108      * https://github.com/behdad/harfbuzz/issues/63 */

   109     map->add_feature (HB_TAG ('v','e','r','t'), 1, F_GLOBAL | F_GLOBAL_SEARCH);

   110   }

   111 

   112   if (planner->shaper->override_features)

   113     planner->shaper->override_features (planner);

   114 

   115   for (unsigned int i = 0; i < num_user_features; i++) {

   116     const hb_feature_t *feature = &user_features[i];

   117     map->add_feature (feature->tag, feature->value,

   118                       (feature->start == 0 && feature->end == (unsigned int) -1) ?

   119                        F_GLOBAL : F_NONE);

   120   }

   121 }

   122 

   123 

   124 /*

   125  * shaper face data

   126  */

   127 

   128 hb_ot_shaper_face_data_t *

   129 _hb_ot_shaper_face_data_create (hb_face_t *face)

   130 {

   131   return _hb_ot_layout_create (face);

   132 }

   133 

   134 void

   135 _hb_ot_shaper_face_data_destroy (hb_ot_shaper_face_data_t *data)

   136 {

   137   _hb_ot_layout_destroy (data);

   138 }

   139 

   140 

   141 /*

   142  * shaper font data

   143  */

   144 

   145 struct hb_ot_shaper_font_data_t {};

   146 

   147 hb_ot_shaper_font_data_t *

   148 _hb_ot_shaper_font_data_create (hb_font_t *font)

   149 {

   150   return (hb_ot_shaper_font_data_t *) HB_SHAPER_DATA_SUCCEEDED;

   151 }

   152 

   153 void

   154 _hb_ot_shaper_font_data_destroy (hb_ot_shaper_font_data_t *data)

   155 {

   156 }

   157 

   158 

   159 /*

   160  * shaper shape_plan data

   161  */

   162 

   163 hb_ot_shaper_shape_plan_data_t *

   164 _hb_ot_shaper_shape_plan_data_create (hb_shape_plan_t    *shape_plan,

   165                                       const hb_feature_t *user_features,

   166                                       unsigned int        num_user_features)

   167 {

   168   hb_ot_shape_plan_t *plan = (hb_ot_shape_plan_t *) calloc (1, sizeof (hb_ot_shape_plan_t));

   169   if (unlikely (!plan))

   170     return NULL;

   171 

   172   hb_ot_shape_planner_t planner (shape_plan);

   173 

   174   planner.shaper = hb_ot_shape_complex_categorize (&planner);

   175 

   176   hb_ot_shape_collect_features (&planner, &shape_plan->props, user_features, num_user_features);

   177 

   178   planner.compile (*plan);

   179 

   180   if (plan->shaper->data_create) {

   181     plan->data = plan->shaper->data_create (plan);

   182     if (unlikely (!plan->data))

   183       return NULL;

   184   }

   185 

   186   return plan;

   187 }

   188 

   189 void

   190 _hb_ot_shaper_shape_plan_data_destroy (hb_ot_shaper_shape_plan_data_t *plan)

   191 {

   192   if (plan->shaper->data_destroy)

   193     plan->shaper->data_destroy (const_cast<void *> (plan->data));

   194 

   195   plan->finish ();

   196 

   197   free (plan);

   198 }

   199 

   200 

   201 /*

   202  * shaper

   203  */

   204 

   205 struct hb_ot_shape_context_t

   206 {

   207   hb_ot_shape_plan_t *plan;

   208   hb_font_t *font;

   209   hb_face_t *face;

   210   hb_buffer_t  *buffer;

   211   const hb_feature_t *user_features;

   212   unsigned int        num_user_features;

   213 

   214   /* Transient stuff */

   215   hb_direction_t target_direction;

   216 };

   217 

   218 

   219 

   220 /* Main shaper */

   221 

   222 

   223 /* Prepare */

   224 

   225 static void

   226 hb_set_unicode_props (hb_buffer_t *buffer)

   227 {

   228   unsigned int count = buffer->len;

   229   hb_glyph_info_t *info = buffer->info;

   230   for (unsigned int i = 0; i < count; i++)

   231     _hb_glyph_info_set_unicode_props (&info[i], buffer->unicode);

   232 }

   233 

   234 static void

   235 hb_insert_dotted_circle (hb_buffer_t *buffer, hb_font_t *font)

   236 {

   237   if (!(buffer->flags & HB_BUFFER_FLAG_BOT) ||

   238       buffer->context_len[0] ||

   239       _hb_glyph_info_get_general_category (&buffer->info[0]) !=

   240       HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK)

   241     return;

   242 

   243   if (!font->has_glyph (0x25CCu))

   244     return;

   245 

   246   hb_glyph_info_t dottedcircle = {0};

   247   dottedcircle.codepoint = 0x25CCu;

   248   _hb_glyph_info_set_unicode_props (&dottedcircle, buffer->unicode);

   249 

   250   buffer->clear_output ();

   251 

   252   buffer->idx = 0;

   253   hb_glyph_info_t info = dottedcircle;

   254   info.cluster = buffer->cur().cluster;

   255   info.mask = buffer->cur().mask;

   256   buffer->output_info (info);

   257   while (buffer->idx < buffer->len)

   258     buffer->next_glyph ();

   259 

   260   buffer->swap_buffers ();

   261 }

   262 

   263 static void

   264 hb_form_clusters (hb_buffer_t *buffer)

   265 {

   266   if (buffer->cluster_level != HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES)

   267     return;

   268 

   269   /* Loop duplicated in hb_ensure_native_direction(). */

   270   unsigned int base = 0;

   271   unsigned int count = buffer->len;

   272   hb_glyph_info_t *info = buffer->info;

   273   for (unsigned int i = 1; i < count; i++)

   274   {

   275     if (likely (!HB_UNICODE_GENERAL_CATEGORY_IS_MARK (_hb_glyph_info_get_general_category (&info[i]))))

   276     {

   277       buffer->merge_clusters (base, i);

   278       base = i;

   279     }

   280   }

   281   buffer->merge_clusters (base, count);

   282 }

   283 

   284 static void

   285 hb_ensure_native_direction (hb_buffer_t *buffer)

   286 {

   287   hb_direction_t direction = buffer->props.direction;

   288 

   289   /* TODO vertical:

   290    * The only BTT vertical script is Ogham, but it's not clear to me whether OpenType

   291    * Ogham fonts are supposed to be implemented BTT or not.  Need to research that

   292    * first. */

   293   if ((HB_DIRECTION_IS_HORIZONTAL (direction) && direction != hb_script_get_horizontal_direction (buffer->props.script)) ||

   294       (HB_DIRECTION_IS_VERTICAL   (direction) && direction != HB_DIRECTION_TTB))

   295   {

   296     /* Same loop as hb_form_clusters().

   297      * Since form_clusters() merged clusters already, we don't merge. */

   298     unsigned int base = 0;

   299     unsigned int count = buffer->len;

   300     hb_glyph_info_t *info = buffer->info;

   301     for (unsigned int i = 1; i < count; i++)

   302     {

   303       if (likely (!HB_UNICODE_GENERAL_CATEGORY_IS_MARK (_hb_glyph_info_get_general_category (&info[i]))))

   304       {

   305         if (buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS)

   306           buffer->merge_clusters (base, i);

   307         buffer->reverse_range (base, i);

   308 

   309         base = i;

   310       }

   311     }

   312     if (buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS)

   313       buffer->merge_clusters (base, count);

   314     buffer->reverse_range (base, count);

   315 

   316     buffer->reverse ();

   317 

   318     buffer->props.direction = HB_DIRECTION_REVERSE (buffer->props.direction);

   319   }

   320 }

   321 

   322 

   323 /* Substitute */

   324 

   325 static inline void

   326 hb_ot_mirror_chars (hb_ot_shape_context_t *c)

   327 {

   328   if (HB_DIRECTION_IS_FORWARD (c->target_direction))

   329     return;

   330 

   331   hb_buffer_t *buffer = c->buffer;

   332   hb_unicode_funcs_t *unicode = buffer->unicode;

   333   hb_mask_t rtlm_mask = c->plan->rtlm_mask;

   334 

   335   unsigned int count = buffer->len;

   336   hb_glyph_info_t *info = buffer->info;

   337   for (unsigned int i = 0; i < count; i++) {

   338     hb_codepoint_t codepoint = unicode->mirroring (info[i].codepoint);

   339     if (likely (codepoint == info[i].codepoint || !c->font->has_glyph (codepoint)))

   340       info[i].mask |= rtlm_mask;

   341     else

   342       info[i].codepoint = codepoint;

   343   }

   344 }

   345 

   346 static inline void

   347 hb_ot_shape_setup_masks_fraction (hb_ot_shape_context_t *c)

   348 {

   349   if (!c->plan->has_frac)

   350     return;

   351 

   352   hb_buffer_t *buffer = c->buffer;

   353 

   354   /* TODO look in pre/post context text also. */

   355   unsigned int count = buffer->len;

   356   hb_glyph_info_t *info = buffer->info;

   357   for (unsigned int i = 0; i < count; i++)

   358   {

   359     if (info[i].codepoint == 0x2044u) /* FRACTION SLASH */

   360     {

   361       unsigned int start = i, end = i + 1;

   362       while (start &&

   363              _hb_glyph_info_get_general_category (&info[start - 1]) ==

   364              HB_UNICODE_GENERAL_CATEGORY_DECIMAL_NUMBER)

   365         start--;

   366       while (end < count &&

   367              _hb_glyph_info_get_general_category (&info[end]) ==

   368              HB_UNICODE_GENERAL_CATEGORY_DECIMAL_NUMBER)

   369         end++;

   370 

   371       for (unsigned int j = start; j < i; j++)

   372         info[j].mask |= c->plan->numr_mask | c->plan->frac_mask;

   373       info[i].mask |= c->plan->frac_mask;

   374       for (unsigned int j = i + 1; j < end; j++)

   375         info[j].mask |= c->plan->frac_mask | c->plan->dnom_mask;

   376 

   377       i = end - 1;

   378     }

   379   }

   380 }

   381 

   382 static inline void

   383 hb_ot_shape_initialize_masks (hb_ot_shape_context_t *c)

   384 {

   385   hb_ot_map_t *map = &c->plan->map;

   386   hb_buffer_t *buffer = c->buffer;

   387 

   388   hb_mask_t global_mask = map->get_global_mask ();

   389   buffer->reset_masks (global_mask);

   390 }

   391 

   392 static inline void

   393 hb_ot_shape_setup_masks (hb_ot_shape_context_t *c)

   394 {

   395   hb_ot_map_t *map = &c->plan->map;

   396   hb_buffer_t *buffer = c->buffer;

   397 

   398   hb_ot_shape_setup_masks_fraction (c);

   399 

   400   if (c->plan->shaper->setup_masks)

   401     c->plan->shaper->setup_masks (c->plan, buffer, c->font);

   402 

   403   for (unsigned int i = 0; i < c->num_user_features; i++)

   404   {

   405     const hb_feature_t *feature = &c->user_features[i];

   406     if (!(feature->start == 0 && feature->end == (unsigned int)-1)) {

   407       unsigned int shift;

   408       hb_mask_t mask = map->get_mask (feature->tag, &shift);

   409       buffer->set_masks (feature->value << shift, mask, feature->start, feature->end);

   410     }

   411   }

   412 }

   413 

   414 static void

   415 hb_ot_zero_width_default_ignorables (hb_ot_shape_context_t *c)

   416 {

   417   hb_buffer_t *buffer = c->buffer;

   418 

   419   if (buffer->flags & HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES)

   420     return;

   421 

   422   unsigned int count = buffer->len;

   423   hb_glyph_info_t *info = buffer->info;

   424   hb_glyph_position_t *pos = buffer->pos;

   425   unsigned int i = 0;

   426   for (i = 0; i < count; i++)

   427     if (unlikely (_hb_glyph_info_is_default_ignorable (&info[i])))

   428       pos[i].x_advance = pos[i].y_advance = pos[i].x_offset = pos[i].y_offset = 0;

   429 }

   430 

   431 static void

   432 hb_ot_hide_default_ignorables (hb_ot_shape_context_t *c)

   433 {

   434   hb_buffer_t *buffer = c->buffer;

   435 

   436   if (buffer->flags & HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES)

   437     return;

   438 

   439   unsigned int count = buffer->len;

   440   hb_glyph_info_t *info = buffer->info;

   441   hb_glyph_position_t *pos = buffer->pos;

   442   unsigned int i = 0;

   443   for (i = 0; i < count; i++)

   444   {

   445     if (unlikely (_hb_glyph_info_is_default_ignorable (&info[i])))

   446       break;

   447   }

   448 

   449   /* No default-ignorables found; return. */

   450   if (i == count)

   451     return;

   452 

   453   hb_codepoint_t space;

   454   if (c->font->get_glyph (' ', 0, &space))

   455   {

   456     /* Replace default-ignorables with a zero-advance space glyph. */

   457     for (/*continue*/; i < count; i++)

   458     {

   459       if (_hb_glyph_info_is_default_ignorable (&info[i]))

   460         info[i].codepoint = space;

   461     }

   462   }

   463   else

   464   {

   465     /* Merge clusters and delete default-ignorables.

   466      * NOTE! We can't use out-buffer as we have positioning data. */

   467     unsigned int j = i;

   468     for (; i < count; i++)

   469     {

   470       if (_hb_glyph_info_is_default_ignorable (&info[i]))

   471       {

   472         /* Merge clusters.

   473          * Same logic as buffer->delete_glyph(), but for in-place removal. */

   474 

   475         unsigned int cluster = info[i].cluster;

   476         if (i + 1 < count && cluster == info[i + 1].cluster)

   477           continue; /* Cluster survives; do nothing. */

   478 

   479         if (j)

   480         {

   481           /* Merge cluster backward. */

   482           if (cluster < info[j - 1].cluster)

   483           {

   484             unsigned int old_cluster = info[j - 1].cluster;

   485             for (unsigned k = j; k && info[k - 1].cluster == old_cluster; k--)

   486               info[k - 1].cluster = cluster;

   487           }

   488           continue;

   489         }

   490 

   491         if (i + 1 < count)

   492           buffer->merge_clusters (i, i + 2); /* Merge cluster forward. */

   493 

   494         continue;

   495       }

   496 

   497       if (j != i)

   498       {

   499         info[j] = info[i];

   500         pos[j] = pos[i];

   501       }

   502       j++;

   503     }

   504     buffer->len = j;

   505   }

   506 }

   507 

   508 

   509 static inline void

   510 hb_ot_map_glyphs_fast (hb_buffer_t  *buffer)

   511 {

   512   /* Normalization process sets up glyph_index(), we just copy it. */

   513   unsigned int count = buffer->len;

   514   hb_glyph_info_t *info = buffer->info;

   515   for (unsigned int i = 0; i < count; i++)

   516     info[i].codepoint = info[i].glyph_index();

   517 

   518   buffer->content_type = HB_BUFFER_CONTENT_TYPE_GLYPHS;

   519 }

   520 

   521 static inline void

   522 hb_synthesize_glyph_classes (hb_ot_shape_context_t *c)

   523 {

   524   unsigned int count = c->buffer->len;

   525   hb_glyph_info_t *info = c->buffer->info;

   526   for (unsigned int i = 0; i < count; i++)

   527   {

   528     hb_ot_layout_glyph_class_mask_t klass;

   529 

   530     /* Never mark default-ignorables as marks.

   531      * They won't get in the way of lookups anyway,

   532      * but having them as mark will cause them to be skipped

   533      * over if the lookup-flag says so, but at least for the

   534      * Mongolian variation selectors, looks like Uniscribe

   535      * marks them as non-mark.  Some Mongolian fonts without

   536      * GDEF rely on this.  Another notable character that

   537      * this applies to is COMBINING GRAPHEME JOINER. */

   538     klass = (_hb_glyph_info_get_general_category (&info[i]) !=

   539              HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK ||

   540              _hb_glyph_info_is_default_ignorable (&info[i])) ?

   541             HB_OT_LAYOUT_GLYPH_PROPS_BASE_GLYPH :

   542             HB_OT_LAYOUT_GLYPH_PROPS_MARK;

   543     _hb_glyph_info_set_glyph_props (&info[i], klass);

   544   }

   545 }

   546 

   547 static inline void

   548 hb_ot_substitute_default (hb_ot_shape_context_t *c)

   549 {

   550   hb_buffer_t *buffer = c->buffer;

   551 

   552   if (c->plan->shaper->preprocess_text)

   553     c->plan->shaper->preprocess_text (c->plan, buffer, c->font);

   554 

   555   hb_ot_shape_initialize_masks (c);

   556 

   557   hb_ot_mirror_chars (c);

   558 

   559   HB_BUFFER_ALLOCATE_VAR (buffer, glyph_index);

   560 

   561   _hb_ot_shape_normalize (c->plan, buffer, c->font);

   562 

   563   hb_ot_shape_setup_masks (c);

   564 

   565   /* This is unfortunate to go here, but necessary... */

   566   if (!hb_ot_layout_has_positioning (c->face))

   567     _hb_ot_shape_fallback_position_recategorize_marks (c->plan, c->font, buffer);

   568 

   569   hb_ot_map_glyphs_fast (buffer);

   570 

   571   HB_BUFFER_DEALLOCATE_VAR (buffer, glyph_index);

   572 }

   573 

   574 static inline void

   575 hb_ot_substitute_complex (hb_ot_shape_context_t *c)

   576 {

   577   hb_buffer_t *buffer = c->buffer;

   578 

   579   _hb_buffer_allocate_gsubgpos_vars (buffer);

   580   hb_ot_layout_substitute_start (c->font, buffer);

   581 

   582   if (!hb_ot_layout_has_glyph_classes (c->face))

   583     hb_synthesize_glyph_classes (c);

   584 

   585   c->plan->substitute (c->font, buffer);

   586 

   587   hb_ot_layout_substitute_finish (c->font, buffer);

   588 

   589   return;

   590 }

   591 

   592 static inline void

   593 hb_ot_substitute (hb_ot_shape_context_t *c)

   594 {

   595   hb_ot_substitute_default (c);

   596   hb_ot_substitute_complex (c);

   597 }

   598 

   599 /* Position */

   600 

   601 static inline void

   602 adjust_mark_offsets (hb_glyph_position_t *pos)

   603 {

   604   pos->x_offset -= pos->x_advance;

   605   pos->y_offset -= pos->y_advance;

   606 }

   607 

   608 static inline void

   609 zero_mark_width (hb_glyph_position_t *pos)

   610 {

   611   pos->x_advance = 0;

   612   pos->y_advance = 0;

   613 }

   614 

   615 static inline void

   616 zero_mark_widths_by_unicode (hb_buffer_t *buffer, bool adjust_offsets)

   617 {

   618   unsigned int count = buffer->len;

   619   hb_glyph_info_t *info = buffer->info;

   620   for (unsigned int i = 0; i < count; i++)

   621     if (_hb_glyph_info_get_general_category (&info[i]) == HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK)

   622     {

   623       if (adjust_offsets)

   624         adjust_mark_offsets (&buffer->pos[i]);

   625       zero_mark_width (&buffer->pos[i]);

   626     }

   627 }

   628 

   629 static inline void

   630 zero_mark_widths_by_gdef (hb_buffer_t *buffer, bool adjust_offsets)

   631 {

   632   unsigned int count = buffer->len;

   633   hb_glyph_info_t *info = buffer->info;

   634   for (unsigned int i = 0; i < count; i++)

   635     if (_hb_glyph_info_is_mark (&info[i]))

   636     {

   637       if (adjust_offsets)

   638         adjust_mark_offsets (&buffer->pos[i]);

   639       zero_mark_width (&buffer->pos[i]);

   640     }

   641 }

   642 

   643 static inline void

   644 hb_ot_position_default (hb_ot_shape_context_t *c)

   645 {

   646   hb_direction_t direction = c->buffer->props.direction;

   647   unsigned int count = c->buffer->len;

   648   hb_glyph_info_t *info = c->buffer->info;

   649   hb_glyph_position_t *pos = c->buffer->pos;

   650   for (unsigned int i = 0; i < count; i++)

   651   {

   652     c->font->get_glyph_advance_for_direction (info[i].codepoint,

   653                                               direction,

   654                                               &pos[i].x_advance,

   655                                               &pos[i].y_advance);

   656     c->font->subtract_glyph_origin_for_direction (info[i].codepoint,

   657                                                   direction,

   658                                                   &pos[i].x_offset,

   659                                                   &pos[i].y_offset);

   660 

   661   }

   662 }

   663 

   664 static inline bool

   665 hb_ot_position_complex (hb_ot_shape_context_t *c)

   666 {

   667   bool ret = false;

   668   unsigned int count = c->buffer->len;

   669   bool has_positioning = hb_ot_layout_has_positioning (c->face);

   670   /* If the font has no GPOS, AND, no fallback positioning will

   671    * happen, AND, direction is forward, then when zeroing mark

   672    * widths, we shift the mark with it, such that the mark

   673    * is positioned hanging over the previous glyph.  When

   674    * direction is backward we don't shift and it will end up

   675    * hanging over the next glyph after the final reordering.

   676    * If fallback positinoing happens or GPOS is present, we don't

   677    * care.

   678    */

   679   bool adjust_offsets_when_zeroing = !(has_positioning || c->plan->shaper->fallback_position ||

   680                                        HB_DIRECTION_IS_BACKWARD (c->buffer->props.direction));

   681 

   682   switch (c->plan->shaper->zero_width_marks)

   683   {

   684     case HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_EARLY:

   685       zero_mark_widths_by_gdef (c->buffer, adjust_offsets_when_zeroing);

   686       break;

   687 

   688     /* Not currently used for any shaper:

   689     case HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_UNICODE_EARLY:

   690       zero_mark_widths_by_unicode (c->buffer, adjust_offsets_when_zeroing);

   691       break;

   692     */

   693 

   694     default:

   695     case HB_OT_SHAPE_ZERO_WIDTH_MARKS_NONE:

   696     case HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_UNICODE_LATE:

   697     case HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_LATE:

   698       break;

   699   }

   700 

   701   if (has_positioning)

   702   {

   703     hb_glyph_info_t *info = c->buffer->info;

   704     hb_glyph_position_t *pos = c->buffer->pos;

   705 

   706     /* Change glyph origin to what GPOS expects, apply GPOS, change it back. */

   707 

   708     for (unsigned int i = 0; i < count; i++) {

   709       c->font->add_glyph_origin_for_direction (info[i].codepoint,

   710                                                HB_DIRECTION_LTR,

   711                                                &pos[i].x_offset,

   712                                                &pos[i].y_offset);

   713     }

   714 

   715     c->plan->position (c->font, c->buffer);

   716 

   717     for (unsigned int i = 0; i < count; i++) {

   718       c->font->subtract_glyph_origin_for_direction (info[i].codepoint,

   719                                                     HB_DIRECTION_LTR,

   720                                                     &pos[i].x_offset,

   721                                                     &pos[i].y_offset);

   722     }

   723 

   724     ret = true;

   725   }

   726 

   727   switch (c->plan->shaper->zero_width_marks)

   728   {

   729     case HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_UNICODE_LATE:

   730       zero_mark_widths_by_unicode (c->buffer, adjust_offsets_when_zeroing);

   731       break;

   732 

   733     case HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_LATE:

   734       zero_mark_widths_by_gdef (c->buffer, adjust_offsets_when_zeroing);

   735       break;

   736 

   737     default:

   738     case HB_OT_SHAPE_ZERO_WIDTH_MARKS_NONE:

   739     //case HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_UNICODE_EARLY:

   740     case HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_EARLY:

   741       break;

   742   }

   743 

   744   return ret;

   745 }

   746 

   747 static inline void

   748 hb_ot_position (hb_ot_shape_context_t *c)

   749 {

   750   hb_ot_layout_position_start (c->font, c->buffer);

   751 

   752   hb_ot_position_default (c);

   753 

   754   hb_bool_t fallback = !hb_ot_position_complex (c);

   755 

   756   hb_ot_zero_width_default_ignorables (c);

   757 

   758   hb_ot_layout_position_finish (c->font, c->buffer);

   759 

   760   if (fallback && c->plan->shaper->fallback_position)

   761     _hb_ot_shape_fallback_position (c->plan, c->font, c->buffer);

   762 

   763   if (HB_DIRECTION_IS_BACKWARD (c->buffer->props.direction))

   764     hb_buffer_reverse (c->buffer);

   765 

   766   /* Visual fallback goes here. */

   767 

   768   if (fallback)

   769     _hb_ot_shape_fallback_kern (c->plan, c->font, c->buffer);

   770 

   771   _hb_buffer_deallocate_gsubgpos_vars (c->buffer);

   772 }

   773 

   774 

   775 /* Pull it all together! */

   776 

   777 static void

   778 hb_ot_shape_internal (hb_ot_shape_context_t *c)

   779 {

   780   c->buffer->deallocate_var_all ();

   781 

   782   /* Save the original direction, we use it later. */

   783   c->target_direction = c->buffer->props.direction;

   784 

   785   _hb_buffer_allocate_unicode_vars (c->buffer);

   786 

   787   c->buffer->clear_output ();

   788 

   789   hb_set_unicode_props (c->buffer);

   790   hb_insert_dotted_circle (c->buffer, c->font);

   791   hb_form_clusters (c->buffer);

   792 

   793   hb_ensure_native_direction (c->buffer);

   794 

   795   hb_ot_substitute (c);

   796   hb_ot_position (c);

   797 

   798   hb_ot_hide_default_ignorables (c);

   799 

   800   _hb_buffer_deallocate_unicode_vars (c->buffer);

   801 

   802   c->buffer->props.direction = c->target_direction;

   803 

   804   c->buffer->deallocate_var_all ();

   805 }

   806 

   807 

   808 hb_bool_t

   809 _hb_ot_shape (hb_shape_plan_t    *shape_plan,

   810               hb_font_t          *font,

   811               hb_buffer_t        *buffer,

   812               const hb_feature_t *features,

   813               unsigned int        num_features)

   814 {

   815   hb_ot_shape_context_t c = {HB_SHAPER_DATA_GET (shape_plan), font, font->face, buffer, features, num_features};

   816   hb_ot_shape_internal (&c);

   817 

   818   return true;

   819 }

   820 

   821 

   822 /**

   823  * Since: 0.9.7

   824  **/

   825 void

   826 hb_ot_shape_plan_collect_lookups (hb_shape_plan_t *shape_plan,

   827                                   hb_tag_t         table_tag,

   828                                   hb_set_t        *lookup_indexes /* OUT */)

   829 {

   830   /* XXX Does the first part always succeed? */

   831   HB_SHAPER_DATA_GET (shape_plan)->collect_lookups (table_tag, lookup_indexes);

   832 }

   833 

   834 

   835 /* TODO Move this to hb-ot-shape-normalize, make it do decompose, and make it public. */

   836 static void

   837 add_char (hb_font_t          *font,

   838           hb_unicode_funcs_t *unicode,

   839           hb_bool_t           mirror,

   840           hb_codepoint_t      u,

   841           hb_set_t           *glyphs)

   842 {

   843   hb_codepoint_t glyph;

   844   if (font->get_glyph (u, 0, &glyph))

   845     glyphs->add (glyph);

   846   if (mirror)

   847   {

   848     hb_codepoint_t m = unicode->mirroring (u);

   849     if (m != u && font->get_glyph (m, 0, &glyph))

   850       glyphs->add (glyph);

   851   }

   852 }

   853 

   854 

   855 /**

   856  * Since: 0.9.2

   857  **/

   858 void

   859 hb_ot_shape_glyphs_closure (hb_font_t          *font,

   860                             hb_buffer_t        *buffer,

   861                             const hb_feature_t *features,

   862                             unsigned int        num_features,

   863                             hb_set_t           *glyphs)

   864 {

   865   hb_ot_shape_plan_t plan;

   866 

   867   const char *shapers[] = {"ot", NULL};

   868   hb_shape_plan_t *shape_plan = hb_shape_plan_create_cached (font->face, &buffer->props,

   869                                                              features, num_features, shapers);

   870 

   871   bool mirror = hb_script_get_horizontal_direction (buffer->props.script) == HB_DIRECTION_RTL;

   872 

   873   unsigned int count = buffer->len;

   874   hb_glyph_info_t *info = buffer->info;

   875   for (unsigned int i = 0; i < count; i++)

   876     add_char (font, buffer->unicode, mirror, info[i].codepoint, glyphs);

   877 

   878   hb_set_t lookups;

   879   lookups.init ();

   880   hb_ot_shape_plan_collect_lookups (shape_plan, HB_OT_TAG_GSUB, &lookups);

   881 

   882   /* And find transitive closure. */

   883   hb_set_t copy;

   884   copy.init ();

   885   do {

   886     copy.set (glyphs);

   887     for (hb_codepoint_t lookup_index = -1; hb_set_next (&lookups, &lookup_index);)

   888       hb_ot_layout_lookup_substitute_closure (font->face, lookup_index, glyphs);

   889   } while (!copy.is_equal (glyphs));

   890 

   891   hb_shape_plan_destroy (shape_plan);

   892 }