while ( p < q )        {          swap = *p;          *p   = *q;          *q   = swap;          p++;          q--;        }      }      /* reverse tags table */      {        char*  p = outline->tags + first;        char*  q = outline->tags + last;        char   swap;        while ( p < q )        {          swap = *p;          *p   = *q;          *q   = swap;          p++;          q--;        }      }      first = last + 1;    }    outline->flags ^= FT_OUTLINE_REVERSE_FILL;  }  /* documentation is in ftoutln.h */  FT_EXPORT_DEF( FT_Error )  FT_Outline_Render( FT_Library         library,                     FT_Outline*        outline,                     FT_Raster_Params*  params )  {    FT_Error     error;    FT_Bool      update = 0;    FT_Renderer  renderer;    FT_ListNode  node;    if ( !library )      return FT_Err_Invalid_Library_Handle;    if ( !outline || !params )      return FT_Err_Invalid_Argument;    renderer = library->cur_renderer;    node     = library->renderers.head;    params->source = (void*)outline;    error = FT_Err_Cannot_Render_Glyph;    while ( renderer )    {      error = renderer->raster_render( renderer->raster, params );      if ( !error || FT_ERROR_BASE( error ) != FT_Err_Cannot_Render_Glyph )        break;      /* FT_Err_Cannot_Render_Glyph is returned if the render mode   */      /* is unsupported by the current renderer for this glyph image */      /* format                                                      */      /* now, look for another renderer that supports the same */      /* format                                                */      renderer = FT_Lookup_Renderer( library, FT_GLYPH_FORMAT_OUTLINE,                                     &node );      update   = 1;    }    /* if we changed the current renderer for the glyph image format */    /* we need to select it as the next current one                  */    if ( !error && update && renderer )      FT_Set_Renderer( library, renderer, 0, 0 );    return error;  }  /* documentation is in ftoutln.h */  FT_EXPORT_DEF( FT_Error )  FT_Outline_Get_Bitmap( FT_Library        library,                         FT_Outline*       outline,                         const FT_Bitmap  *abitmap )  {    FT_Raster_Params  params;    if ( !abitmap )      return FT_Err_Invalid_Argument;    /* other checks are delayed to FT_Outline_Render() */    params.target = abitmap;    params.flags  = 0;    if ( abitmap->pixel_mode == FT_PIXEL_MODE_GRAY  ||         abitmap->pixel_mode == FT_PIXEL_MODE_LCD   ||         abitmap->pixel_mode == FT_PIXEL_MODE_LCD_V )      params.flags |= FT_RASTER_FLAG_AA;    return FT_Outline_Render( library, outline, &params );  }  /* documentation is in ftoutln.h */  FT_EXPORT_DEF( void )  FT_Vector_Transform( FT_Vector*        vector,                       const FT_Matrix*  matrix )  {    FT_Pos xz, yz;    if ( !vector || !matrix )      return;    xz = FT_MulFix( vector->x, matrix->xx ) +         FT_MulFix( vector->y, matrix->xy );    yz = FT_MulFix( vector->x, matrix->yx ) +         FT_MulFix( vector->y, matrix->yy );    vector->x = xz;    vector->y = yz;  }  /* documentation is in ftoutln.h */  FT_EXPORT_DEF( void )  FT_Outline_Transform( const FT_Outline*  outline,                        const FT_Matrix*   matrix )  {    FT_Vector*  vec;    FT_Vector*  limit;    if ( !outline || !matrix )      return;    vec   = outline->points;    limit = vec + outline->n_points;    for ( ; vec < limit; vec++ )      FT_Vector_Transform( vec, matrix );  }#if 0#define FT_OUTLINE_GET_CONTOUR( outline, c, first, last )  \  do {                                                     \    (first) = ( c > 0 ) ? (outline)->points +              \                            (outline)->contours[c - 1] + 1 \                        : (outline)->points;               \    (last) = (outline)->points + (outline)->contours[c];   \  } while ( 0 )  /* Is a point in some contour?                     */  /*                                                 */  /* We treat every point of the contour as if it    */  /* it were ON.  That is, we allow false positives, */  /* but disallow false negatives.  (XXX really?)    */  static FT_Bool  ft_contour_has( FT_Outline*  outline,                  FT_Short     c,                  FT_Vector*   point )  {    FT_Vector*  first;    FT_Vector*  last;    FT_Vector*  a;    FT_Vector*  b;    FT_UInt     n = 0;    FT_OUTLINE_GET_CONTOUR( outline, c, first, last );    for ( a = first; a <= last; a++ )    {      FT_Pos  x;      FT_Int  intersect;      b = ( a == last ) ? first : a + 1;      intersect = ( a->y - point->y ) ^ ( b->y - point->y );      /* a and b are on the same side */      if ( intersect >= 0 )      {        if ( intersect == 0 && a->y == point->y )        {          if ( ( a->x <= point->x && b->x >= point->x ) ||               ( a->x >= point->x && b->x <= point->x ) )            return 1;        }        continue;      }      x = a->x + ( b->x - a->x ) * (point->y - a->y ) / ( b->y - a->y );      if ( x < point->x )        n++;      else if ( x == point->x )        return 1;    }    return ( n % 2 );  }    static FT_Bool  ft_contour_enclosed( FT_Outline*  outline,                       FT_UShort    c )  {    FT_Vector*  first;    FT_Vector*  last;    FT_Short    i;    FT_OUTLINE_GET_CONTOUR( outline, c, first, last );    for ( i = 0; i < outline->n_contours; i++ )    {      if ( i != c && ft_contour_has( outline, i, first ) )      {        FT_Vector*  pt;        for ( pt = first + 1; pt <= last; pt++ )          if ( !ft_contour_has( outline, i, pt ) )            return 0;        return 1;      }    }    return 0;  }  /* This version differs from the public one in that each */  /* part (contour not enclosed in another contour) of the */  /* outline is checked for orientation.  This is          */  /* necessary for some buggy CJK fonts.                   */  static FT_Orientation  ft_outline_get_orientation( FT_Outline*  outline )  {    FT_Short        i;    FT_Vector*      first;    FT_Vector*      last;    FT_Orientation  orient = FT_ORIENTATION_NONE;    first = outline->points;    for ( i = 0; i < outline->n_contours; i++, first = last + 1 )    {      FT_Vector*  point;      FT_Vector*  xmin_point;      FT_Pos      xmin;      last = outline->points + outline->contours[i];      /* skip degenerate contours */      if ( last < first + 2 )        continue;      if ( ft_contour_enclosed( outline, i ) )        continue;      xmin       = first->x;      xmin_point = first;      for ( point = first + 1; point <= last; point++ )      {        if ( point->x < xmin )        {          xmin       = point->x;          xmin_point = point;        }      }      /* check the orientation of the contour */      {        FT_Vector*      prev;        FT_Vector*      next;        FT_Orientation  o;        prev = ( xmin_point == first ) ? last : xmin_point - 1;        next = ( xmin_point == last ) ? first : xmin_point + 1;        if ( FT_Atan2( prev->x - xmin_point->x, prev->y - xmin_point->y ) >             FT_Atan2( next->x - xmin_point->x, next->y - xmin_point->y ) )          o = FT_ORIENTATION_POSTSCRIPT;        else          o = FT_ORIENTATION_TRUETYPE;        if ( orient == FT_ORIENTATION_NONE )          orient = o;        else if ( orient != o )          return FT_ORIENTATION_NONE;      }    }    return orient;  }#endif /* 0 */  /* documentation is in ftoutln.h */  FT_EXPORT_DEF( FT_Error )  FT_Outline_Embolden( FT_Outline*  outline,                       FT_Pos       strength )  {    FT_Vector*  points;    FT_Vector   v_prev, v_first, v_next, v_cur;    FT_Angle    rotate, angle_in, angle_out;    FT_Int      c, n, first;    FT_Int      orientation;    if ( !outline )      return FT_Err_Invalid_Argument;    strength /= 2;    if ( strength == 0 )      return FT_Err_Ok;    orientation = FT_Outline_Get_Orientation( outline );    if ( orientation == FT_ORIENTATION_NONE )    {      if ( outline->n_contours )        return FT_Err_Invalid_Argument;      else        return FT_Err_Ok;    }    if ( orientation == FT_ORIENTATION_TRUETYPE )      rotate = -FT_ANGLE_PI2;    else      rotate = FT_ANGLE_PI2;    points = outline->points;    first = 0;    for ( c = 0; c < outline->n_contours; c++ )    {      int  last = outline->contours[c];      v_first = points[first];      v_prev  = points[last];      v_cur   = v_first;      for ( n = first; n <= last; n++ )      {        FT_Vector  in, out;        FT_Angle   angle_diff;        FT_Pos     d;        FT_Fixed   scale;        if ( n < last )          v_next = points[n + 1];        else          v_next = v_first;        /* compute the in and out vectors */        in.x = v_cur.x - v_prev.x;        in.y = v_cur.y - v_prev.y;        out.x = v_next.x - v_cur.x;        out.y = v_next.y - v_cur.y;        angle_in   = FT_Atan2( in.x, in.y );        angle_out  = FT_Atan2( out.x, out.y );        angle_diff = FT_Angle_Diff( angle_in, angle_out );        scale      = FT_Cos( angle_diff / 2 );        if ( scale < 0x4000L && scale > -0x4000L )          in.x = in.y = 0;        else        {          d = FT_DivFix( strength, scale );          FT_Vector_From_Polar( &in, d, angle_in + angle_diff / 2 - rotate );        }        outline->points[n].x = v_cur.x + strength + in.x;        outline->points[n].y = v_cur.y + strength + in.y;        v_prev = v_cur;        v_cur  = v_next;      }      first = last + 1;    }    return FT_Err_Ok;  }  /* documentation is in ftoutln.h */  FT_EXPORT_DEF( FT_Orientation )  FT_Outline_Get_Orientation( FT_Outline*  outline )  {    FT_Pos      xmin       = 32768L;    FT_Vector*  xmin_point = NULL;    FT_Vector*  xmin_first = NULL;    FT_Vector*  xmin_last  = NULL;    short*      contour;    FT_Vector*  first;    FT_Vector*  last;    FT_Vector*  prev;    FT_Vector*  next;    if ( !outline || outline->n_points <= 0 )      return FT_ORIENTATION_TRUETYPE;    first = outline->points;    for ( contour = outline->contours;          contour < outline->contours + outline->n_contours;          contour++, first = last + 1 )    {      FT_Vector*  point;      FT_Int      on_curve;      FT_Int      on_curve_count = 0;      FT_Pos      tmp_xmin       = 32768L;      FT_Vector*  tmp_xmin_point = NULL;      last = outline->points + *contour;      /* skip degenerate contours */      if ( last < first + 2 )        continue;      for ( point = first; point <= last; ++point )      {        /* Count on-curve points.  If there are less than 3 on-curve */        /* points, just bypass this contour.                         */        on_curve        = outline->tags[point - outline->points] & 1;        on_curve_count += on_curve;        if ( point->x < tmp_xmin && on_curve )        {          tmp_xmin       = point->x;          tmp_xmin_point = point;        }      }      if ( on_curve_count > 2 && tmp_xmin < xmin )      {        xmin       = tmp_xmin;        xmin_point = tmp_xmin_point;        xmin_first = first;        xmin_last  = last;      }    }    if ( !xmin_point )      return FT_ORIENTATION_TRUETYPE;    prev = ( xmin_point == xmin_first ) ? xmin_last : xmin_point - 1;    next = ( xmin_point == xmin_last ) ? xmin_first : xmin_point + 1;    /* Skip off-curve points */    while ( ( outline->tags[prev - outline->points] & 1 ) == 0 )    {      if ( prev == xmin_first )        prev = xmin_last;      else        --prev;    }    while ( ( outline->tags[next - outline->points] & 1 ) == 0 )    {      if ( next == xmin_last )        next = xmin_first;      else        ++next;    }    if ( FT_Atan2( prev->x - xmin_point->x, prev->y - xmin_point->y ) >         FT_Atan2( next->x - xmin_point->x, next->y - xmin_point->y ) )      return FT_ORIENTATION_POSTSCRIPT;    else      return FT_ORIENTATION_TRUETYPE;  }/* END */