reactos/lib/3rdparty/freetype/src/cff/cf2hints.h

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  cf2hints.h                                                             */
   4 /*                                                                         */
   5 /*    Adobe's code for handling CFF hints (body).                          */
   6 /*                                                                         */
   7 /*  Copyright 2007-2013 Adobe Systems Incorporated.                        */
   8 /*                                                                         */
   9 /*  This software, and all works of authorship, whether in source or       */
  10 /*  object code form as indicated by the copyright notice(s) included      */
  11 /*  herein (collectively, the "Work") is made available, and may only be   */
  12 /*  used, modified, and distributed under the FreeType Project License,    */
  13 /*  LICENSE.TXT.  Additionally, subject to the terms and conditions of the */
  14 /*  FreeType Project License, each contributor to the Work hereby grants   */
  15 /*  to any individual or legal entity exercising permissions granted by    */
  16 /*  the FreeType Project License and this section (hereafter, "You" or     */
  17 /*  "Your") a perpetual, worldwide, non-exclusive, no-charge,              */
  18 /*  royalty-free, irrevocable (except as stated in this section) patent    */
  19 /*  license to make, have made, use, offer to sell, sell, import, and      */
  20 /*  otherwise transfer the Work, where such license applies only to those  */
  21 /*  patent claims licensable by such contributor that are necessarily      */
  22 /*  infringed by their contribution(s) alone or by combination of their    */
  23 /*  contribution(s) with the Work to which such contribution(s) was        */
  24 /*  submitted.  If You institute patent litigation against any entity      */
  25 /*  (including a cross-claim or counterclaim in a lawsuit) alleging that   */
  26 /*  the Work or a contribution incorporated within the Work constitutes    */
  27 /*  direct or contributory patent infringement, then any patent licenses   */
  28 /*  granted to You under this License for that Work shall terminate as of  */
  29 /*  the date such litigation is filed.                                     */
  30 /*                                                                         */
  31 /*  By using, modifying, or distributing the Work you indicate that you    */
  32 /*  have read and understood the terms and conditions of the               */
  33 /*  FreeType Project License as well as those provided in this section,    */
  34 /*  and you accept them fully.                                             */
  35 /*                                                                         */
  36 /***************************************************************************/
  37
  38
  39 #ifndef __CF2HINTS_H__
  40 #define __CF2HINTS_H__
  41
  42
  43 FT_BEGIN_HEADER
  44
  45
  46   enum
  47   {
  48     CF2_MAX_HINTS = 96    /* maximum # of hints */
  49   };
  50
  51
  52   /*
  53    * A HintMask object stores a bit mask that specifies which hints in the
  54    * charstring are active at a given time.  Hints in CFF must be declared
  55    * at the start, before any drawing operators, with horizontal hints
  56    * preceding vertical hints.  The HintMask is ordered the same way, with
  57    * horizontal hints immediately followed by vertical hints.  Clients are
  58    * responsible for knowing how many of each type are present.
  59    *
  60    * The maximum total number of hints is 96, as specified by the CFF
  61    * specification.
  62    *
  63    * A HintMask is built 0 or more times while interpreting a charstring, by
  64    * the HintMask operator.  There is only one HintMask, but it is built or
  65    * rebuilt each time there is a hint substitution (HintMask operator) in
  66    * the charstring.  A default HintMask with all bits set is built if there
  67    * has been no HintMask operator prior to the first drawing operator.
  68    *
  69    */
  70
  71   typedef struct  CF2_HintMaskRec_
  72   {
  73     FT_Error*  error;
  74
  75     FT_Bool  isValid;
  76     FT_Bool  isNew;
  77
  78     size_t  bitCount;
  79     size_t  byteCount;
  80
  81     FT_Byte  mask[( CF2_MAX_HINTS + 7 ) / 8];
  82
  83   } CF2_HintMaskRec, *CF2_HintMask;
  84
  85
  86   typedef struct  CF2_StemHintRec_
  87   {
  88     FT_Bool  used;     /* DS positions are valid         */
  89
  90     CF2_Fixed  min;    /* original character space value */
  91     CF2_Fixed  max;
  92
  93     CF2_Fixed  minDS;  /* DS position after first use    */
  94     CF2_Fixed  maxDS;
  95
  96   } CF2_StemHintRec, *CF2_StemHint;
  97
  98
  99   /*
 100    * A HintMap object stores a piecewise linear function for mapping
 101    * y-coordinates from character space to device space, providing
 102    * appropriate pixel alignment to stem edges.
 103    *
 104    * The map is implemented as an array of `CF2_Hint' elements, each
 105    * representing an edge.  When edges are paired, as from stem hints, the
 106    * bottom edge must immediately precede the top edge in the array.
 107    * Element character space AND device space positions must both increase
 108    * monotonically in the array.  `CF2_Hint' elements are also used as
 109    * parameters to `cf2_blues_capture'.
 110    *
 111    * The `cf2_hintmap_build' method must be called before any drawing
 112    * operation (beginning with a Move operator) and at each hint
 113    * substitution (HintMask operator).
 114    *
 115    * The `cf2_hintmap_map' method is called to transform y-coordinates at
 116    * each drawing operation (move, line, curve).
 117    *
 118    */
 119
 120   /* TODO: make this a CF2_ArrStack and add a deep copy method */
 121   enum
 122   {
 123     CF2_MAX_HINT_EDGES = CF2_MAX_HINTS * 2
 124   };
 125
 126
 127   typedef struct  CF2_HintMapRec_
 128   {
 129     CF2_Font  font;
 130
 131     /* initial map based on blue zones */
 132     struct CF2_HintMapRec_*  initialHintMap;
 133
 134     /* working storage for 2nd pass adjustHints */
 135     CF2_ArrStack  hintMoves;
 136
 137     FT_Bool  isValid;
 138     FT_Bool  hinted;
 139
 140     CF2_Fixed  scale;
 141     CF2_UInt   count;
 142
 143     /* start search from this index */
 144     CF2_UInt  lastIndex;
 145
 146     CF2_HintRec  edge[CF2_MAX_HINT_EDGES]; /* 192 */
 147
 148   } CF2_HintMapRec, *CF2_HintMap;
 149
 150
 151   FT_LOCAL( FT_Bool )
 152   cf2_hint_isValid( const CF2_Hint  hint );
 153   FT_LOCAL( FT_Bool )
 154   cf2_hint_isTop( const CF2_Hint  hint );
 155   FT_LOCAL( FT_Bool )
 156   cf2_hint_isBottom( const CF2_Hint  hint );
 157   FT_LOCAL( void )
 158   cf2_hint_lock( CF2_Hint  hint );
 159
 160
 161   FT_LOCAL( void )
 162   cf2_hintmap_init( CF2_HintMap   hintmap,
 163                     CF2_Font      font,
 164                     CF2_HintMap   initialMap,
 165                     CF2_ArrStack  hintMoves,
 166                     CF2_Fixed     scale );
 167   FT_LOCAL( void )
 168   cf2_hintmap_build( CF2_HintMap   hintmap,
 169                      CF2_ArrStack  hStemHintArray,
 170                      CF2_ArrStack  vStemHintArray,
 171                      CF2_HintMask  hintMask,
 172                      CF2_Fixed     hintOrigin,
 173                      FT_Bool       initialMap );
 174
 175
 176   /*
 177    * GlyphPath is a wrapper for drawing operations that scales the
 178    * coordinates according to the render matrix and HintMap.  It also tracks
 179    * open paths to control ClosePath and to insert MoveTo for broken fonts.
 180    *
 181    */
 182   typedef struct  CF2_GlyphPathRec_
 183   {
 184     /* TODO: gather some of these into a hinting context */
 185
 186     CF2_Font              font;           /* font instance    */
 187     CF2_OutlineCallbacks  callbacks;      /* outline consumer */
 188
 189
 190     CF2_HintMapRec  hintMap;        /* current hint map            */
 191     CF2_HintMapRec  firstHintMap;   /* saved copy                  */
 192     CF2_HintMapRec  initialHintMap; /* based on all captured hints */
 193
 194     CF2_ArrStackRec  hintMoves;  /* list of hint moves for 2nd pass */
 195
 196     CF2_Fixed  scaleX;         /* matrix a */
 197     CF2_Fixed  scaleC;         /* matrix c */
 198     CF2_Fixed  scaleY;         /* matrix d */
 199
 200     FT_Vector  fractionalTranslation;  /* including deviceXScale */
 201 #if 0
 202     CF2_Fixed  hShift;    /* character space horizontal shift */
 203                           /* (for fauxing)                    */
 204 #endif
 205
 206     FT_Bool  pathIsOpen;     /* true after MoveTo                     */
 207     FT_Bool  pathIsClosing;  /* true when synthesizing closepath line */
 208     FT_Bool  darken;         /* true if stem darkening                */
 209     FT_Bool  moveIsPending;  /* true between MoveTo and offset MoveTo */
 210
 211     /* references used to call `cf2_hintmap_build', if necessary */
 212     CF2_ArrStack         hStemHintArray;
 213     CF2_ArrStack         vStemHintArray;
 214     CF2_HintMask         hintMask;     /* ptr to the current mask */
 215     CF2_Fixed            hintOriginY;  /* copy of current origin  */
 216     const CF2_BluesRec*  blues;
 217
 218     CF2_Fixed  xOffset;        /* character space offsets */
 219     CF2_Fixed  yOffset;
 220
 221     /* character space miter limit threshold */
 222     CF2_Fixed  miterLimit;
 223     /* vertical/horzizontal snap distance in character space */
 224     CF2_Fixed  snapThreshold;
 225
 226     FT_Vector  offsetStart0;  /* first and second points of first */
 227     FT_Vector  offsetStart1;  /* element with offset applied      */
 228
 229     /* current point, character space, before offset */
 230     FT_Vector  currentCS;
 231     /* current point, device space */
 232     FT_Vector  currentDS;
 233     /* start point of subpath, character space */
 234     FT_Vector  start;
 235
 236     /* the following members constitute the `queue' of one element */
 237     FT_Bool  elemIsQueued;
 238     CF2_Int  prevElemOp;
 239
 240     FT_Vector  prevElemP0;
 241     FT_Vector  prevElemP1;
 242     FT_Vector  prevElemP2;
 243     FT_Vector  prevElemP3;
 244
 245   } CF2_GlyphPathRec, *CF2_GlyphPath;
 246
 247
 248   FT_LOCAL( void )
 249   cf2_glyphpath_init( CF2_GlyphPath         glyphpath,
 250                       CF2_Font              font,
 251                       CF2_OutlineCallbacks  callbacks,
 252                       CF2_Fixed             scaleY,
 253                       /* CF2_Fixed hShift, */
 254                       CF2_ArrStack          hStemHintArray,
 255                       CF2_ArrStack          vStemHintArray,
 256                       CF2_HintMask          hintMask,
 257                       CF2_Fixed             hintOrigin,
 258                       const CF2_Blues       blues,
 259                       const FT_Vector*      fractionalTranslation );
 260   FT_LOCAL( void )
 261   cf2_glyphpath_finalize( CF2_GlyphPath  glyphpath );
 262
 263   FT_LOCAL( void )
 264   cf2_glyphpath_moveTo( CF2_GlyphPath  glyphpath,
 265                         CF2_Fixed      x,
 266                         CF2_Fixed      y );
 267   FT_LOCAL( void )
 268   cf2_glyphpath_lineTo( CF2_GlyphPath  glyphpath,
 269                         CF2_Fixed      x,
 270                         CF2_Fixed      y );
 271   FT_LOCAL( void )
 272   cf2_glyphpath_curveTo( CF2_GlyphPath  glyphpath,
 273                          CF2_Fixed      x1,
 274                          CF2_Fixed      y1,
 275                          CF2_Fixed      x2,
 276                          CF2_Fixed      y2,
 277                          CF2_Fixed      x3,
 278                          CF2_Fixed      y3 );
 279   FT_LOCAL( void )
 280   cf2_glyphpath_closeOpenPath( CF2_GlyphPath  glyphpath );
 281
 282
 283 FT_END_HEADER
 284
 285
 286 #endif /* __CF2HINTS_H__ */
 287
 288
 289 /* END */