kc3-lang/freetype/src/base/ftgloadr.c

• Show log

  Commit

• Hash : 80cfbd70
  Author :
  Date : 2003-12-26T07:26:08
  

  * src/base/fttrigon.c, src/base/ftgloadr.c: Inlude FT_INTERNAL_OBJECTS_H. * src/base/ftstroke.c (FT_Outline_GetInsideBorder, FT_Outline_GetOutsideBorder): s/or/o/ to make it compile with C++ compilers. * src/cache/ftcmru.c, include/freetype/cache/ftcmru.h: s/select/selection/ to avoid compiler warning. * src/cff/cffload.h: s/select/ftselect/ to avoid potential compiler warning. Formatting.

Download

• src/base/ftgloadr.c

• /***************************************************************************/
  /*                                                                         */
  /*  ftgloadr.c                                                             */
  /*                                                                         */
  /*    The FreeType glyph loader (body).                                    */
  /*                                                                         */
  /*  Copyright 2002, 2003 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.                                        */
  /*                                                                         */
  /***************************************************************************/
  
  
  #include <ft2build.h>
  #include FT_INTERNAL_GLYPH_LOADER_H
  #include FT_INTERNAL_MEMORY_H
  #include FT_INTERNAL_OBJECTS_H
  
  #undef  FT_COMPONENT
  #define FT_COMPONENT  trace_gloader
  
  
    /*************************************************************************/
    /*************************************************************************/
    /*************************************************************************/
    /*****                                                               *****/
    /*****                                                               *****/
    /*****                    G L Y P H   L O A D E R                    *****/
    /*****                                                               *****/
    /*****                                                               *****/
    /*************************************************************************/
    /*************************************************************************/
    /*************************************************************************/
  
    /*************************************************************************/
    /*                                                                       */
    /* The glyph loader is a simple object which is used to load a set of    */
    /* glyphs easily.  It is critical for the correct loading of composites. */
    /*                                                                       */
    /* Ideally, one can see it as a stack of abstract `glyph' objects.       */
    /*                                                                       */
    /*   loader.base     Is really the bottom of the stack.  It describes a  */
    /*                   single glyph image made of the juxtaposition of     */
    /*                   several glyphs (those `in the stack').              */
    /*                                                                       */
    /*   loader.current  Describes the top of the stack, on which a new      */
    /*                   glyph can be loaded.                                */
    /*                                                                       */
    /*   Rewind          Clears the stack.                                   */
    /*   Prepare         Set up `loader.current' for addition of a new glyph */
    /*                   image.                                              */
    /*   Add             Add the `current' glyph image to the `base' one,    */
    /*                   and prepare for another one.                        */
    /*                                                                       */
    /* The glyph loader is now a base object.  Each driver used to           */
    /* re-implement it in one way or the other, which wasted code and        */
    /* energy.                                                               */
    /*                                                                       */
    /*************************************************************************/
  
  
    /* create a new glyph loader */
    FT_BASE_DEF( FT_Error )
    FT_GlyphLoader_New( FT_Memory        memory,
                        FT_GlyphLoader  *aloader )
    {
      FT_GlyphLoader  loader;
      FT_Error        error;
  
  
      if ( !FT_NEW( loader ) )
      {
        loader->memory = memory;
        *aloader       = loader;
      }
      return error;
    }
  
  
    /* rewind the glyph loader - reset counters to 0 */
    FT_BASE_DEF( void )
    FT_GlyphLoader_Rewind( FT_GlyphLoader  loader )
    {
      FT_GlyphLoad  base    = &loader->base;
      FT_GlyphLoad  current = &loader->current;
  
  
      base->outline.n_points   = 0;
      base->outline.n_contours = 0;
      base->num_subglyphs      = 0;
  
      *current = *base;
    }
  
  
    /* reset the glyph loader, frees all allocated tables */
    /* and starts from zero                               */
    FT_BASE_DEF( void )
    FT_GlyphLoader_Reset( FT_GlyphLoader  loader )
    {
      FT_Memory memory = loader->memory;
  
  
      FT_FREE( loader->base.outline.points );
      FT_FREE( loader->base.outline.tags );
      FT_FREE( loader->base.outline.contours );
      FT_FREE( loader->base.extra_points );
      FT_FREE( loader->base.subglyphs );
  
      loader->max_points    = 0;
      loader->max_contours  = 0;
      loader->max_subglyphs = 0;
  
      FT_GlyphLoader_Rewind( loader );
    }
  
  
    /* delete a glyph loader */
    FT_BASE_DEF( void )
    FT_GlyphLoader_Done( FT_GlyphLoader  loader )
    {
      if ( loader )
      {
        FT_Memory memory = loader->memory;
  
  
        FT_GlyphLoader_Reset( loader );
        FT_FREE( loader );
      }
    }
  
  
    /* re-adjust the `current' outline fields */
    static void
    FT_GlyphLoader_Adjust_Points( FT_GlyphLoader  loader )
    {
      FT_Outline*  base    = &loader->base.outline;
      FT_Outline*  current = &loader->current.outline;
  
  
      current->points   = base->points   + base->n_points;
      current->tags     = base->tags     + base->n_points;
      current->contours = base->contours + base->n_contours;
  
      /* handle extra points table - if any */
      if ( loader->use_extra )
        loader->current.extra_points =
          loader->base.extra_points + base->n_points;
    }
  
  
    FT_BASE_DEF( FT_Error )
    FT_GlyphLoader_CreateExtra( FT_GlyphLoader  loader )
    {
      FT_Error   error;
      FT_Memory  memory = loader->memory;
  
  
      if ( !FT_NEW_ARRAY( loader->base.extra_points, loader->max_points ) )
      {
        loader->use_extra = 1;
        FT_GlyphLoader_Adjust_Points( loader );
      }
      return error;
    }
  
  
    /* re-adjust the `current' subglyphs field */
    static void
    FT_GlyphLoader_Adjust_Subglyphs( FT_GlyphLoader  loader )
    {
      FT_GlyphLoad  base    = &loader->base;
      FT_GlyphLoad  current = &loader->current;
  
  
      current->subglyphs = base->subglyphs + base->num_subglyphs;
    }
  
  
    /* Ensure that we can add `n_points' and `n_contours' to our glyph. this */
    /* function reallocates its outline tables if necessary.  Note that it   */
    /* DOESN'T change the number of points within the loader!                */
    /*                                                                       */
    FT_BASE_DEF( FT_Error )
    FT_GlyphLoader_CheckPoints( FT_GlyphLoader  loader,
                                 FT_UInt        n_points,
                                 FT_UInt        n_contours )
    {
      FT_Memory    memory  = loader->memory;
      FT_Error     error   = FT_Err_Ok;
      FT_Outline*  base    = &loader->base.outline;
      FT_Outline*  current = &loader->current.outline;
      FT_Bool      adjust  = 1;
  
      FT_UInt      new_max, old_max;
  
  
      /* check points & tags */
      new_max = base->n_points + current->n_points + n_points;
      old_max = loader->max_points;
  
      if ( new_max > old_max )
      {
        new_max = FT_PAD_CEIL( new_max, 8 );
  
        if ( FT_RENEW_ARRAY( base->points, old_max, new_max ) ||
             FT_RENEW_ARRAY( base->tags,   old_max, new_max ) )
          goto Exit;
  
        if ( loader->use_extra &&
             FT_RENEW_ARRAY( loader->base.extra_points, old_max, new_max ) )
          goto Exit;
  
        adjust = 1;
        loader->max_points = new_max;
      }
  
      /* check contours */
      old_max = loader->max_contours;
      new_max = base->n_contours + current->n_contours +
                n_contours;
      if ( new_max > old_max )
      {
        new_max = FT_PAD_CEIL( new_max, 4 );
        if ( FT_RENEW_ARRAY( base->contours, old_max, new_max ) )
          goto Exit;
  
        adjust = 1;
        loader->max_contours = new_max;
      }
  
      if ( adjust )
        FT_GlyphLoader_Adjust_Points( loader );
  
    Exit:
      return error;
    }
  
  
    /* Ensure that we can add `n_subglyphs' to our glyph. this function */
    /* reallocates its subglyphs table if necessary.  Note that it DOES */
    /* NOT change the number of subglyphs within the loader!            */
    /*                                                                  */
    FT_BASE_DEF( FT_Error )
    FT_GlyphLoader_CheckSubGlyphs( FT_GlyphLoader  loader,
                                   FT_UInt         n_subs )
    {
      FT_Memory     memory = loader->memory;
      FT_Error      error  = FT_Err_Ok;
      FT_UInt       new_max, old_max;
  
      FT_GlyphLoad  base    = &loader->base;
      FT_GlyphLoad  current = &loader->current;
  
  
      new_max = base->num_subglyphs + current->num_subglyphs + n_subs;
      old_max = loader->max_subglyphs;
      if ( new_max > old_max )
      {
        new_max = FT_PAD_CEIL( new_max, 2 );
        if ( FT_RENEW_ARRAY( base->subglyphs, old_max, new_max ) )
          goto Exit;
  
        loader->max_subglyphs = new_max;
  
        FT_GlyphLoader_Adjust_Subglyphs( loader );
      }
  
    Exit:
      return error;
    }
  
  
    /* prepare loader for the addition of a new glyph on top of the base one */
    FT_BASE_DEF( void )
    FT_GlyphLoader_Prepare( FT_GlyphLoader  loader )
    {
      FT_GlyphLoad  current = &loader->current;
  
  
      current->outline.n_points   = 0;
      current->outline.n_contours = 0;
      current->num_subglyphs      = 0;
  
      FT_GlyphLoader_Adjust_Points   ( loader );
      FT_GlyphLoader_Adjust_Subglyphs( loader );
    }
  
  
    /* add current glyph to the base image - and prepare for another */
    FT_BASE_DEF( void )
    FT_GlyphLoader_Add( FT_GlyphLoader  loader )
    {
      FT_GlyphLoad  base    = &loader->base;
      FT_GlyphLoad  current = &loader->current;
  
      FT_UInt       n_curr_contours = current->outline.n_contours;
      FT_UInt       n_base_points   = base->outline.n_points;
      FT_UInt       n;
  
  
      base->outline.n_points =
        (short)( base->outline.n_points + current->outline.n_points );
      base->outline.n_contours =
        (short)( base->outline.n_contours + current->outline.n_contours );
  
      base->num_subglyphs += current->num_subglyphs;
  
      /* adjust contours count in newest outline */
      for ( n = 0; n < n_curr_contours; n++ )
        current->outline.contours[n] =
          (short)( current->outline.contours[n] + n_base_points );
  
      /* prepare for another new glyph image */
      FT_GlyphLoader_Prepare( loader );
    }
  
  
    FT_BASE_DEF( FT_Error )
    FT_GlyphLoader_CopyPoints( FT_GlyphLoader  target,
                               FT_GlyphLoader  source )
    {
      FT_Error  error;
      FT_UInt   num_points   = source->base.outline.n_points;
      FT_UInt   num_contours = source->base.outline.n_contours;
  
  
      error = FT_GlyphLoader_CheckPoints( target, num_points, num_contours );
      if ( !error )
      {
        FT_Outline*  out = &target->base.outline;
        FT_Outline*  in  = &source->base.outline;
  
  
        FT_MEM_COPY( out->points, in->points,
                     num_points * sizeof ( FT_Vector ) );
        FT_MEM_COPY( out->tags, in->tags,
                     num_points * sizeof ( char ) );
        FT_MEM_COPY( out->contours, in->contours,
                     num_contours * sizeof ( short ) );
  
        /* do we need to copy the extra points? */
        if ( target->use_extra && source->use_extra )
          FT_MEM_COPY( target->base.extra_points, source->base.extra_points,
                       num_points * sizeof ( FT_Vector ) );
  
        out->n_points   = (short)num_points;
        out->n_contours = (short)num_contours;
  
        FT_GlyphLoader_Adjust_Points( target );
      }
  
      return error;
    }
  
  
  /* END */
  

Download