1 /***************************************************************************/

     2 /*                                                                         */

     3 /*  ftcimage.c                                                             */

     4 /*                                                                         */

     5 /*    FreeType Image cache (body).                                         */

     6 /*                                                                         */

     7 /*  Copyright 2000-2001, 2003, 2004, 2006, 2010 by                         */

     8 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */

     9 /*                                                                         */

    10 /*  This file is part of the FreeType project, and may only be used,       */

    11 /*  modified, and distributed under the terms of the FreeType project      */

    12 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */

    13 /*  this file you indicate that you have read the license and              */

    14 /*  understand and accept it fully.                                        */

    15 /*                                                                         */

    16 /***************************************************************************/

    17 

    18 

    19 #include <ft2build.h>

    20 #include FT_CACHE_H

    21 #include "ftcimage.h"

    22 #include FT_INTERNAL_MEMORY_H

    23 

    24 #include "ftccback.h"

    25 #include "ftcerror.h"

    26 

    27 

    28   /* finalize a given glyph image node */

    29   FT_LOCAL_DEF( void )

    30   ftc_inode_free( FTC_Node   ftcinode,

    31                   FTC_Cache  cache )

    32   {

    33     FTC_INode  inode = (FTC_INode)ftcinode;

    34     FT_Memory  memory = cache->memory;

    35 

    36 

    37     if ( inode->glyph )

    38     {

    39       FT_Done_Glyph( inode->glyph );

    40       inode->glyph = NULL;

    41     }

    42 

    43     FTC_GNode_Done( FTC_GNODE( inode ), cache );

    44     FT_FREE( inode );

    45   }

    46 

    47 

    48   FT_LOCAL_DEF( void )

    49   FTC_INode_Free( FTC_INode  inode,

    50                   FTC_Cache  cache )

    51   {

    52     ftc_inode_free( FTC_NODE( inode ), cache );

    53   }

    54 

    55 

    56   /* initialize a new glyph image node */

    57   FT_LOCAL_DEF( FT_Error )

    58   FTC_INode_New( FTC_INode   *pinode,

    59                  FTC_GQuery   gquery,

    60                  FTC_Cache    cache )

    61   {

    62     FT_Memory  memory = cache->memory;

    63     FT_Error   error;

    64     FTC_INode  inode  = NULL;

    65 

    66 

    67     if ( !FT_NEW( inode ) )

    68     {

    69       FTC_GNode         gnode  = FTC_GNODE( inode );

    70       FTC_Family        family = gquery->family;

    71       FT_UInt           gindex = gquery->gindex;

    72       FTC_IFamilyClass  clazz  = FTC_CACHE__IFAMILY_CLASS( cache );

    73 

    74 

    75       /* initialize its inner fields */

    76       FTC_GNode_Init( gnode, gindex, family );

    77 

    78       /* we will now load the glyph image */

    79       error = clazz->family_load_glyph( family, gindex, cache,

    80                                         &inode->glyph );

    81       if ( error )

    82       {

    83         FTC_INode_Free( inode, cache );

    84         inode = NULL;

    85       }

    86     }

    87 

    88     *pinode = inode;

    89     return error;

    90   }

    91 

    92 

    93   FT_LOCAL_DEF( FT_Error )

    94   ftc_inode_new( FTC_Node   *ftcpinode,

    95                  FT_Pointer  ftcgquery,

    96                  FTC_Cache   cache )

    97   {

    98     FTC_INode  *pinode = (FTC_INode*)ftcpinode;

    99     FTC_GQuery  gquery = (FTC_GQuery)ftcgquery;

   100 

   101 

   102     return FTC_INode_New( pinode, gquery, cache );

   103   }

   104 

   105 

   106   FT_LOCAL_DEF( FT_Offset )

   107   ftc_inode_weight( FTC_Node   ftcinode,

   108                     FTC_Cache  ftccache )

   109   {

   110     FTC_INode  inode = (FTC_INode)ftcinode;

   111     FT_Offset  size  = 0;

   112     FT_Glyph   glyph = inode->glyph;

   113 

   114     FT_UNUSED( ftccache );

   115 

   116 

   117     switch ( glyph->format )

   118     {

   119     case FT_GLYPH_FORMAT_BITMAP:

   120       {

   121         FT_BitmapGlyph  bitg;

   122 

   123 

   124         bitg = (FT_BitmapGlyph)glyph;

   125         size = bitg->bitmap.rows * ft_labs( bitg->bitmap.pitch ) +

   126                sizeof ( *bitg );

   127       }

   128       break;

   129 

   130     case FT_GLYPH_FORMAT_OUTLINE:

   131       {

   132         FT_OutlineGlyph  outg;

   133 

   134 

   135         outg = (FT_OutlineGlyph)glyph;

   136         size = outg->outline.n_points *

   137                  ( sizeof ( FT_Vector ) + sizeof ( FT_Byte ) ) +

   138                outg->outline.n_contours * sizeof ( FT_Short ) +

   139                sizeof ( *outg );

   140       }

   141       break;

   142 

   143     default:

   144       ;

   145     }

   146 

   147     size += sizeof ( *inode );

   148     return size;

   149   }

   150 

   151 

   152 #if 0

   153 

   154   FT_LOCAL_DEF( FT_Offset )

   155   FTC_INode_Weight( FTC_INode  inode )

   156   {

   157     return ftc_inode_weight( FTC_NODE( inode ), NULL );

   158   }

   159 

   160 #endif /* 0 */

   161 

   162 

   163 /* END */