ftcmanag.c

下载来的一个看图软件的源代码

/***************************************************************************/
/*                                                                         */
/*  ftcmanag.c                                                             */
/*                                                                         */
/*    FreeType Cache Manager (body).                                       */
/*                                                                         */
/*  Copyright 2000-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.                                        */
/*                                                                         */
/***************************************************************************/


#include <ft2build.h>
#include FT_CACHE_H
#include FT_CACHE_MANAGER_H
#include FT_CACHE_INTERNAL_LRU_H
#include FT_INTERNAL_OBJECTS_H
#include FT_INTERNAL_DEBUG_H
#include FT_SIZES_H

#include "ftcerror.h"


#undef  FT_COMPONENT
#define FT_COMPONENT  trace_cache

#define FTC_LRU_GET_MANAGER( lru )  ( (FTC_Manager)(lru)->user_data )


  /*************************************************************************/
  /*************************************************************************/
  /*****                                                               *****/
  /*****                    FACE LRU IMPLEMENTATION                    *****/
  /*****                                                               *****/
  /*************************************************************************/
  /*************************************************************************/

  typedef struct FTC_FaceNodeRec_*  FTC_FaceNode;
  typedef struct FTC_SizeNodeRec_*  FTC_SizeNode;


  typedef struct  FTC_FaceNodeRec_
  {
    FT_LruNodeRec  lru;
    FT_Face        face;

  } FTC_FaceNodeRec;


  typedef struct  FTC_SizeNodeRec_
  {
    FT_LruNodeRec  lru;
    FT_Size        size;

  } FTC_SizeNodeRec;


  FT_CALLBACK_DEF( FT_Error )
  ftc_face_node_init( FTC_FaceNode  node,
                      FTC_FaceID    face_id,
                      FTC_Manager   manager )
  {
    FT_Error  error;


    error = manager->request_face( face_id,
                                   manager->library,
                                   manager->request_data,
                                   &node->face );
    if ( !error )
    {
      /* destroy initial size object; it will be re-created later */
      if ( node->face->size )
        FT_Done_Size( node->face->size );
    }

    return error;
  }


  /* helper function for ftc_face_node_done() */
  FT_CALLBACK_DEF( FT_Bool )
  ftc_size_node_select( FTC_SizeNode  node,
                        FT_Face       face )
  {
    return FT_BOOL( node->size->face == face );
  }


  FT_CALLBACK_DEF( void )
  ftc_face_node_done( FTC_FaceNode  node,
                      FTC_Manager   manager )
  {
    FT_Face  face    = node->face;


    /* we must begin by removing all sizes for the target face */
    /* from the manager's list                                 */
    FT_LruList_Remove_Selection( manager->sizes_list,
                                 (FT_LruNode_SelectFunc)ftc_size_node_select,
                                 face );

    /* all right, we can discard the face now */
    FT_Done_Face( face );
    node->face = NULL;
  }


  FT_CALLBACK_TABLE_DEF
  const FT_LruList_ClassRec  ftc_face_list_class =
  {
    sizeof ( FT_LruListRec ),
    (FT_LruList_InitFunc)0,
    (FT_LruList_DoneFunc)0,

    sizeof ( FTC_FaceNodeRec ),
    (FT_LruNode_InitFunc)   ftc_face_node_init,
    (FT_LruNode_DoneFunc)   ftc_face_node_done,
    (FT_LruNode_FlushFunc)  0,  /* no flushing needed                      */
    (FT_LruNode_CompareFunc)0,  /* direct comparison of FTC_FaceID handles */
  };


  /* documentation is in ftcache.h */

  FT_EXPORT_DEF( FT_Error )
  FTC_Manager_Lookup_Face( FTC_Manager  manager,
                           FTC_FaceID   face_id,
                           FT_Face     *aface )
  {
    FT_Error      error;
    FTC_FaceNode  node;


    if ( aface == NULL )
      return FTC_Err_Bad_Argument;

    *aface = NULL;

    if ( !manager )
      return FTC_Err_Invalid_Cache_Handle;

    error = FT_LruList_Lookup( manager->faces_list,
                               (FT_LruKey)face_id,
                               (FT_LruNode*)&node );
    if ( !error )
      *aface = node->face;

    return error;
  }


  /*************************************************************************/
  /*************************************************************************/
  /*****                                                               *****/
  /*****                      SIZES LRU IMPLEMENTATION                 *****/
  /*****                                                               *****/
  /*************************************************************************/
  /*************************************************************************/


  typedef struct  FTC_SizeQueryRec_
  {
    FT_Face  face;
    FT_UInt  width;
    FT_UInt  height;

  } FTC_SizeQueryRec, *FTC_SizeQuery;


  FT_CALLBACK_DEF( FT_Error )
  ftc_size_node_init( FTC_SizeNode   node,
                      FTC_SizeQuery  query )
  {
    FT_Face   face = query->face;
    FT_Size   size;
    FT_Error  error;


    node->size = NULL;
    error = FT_New_Size( face, &size );
    if ( !error )
    {
      FT_Activate_Size( size );
      error = FT_Set_Pixel_Sizes( query->face,
                                  query->width,
                                  query->height );
      if ( error )
        FT_Done_Size( size );
      else
        node->size = size;
    }
    return error;
  }


  FT_CALLBACK_DEF( void )
  ftc_size_node_done( FTC_SizeNode  node )
  {
    if ( node->size )
    {
      FT_Done_Size( node->size );
      node->size = NULL;
    }
  }


  FT_CALLBACK_DEF( FT_Error )
  ftc_size_node_flush( FTC_SizeNode   node,
                       FTC_SizeQuery  query )
  {
    FT_Size   size = node->size;
    FT_Error  error;


    if ( size->face == query->face )
    {
      FT_Activate_Size( size );
      error = FT_Set_Pixel_Sizes( query->face, query->width, query->height );
      if ( error )
      {
        FT_Done_Size( size );
        node->size = NULL;
      }
    }
    else
    {
      FT_Done_Size( size );
      node->size = NULL;

      error = ftc_size_node_init( node, query );
    }
    return error;
  }


  FT_CALLBACK_DEF( FT_Bool )
  ftc_size_node_compare( FTC_SizeNode   node,
                         FTC_SizeQuery  query )
  {
    FT_Size  size = node->size;


    return FT_BOOL( size->face                    == query->face   &&
                    (FT_UInt)size->metrics.x_ppem == query->width  &&
                    (FT_UInt)size->metrics.y_ppem == query->height );
  }


  FT_CALLBACK_TABLE_DEF
  const FT_LruList_ClassRec  ftc_size_list_class =
  {
    sizeof ( FT_LruListRec ),
    (FT_LruList_InitFunc)0,
    (FT_LruList_DoneFunc)0,

    sizeof ( FTC_SizeNodeRec ),
    (FT_LruNode_InitFunc)   ftc_size_node_init,
    (FT_LruNode_DoneFunc)   ftc_size_node_done,
    (FT_LruNode_FlushFunc)  ftc_size_node_flush,
    (FT_LruNode_CompareFunc)ftc_size_node_compare
  };


  /* documentation is in ftcache.h */

  FT_EXPORT_DEF( FT_Error )
  FTC_Manager_Lookup_Size( FTC_Manager  manager,
                           FTC_Font     font,
                           FT_Face     *aface,
                           FT_Size     *asize )
  {
    FT_Error  error;


    /* check for valid `manager' delayed to FTC_Manager_Lookup_Face() */
    if ( aface )
      *aface = 0;

    if ( asize )
      *asize = 0;

    error = FTC_Manager_Lookup_Face( manager, font->face_id, aface );
    if ( !error )
    {
      FTC_SizeQueryRec  query;
      FTC_SizeNode      node;


      query.face   = *aface;
      query.width  = font->pix_width;
      query.height = font->pix_height;

      error = FT_LruList_Lookup( manager->sizes_list,
                                 (FT_LruKey)&query,
                                 (FT_LruNode*)&node );
      if ( !error )
      {
        /* select the size as the current one for this face */
        FT_Activate_Size( node->size );

        if ( asize )
          *asize = node->size;
      }
    }

    return error;
  }


  /*************************************************************************/
  /*************************************************************************/
  /*****                                                               *****/
  /*****                    SET TABLE MANAGEMENT                       *****/
  /*****                                                               *****/
  /*************************************************************************/
  /*************************************************************************/

  static void
  ftc_family_table_init( FTC_FamilyTable  table )
  {
    table->count   = 0;
    table->size    = 0;
    table->entries = NULL;
    table->free    = FTC_FAMILY_ENTRY_NONE;
  }


  static void
  ftc_family_table_done( FTC_FamilyTable  table,
                         FT_Memory        memory )
  {
    FT_FREE( table->entries );
    table->free  = 0;
    table->count = 0;
    table->size  = 0;
  }


  FT_EXPORT_DEF( FT_Error )
  ftc_family_table_alloc( FTC_FamilyTable   table,
                          FT_Memory         memory,
                          FTC_FamilyEntry  *aentry )
  {
    FTC_FamilyEntry  entry;
    FT_Error         error = 0;


    /* re-allocate table size when needed */
    if ( table->free == FTC_FAMILY_ENTRY_NONE && table->count >= table->size )
    {
      FT_UInt  old_size = table->size;
      FT_UInt  new_size, idx;


      if ( old_size == 0 )
        new_size = 8;
      else
      {
        new_size = old_size * 2;

        /* check for (unlikely) overflow */
        if ( new_size < old_size )
          new_size = 65534;
      }

      if ( FT_RENEW_ARRAY( table->entries, old_size, new_size ) )
        return error;

      table->size = new_size;

      entry       = table->entries + old_size;
      table->free = old_size;

      for ( idx = old_size; idx + 1 < new_size; idx++, entry++ )
      {
        entry->link  = idx + 1;