ftimage.h

Qt/Embedded是一个多平台的C++图形用户界面应用程序框架

  /*                                                                       */
  /* <Fields>                                                              */
  /*    n_contours :: The number of contours in the outline.               */
  /*                                                                       */
  /*    n_points   :: The number of points in the outline.                 */
  /*                                                                       */
  /*    points     :: A pointer to an array of `n_points' FT_Vector        */
  /*                  elements, giving the outline's point                 */
  /*                  coordinates.                                         */
  /*                                                                       */
  /*    tags       :: A pointer to an array of `n_points' chars,           */
  /*                  giving each outline point's type.  If bit 0 is       */
  /*                  unset, the point is 'off' the curve, i.e. a          */
  /*                  Bezier control point, while it is `on' when          */
  /*                  unset.                                               */
  /*                                                                       */
  /*                  Bit 1 is meaningful for `off' points only.  If       */
  /*                  set, it indicates a third-order Bezier arc           */
  /*                  control point; and a second-order control point      */
  /*                  if unset.                                            */
  /*                                                                       */
  /*    contours   :: An array of `n_contours' shorts, giving the end      */
  /*                  point of each contour within the outline.  For       */
  /*                  example, the first contour is defined by the         */
  /*                  points `0' to `contours[0]', the second one is       */
  /*                  defined by the points `contours[0]+1' to             */
  /*                  `contours[1]', etc.                                  */
  /*                                                                       */
  /*    flags      :: a set of bit flags used to characterize the          */
  /*                  outline and give hints to the scan-converter         */
  /*                  and hinter on how to convert/grid-fit it..           */
  /*                  see FT_Outline_Flags..                               */
  /*                                                                       */
  typedef struct  FT_Outline_
  {
    short       n_contours;      /* number of contours in glyph        */
    short       n_points;        /* number of points in the glyph      */

    FT_Vector*  points;          /* the outline's points               */
    char*       tags;            /* the points flags                   */
    short*      contours;        /* the contour end points             */

    int         flags;           /* outline masks                      */
    
  } FT_Outline;

  /*************************************************************************/
  /*                                                                       */
  /* <Enum>                                                                */
  /*   FT_Outline_Flags                                                    */
  /*                                                                       */
  /* <Description>                                                         */
  /*   A simple type used to enumerates the flags in an outline's          */
  /*   "outline_flags" field.                                              */
  /*                                                                       */
  /* <Fields>                                                              */
  /*   ft_outline_owner  ::                                                */
  /*       when set, this flag indicates that the outline's field arrays   */
  /*       (i.e. "points", "flags" & "contours") are "owned" by the        */
  /*       outline object, and should thus be freed when it is destroyed.  */
  /*                                                                       */
  /*   ft_outline_even_odd_fill ::                                         */
  /*       by default, outlines are filled using the non-zero winding      */
  /*       rule. When set to 1, the outline will be filled using the       */
  /*       even-odd fill rule.. (XXX: unimplemented)                       */
  /*                                                                       */
  /*   ft_outline_reverse_fill ::                                          */
  /*       By default, outside contours of an outline are oriented in      */
  /*       clock-wise direction, as defined in the TrueType specification. */
  /*       This flag is set when the outline uses the opposite direction,  */
  /*       (typically for Type 1 fonts). This flag is ignored by the       */
  /*       scan-converter. However, it is very important for the           */
  /*       auto-hinter..                                                   */
  /*                                                                       */
  /*   ft_outline_ignore_dropouts ::                                       */
  /*       By default, the scan converter will try to detect drop-outs     */
  /*       in an outline and correct the glyph bitmap to ensure consistent */
  /*       shape continuity. When set, this flag hints the scan-line       */
  /*       converter to ignore such cases.                                 */
  /*                                                                       */
  /*   ft_outline_high_precision ::                                        */
  /*       this flag indicates that the scan-line converter should try     */
  /*       to convert this outline to bitmaps with the highest possible    */
  /*       quality. It is typically set for small character sizes. Note    */
  /*       that this is only a hint, that might be completely ignored      */
  /*       by a given scan-converter.                                      */
  /*                                                                       */
  /*   ft_outline_single_pass ::                                           */
  /*       this flag is set to force a given scan-converter to only        */
  /*       use a single pass over the outline to render a bitmap glyph     */
  /*       image. Normally, it is set for very large character sizes.      */
  /*       It is only a hint, that might be completely ignored by a        */
  /*       given scan-converter.                                           */
  /*                                                                       */
  typedef enum FT_Outline_Flags_
  {
    ft_outline_none            = 0,
    ft_outline_owner           = 1,
    ft_outline_even_odd_fill   = 2,
    ft_outline_reverse_fill    = 4,
    ft_outline_ignore_dropouts = 8,
    ft_outline_high_precision  = 256,
    ft_outline_single_pass     = 512
  
  } FT_Outline_Flags;



