reactos/lib/3rdparty/freetype/include/ftadvanc.h

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  ftadvanc.h                                                             */
   4 /*                                                                         */
   5 /*    Quick computation of advance widths (specification only).            */
   6 /*                                                                         */
   7 /*  Copyright 2008, 2013 by                                                */
   8 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
   9 /*                                                                         */
  10 /*  This file is part of the FreeType project, and may only be used,       */
  11 /*  modified, and distributed under the terms of the FreeType project      */
  12 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  13 /*  this file you indicate that you have read the license and              */
  14 /*  understand and accept it fully.                                        */
  15 /*                                                                         */
  16 /***************************************************************************/
  17
  18
  19 #ifndef __FTADVANC_H__
  20 #define __FTADVANC_H__
  21
  22
  23 #include <ft2build.h>
  24 #include FT_FREETYPE_H
  25
  26 #ifdef FREETYPE_H
  27 #error "freetype.h of FreeType 1 has been loaded!"
  28 #error "Please fix the directory search order for header files"
  29 #error "so that freetype.h of FreeType 2 is found first."
  30 #endif
  31
  32
  33 FT_BEGIN_HEADER
  34
  35
  36   /**************************************************************************
  37    *
  38    * @section:
  39    *   quick_advance
  40    *
  41    * @title:
  42    *   Quick retrieval of advance values
  43    *
  44    * @abstract:
  45    *   Retrieve horizontal and vertical advance values without processing
  46    *   glyph outlines, if possible.
  47    *
  48    * @description:
  49    *   This section contains functions to quickly extract advance values
  50    *   without handling glyph outlines, if possible.
  51    */
  52
  53
  54   /*************************************************************************/
  55   /*                                                                       */
  56   /* <Const>                                                               */
  57   /*    FT_ADVANCE_FLAG_FAST_ONLY                                          */
  58   /*                                                                       */
  59   /* <Description>                                                         */
  60   /*    A bit-flag to be OR-ed with the `flags' parameter of the           */
  61   /*    @FT_Get_Advance and @FT_Get_Advances functions.                    */
  62   /*                                                                       */
  63   /*    If set, it indicates that you want these functions to fail if the  */
  64   /*    corresponding hinting mode or font driver doesn't allow for very   */
  65   /*    quick advance computation.                                         */
  66   /*                                                                       */
  67   /*    Typically, glyphs that are either unscaled, unhinted, bitmapped,   */
  68   /*    or light-hinted can have their advance width computed very         */
  69   /*    quickly.                                                           */
  70   /*                                                                       */
  71   /*    Normal and bytecode hinted modes that require loading, scaling,    */
  72   /*    and hinting of the glyph outline, are extremely slow by            */
  73   /*    comparison.                                                        */
  74   /*                                                                       */
  75 #define FT_ADVANCE_FLAG_FAST_ONLY  0x20000000UL
  76
  77
  78   /*************************************************************************/
  79   /*                                                                       */
  80   /* <Function>                                                            */
  81   /*    FT_Get_Advance                                                     */
  82   /*                                                                       */
  83   /* <Description>                                                         */
  84   /*    Retrieve the advance value of a given glyph outline in an          */
  85   /*    @FT_Face.                                                          */
  86   /*                                                                       */
  87   /* <Input>                                                               */
  88   /*    face       :: The source @FT_Face handle.                          */
  89   /*                                                                       */
  90   /*    gindex     :: The glyph index.                                     */
  91   /*                                                                       */
  92   /*    load_flags :: A set of bit flags similar to those used when        */
  93   /*                  calling @FT_Load_Glyph, used to determine what kind  */
  94   /*                  of advances you need.                                */
  95   /* <Output>                                                              */
  96   /*    padvance :: The advance value.  If scaling is performed (based on  */
  97   /*                the value of `load_flags'), the advance value is in    */
  98   /*                16.16 format.  Otherwise, it is in font units.         */
  99   /*                                                                       */
 100   /*                If @FT_LOAD_VERTICAL_LAYOUT is set, this is the        */
 101   /*                vertical advance corresponding to a vertical layout.   */
 102   /*                Otherwise, it is the horizontal advance in a           */
 103   /*                horizontal layout.                                     */
 104   /*                                                                       */
 105   /* <Return>                                                              */
 106   /*    FreeType error code.  0 means success.                             */
 107   /*                                                                       */
 108   /* <Note>                                                                */
 109   /*    This function may fail if you use @FT_ADVANCE_FLAG_FAST_ONLY and   */
 110   /*    if the corresponding font backend doesn't have a quick way to      */
 111   /*    retrieve the advances.                                             */
 112   /*                                                                       */
 113   /*    A scaled advance is returned in 16.16 format but isn't transformed */
 114   /*    by the affine transformation specified by @FT_Set_Transform.       */
 115   /*                                                                       */
 116   FT_EXPORT( FT_Error )
 117   FT_Get_Advance( FT_Face    face,
 118                   FT_UInt    gindex,
 119                   FT_Int32   load_flags,
 120                   FT_Fixed  *padvance );
 121
 122
 123   /*************************************************************************/
 124   /*                                                                       */
 125   /* <Function>                                                            */
 126   /*    FT_Get_Advances                                                    */
 127   /*                                                                       */
 128   /* <Description>                                                         */
 129   /*    Retrieve the advance values of several glyph outlines in an        */
 130   /*    @FT_Face.                                                          */
 131   /*                                                                       */
 132   /* <Input>                                                               */
 133   /*    face        :: The source @FT_Face handle.                         */
 134   /*                                                                       */
 135   /*    start       :: The first glyph index.                              */
 136   /*                                                                       */
 137   /*    count       :: The number of advance values you want to retrieve.  */
 138   /*                                                                       */
 139   /*    load_flags  :: A set of bit flags similar to those used when       */
 140   /*                   calling @FT_Load_Glyph.                             */
 141   /*                                                                       */
 142   /* <Output>                                                              */
 143   /*    padvance :: The advance values.  This array, to be provided by the */
 144   /*                caller, must contain at least `count' elements.        */
 145   /*                                                                       */
 146   /*                If scaling is performed (based on the value of         */
 147   /*                `load_flags'), the advance values are in 16.16 format. */
 148   /*                Otherwise, they are in font units.                     */
 149   /*                                                                       */
 150   /*                If @FT_LOAD_VERTICAL_LAYOUT is set, these are the      */
 151   /*                vertical advances corresponding to a vertical layout.  */
 152   /*                Otherwise, they are the horizontal advances in a       */
 153   /*                horizontal layout.                                     */
 154   /*                                                                       */
 155   /* <Return>                                                              */
 156   /*    FreeType error code.  0 means success.                             */
 157   /*                                                                       */
 158   /* <Note>                                                                */
 159   /*    This function may fail if you use @FT_ADVANCE_FLAG_FAST_ONLY and   */
 160   /*    if the corresponding font backend doesn't have a quick way to      */
 161   /*    retrieve the advances.                                             */
 162   /*                                                                       */
 163   /*    Scaled advances are returned in 16.16 format but aren't            */
 164   /*    transformed by the affine transformation specified by              */
 165   /*    @FT_Set_Transform.                                                 */
 166   /*                                                                       */
 167   FT_EXPORT( FT_Error )
 168   FT_Get_Advances( FT_Face    face,
 169                    FT_UInt    start,
 170                    FT_UInt    count,
 171                    FT_Int32   load_flags,
 172                    FT_Fixed  *padvances );
 173
 174 /* */
 175
 176
 177 FT_END_HEADER
 178
 179 #endif /* __FTADVANC_H__ */
 180
 181
 182 /* END */