/***************************************************************************//*                                                                         *//*  ftoutln.c                                                              *//*                                                                         *//*    FreeType outline management (body).                                  *//*                                                                         *//*  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.                                        *//*                                                                         *//***************************************************************************/  /*************************************************************************/  /*                                                                       */  /* All functions are declared in freetype.h.                             */  /*                                                                       */  /*************************************************************************/#include <ft2build.h>#include FT_OUTLINE_H#include FT_INTERNAL_OBJECTS_H  /*************************************************************************/  /*                                                                       */  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */  /* messages during execution.                                            */  /*                                                                       */#undef  FT_COMPONENT#define FT_COMPONENT  trace_outline  static  const FT_Outline  null_outline = { 0, 0, 0, 0, 0, 0 };  /* documentation is in ftoutln.h */  FT_EXPORT_DEF( FT_Error )  FT_Outline_Decompose( FT_Outline*              outline,                        const FT_Outline_Funcs*  func_interface,                        void*                    user )  {#undef SCALED#define SCALED( x )  ( ( (x) << shift ) - delta )    FT_Vector   v_last;    FT_Vector   v_control;    FT_Vector   v_start;    FT_Vector*  point;    FT_Vector*  limit;    char*       tags;    FT_Error    error;    FT_Int   n;         /* index of contour in outline     */    FT_UInt  first;     /* index of first point in contour */    FT_Int   tag;       /* current point's state           */    FT_Int   shift;    FT_Pos   delta;    if ( !outline || !func_interface )      return FT_Err_Invalid_Argument;    shift = func_interface->shift;    delta = func_interface->delta;    first = 0;    for ( n = 0; n < outline->n_contours; n++ )    {      FT_Int  last;  /* index of last point in contour */      last  = outline->contours[n];      limit = outline->points + last;      v_start = outline->points[first];      v_last  = outline->points[last];      v_start.x = SCALED( v_start.x ); v_start.y = SCALED( v_start.y );      v_last.x  = SCALED( v_last.x );  v_last.y  = SCALED( v_last.y );      v_control = v_start;      point = outline->points + first;      tags  = outline->tags  + first;      tag   = FT_CURVE_TAG( tags[0] );      /* A contour cannot start with a cubic control point! */      if ( tag == FT_Curve_Tag_Cubic )        goto Invalid_Outline;      /* check first point to determine origin */      if ( tag == FT_Curve_Tag_Conic )      {        /* first point is conic control.  Yes, this happens. */        if ( FT_CURVE_TAG( outline->tags[last] ) == FT_Curve_Tag_On )        {          /* start at last point if it is on the curve */          v_start = v_last;          limit--;        }        else        {          /* if both first and last points are conic,         */          /* start at their middle and record its position    */          /* for closure                                      */          v_start.x = ( v_start.x + v_last.x ) / 2;          v_start.y = ( v_start.y + v_last.y ) / 2;          v_last = v_start;        }        point--;        tags--;      }      error = func_interface->move_to( &v_start, user );      if ( error )        goto Exit;      while ( point < limit )      {        point++;        tags++;        tag = FT_CURVE_TAG( tags[0] );        switch ( tag )        {        case FT_Curve_Tag_On:  /* emit a single line_to */          {            FT_Vector  vec;            vec.x = SCALED( point->x );            vec.y = SCALED( point->y );            error = func_interface->line_to( &vec, user );            if ( error )              goto Exit;            continue;          }        case FT_Curve_Tag_Conic:  /* consume conic arcs */          v_control.x = SCALED( point->x );          v_control.y = SCALED( point->y );        Do_Conic:          if ( point < limit )          {            FT_Vector  vec;            FT_Vector  v_middle;            point++;            tags++;            tag = FT_CURVE_TAG( tags[0] );            vec.x = SCALED( point->x );            vec.y = SCALED( point->y );            if ( tag == FT_Curve_Tag_On )            {              error = func_interface->conic_to( &v_control, &vec, user );              if ( error )                goto Exit;              continue;            }            if ( tag != FT_Curve_Tag_Conic )              goto Invalid_Outline;            v_middle.x = ( v_control.x + vec.x ) / 2;            v_middle.y = ( v_control.y + vec.y ) / 2;            error = func_interface->conic_to( &v_control, &v_middle, user );            if ( error )              goto Exit;            v_control = vec;            goto Do_Conic;          }          error = func_interface->conic_to( &v_control, &v_start, user );          goto Close;        default:  /* FT_Curve_Tag_Cubic */          {            FT_Vector  vec1, vec2;            if ( point + 1 > limit                             ||                 FT_CURVE_TAG( tags[1] ) != FT_Curve_Tag_Cubic )              goto Invalid_Outline;            point += 2;            tags  += 2;            vec1.x = SCALED( point[-2].x ); vec1.y = SCALED( point[-2].y );            vec2.x = SCALED( point[-1].x ); vec2.y = SCALED( point[-1].y );            if ( point <= limit )            {              FT_Vector  vec;              vec.x = SCALED( point->x );              vec.y = SCALED( point->y );              error = func_interface->cubic_to( &vec1, &vec2, &vec, user );              if ( error )                goto Exit;              continue;            }            error = func_interface->cubic_to( &vec1, &vec2, &v_start, user );            goto Close;          }        }      }      /* close the contour with a line segment */      error = func_interface->line_to( &v_start, user );    Close:      if ( error )        goto Exit;      first = last + 1;    }    return 0;  Exit:    return error;  Invalid_Outline:    return FT_Err_Invalid_Outline;  }  FT_EXPORT_DEF( FT_Error )  FT_Outline_New_Internal( FT_Memory    memory,                           FT_UInt      numPoints,                           FT_Int       numContours,                           FT_Outline  *anoutline )  {    FT_Error  error;    if ( !anoutline || !memory )      return FT_Err_Invalid_Argument;    *anoutline = null_outline;    if ( FT_NEW_ARRAY( anoutline->points,   numPoints * 2L ) ||         FT_NEW_ARRAY( anoutline->tags,     numPoints      ) ||         FT_NEW_ARRAY( anoutline->contours, numContours    ) )      goto Fail;    anoutline->n_points    = (FT_UShort)numPoints;    anoutline->n_contours  = (FT_Short)numContours;    anoutline->flags      |= ft_outline_owner;    return FT_Err_Ok;  Fail:    anoutline->flags |= ft_outline_owner;    FT_Outline_Done_Internal( memory, anoutline );    return error;  }  /* documentation is in ftoutln.h */  FT_EXPORT_DEF( FT_Error )  FT_Outline_New( FT_Library   library,                  FT_UInt      numPoints,                  FT_Int       numContours,                  FT_Outline  *anoutline )  {    if ( !library )      return FT_Err_Invalid_Library_Handle;    return FT_Outline_New_Internal( library->memory, numPoints,                                    numContours, anoutline );  }  /* documentation is in ftoutln.h */  FT_EXPORT_DEF( FT_Error )  FT_Outline_Check( FT_Outline*  outline )  {    if ( outline )    {      FT_Int  n_points   = outline->n_points;      FT_Int  n_contours = outline->n_contours;      FT_Int  end0, end;      FT_Int  n;      /* empty glyph? */      if ( n_points == 0 && n_contours == 0 )        return 0;      /* check point and contour counts */      if ( n_points <= 0 || n_contours <= 0 )        goto Bad;      end0 = end = -1;      for ( n = 0; n < n_contours; n++ )      {        end = outline->contours[n];        /* note that we don't accept empty contours */        if ( end <= end0 || end >= n_points )          goto Bad;