#define FT_CURVE_TAG( flag )  (flag & 3)

#define FT_Curve_Tag_On       1
#define FT_Curve_Tag_Conic    0
#define FT_Curve_Tag_Cubic    2

#define FT_Curve_Tag_Touch_X  8   /* reserved for the TrueType hinter */
#define FT_Curve_Tag_Touch_Y  16  /* reserved for the TrueType hinter */

#define FT_Curve_Tag_Touch_Both  ( FT_Curve_Tag_Touch_X | \
                                   FT_Curve_Tag_Touch_Y)

  /*************************************************************************/
  /*                                                                       */
  /* <FuncType>                                                            */
  /*    FT_Outline_MoveTo_Func                                             */
  /*                                                                       */
  /* <Description>                                                         */
  /*    A function pointer type used to describe the signature of a `move  */
  /*    to' function during outline walking/decomposition.                 */
  /*                                                                       */
  /*    A `move to' is emitted to start a new contour in an outline.       */
  /*                                                                       */
  /* <Input>                                                               */
  /*    to   :: A pointer to the target point of the `move to'.            */
  /*    user :: A typeless pointer which is passed from the caller of the  */
  /*            decomposition function.                                    */
  /*                                                                       */
  /* <Return>                                                              */
  /*    Error code.  0 means success.                                      */
  /*                                                                       */
  typedef int  (*FT_Outline_MoveTo_Func)( FT_Vector*  to,
                                          void*       user );


  /*************************************************************************/
  /*                                                                       */
  /* <FuncType>                                                            */
  /*    FT_Outline_LineTo_Func                                             */
  /*                                                                       */
  /* <Description>                                                         */
  /*    A function pointer type used to describe the signature of a `line  */
  /*    to' function during outline walking/decomposition.                 */
  /*                                                                       */
  /*    A `line to' is emitted to indicate a segment in the outline.       */
  /*                                                                       */
  /* <Input>                                                               */
  /*    to   :: A pointer to the target point of the `line to'.            */
  /*    user :: A typeless pointer which is passed from the caller of the  */
  /*            decomposition function.                                    */
  /*                                                                       */
  /* <Return>                                                              */
  /*    Error code.  0 means success.                                      */
  /*                                                                       */
  typedef int  (*FT_Outline_LineTo_Func)( FT_Vector*  to,
                                          void*       user );


  /*************************************************************************/
  /*                                                                       */
  /* <FuncType>                                                            */
  /*    FT_Outline_ConicTo_Func                                            */
  /*                                                                       */
  /* <Description>                                                         */
  /*    A function pointer type use to describe the signature of a `conic  */
  /*    to' function during outline walking/decomposition.                 */
  /*                                                                       */
  /*    A `conic to' is emitted to indicate a second-order Bezier arc in   */
  /*    the outline.                                                       */
  /*                                                                       */
  /* <Input>                                                               */
  /*    control :: An intermediate control point between the last position */
  /*               and the new target in `to'.                             */
  /*                                                                       */
  /*    to      :: A pointer to the target end point of the conic arc.     */
  /*                                                                       */
  /*    user    :: A typeless pointer which is passed from the caller of   */
  /*               the decomposition function.                             */
  /*                                                                       */
  /* <Return>                                                              */
  /*    Error code.  0 means success.                                      */
  /*                                                                       */
  typedef int  (*FT_Outline_ConicTo_Func)( FT_Vector*  control,
                                           FT_Vector*  to,
                                           void*       user );


  /*************************************************************************/
  /*                                                                       */
  /* <FuncType>                                                            */
  /*    FT_Outline_CubicTo_Func                                            */
  /*                                                                       */
  /* <Description>                                                         */
  /*    A function pointer type used to describe the signature of a `cubic */
  /*    to' function during outline walking/decomposition.                 */
  /*                                                                       */
  /*    A `cubic to' is emitted to indicate a third-order Bezier arc.      */
  /*                                                                       */
  /* <Input>                                                               */
  /*    control1 :: A pointer to the first Bezier control point.           */
  /*    control2 :: A pointer to the second Bezier control point.          */
  /*    to       :: A pointer to the target end point.                     */
  /*    user     :: A typeless pointer which is passed from the caller of  */
  /*                the decomposition function.                            */
  /*                                                                       */
  /* <Return>                                                              */
  /*    Error code.  0 means success.                                      */
  /*                                                                       */
  typedef int  (*FT_Outline_CubicTo_Func)( FT_Vector*  control1,
                                           FT_Vector*  control2,
                                           FT_Vector*  to,
                                           void*       user );


  /*************************************************************************/
  /*                                                                       */