| /**************************************************************************** |
| * |
| * ftglyph.c |
| * |
| * FreeType convenience functions to handle glyphs (body). |
| * |
| * Copyright (C) 1996-2020 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. |
| * |
| */ |
| |
| /************************************************************************** |
| * |
| * This file contains the definition of several convenience functions |
| * that can be used by client applications to easily retrieve glyph |
| * bitmaps and outlines from a given face. |
| * |
| * These functions should be optional if you are writing a font server |
| * or text layout engine on top of FreeType. However, they are pretty |
| * handy for many other simple uses of the library. |
| * |
| */ |
| |
| |
| #include <freetype/internal/ftdebug.h> |
| |
| #include <freetype/ftglyph.h> |
| #include <freetype/ftoutln.h> |
| #include <freetype/ftbitmap.h> |
| #include <freetype/internal/ftobjs.h> |
| |
| #include "ftbase.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 glyph |
| |
| |
| /*************************************************************************/ |
| /*************************************************************************/ |
| /**** ****/ |
| /**** FT_BitmapGlyph support ****/ |
| /**** ****/ |
| /*************************************************************************/ |
| /*************************************************************************/ |
| |
| FT_CALLBACK_DEF( FT_Error ) |
| ft_bitmap_glyph_init( FT_Glyph bitmap_glyph, |
| FT_GlyphSlot slot ) |
| { |
| FT_BitmapGlyph glyph = (FT_BitmapGlyph)bitmap_glyph; |
| FT_Error error = FT_Err_Ok; |
| FT_Library library = FT_GLYPH( glyph )->library; |
| |
| |
| if ( slot->format != FT_GLYPH_FORMAT_BITMAP ) |
| { |
| error = FT_THROW( Invalid_Glyph_Format ); |
| goto Exit; |
| } |
| |
| glyph->left = slot->bitmap_left; |
| glyph->top = slot->bitmap_top; |
| |
| /* do lazy copying whenever possible */ |
| if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP ) |
| { |
| glyph->bitmap = slot->bitmap; |
| slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP; |
| } |
| else |
| { |
| FT_Bitmap_Init( &glyph->bitmap ); |
| error = FT_Bitmap_Copy( library, &slot->bitmap, &glyph->bitmap ); |
| } |
| |
| Exit: |
| return error; |
| } |
| |
| |
| FT_CALLBACK_DEF( FT_Error ) |
| ft_bitmap_glyph_copy( FT_Glyph bitmap_source, |
| FT_Glyph bitmap_target ) |
| { |
| FT_Library library = bitmap_source->library; |
| FT_BitmapGlyph source = (FT_BitmapGlyph)bitmap_source; |
| FT_BitmapGlyph target = (FT_BitmapGlyph)bitmap_target; |
| |
| |
| target->left = source->left; |
| target->top = source->top; |
| |
| return FT_Bitmap_Copy( library, &source->bitmap, &target->bitmap ); |
| } |
| |
| |
| FT_CALLBACK_DEF( void ) |
| ft_bitmap_glyph_done( FT_Glyph bitmap_glyph ) |
| { |
| FT_BitmapGlyph glyph = (FT_BitmapGlyph)bitmap_glyph; |
| FT_Library library = FT_GLYPH( glyph )->library; |
| |
| |
| FT_Bitmap_Done( library, &glyph->bitmap ); |
| } |
| |
| |
| FT_CALLBACK_DEF( void ) |
| ft_bitmap_glyph_bbox( FT_Glyph bitmap_glyph, |
| FT_BBox* cbox ) |
| { |
| FT_BitmapGlyph glyph = (FT_BitmapGlyph)bitmap_glyph; |
| |
| |
| cbox->xMin = glyph->left * 64; |
| cbox->xMax = cbox->xMin + (FT_Pos)( glyph->bitmap.width * 64 ); |
| cbox->yMax = glyph->top * 64; |
| cbox->yMin = cbox->yMax - (FT_Pos)( glyph->bitmap.rows * 64 ); |
| } |
| |
| |
| FT_DEFINE_GLYPH( |
| ft_bitmap_glyph_class, |
| |
| sizeof ( FT_BitmapGlyphRec ), |
| FT_GLYPH_FORMAT_BITMAP, |
| |
| ft_bitmap_glyph_init, /* FT_Glyph_InitFunc glyph_init */ |
| ft_bitmap_glyph_done, /* FT_Glyph_DoneFunc glyph_done */ |
| ft_bitmap_glyph_copy, /* FT_Glyph_CopyFunc glyph_copy */ |
| NULL, /* FT_Glyph_TransformFunc glyph_transform */ |
| ft_bitmap_glyph_bbox, /* FT_Glyph_GetBBoxFunc glyph_bbox */ |
| NULL /* FT_Glyph_PrepareFunc glyph_prepare */ |
| ) |
| |
| |
| /*************************************************************************/ |
| /*************************************************************************/ |
| /**** ****/ |
| /**** FT_OutlineGlyph support ****/ |
| /**** ****/ |
| /*************************************************************************/ |
| /*************************************************************************/ |
| |
| |
| FT_CALLBACK_DEF( FT_Error ) |
| ft_outline_glyph_init( FT_Glyph outline_glyph, |
| FT_GlyphSlot slot ) |
| { |
| FT_OutlineGlyph glyph = (FT_OutlineGlyph)outline_glyph; |
| FT_Error error = FT_Err_Ok; |
| FT_Library library = FT_GLYPH( glyph )->library; |
| FT_Outline* source = &slot->outline; |
| FT_Outline* target = &glyph->outline; |
| |
| |
| /* check format in glyph slot */ |
| if ( slot->format != FT_GLYPH_FORMAT_OUTLINE ) |
| { |
| error = FT_THROW( Invalid_Glyph_Format ); |
| goto Exit; |
| } |
| |
| /* allocate new outline */ |
| error = FT_Outline_New( library, |
| (FT_UInt)source->n_points, |
| source->n_contours, |
| &glyph->outline ); |
| if ( error ) |
| goto Exit; |
| |
| FT_Outline_Copy( source, target ); |
| |
| Exit: |
| return error; |
| } |
| |
| |
| FT_CALLBACK_DEF( void ) |
| ft_outline_glyph_done( FT_Glyph outline_glyph ) |
| { |
| FT_OutlineGlyph glyph = (FT_OutlineGlyph)outline_glyph; |
| |
| |
| FT_Outline_Done( FT_GLYPH( glyph )->library, &glyph->outline ); |
| } |
| |
| |
| FT_CALLBACK_DEF( FT_Error ) |
| ft_outline_glyph_copy( FT_Glyph outline_source, |
| FT_Glyph outline_target ) |
| { |
| FT_OutlineGlyph source = (FT_OutlineGlyph)outline_source; |
| FT_OutlineGlyph target = (FT_OutlineGlyph)outline_target; |
| FT_Error error; |
| FT_Library library = FT_GLYPH( source )->library; |
| |
| |
| error = FT_Outline_New( library, |
| (FT_UInt)source->outline.n_points, |
| source->outline.n_contours, |
| &target->outline ); |
| if ( !error ) |
| FT_Outline_Copy( &source->outline, &target->outline ); |
| |
| return error; |
| } |
| |
| |
| FT_CALLBACK_DEF( void ) |
| ft_outline_glyph_transform( FT_Glyph outline_glyph, |
| const FT_Matrix* matrix, |
| const FT_Vector* delta ) |
| { |
| FT_OutlineGlyph glyph = (FT_OutlineGlyph)outline_glyph; |
| |
| |
| if ( matrix ) |
| FT_Outline_Transform( &glyph->outline, matrix ); |
| |
| if ( delta ) |
| FT_Outline_Translate( &glyph->outline, delta->x, delta->y ); |
| } |
| |
| |
| FT_CALLBACK_DEF( void ) |
| ft_outline_glyph_bbox( FT_Glyph outline_glyph, |
| FT_BBox* bbox ) |
| { |
| FT_OutlineGlyph glyph = (FT_OutlineGlyph)outline_glyph; |
| |
| |
| FT_Outline_Get_CBox( &glyph->outline, bbox ); |
| } |
| |
| |
| FT_CALLBACK_DEF( FT_Error ) |
| ft_outline_glyph_prepare( FT_Glyph outline_glyph, |
| FT_GlyphSlot slot ) |
| { |
| FT_OutlineGlyph glyph = (FT_OutlineGlyph)outline_glyph; |
| |
| |
| slot->format = FT_GLYPH_FORMAT_OUTLINE; |
| slot->outline = glyph->outline; |
| slot->outline.flags &= ~FT_OUTLINE_OWNER; |
| |
| return FT_Err_Ok; |
| } |
| |
| |
| FT_DEFINE_GLYPH( |
| ft_outline_glyph_class, |
| |
| sizeof ( FT_OutlineGlyphRec ), |
| FT_GLYPH_FORMAT_OUTLINE, |
| |
| ft_outline_glyph_init, /* FT_Glyph_InitFunc glyph_init */ |
| ft_outline_glyph_done, /* FT_Glyph_DoneFunc glyph_done */ |
| ft_outline_glyph_copy, /* FT_Glyph_CopyFunc glyph_copy */ |
| ft_outline_glyph_transform, /* FT_Glyph_TransformFunc glyph_transform */ |
| ft_outline_glyph_bbox, /* FT_Glyph_GetBBoxFunc glyph_bbox */ |
| ft_outline_glyph_prepare /* FT_Glyph_PrepareFunc glyph_prepare */ |
| ) |
| |
| |
| /*************************************************************************/ |
| /*************************************************************************/ |
| /**** ****/ |
| /**** FT_Glyph class and API ****/ |
| /**** ****/ |
| /*************************************************************************/ |
| /*************************************************************************/ |
| |
| static FT_Error |
| ft_new_glyph( FT_Library library, |
| const FT_Glyph_Class* clazz, |
| FT_Glyph* aglyph ) |
| { |
| FT_Memory memory = library->memory; |
| FT_Error error; |
| FT_Glyph glyph = NULL; |
| |
| |
| *aglyph = NULL; |
| |
| if ( !FT_ALLOC( glyph, clazz->glyph_size ) ) |
| { |
| glyph->library = library; |
| glyph->clazz = clazz; |
| glyph->format = clazz->glyph_format; |
| |
| *aglyph = glyph; |
| } |
| |
| return error; |
| } |
| |
| |
| /* documentation is in ftglyph.h */ |
| |
| FT_EXPORT_DEF( FT_Error ) |
| FT_Glyph_Copy( FT_Glyph source, |
| FT_Glyph *target ) |
| { |
| FT_Glyph copy; |
| FT_Error error; |
| const FT_Glyph_Class* clazz; |
| |
| |
| /* check arguments */ |
| if ( !target || !source || !source->clazz ) |
| { |
| error = FT_THROW( Invalid_Argument ); |
| goto Exit; |
| } |
| |
| *target = NULL; |
| |
| if ( !source || !source->clazz ) |
| { |
| error = FT_THROW( Invalid_Argument ); |
| goto Exit; |
| } |
| |
| clazz = source->clazz; |
| error = ft_new_glyph( source->library, clazz, © ); |
| if ( error ) |
| goto Exit; |
| |
| copy->advance = source->advance; |
| copy->format = source->format; |
| |
| if ( clazz->glyph_copy ) |
| error = clazz->glyph_copy( source, copy ); |
| |
| if ( error ) |
| FT_Done_Glyph( copy ); |
| else |
| *target = copy; |
| |
| Exit: |
| return error; |
| } |
| |
| |
| /* documentation is in ftglyph.h */ |
| |
| FT_EXPORT( FT_Error ) |
| FT_New_Glyph( FT_Library library, |
| FT_Glyph_Format format, |
| FT_Glyph *aglyph ) |
| { |
| const FT_Glyph_Class* clazz = NULL; |
| |
| if ( !library || !aglyph ) |
| return FT_THROW( Invalid_Argument ); |
| |
| /* if it is a bitmap, that's easy :-) */ |
| if ( format == FT_GLYPH_FORMAT_BITMAP ) |
| clazz = &ft_bitmap_glyph_class; |
| |
| /* if it is an outline */ |
| else if ( format == FT_GLYPH_FORMAT_OUTLINE ) |
| clazz = &ft_outline_glyph_class; |
| |
| else |
| { |
| /* try to find a renderer that supports the glyph image format */ |
| FT_Renderer render = FT_Lookup_Renderer( library, format, 0 ); |
| |
| |
| if ( render ) |
| clazz = &render->glyph_class; |
| } |
| |
| if ( !clazz ) |
| return FT_THROW( Invalid_Glyph_Format ); |
| |
| /* create FT_Glyph object */ |
| return ft_new_glyph( library, clazz, aglyph ); |
| } |
| |
| |
| /* documentation is in ftglyph.h */ |
| |
| FT_EXPORT_DEF( FT_Error ) |
| FT_Get_Glyph( FT_GlyphSlot slot, |
| FT_Glyph *aglyph ) |
| { |
| FT_Error error; |
| FT_Glyph glyph; |
| |
| |
| if ( !slot ) |
| return FT_THROW( Invalid_Slot_Handle ); |
| |
| if ( !aglyph ) |
| return FT_THROW( Invalid_Argument ); |
| |
| /* create FT_Glyph object */ |
| error = FT_New_Glyph( slot->library, slot->format, &glyph ); |
| if ( error ) |
| goto Exit; |
| |
| /* copy advance while converting 26.6 to 16.16 format */ |
| if ( slot->advance.x >= 0x8000L * 64 || |
| slot->advance.x <= -0x8000L * 64 ) |
| { |
| FT_ERROR(( "FT_Get_Glyph: advance width too large\n" )); |
| error = FT_THROW( Invalid_Argument ); |
| goto Exit2; |
| } |
| if ( slot->advance.y >= 0x8000L * 64 || |
| slot->advance.y <= -0x8000L * 64 ) |
| { |
| FT_ERROR(( "FT_Get_Glyph: advance height too large\n" )); |
| error = FT_THROW( Invalid_Argument ); |
| goto Exit2; |
| } |
| |
| glyph->advance.x = slot->advance.x * 1024; |
| glyph->advance.y = slot->advance.y * 1024; |
| |
| /* now import the image from the glyph slot */ |
| error = glyph->clazz->glyph_init( glyph, slot ); |
| |
| Exit2: |
| /* if an error occurred, destroy the glyph */ |
| if ( error ) |
| FT_Done_Glyph( glyph ); |
| else |
| *aglyph = glyph; |
| |
| Exit: |
| return error; |
| } |
| |
| |
| /* documentation is in ftglyph.h */ |
| |
| FT_EXPORT_DEF( FT_Error ) |
| FT_Glyph_Transform( FT_Glyph glyph, |
| FT_Matrix* matrix, |
| FT_Vector* delta ) |
| { |
| FT_Error error = FT_Err_Ok; |
| |
| |
| if ( !glyph || !glyph->clazz ) |
| error = FT_THROW( Invalid_Argument ); |
| else |
| { |
| const FT_Glyph_Class* clazz = glyph->clazz; |
| |
| |
| if ( clazz->glyph_transform ) |
| { |
| /* transform glyph image */ |
| clazz->glyph_transform( glyph, matrix, delta ); |
| |
| /* transform advance vector */ |
| if ( matrix ) |
| FT_Vector_Transform( &glyph->advance, matrix ); |
| } |
| else |
| error = FT_THROW( Invalid_Glyph_Format ); |
| } |
| return error; |
| } |
| |
| |
| /* documentation is in ftglyph.h */ |
| |
| FT_EXPORT_DEF( void ) |
| FT_Glyph_Get_CBox( FT_Glyph glyph, |
| FT_UInt bbox_mode, |
| FT_BBox *acbox ) |
| { |
| const FT_Glyph_Class* clazz; |
| |
| |
| if ( !acbox ) |
| return; |
| |
| acbox->xMin = acbox->yMin = acbox->xMax = acbox->yMax = 0; |
| |
| if ( !glyph || !glyph->clazz ) |
| return; |
| |
| clazz = glyph->clazz; |
| if ( !clazz->glyph_bbox ) |
| return; |
| |
| /* retrieve bbox in 26.6 coordinates */ |
| clazz->glyph_bbox( glyph, acbox ); |
| |
| /* perform grid fitting if needed */ |
| if ( bbox_mode == FT_GLYPH_BBOX_GRIDFIT || |
| bbox_mode == FT_GLYPH_BBOX_PIXELS ) |
| { |
| acbox->xMin = FT_PIX_FLOOR( acbox->xMin ); |
| acbox->yMin = FT_PIX_FLOOR( acbox->yMin ); |
| acbox->xMax = FT_PIX_CEIL_LONG( acbox->xMax ); |
| acbox->yMax = FT_PIX_CEIL_LONG( acbox->yMax ); |
| } |
| |
| /* convert to integer pixels if needed */ |
| if ( bbox_mode == FT_GLYPH_BBOX_TRUNCATE || |
| bbox_mode == FT_GLYPH_BBOX_PIXELS ) |
| { |
| acbox->xMin >>= 6; |
| acbox->yMin >>= 6; |
| acbox->xMax >>= 6; |
| acbox->yMax >>= 6; |
| } |
| } |
| |
| |
| /* documentation is in ftglyph.h */ |
| |
| FT_EXPORT_DEF( FT_Error ) |
| FT_Glyph_To_Bitmap( FT_Glyph* the_glyph, |
| FT_Render_Mode render_mode, |
| FT_Vector* origin, |
| FT_Bool destroy ) |
| { |
| FT_GlyphSlotRec dummy; |
| FT_GlyphSlot_InternalRec dummy_internal; |
| FT_Error error = FT_Err_Ok; |
| FT_Glyph b, glyph; |
| FT_BitmapGlyph bitmap = NULL; |
| const FT_Glyph_Class* clazz; |
| |
| FT_Library library; |
| |
| |
| /* check argument */ |
| if ( !the_glyph ) |
| goto Bad; |
| glyph = *the_glyph; |
| if ( !glyph ) |
| goto Bad; |
| |
| clazz = glyph->clazz; |
| library = glyph->library; |
| if ( !library || !clazz ) |
| goto Bad; |
| |
| /* when called with a bitmap glyph, do nothing and return successfully */ |
| if ( clazz == &ft_bitmap_glyph_class ) |
| goto Exit; |
| |
| if ( !clazz->glyph_prepare ) |
| goto Bad; |
| |
| /* we render the glyph into a glyph bitmap using a `dummy' glyph slot */ |
| /* then calling FT_Render_Glyph_Internal() */ |
| |
| FT_ZERO( &dummy ); |
| FT_ZERO( &dummy_internal ); |
| dummy.internal = &dummy_internal; |
| dummy.library = library; |
| dummy.format = clazz->glyph_format; |
| |
| /* create result bitmap glyph */ |
| error = ft_new_glyph( library, &ft_bitmap_glyph_class, &b ); |
| if ( error ) |
| goto Exit; |
| bitmap = (FT_BitmapGlyph)b; |
| |
| #if 1 |
| /* if `origin' is set, translate the glyph image */ |
| if ( origin ) |
| FT_Glyph_Transform( glyph, 0, origin ); |
| #else |
| FT_UNUSED( origin ); |
| #endif |
| |
| /* prepare dummy slot for rendering */ |
| error = clazz->glyph_prepare( glyph, &dummy ); |
| if ( !error ) |
| error = FT_Render_Glyph_Internal( glyph->library, &dummy, render_mode ); |
| |
| #if 1 |
| if ( !destroy && origin ) |
| { |
| FT_Vector v; |
| |
| |
| v.x = -origin->x; |
| v.y = -origin->y; |
| FT_Glyph_Transform( glyph, 0, &v ); |
| } |
| #endif |
| |
| if ( error ) |
| goto Exit; |
| |
| /* in case of success, copy the bitmap to the glyph bitmap */ |
| error = ft_bitmap_glyph_init( (FT_Glyph)bitmap, &dummy ); |
| if ( error ) |
| goto Exit; |
| |
| /* copy advance */ |
| bitmap->root.advance = glyph->advance; |
| |
| if ( destroy ) |
| FT_Done_Glyph( glyph ); |
| |
| *the_glyph = FT_GLYPH( bitmap ); |
| |
| Exit: |
| if ( error && bitmap ) |
| FT_Done_Glyph( FT_GLYPH( bitmap ) ); |
| |
| return error; |
| |
| Bad: |
| error = FT_THROW( Invalid_Argument ); |
| goto Exit; |
| } |
| |
| |
| /* documentation is in ftglyph.h */ |
| |
| FT_EXPORT_DEF( void ) |
| FT_Done_Glyph( FT_Glyph glyph ) |
| { |
| if ( glyph ) |
| { |
| FT_Memory memory = glyph->library->memory; |
| const FT_Glyph_Class* clazz = glyph->clazz; |
| |
| |
| if ( clazz->glyph_done ) |
| clazz->glyph_done( glyph ); |
| |
| FT_FREE( glyph ); |
| } |
| } |
| |
| |
| /* END */ |
