/***************************************************************************//*                                                                         *//*  ftoutln.h                                                              *//*                                                                         *//*    Support for the FT_Outline type used to store glyph shapes of        *//*    most scalable font formats (specification).                          *//*                                                                         *//*  Copyright 1996-2001, 2002 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.                                        *//*                                                                         *//***************************************************************************/#ifndef __FTOUTLN_H__#define __FTOUTLN_H__#include <ft2build.h>#include FT_FREETYPE_HFT_BEGIN_HEADER  /*************************************************************************/  /*                                                                       */  /* <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_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                                            */  /*                                                                       */  /*************************************************************************/  /*************************************************************************/  /*                                                                       */  /* <Function>                                                            */  /*    FT_Outline_Decompose                                               */  /*                                                                       */  /* <Description>                                                         */  /*    Walks over an outline's structure to decompose it into individual  */  /*    segments and Bezier 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 sucess.                              */  /*                                                                       */  FT_EXPORT( FT_Error )  FT_Outline_Decompose( FT_Outline*              outline,                        const FT_Outline_Funcs*  func_interface,                        void*                    user );  /*************************************************************************/  /*                                                                       */  /* <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.                             */  /*                                                                       */  FT_EXPORT( FT_Error )  FT_Outline_New( FT_Library   library,                  FT_UInt      numPoints,                  FT_Int       numContours,                  FT_Outline  *anoutline );  FT_EXPORT( FT_Error )  FT_Outline_New_Internal( FT_Memory    memory,                           FT_UInt      numPoints,                           FT_Int       numContours,                           FT_Outline  *anoutline );  /*************************************************************************/  /*                                                                       */  /* <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_Free().                                           */  /*                                                                       */  FT_EXPORT( FT_Error )  FT_Outline_Done( FT_Library   library,                   FT_Outline*  outline );  FT_EXPORT( FT_Error )  FT_Outline_Done_Internal( FT_Memory    memory,                            FT_Outline*  outline );  /*************************************************************************/  /*                                                                       */  /* <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.                             */  /*                                                                       */  FT_EXPORT( FT_Error )  FT_Outline_Check( FT_Outline*  outline );