src/hb-ot-cff2-table.cc

   1 /*
   2  * Copyright © 2018 Adobe Inc.
   3  *
   4  *  This is part of HarfBuzz, a text shaping library.
   5  *
   6  * Permission is hereby granted, without written agreement and without
   7  * license or royalty fees, to use, copy, modify, and distribute this
   8  * software and its documentation for any purpose, provided that the
   9  * above copyright notice and the following two paragraphs appear in
  10  * all copies of this software.
  11  *
  12  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
  13  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  14  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
  15  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
  16  * DAMAGE.
  17  *
  18  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  19  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  20  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  21  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
  22  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  23  *
  24  * Adobe Author(s): Michiharu Ariza
  25  */
  26
  27 #include "hb.hh"
  28
  29 #ifndef HB_NO_OT_FONT_CFF
  30
  31 #include "hb-ot-cff2-table.hh"
  32 #include "hb-cff2-interp-cs.hh"
  33 #include "hb-draw.hh"
  34
  35 using namespace CFF;
  36
  37 struct cff2_extents_param_t
  38 {
  39   cff2_extents_param_t ()
  40   {
  41     min_x.set_int (INT_MAX);
  42     min_y.set_int (INT_MAX);
  43     max_x.set_int (INT_MIN);
  44     max_y.set_int (INT_MIN);
  45   }
  46
  47   void   start_path ()       { path_open = true; }
  48   void     end_path ()       { path_open = false; }
  49   bool is_path_open () const { return path_open; }
  50
  51   void update_bounds (const point_t &pt)
  52   {
  53     if (pt.x < min_x) min_x = pt.x;
  54     if (pt.x > max_x) max_x = pt.x;
  55     if (pt.y < min_y) min_y = pt.y;
  56     if (pt.y > max_y) max_y = pt.y;
  57   }
  58
  59   bool  path_open = false;
  60   number_t min_x;
  61   number_t min_y;
  62   number_t max_x;
  63   number_t max_y;
  64 };
  65
  66 struct cff2_path_procs_extents_t : path_procs_t<cff2_path_procs_extents_t, cff2_cs_interp_env_t<number_t>, cff2_extents_param_t>
  67 {
  68   static void moveto (cff2_cs_interp_env_t<number_t> &env, cff2_extents_param_t& param, const point_t &pt)
  69   {
  70     param.end_path ();
  71     env.moveto (pt);
  72   }
  73
  74   static void line (cff2_cs_interp_env_t<number_t> &env, cff2_extents_param_t& param, const point_t &pt1)
  75   {
  76     if (!param.is_path_open ())
  77     {
  78       param.start_path ();
  79       param.update_bounds (env.get_pt ());
  80     }
  81     env.moveto (pt1);
  82     param.update_bounds (env.get_pt ());
  83   }
  84
  85   static void curve (cff2_cs_interp_env_t<number_t> &env, cff2_extents_param_t& param, const point_t &pt1, const point_t &pt2, const point_t &pt3)
  86   {
  87     if (!param.is_path_open ())
  88     {
  89       param.start_path ();
  90       param.update_bounds (env.get_pt ());
  91     }
  92     /* include control points */
  93     param.update_bounds (pt1);
  94     param.update_bounds (pt2);
  95     env.moveto (pt3);
  96     param.update_bounds (env.get_pt ());
  97   }
  98 };
  99
 100 struct cff2_cs_opset_extents_t : cff2_cs_opset_t<cff2_cs_opset_extents_t, cff2_extents_param_t, number_t, cff2_path_procs_extents_t> {};
 101
 102 bool OT::cff2::accelerator_t::get_extents (hb_font_t *font,
 103                                            hb_codepoint_t glyph,
 104                                            hb_glyph_extents_t *extents) const
 105 {
 106 #ifdef HB_NO_OT_FONT_CFF
 107   /* XXX Remove check when this code moves to .hh file. */
 108   return true;
 109 #endif
 110
 111   if (unlikely (!is_valid () || (glyph >= num_glyphs))) return false;
 112
 113   unsigned int fd = fdSelect->get_fd (glyph);
 114   const hb_ubytes_t str = (*charStrings)[glyph];
 115   cff2_cs_interp_env_t<number_t> env (str, *this, fd, font->coords, font->num_coords);
 116   cff2_cs_interpreter_t<cff2_cs_opset_extents_t, cff2_extents_param_t, number_t> interp (env);
 117   cff2_extents_param_t  param;
 118   if (unlikely (!interp.interpret (param))) return false;
 119
 120   if (param.min_x >= param.max_x)
 121   {
 122     extents->width = 0;
 123     extents->x_bearing = 0;
 124   }
 125   else
 126   {
 127     extents->x_bearing = roundf (param.min_x.to_real ());
 128     extents->width = roundf (param.max_x.to_real () - extents->x_bearing);
 129   }
 130   if (param.min_y >= param.max_y)
 131   {
 132     extents->height = 0;
 133     extents->y_bearing = 0;
 134   }
 135   else
 136   {
 137     extents->y_bearing = roundf (param.max_y.to_real ());
 138     extents->height = roundf (param.min_y.to_real () - extents->y_bearing);
 139   }
 140
 141   font->scale_glyph_extents (extents);
 142
 143   return true;
 144 }
 145
 146 bool OT::cff2::accelerator_t::paint_glyph (hb_font_t *font, hb_codepoint_t glyph, hb_paint_funcs_t *funcs, void *data, hb_color_t foreground) const
 147 {
 148   funcs->push_clip_glyph (data, glyph, font);
 149   funcs->color (data, true, foreground);
 150   funcs->pop_clip (data);
 151
 152   return true;
 153 }
 154
 155 struct cff2_path_param_t
 156 {
 157   cff2_path_param_t (hb_font_t *font_, hb_draw_session_t &draw_session_)
 158   {
 159     draw_session = &draw_session_;
 160     font = font_;
 161   }
 162
 163   void move_to (const point_t &p)
 164   { draw_session->move_to (font->em_fscalef_x (p.x.to_real ()), font->em_fscalef_y (p.y.to_real ())); }
 165
 166   void line_to (const point_t &p)
 167   { draw_session->line_to (font->em_fscalef_x (p.x.to_real ()), font->em_fscalef_y (p.y.to_real ())); }
 168
 169   void cubic_to (const point_t &p1, const point_t &p2, const point_t &p3)
 170   {
 171     draw_session->cubic_to (font->em_fscalef_x (p1.x.to_real ()), font->em_fscalef_y (p1.y.to_real ()),
 172                            font->em_fscalef_x (p2.x.to_real ()), font->em_fscalef_y (p2.y.to_real ()),
 173                            font->em_fscalef_x (p3.x.to_real ()), font->em_fscalef_y (p3.y.to_real ()));
 174   }
 175
 176   protected:
 177   hb_draw_session_t *draw_session;
 178   hb_font_t *font;
 179 };
 180
 181 struct cff2_path_procs_path_t : path_procs_t<cff2_path_procs_path_t, cff2_cs_interp_env_t<number_t>, cff2_path_param_t>
 182 {
 183   static void moveto (cff2_cs_interp_env_t<number_t> &env, cff2_path_param_t& param, const point_t &pt)
 184   {
 185     param.move_to (pt);
 186     env.moveto (pt);
 187   }
 188
 189   static void line (cff2_cs_interp_env_t<number_t> &env, cff2_path_param_t& param, const point_t &pt1)
 190   {
 191     param.line_to (pt1);
 192     env.moveto (pt1);
 193   }
 194
 195   static void curve (cff2_cs_interp_env_t<number_t> &env, cff2_path_param_t& param, const point_t &pt1, const point_t &pt2, const point_t &pt3)
 196   {
 197     param.cubic_to (pt1, pt2, pt3);
 198     env.moveto (pt3);
 199   }
 200 };
 201
 202 struct cff2_cs_opset_path_t : cff2_cs_opset_t<cff2_cs_opset_path_t, cff2_path_param_t, number_t, cff2_path_procs_path_t> {};
 203
 204 bool OT::cff2::accelerator_t::get_path (hb_font_t *font, hb_codepoint_t glyph, hb_draw_session_t &draw_session) const
 205 {
 206 #ifdef HB_NO_OT_FONT_CFF
 207   /* XXX Remove check when this code moves to .hh file. */
 208   return true;
 209 #endif
 210
 211   if (unlikely (!is_valid () || (glyph >= num_glyphs))) return false;
 212
 213   unsigned int fd = fdSelect->get_fd (glyph);
 214   const hb_ubytes_t str = (*charStrings)[glyph];
 215   cff2_cs_interp_env_t<number_t> env (str, *this, fd, font->coords, font->num_coords);
 216   cff2_cs_interpreter_t<cff2_cs_opset_path_t, cff2_path_param_t, number_t> interp (env);
 217   cff2_path_param_t param (font, draw_session);
 218   if (unlikely (!interp.interpret (param))) return false;
 219   return true;
 220 }
 221
 222 #endif