LCOV - code coverage report
Current view: directory - gfx/harfbuzz/src - hb-ot-map-private.hh (source / functions) Found Hit Coverage
Test: app.info Lines: 40 0 0.0 %
Date: 2012-06-02 Functions: 16 0 0.0 %

       1                 : /*
       2                 :  * Copyright © 2009,2010  Red Hat, Inc.
       3                 :  * Copyright © 2010,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_OT_MAP_PRIVATE_HH
      30                 : #define HB_OT_MAP_PRIVATE_HH
      31                 : 
      32                 : #include "hb-buffer-private.hh"
      33                 : 
      34                 : #include "hb-ot-layout.h"
      35                 : 
      36                 : 
      37                 : 
      38                 : static const hb_tag_t table_tags[2] = {HB_OT_TAG_GSUB, HB_OT_TAG_GPOS};
      39                 : 
      40                 : struct hb_ot_map_t
      41                 : {
      42                 :   friend struct hb_ot_map_builder_t;
      43                 : 
      44                 :   public:
      45                 : 
      46               0 :   hb_ot_map_t (void) { memset (this, 0, sizeof (*this)); }
      47                 : 
      48                 :   typedef void (*gsub_pause_func_t) (const hb_ot_map_t *map, hb_face_t *face, hb_buffer_t *buffer, void *user_data);
      49                 :   typedef void (*gpos_pause_func_t) (const hb_ot_map_t *map, hb_font_t *font, hb_buffer_t *buffer, void *user_data);
      50                 : 
      51               0 :   inline hb_mask_t get_global_mask (void) const { return global_mask; }
      52                 : 
      53               0 :   inline hb_mask_t get_mask (hb_tag_t tag, unsigned int *shift = NULL) const {
      54               0 :     const feature_map_t *map = features.bsearch (&tag);
      55               0 :     if (shift) *shift = map ? map->shift : 0;
      56               0 :     return map ? map->mask : 0;
      57                 :   }
      58                 : 
      59               0 :   inline hb_mask_t get_1_mask (hb_tag_t tag) const {
      60               0 :     const feature_map_t *map = features.bsearch (&tag);
      61               0 :     return map ? map->_1_mask : 0;
      62                 :   }
      63                 : 
      64               0 :   inline hb_tag_t get_chosen_script (unsigned int table_index) const
      65               0 :   { return chosen_script[table_index]; }
      66                 : 
      67               0 :   inline void substitute (hb_face_t *face, hb_buffer_t *buffer) const
      68               0 :   { apply (0, (hb_ot_map_t::apply_lookup_func_t) hb_ot_layout_substitute_lookup, face, buffer); }
      69               0 :   inline void position (hb_font_t *font, hb_buffer_t *buffer) const
      70               0 :   { apply (1, (hb_ot_map_t::apply_lookup_func_t) hb_ot_layout_position_lookup, font, buffer); }
      71                 : 
      72               0 :   inline void finish (void) {
      73               0 :     features.finish ();
      74               0 :     lookups[0].finish ();
      75               0 :     lookups[1].finish ();
      76               0 :     pauses[0].finish ();
      77               0 :     pauses[1].finish ();
      78               0 :   }
      79                 : 
      80                 :   private:
      81                 : 
      82                 :   struct feature_map_t {
      83                 :     hb_tag_t tag; /* should be first for our bsearch to work */
      84                 :     unsigned int index[2]; /* GSUB/GPOS */
      85                 :     unsigned int stage[2]; /* GSUB/GPOS */
      86                 :     unsigned int shift;
      87                 :     hb_mask_t mask;
      88                 :     hb_mask_t _1_mask; /* mask for value=1, for quick access */
      89                 : 
      90               0 :     static int cmp (const feature_map_t *a, const feature_map_t *b)
      91               0 :     { return a->tag < b->tag ? -1 : a->tag > b->tag ? 1 : 0; }
      92                 :   };
      93                 : 
      94                 :   struct lookup_map_t {
      95                 :     unsigned int index;
      96                 :     hb_mask_t mask;
      97                 : 
      98               0 :     static int cmp (const lookup_map_t *a, const lookup_map_t *b)
      99               0 :     { return a->index < b->index ? -1 : a->index > b->index ? 1 : 0; }
     100                 :   };
     101                 : 
     102                 :   typedef void (*pause_func_t) (const hb_ot_map_t *map, void *face_or_font, hb_buffer_t *buffer, void *user_data);
     103                 :   typedef struct {
     104                 :     pause_func_t func;
     105                 :     void *user_data;
     106                 :   } pause_callback_t;
     107                 : 
     108                 :   struct pause_map_t {
     109                 :     unsigned int num_lookups; /* Cumulative */
     110                 :     pause_callback_t callback;
     111                 :   };
     112                 : 
     113                 :   typedef hb_bool_t (*apply_lookup_func_t) (void *face_or_font,
     114                 :                                             hb_buffer_t  *buffer,
     115                 :                                             unsigned int  lookup_index,
     116                 :                                             hb_mask_t     mask);
     117                 : 
     118                 :   HB_INTERNAL void add_lookups (hb_face_t    *face,
     119                 :                                 unsigned int  table_index,
     120                 :                                 unsigned int  feature_index,
     121                 :                                 hb_mask_t     mask);
     122                 : 
     123                 :   HB_INTERNAL void apply (unsigned int table_index,
     124                 :                           hb_ot_map_t::apply_lookup_func_t apply_lookup_func,
     125                 :                           void *face_or_font,
     126                 :                           hb_buffer_t *buffer) const;
     127                 : 
     128                 :   hb_mask_t global_mask;
     129                 : 
     130                 :   hb_tag_t chosen_script[2];
     131                 :   hb_prealloced_array_t<feature_map_t, 8> features;
     132                 :   hb_prealloced_array_t<lookup_map_t, 32> lookups[2]; /* GSUB/GPOS */
     133                 :   hb_prealloced_array_t<pause_map_t, 1> pauses[2]; /* GSUB/GPOS */
     134                 : };
     135                 : 
     136                 : 
     137                 : struct hb_ot_map_builder_t
     138                 : {
     139                 :   public:
     140                 : 
     141               0 :   hb_ot_map_builder_t (void) { memset (this, 0, sizeof (*this)); }
     142                 : 
     143                 :   HB_INTERNAL void add_feature (hb_tag_t tag, unsigned int value, bool global);
     144                 : 
     145               0 :   inline void add_bool_feature (hb_tag_t tag, bool global = true)
     146               0 :   { add_feature (tag, 1, global); }
     147                 : 
     148               0 :   inline void add_gsub_pause (hb_ot_map_t::gsub_pause_func_t pause_func, void *user_data)
     149               0 :   { add_pause (0, (hb_ot_map_t::pause_func_t) pause_func, user_data); }
     150               0 :   inline void add_gpos_pause (hb_ot_map_t::gpos_pause_func_t pause_func, void *user_data)
     151               0 :   { add_pause (1, (hb_ot_map_t::pause_func_t) pause_func, user_data); }
     152                 : 
     153                 :   HB_INTERNAL void compile (hb_face_t *face,
     154                 :                             const hb_segment_properties_t *props,
     155                 :                             struct hb_ot_map_t &m);
     156                 : 
     157               0 :   inline void finish (void) {
     158               0 :     feature_infos.finish ();
     159               0 :     pauses[0].finish ();
     160               0 :     pauses[1].finish ();
     161               0 :   }
     162                 : 
     163                 :   private:
     164                 : 
     165                 :   struct feature_info_t {
     166                 :     hb_tag_t tag;
     167                 :     unsigned int seq; /* sequence#, used for stable sorting only */
     168                 :     unsigned int max_value;
     169                 :     bool global; /* whether the feature applies value to every glyph in the buffer */
     170                 :     unsigned int default_value; /* for non-global features, what should the unset glyphs take */
     171                 :     unsigned int stage[2]; /* GSUB/GPOS */
     172                 : 
     173               0 :     static int cmp (const feature_info_t *a, const feature_info_t *b)
     174               0 :     { return (a->tag != b->tag) ?  (a->tag < b->tag ? -1 : 1) : (a->seq < b->seq ? -1 : 1); }
     175                 :   };
     176                 : 
     177                 :   struct pause_info_t {
     178                 :     unsigned int stage;
     179                 :     hb_ot_map_t::pause_callback_t callback;
     180                 :   };
     181                 : 
     182                 :   HB_INTERNAL void add_pause (unsigned int table_index, hb_ot_map_t::pause_func_t pause_func, void *user_data);
     183                 : 
     184                 :   unsigned int current_stage[2]; /* GSUB/GPOS */
     185                 :   hb_prealloced_array_t<feature_info_t,16> feature_infos;
     186                 :   hb_prealloced_array_t<pause_info_t, 1> pauses[2]; /* GSUB/GPOS */
     187                 : };
     188                 : 
     189                 : 
     190                 : 
     191                 : #endif /* HB_OT_MAP_PRIVATE_HH */

Generated by: LCOV version 1.7