(***************************************************************************)
(*                                                                         *)
(*  ftoutln.h                                                              *)
(*                                                                         *)
(*    Support for the FT_Outline type used to store glyph shapes of        *)
(*    most scalable font formats (specification).                          *)
(*                                                                         *)
(*  Copyright 1996-2001, 2002, 2003, 2005, 2006, 2007 by                   *)
(*  David Turner, Robert Wilhelm, and Werner Lemberg.                      *)
(*                                                                         *)
(*  This file is part of the FreeType project, and may only be used,       *)
(*  modified, and distributed under the terms of the FreeType project      *)
(*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     *)
(*  this file you indicate that you have read the license and              *)
(*  understand and accept it fully.                                        *)
(*                                                                         *)
(***************************************************************************)
(***************************************************************************)
(* Pascal port by the UltraStar Deluxe Team                                *)
(***************************************************************************)


  (*************************************************************************)
  (*                                                                       *)
  (* <Section>                                                             *)
  (*    outline_processing                                                 *)
  (*                                                                       *)
  (* <Title>                                                               *)
  (*    Outline Processing                                                 *)
  (*                                                                       *)
  (* <Abstract>                                                            *)
  (*    Functions to create, transform, and render vectorial glyph images. *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    This section contains routines used to create and destroy scalable *)
  (*    glyph images known as `outlines'.  These can also be measured,     *)
  (*    transformed, and converted into bitmaps and pixmaps.               *)
  (*                                                                       *)
  (* <Order>                                                               *)
  (*    FT_Outline                                                         *)
  (*    FT_OUTLINE_FLAGS                                                   *)
  (*    FT_Outline_New                                                     *)
  (*    FT_Outline_Done                                                    *)
  (*    FT_Outline_Copy                                                    *)
  (*    FT_Outline_Translate                                               *)
  (*    FT_Outline_Transform                                               *)
  (*    FT_Outline_Embolden                                                *)
  (*    FT_Outline_Reverse                                                 *)
  (*    FT_Outline_Check                                                   *)
  (*                                                                       *)
  (*    FT_Outline_Get_CBox                                                *)
  (*    FT_Outline_Get_BBox                                                *)
  (*                                                                       *)
  (*    FT_Outline_Get_Bitmap                                              *)
  (*    FT_Outline_Render                                                  *)
  (*                                                                       *)
  (*    FT_Outline_Decompose                                               *)
  (*    FT_Outline_Funcs                                                   *)
  (*    FT_Outline_MoveTo_Func                                             *)
  (*    FT_Outline_LineTo_Func                                             *)
  (*    FT_Outline_ConicTo_Func                                            *)
  (*    FT_Outline_CubicTo_Func                                            *)
  (*                                                                       *)
  (*************************************************************************)

{$IFNDEF TYPE_DECL}

  (*************************************************************************)
  (*                                                                       *)
  (* <Function>                                                            *)
  (*    FT_Outline_Decompose                                               *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    Walks over an outline's structure to decompose it into individual  *)
  (*    segments and Bézier arcs.  This function is also able to emit      *)
  (*    `move to' and `close to' operations to indicate the start and end  *)
  (*    of new contours in the outline.                                    *)
  (*                                                                       *)
  (* <Input>                                                               *)
  (*    outline        :: A pointer to the source target.                  *)
  (*                                                                       *)
  (*    func_interface :: A table of `emitters', i.e,. function pointers   *)
  (*                      called during decomposition to indicate path     *)
  (*                      operations.                                      *)
  (*                                                                       *)
  (* <InOut>                                                               *)
  (*    user           :: A typeless pointer which is passed to each       *)
  (*                      emitter during the decomposition.  It can be     *)
  (*                      used to store the state during the               *)
  (*                      decomposition.                                   *)
  (*                                                                       *)
  (* <Return>                                                              *)
  (*    FreeType error code.  0 means success.                             *)
  (*                                                                       *)
  function FT_Outline_Decompose(
                        outline:        PFT_Outline;
                        func_interface: {const} PFT_Outline_Funcs;
                        user:           Pointer): FT_Error;
    cdecl; external ft_lib name 'FT_Outline_Decompose';

    
  (*************************************************************************)
  (*                                                                       *)
  (* <Function>                                                            *)
  (*    FT_Outline_New                                                     *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    Creates a new outline of a given size.                             *)
  (*                                                                       *)
  (* <Input>                                                               *)
  (*    library     :: A handle to the library object from where the       *)
  (*                   outline is allocated.  Note however that the new    *)
  (*                   outline will *not* necessarily be *freed*, when     *)
  (*                   destroying the library, by @FT_Done_FreeType.       *)
  (*                                                                       *)
  (*    numPoints   :: The maximal number of points within the outline.    *)
  (*                                                                       *)
  (*    numContours :: The maximal number of contours within the outline.  *)
  (*                                                                       *)
  (* <Output>                                                              *)
  (*    anoutline   :: A handle to the new outline.  NULL in case of       *)
  (*                   error.                                              *)
  (*                                                                       *)
  (* <Return>                                                              *)
  (*    FreeType error code.  0 means success.                             *)
  (*                                                                       *)
  (* <Note>                                                                *)
  (*    The reason why this function takes a `library' parameter is simply *)
  (*    to use the library's memory allocator.                             *)
  (*                                                                       *)
  function FT_Outline_New(
                  library_:    FT_Library;
                  numPoints:   FT_UInt;
                  numContours: FT_Int;
                  anoutline:   PFT_Outline): FT_Error;
    cdecl; external ft_lib name 'FT_Outline_New';

                  
  (*************************************************************************)
  (*                                                                       *)
  (* <Function>                                                            *)
  (*    FT_Outline_Done                                                    *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    Destroys an outline created with @FT_Outline_New.                  *)
  (*                                                                       *)
  (* <Input>                                                               *)
  (*    library :: A handle of the library object used to allocate the     *)
  (*               outline.                                                *)
  (*                                                                       *)
  (*    outline :: A pointer to the outline object to be discarded.        *)
  (*                                                                       *)
  (* <Return>                                                              *)
  (*    FreeType error code.  0 means success.                             *)
  (*                                                                       *)
  (* <Note>                                                                *)
  (*    If the outline's `owner' field is not set, only the outline        *)
  (*    descriptor will be released.                                       *)
  (*                                                                       *)
  (*    The reason why this function takes an `library' parameter is       *)
  (*    simply to use ft_mem_free().                                       *)
  (*                                                                       *)
  function FT_Outline_Done(library_: FT_Library;
                           outline:  PFT_Outline): FT_Error;
    cdecl; external ft_lib name 'FT_Outline_Done';


  (*************************************************************************)
  (*                                                                       *)
  (* <Function>                                                            *)
  (*    FT_Outline_Check                                                   *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    Check the contents of an outline descriptor.                       *)
  (*                                                                       *)
  (* <Input>                                                               *)
  (*    outline :: A handle to a source outline.                           *)
  (*                                                                       *)
  (* <Return>                                                              *)
  (*    FreeType error code.  0 means success.                             *)
  (*                                                                       *)
  function FT_Outline_Check( outline: PFT_Outline ): FT_Error;
    cdecl; external ft_lib name 'FT_Outline_Check';


  (*************************************************************************)
  (*                                                                       *)
  (* <Function>                                                            *)
  (*    FT_Outline_Get_CBox                                                *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    Returns an outline's `control box'.  The control box encloses all  *)
  (*    the outline's points, including Bézier control points.  Though it  *)
  (*    coincides with the exact bounding box for most glyphs, it can be   *)
  (*    slightly larger in some situations (like when rotating an outline  *)
  (*    which contains Bézier outside arcs).                               *)
  (*                                                                       *)
  (*    Computing the control box is very fast, while getting the bounding *)
  (*    box can take much more time as it needs to walk over all segments  *)
  (*    and arcs in the outline.  To get the latter, you can use the       *)
  (*    `ftbbox' component which is dedicated to this single task.         *)
  (*                                                                       *)
  (* <Input>                                                               *)
  (*    outline :: A pointer to the source outline descriptor.             *)
  (*                                                                       *)
  (* <Output>                                                              *)
  (*    acbox   :: The outline's control box.                              *)
  (*                                                                       *)
  procedure FT_Outline_Get_CBox(
                       outline: {const} PFT_Outline;
                       acbox: PFT_BBox);
    cdecl; external ft_lib name 'FT_Outline_Get_CBox';


  (*************************************************************************)
  (*                                                                       *)
  (* <Function>                                                            *)
  (*    FT_Outline_Translate                                               *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    Applies a simple translation to the points of an outline.          *)
  (*                                                                       *)
  (* <InOut>                                                               *)
  (*    outline :: A pointer to the target outline descriptor.             *)
  (*                                                                       *)
  (* <Input>                                                               *)
  (*    xOffset :: The horizontal offset.                                  *)
  (*                                                                       *)
  (*    yOffset :: The vertical offset.                                    *)
  (*                                                                       *)
  procedure FT_Outline_Translate(
                        outline: {const} PFT_Outline;
                        xOffset: FT_Pos;
                        yOffset: FT_Pos);
    cdecl; external ft_lib name 'FT_Outline_Translate';


  (*************************************************************************)
  (*                                                                       *)
  (* <Function>                                                            *)
  (*    FT_Outline_Copy                                                    *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    Copies an outline into another one.  Both objects must have the    *)
  (*    same sizes (number of points & number of contours) when this       *)
  (*    function is called.                                                *)
  (*                                                                       *)
  (* <Input>                                                               *)
  (*    source :: A handle to the source outline.                          *)
  (*                                                                       *)
  (* <Output>                                                              *)
  (*    target :: A handle to the target outline.                          *)
  (*                                                                       *)
  (* <Return>                                                              *)
  (*    FreeType error code.  0 means success.                             *)
  (*                                                                       *)
  function FT_Outline_Copy(
                   source: {const} PFT_Outline;
                   target: PFT_Outline): FT_Error;
    cdecl; external ft_lib name 'FT_Outline_Copy';


  (*************************************************************************)
  (*                                                                       *)
  (* <Function>                                                            *)
  (*    FT_Outline_Transform                                               *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    Applies a simple 2x2 matrix to all of an outline's points.  Useful *)
  (*    for applying rotations, slanting, flipping, etc.                   *)
  (*                                                                       *)
  (* <InOut>                                                               *)
  (*    outline :: A pointer to the target outline descriptor.             *)
  (*                                                                       *)
  (* <Input>                                                               *)
  (*    matrix  :: A pointer to the transformation matrix.                 *)
  (*                                                                       *)
  (* <Note>                                                                *)
  (*    You can use @FT_Outline_Translate if you need to translate the     *)
  (*    outline's points.                                                  *)
  (*                                                                       *)
  procedure FT_Outline_Transform(
                        outline: {const} PFT_Outline;
                        matrix:  {const} PFT_Matrix);
    cdecl; external ft_lib name 'FT_Outline_Transform';


  (*************************************************************************)
  (*                                                                       *)
  (* <Function>                                                            *)
  (*    FT_Outline_Embolden                                                *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    Emboldens an outline.  The new outline will be at most 4 times     *)
  (*    `strength' pixels wider and higher.  You may think of the left and *)
  (*    bottom borders as unchanged.                                       *)
  (*                                                                       *)
  (*    Negative `strength' values to reduce the outline thickness are     *)
  (*    possible also.                                                     *)
  (*                                                                       *)
  (* <InOut>                                                               *)
  (*    outline  :: A handle to the target outline.                        *)
  (*                                                                       *)
  (* <Input>                                                               *)
  (*    strength :: How strong the glyph is emboldened.  Expressed in      *)
  (*                26.6 pixel format.                                     *)
  (*                                                                       *)
  (* <Return>                                                              *)
  (*    FreeType error code.  0 means success.                             *)
  (*                                                                       *)
  (* <Note>                                                                *)
  (*    The used algorithm to increase or decrease the thickness of the    *)
  (*    glyph doesn't change the number of points; this means that certain *)
  (*    situations like acute angles or intersections are sometimes        *)
  (*    handled incorrectly.                                               *)
  (*                                                                       *)
  (*    Example call:                                                      *)
  (*                                                                       *)
  (*    {                                                                  *)
  (*      FT_Load_Glyph( face, index, FT_LOAD_DEFAULT );                   *)
  (*      if ( face->slot->format == FT_GLYPH_FORMAT_OUTLINE )             *)
  (*        FT_Outline_Embolden( &face->slot->outline, strength );         *)
  (*    }                                                                  *)
  (*                                                                       *)
  function FT_Outline_Embolden(
                       outline:  PFT_Outline;
                       strength: FT_Pos): FT_Error;
    cdecl; external ft_lib name 'FT_Outline_Embolden';


  (*************************************************************************)
  (*                                                                       *)
  (* <Function>                                                            *)
  (*    FT_Outline_Reverse                                                 *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    Reverses the drawing direction of an outline.  This is used to     *)
  (*    ensure consistent fill conventions for mirrored glyphs.            *)
  (*                                                                       *)
  (* <InOut>                                                               *)
  (*    outline :: A pointer to the target outline descriptor.             *)
  (*                                                                       *)
  (* <Note>                                                                *)
  (*    This functions toggles the bit flag @FT_OUTLINE_REVERSE_FILL in    *)
  (*    the outline's `flags' field.                                       *)
  (*                                                                       *)
  (*    It shouldn't be used by a normal client application, unless it     *)
  (*    knows what it is doing.                                            *)
  (*                                                                       *)
  procedure FT_Outline_Reverse( outline: PFT_Outline );
    cdecl; external ft_lib name 'FT_Outline_Reverse';


  (*************************************************************************)
  (*                                                                       *)
  (* <Function>                                                            *)
  (*    FT_Outline_Get_Bitmap                                              *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    Renders an outline within a bitmap.  The outline's image is simply *)
  (*    OR-ed to the target bitmap.                                        *)
  (*                                                                       *)
  (* <Input>                                                               *)
  (*    library :: A handle to a FreeType library object.                  *)
  (*                                                                       *)
  (*    outline :: A pointer to the source outline descriptor.             *)
  (*                                                                       *)
  (* <InOut>                                                               *)
  (*    abitmap :: A pointer to the target bitmap descriptor.              *)
  (*                                                                       *)
  (* <Return>                                                              *)
  (*    FreeType error code.  0 means success.                             *)
  (*                                                                       *)
  (* <Note>                                                                *)
  (*    This function does NOT CREATE the bitmap, it only renders an       *)
  (*    outline image within the one you pass to it!                       *)
  (*                                                                       *)
  (*    It will use the raster corresponding to the default glyph format.  *)
  (*                                                                       *)
  function FT_Outline_Get_Bitmap(
                         library_: FT_Library;
                         outline:  PFT_Outline;
                         abitmap:  {const} PFT_Bitmap): FT_Error;
    cdecl; external ft_lib name 'FT_Outline_Get_Bitmap';


  (*************************************************************************)
  (*                                                                       *)
  (* <Function>                                                            *)
  (*    FT_Outline_Render                                                  *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    Renders an outline within a bitmap using the current scan-convert. *)
  (*    This functions uses an @FT_Raster_Params structure as an argument, *)
  (*    allowing advanced features like direct composition, translucency,  *)
  (*    etc.                                                               *)
  (*                                                                       *)
  (* <Input>                                                               *)
  (*    library :: A handle to a FreeType library object.                  *)
  (*                                                                       *)
  (*    outline :: A pointer to the source outline descriptor.             *)
  (*                                                                       *)
  (* <InOut>                                                               *)
  (*    params  :: A pointer to an @FT_Raster_Params structure used to     *)
  (*               describe the rendering operation.                       *)
  (*                                                                       *)
  (* <Return>                                                              *)
  (*    FreeType error code.  0 means success.                             *)
  (*                                                                       *)
  (* <Note>                                                                *)
  (*    You should know what you are doing and how @FT_Raster_Params works *)
  (*    to use this function.                                              *)
  (*                                                                       *)
  (*    The field `params.source' will be set to `outline' before the scan *)
  (*    converter is called, which means that the value you give to it is  *)
  (*    actually ignored.                                                  *)
  (*                                                                       *)
  function FT_Outline_Render(
                     library_: FT_Library;
                     outline: PFT_Outline;
                     params:  PFT_Raster_Params): FT_Error;
    cdecl; external ft_lib name 'FT_Outline_Render';

{$ENDIF TYPE_DECL}

 (**************************************************************************
  *
  * @enum:
  *   FT_Orientation
  *
  * @description:
  *   A list of values used to describe an outline's contour orientation.
  *
  *   The TrueType and Postscript specifications use different conventions
  *   to determine whether outline contours should be filled or unfilled.
  *
  * @values:
  *   FT_ORIENTATION_TRUETYPE ::
  *     According to the TrueType specification, clockwise contours must
  *     be filled, and counter-clockwise ones must be unfilled.
  *
  *   FT_ORIENTATION_POSTSCRIPT ::
  *     According to the Postscript specification, counter-clockwise contours
  *     must be filled, and clockwise ones must be unfilled.
  *
  *   FT_ORIENTATION_FILL_RIGHT ::
  *     This is identical to @FT_ORIENTATION_TRUETYPE, but is used to
  *     remember that in TrueType, everything that is to the right of
  *     the drawing direction of a contour must be filled.
  *
  *   FT_ORIENTATION_FILL_LEFT ::
  *     This is identical to @FT_ORIENTATION_POSTSCRIPT, but is used to
  *     remember that in Postscript, everything that is to the left of
  *     the drawing direction of a contour must be filled.
  *
  *   FT_ORIENTATION_NONE ::
  *     The orientation cannot be determined.  That is, different parts of
  *     the glyph have different orientation.
  *
  *)
{$IFDEF TYPE_DECL}
  FT_Orientation = cint;
{$ELSE TYPE_DECL}
const
  FT_ORIENTATION_TRUETYPE   = 0;
  FT_ORIENTATION_POSTSCRIPT = 1;
  FT_ORIENTATION_FILL_RIGHT = FT_ORIENTATION_TRUETYPE;
  FT_ORIENTATION_FILL_LEFT  = FT_ORIENTATION_POSTSCRIPT;
  FT_ORIENTATION_NONE       = FT_ORIENTATION_FILL_LEFT+1;

 (**************************************************************************
  *
  * @function:
  *   FT_Outline_Get_Orientation
  *
  * @description:
  *   This function analyzes a glyph outline and tries to compute its
  *   fill orientation (see @FT_Orientation).  This is done by computing
  *   the direction of each global horizontal and/or vertical extrema
  *   within the outline.
  *
  *   Note that this will return @FT_ORIENTATION_TRUETYPE for empty
  *   outlines.
  *
  * @input:
  *   outline ::
  *     A handle to the source outline.
  *
  * @return:
  *   The orientation.
  *
  *)
  function FT_Outline_Get_Orientation( outline: PFT_Outline ): FT_Orientation;
    cdecl; external ft_lib name 'FT_Outline_Get_Orientation';

{$ENDIF TYPE_DECL}
  
