forked from minhngoc25a/freetype2
Formatting; minor improvements.
This commit is contained in:
parent
026bd17b41
commit
f13e6333f9
|
@ -98,7 +98,7 @@
|
|||
/* UNUSED is a macro used to indicate that a given parameter is not used */
|
||||
/* this is only used to get rid of unpleasant compiler warnings.. */
|
||||
#ifndef UNUSED
|
||||
#define UNUSED( arg ) ( (arg)=(arg) )
|
||||
#define UNUSED( arg ) ( (void)(arg)=(arg) )
|
||||
#endif
|
||||
|
||||
|
||||
|
|
|
@ -260,7 +260,7 @@
|
|||
/* bytecode interpreter. */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* l :: 64-bit integer */
|
||||
/* l :: A 64-bit integer. */
|
||||
/* */
|
||||
/* <Return> */
|
||||
/* The 32-bit square-root. */
|
||||
|
|
|
@ -24,6 +24,7 @@
|
|||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
#include <freetype/internal/ftextend.h>
|
||||
|
||||
/* required by the tracing mode */
|
||||
|
@ -114,7 +115,8 @@
|
|||
/* <Return> */
|
||||
/* FreeType error code. 0 means success. */
|
||||
/* */
|
||||
FT_EXPORT_FUNC(FT_Error) FT_Register_Extension( FT_Driver driver,
|
||||
FT_EXPORT_FUNC( FT_Error ) FT_Register_Extension(
|
||||
FT_Driver driver,
|
||||
FT_Extension_Class* class )
|
||||
{
|
||||
FT_Extension_Registry* registry;
|
||||
|
@ -162,7 +164,8 @@
|
|||
/* <Return> */
|
||||
/* A pointer to the extension block. */
|
||||
/* */
|
||||
FT_EXPORT_FUNC(void*) FT_Get_Extension( FT_Face face,
|
||||
FT_EXPORT_FUNC( void* ) FT_Get_Extension(
|
||||
FT_Face face,
|
||||
const char* extension_id,
|
||||
void* *extension_interface )
|
||||
{
|
||||
|
|
|
@ -2,9 +2,9 @@
|
|||
/* */
|
||||
/* ftglyph.c */
|
||||
/* */
|
||||
/* FreeType convenience functions to handle glyphs.. */
|
||||
/* FreeType convenience functions to handle glyphs (body). */
|
||||
/* */
|
||||
/* Copyright 1996-1999 by */
|
||||
/* Copyright 1996-2000 by */
|
||||
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
|
||||
/* */
|
||||
/* This file is part of the FreeType project, and may only be used */
|
||||
|
@ -13,19 +13,25 @@
|
|||
/* 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're 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.. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* 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/ftglyph.h>
|
||||
#include <freetype/internal/ftobjs.h>
|
||||
|
||||
|
||||
static
|
||||
void ft_prepare_glyph( FT_Glyph glyph,
|
||||
FT_Face face,
|
||||
|
@ -33,11 +39,12 @@
|
|||
{
|
||||
FT_Glyph_Metrics* metrics = &face->glyph->metrics;
|
||||
|
||||
|
||||
glyph->memory = face->memory;
|
||||
glyph->width = metrics->width;
|
||||
glyph->height = metrics->height;
|
||||
|
||||
if (vertical)
|
||||
if ( vertical )
|
||||
{
|
||||
glyph->bearingX = metrics->vertBearingX;
|
||||
glyph->bearingY = metrics->vertBearingY;
|
||||
|
@ -51,74 +58,80 @@
|
|||
}
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* <Function>
|
||||
* FT_Get_Glyph_Bitmap
|
||||
*
|
||||
* <Description>
|
||||
* A function used to directly return a monochrome bitmap glyph image
|
||||
* from a face.
|
||||
*
|
||||
* <Input>
|
||||
* face :: handle to source face object
|
||||
* glyph_index :: glyph index in face
|
||||
* load_flags :: load flags, see FT_LOAD_FLAG_XXXX constants..
|
||||
* grays :: number of gray levels for anti-aliased bitmaps,
|
||||
* set to 0 if you want to render a monochrome bitmap
|
||||
* origin :: a pointer to the origin's position. Set to 0
|
||||
* if the current transform is the identity..
|
||||
*
|
||||
* <Output>
|
||||
* bitglyph :: pointer to the new bitmap glyph
|
||||
*
|
||||
* <Return>
|
||||
* Error code. 0 means success.
|
||||
*
|
||||
* <Note>
|
||||
* If the font contains glyph outlines, these will be automatically
|
||||
* converted to a bitmap according to the value of "grays"
|
||||
*
|
||||
* If "grays" is set to 0, the result is a 1-bit monochrome bitmap
|
||||
* otherwise, it is an 8-bit gray-level bitmap
|
||||
*
|
||||
* The number of gray levels in the result anti-aliased bitmap might
|
||||
* not be "grays", depending on the current scan-converter implementation
|
||||
*
|
||||
* Note that it is not possible to generate 8-bit monochrome bitmaps
|
||||
* with this function. Rather, use FT_Get_Glyph_Outline, then
|
||||
* FT_Glyph_Render_Outline and provide your own span callbacks..
|
||||
*
|
||||
* When the face doesn't contain scalable outlines, this function will
|
||||
* fail if the current transform is not the identity, or if the glyph
|
||||
* origin's phase to the pixel grid is not 0 in both directions !!
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
FT_EXPORT_FUNC(FT_Error) FT_Get_Glyph_Bitmap( FT_Face face,
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* <Function> */
|
||||
/* FT_Get_Glyph_Bitmap */
|
||||
/* */
|
||||
/* <Description> */
|
||||
/* A function used to directly return a monochrome bitmap glyph image */
|
||||
/* from a face. */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* face :: A handle to source face object. */
|
||||
/* glyph_index :: A glyph index into the face. */
|
||||
/* load_flags :: Load flags (see FT_LOAD_FLAG_XXXX constants). */
|
||||
/* grays :: The number of gray levels for anti-aliased bitmaps. */
|
||||
/* Set it to 0 if you want to render a monochrome */
|
||||
/* bitmap. */
|
||||
/* origin :: A pointer to the origin's position. Set it to 0 */
|
||||
/* if the current transform is the identity. */
|
||||
/* */
|
||||
/* <Output> */
|
||||
/* abitglyph :: A pointer to the new bitmap glyph. */
|
||||
/* */
|
||||
/* <Return> */
|
||||
/* FreeType error code. 0 means success. */
|
||||
/* */
|
||||
/* <Note> */
|
||||
/* If the font contains glyph outlines, these will be automatically */
|
||||
/* converted to a bitmap according to the value of `grays' */
|
||||
/* */
|
||||
/* If `grays' is set to 0, the result is a 1-bit monochrome bitmap */
|
||||
/* otherwise, it is an 8-bit gray-level bitmap. */
|
||||
/* */
|
||||
/* The number of gray levels in the result anti-aliased bitmap might */
|
||||
/* not be `grays', depending on the current scan-converter */
|
||||
/* implementation. */
|
||||
/* */
|
||||
/* Note that it is not possible to generate 8-bit monochrome bitmaps */
|
||||
/* with this function. Rather, use FT_Get_Glyph_Outline(), then */
|
||||
/* FT_Glyph_Render_Outline(), and provide your own span callbacks. */
|
||||
/* */
|
||||
/* If the face doesn't contain scalable outlines, this function will */
|
||||
/* fail if the current transformation is not the identity, or if the */
|
||||
/* glyph origin's phase to the pixel grid is not 0 in both */
|
||||
/* directions! */
|
||||
/* */
|
||||
FT_EXPORT_FUNC( FT_Error ) FT_Get_Glyph_Bitmap(
|
||||
FT_Face face,
|
||||
FT_UInt glyph_index,
|
||||
FT_UInt load_flags,
|
||||
FT_Int grays,
|
||||
FT_Vector* origin,
|
||||
FT_BitmapGlyph *abitglyph )
|
||||
FT_BitmapGlyph* abitglyph )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Memory memory;
|
||||
|
||||
FT_BitmapGlyph bitglyph;
|
||||
FT_Glyph glyph;
|
||||
FT_Pos origin_x = 0;
|
||||
FT_Pos origin_y = 0;
|
||||
|
||||
|
||||
*abitglyph = 0;
|
||||
|
||||
if (origin)
|
||||
if ( origin )
|
||||
{
|
||||
origin_x = origin->x & 63;
|
||||
origin_y = origin->y & 63;
|
||||
}
|
||||
|
||||
/* check arguments if the face's format is not scalable */
|
||||
if ( !(face->face_flags & FT_FACE_FLAG_SCALABLE) && face->transform_flags )
|
||||
/* check arguments whether the face's format is not scalable */
|
||||
if ( !( face->face_flags & FT_FACE_FLAG_SCALABLE ) &&
|
||||
face->transform_flags )
|
||||
{
|
||||
/* we can't transform bitmaps, so return an error */
|
||||
error = FT_Err_Unimplemented_Feature;
|
||||
|
@ -126,7 +139,7 @@
|
|||
}
|
||||
|
||||
/* check that NO_SCALE and NO_RECURSE are not set */
|
||||
if (load_flags & (FT_LOAD_NO_SCALE|FT_LOAD_NO_RECURSE))
|
||||
if ( load_flags & ( FT_LOAD_NO_SCALE | FT_LOAD_NO_RECURSE ) )
|
||||
{
|
||||
error = FT_Err_Invalid_Argument;
|
||||
goto Exit;
|
||||
|
@ -137,7 +150,8 @@
|
|||
load_flags |= FT_LOAD_NO_BITMAP;
|
||||
|
||||
error = FT_Load_Glyph( face, glyph_index, load_flags );
|
||||
if (error) goto Exit;
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
/* now, handle bitmap and outline glyph images */
|
||||
memory = face->memory;
|
||||
|
@ -148,7 +162,8 @@
|
|||
FT_Long size;
|
||||
FT_Bitmap* source;
|
||||
|
||||
if ( ALLOC( bitglyph, sizeof(*bitglyph) ) )
|
||||
|
||||
if ( ALLOC( bitglyph, sizeof ( *bitglyph ) ) )
|
||||
goto Exit;
|
||||
|
||||
glyph = (FT_Glyph)bitglyph;
|
||||
|
@ -157,7 +172,8 @@
|
|||
|
||||
source = &face->glyph->bitmap;
|
||||
size = source->rows * source->pitch;
|
||||
if (size < 0) size = -size;
|
||||
if ( size < 0 )
|
||||
size = -size;
|
||||
|
||||
bitglyph->bitmap = *source;
|
||||
if ( ALLOC( bitglyph->bitmap.buffer, size ) )
|
||||
|
@ -174,9 +190,11 @@
|
|||
FT_Int width, height, pitch;
|
||||
FT_Long size;
|
||||
|
||||
/* transform the outline - note that the original metrics are NOT */
|
||||
/* transformed by this.. only the outline points themselves.. */
|
||||
FT_Outline_Transform( &face->glyph->outline, &face->transform_matrix );
|
||||
|
||||
/* transform the outline -- note that the original metrics are NOT */
|
||||
/* transformed by this, only the outline points themselves... */
|
||||
FT_Outline_Transform( &face->glyph->outline,
|
||||
&face->transform_matrix );
|
||||
FT_Outline_Translate( &face->glyph->outline,
|
||||
face->transform_delta.x + origin_x,
|
||||
face->transform_delta.y + origin_y );
|
||||
|
@ -185,18 +203,21 @@
|
|||
FT_Outline_Get_CBox( &face->glyph->outline, &cbox );
|
||||
cbox.xMin &= -64;
|
||||
cbox.yMin &= -64;
|
||||
cbox.xMax = (cbox.xMax+63) & -64;
|
||||
cbox.yMax = (cbox.yMax+63) & -64;
|
||||
cbox.xMax = ( cbox.xMax + 63 ) & -64;
|
||||
cbox.yMax = ( cbox.yMax + 63 ) & -64;
|
||||
|
||||
width = (cbox.xMax - cbox.xMin) >> 6;
|
||||
height = (cbox.yMax - cbox.yMin) >> 6;
|
||||
width = ( cbox.xMax - cbox.xMin ) >> 6;
|
||||
height = ( cbox.yMax - cbox.yMin ) >> 6;
|
||||
|
||||
/* allocate the pixel buffer for the glyph bitmap */
|
||||
if (grays) pitch = (width+3) & -4; /* some raster implementation need this */
|
||||
else pitch = (width+7) >> 3;
|
||||
if ( grays )
|
||||
/* some raster implementation need this */
|
||||
pitch = ( width + 3 ) & -4;
|
||||
else
|
||||
pitch = ( width + 7 ) >> 3;
|
||||
|
||||
size = pitch * height;
|
||||
if ( ALLOC( bitglyph, sizeof(*bitglyph) ) )
|
||||
if ( ALLOC( bitglyph, sizeof ( *bitglyph ) ) )
|
||||
goto Exit;
|
||||
|
||||
glyph = (FT_Glyph)bitglyph;
|
||||
|
@ -213,15 +234,17 @@
|
|||
: ft_pixel_mode_mono;
|
||||
bitglyph->bitmap.num_grays = (short)grays;
|
||||
|
||||
bitglyph->left = (cbox.xMin >> 6);
|
||||
bitglyph->top = (cbox.yMax >> 6);
|
||||
bitglyph->left = cbox.xMin >> 6;
|
||||
bitglyph->top = cbox.yMax >> 6;
|
||||
|
||||
/* render the monochrome outline into the target buffer */
|
||||
FT_Outline_Translate( &face->glyph->outline, -cbox.xMin, -cbox.yMin );
|
||||
FT_Outline_Translate( &face->glyph->outline,
|
||||
-cbox.xMin,
|
||||
-cbox.yMin );
|
||||
error = FT_Outline_Get_Bitmap( face->driver->library,
|
||||
&face->glyph->outline,
|
||||
&bitglyph->bitmap );
|
||||
if (error)
|
||||
if ( error )
|
||||
{
|
||||
FREE( bitglyph->bitmap.buffer );
|
||||
goto Fail;
|
||||
|
@ -235,6 +258,7 @@
|
|||
}
|
||||
|
||||
*abitglyph = bitglyph;
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
|
||||
|
@ -244,45 +268,46 @@
|
|||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* <Function>
|
||||
* FT_Get_Glyph_Outline
|
||||
*
|
||||
* <Description>
|
||||
* A function used to directly return a bitmap glyph image from a
|
||||
* face. This is faster than calling FT_Load_Glyph+FT_Get_Outline_Bitmap..
|
||||
*
|
||||
* <Input>
|
||||
* face :: handle to source face object
|
||||
* glyph_index :: glyph index in face
|
||||
* load_flags :: load flags, see FT_LOAD_FLAG_XXXX constants..
|
||||
*
|
||||
* <Output>
|
||||
* vecglyph :: pointer to the new outline glyph
|
||||
*
|
||||
* <Return>
|
||||
* Error code. 0 means success.
|
||||
*
|
||||
* <Note>
|
||||
* This function will fail if the load flags FT_LOAD_NO_OUTLINE and
|
||||
* FT_LOAD_NO_RECURSE are set..
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
FT_EXPORT_FUNC(FT_Error) FT_Get_Glyph_Outline( FT_Face face,
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* <Function> */
|
||||
/* FT_Get_Glyph_Outline */
|
||||
/* */
|
||||
/* <Description> */
|
||||
/* A function used to directly return a bitmap glyph image from a */
|
||||
/* face. This is faster than calling FT_Load_Glyph() + */
|
||||
/* FT_Get_Outline_Bitmap(). */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* face :: A handle to the source face object. */
|
||||
/* glyph_index :: A glyph index into face */
|
||||
/* load_flags :: Load flags (see FT_LOAD_FLAG_XXXX constants). */
|
||||
/* */
|
||||
/* <Output> */
|
||||
/* vecglyph :: A pointer to the new outline glyph. */
|
||||
/* */
|
||||
/* <Return> */
|
||||
/* FreeType error code. 0 means success. */
|
||||
/* */
|
||||
/* <Note> */
|
||||
/* This function will fail if the load flags FT_LOAD_NO_OUTLINE and */
|
||||
/* FT_LOAD_NO_RECURSE are set. */
|
||||
/* */
|
||||
FT_EXPORT_FUNC( FT_Error ) FT_Get_Glyph_Outline(
|
||||
FT_Face face,
|
||||
FT_UInt glyph_index,
|
||||
FT_UInt load_flags,
|
||||
FT_OutlineGlyph *vecglyph )
|
||||
FT_OutlineGlyph* vecglyph )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Memory memory;
|
||||
FT_OutlineGlyph glyph;
|
||||
|
||||
|
||||
*vecglyph = 0;
|
||||
|
||||
/* check that NO_OUTLINE and NO_RECURSE are not set */
|
||||
if (load_flags & (FT_LOAD_NO_OUTLINE|FT_LOAD_NO_RECURSE))
|
||||
if ( load_flags & ( FT_LOAD_NO_OUTLINE | FT_LOAD_NO_RECURSE ) )
|
||||
{
|
||||
error = FT_Err_Invalid_Argument;
|
||||
goto Exit;
|
||||
|
@ -292,7 +317,8 @@
|
|||
load_flags |= FT_LOAD_NO_BITMAP;
|
||||
|
||||
error = FT_Load_Glyph( face, glyph_index, load_flags );
|
||||
if (error) goto Exit;
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
/* check that we really loaded an outline */
|
||||
if ( face->glyph->format != ft_glyph_format_outline )
|
||||
|
@ -301,8 +327,8 @@
|
|||
goto Exit;
|
||||
}
|
||||
|
||||
/* transform the outline - note that the original metrics are NOT */
|
||||
/* transformed by this.. only the outline points themselves.. */
|
||||
/* transform the outline -- note that the original metrics are NOT */
|
||||
/* transformed by this, only the outline points themselves... */
|
||||
if ( face->transform_flags )
|
||||
{
|
||||
FT_Outline_Transform( &face->glyph->outline, &face->transform_matrix );
|
||||
|
@ -311,9 +337,9 @@
|
|||
face->transform_delta.y );
|
||||
}
|
||||
|
||||
/* now, create a new outline glyph and copy everything there */
|
||||
/* now, create a new outline glyph and copy everything */
|
||||
memory = face->memory;
|
||||
if ( ALLOC( glyph, sizeof(*glyph) ) )
|
||||
if ( ALLOC( glyph, sizeof ( *glyph ) ) )
|
||||
goto Exit;
|
||||
|
||||
ft_prepare_glyph( (FT_Glyph)glyph, face, 0 );
|
||||
|
@ -323,12 +349,13 @@
|
|||
face->glyph->outline.n_points,
|
||||
face->glyph->outline.n_contours,
|
||||
&glyph->outline );
|
||||
if (!error)
|
||||
if ( !error )
|
||||
error = FT_Outline_Copy( &face->glyph->outline, &glyph->outline );
|
||||
|
||||
if (error) goto Fail;
|
||||
if ( error )
|
||||
goto Fail;
|
||||
|
||||
*vecglyph = glyph;
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
|
||||
|
@ -337,37 +364,42 @@
|
|||
goto Exit;
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* <Function>
|
||||
* FT_Set_Transform
|
||||
*
|
||||
* <Description>
|
||||
* A function used to set the transform that is applied to glyph images
|
||||
* just after they're loaded in the face's glyph slot, and before they're
|
||||
* returned by either FT_Get_Glyph_Bitmap or FT_Get_Glyph_Outline
|
||||
*
|
||||
* <Input>
|
||||
* face :: handle to source face object
|
||||
* matrix :: pointer to the transform's 2x2 matrix. 0 for identity
|
||||
* delta :: pointer to the transform's translation. 0 for null vector
|
||||
*
|
||||
* <Note>
|
||||
* The transform is only applied to glyph outlines when they are found
|
||||
* in a font face. It is unable to transform embedded glyph bitmaps
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
FT_EXPORT_FUNC(void) FT_Set_Transform( FT_Face face,
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* <Function> */
|
||||
/* FT_Set_Transform */
|
||||
/* */
|
||||
/* <Description> */
|
||||
/* A function used to set the transformation that is applied to glyph */
|
||||
/* images just after they are loaded in the face's glyph slot, and */
|
||||
/* before they are returned by either FT_Get_Glyph_Bitmap() or */
|
||||
/* FT_Get_Glyph_Outline(). */
|
||||
/* */
|
||||
/* <InOut> */
|
||||
/* face :: A handle to the source face object. */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* matrix :: A pointer to the transformation's 2x2 matrix. Use 0 for */
|
||||
/* the identity matrix. */
|
||||
/* delta :: A pointer to the translation vector. Use 0 for the null */
|
||||
/* vector. */
|
||||
/* */
|
||||
/* <Note> */
|
||||
/* The transformation is only applied to glyph outlines if they are */
|
||||
/* found in a font face. It is unable to transform embedded glyph */
|
||||
/* bitmaps. */
|
||||
/* */
|
||||
FT_EXPORT_FUNC( void ) FT_Set_Transform( FT_Face face,
|
||||
FT_Matrix* matrix,
|
||||
FT_Vector* delta )
|
||||
{
|
||||
face->transform_flags = 0;
|
||||
|
||||
if (!matrix)
|
||||
if ( !matrix )
|
||||
{
|
||||
face->transform_matrix.xx = 0x10000L;
|
||||
face->transform_matrix.xy = 0;
|
||||
face->transform_matrix.xy = 0L;
|
||||
face->transform_matrix.yx = 0L;
|
||||
face->transform_matrix.yy = 0x10000L;
|
||||
matrix = &face->transform_matrix;
|
||||
|
@ -375,13 +407,13 @@
|
|||
else
|
||||
face->transform_matrix = *matrix;
|
||||
|
||||
/* set transform_flags bit flag 0 if delta isn't the null vector */
|
||||
if ( (matrix->xy | matrix->yx) ||
|
||||
/* set transform_flags bit flag 0 if `matrix' isn't the identity */
|
||||
if ( ( matrix->xy | matrix->yx ) ||
|
||||
matrix->xx != 0x10000L ||
|
||||
matrix->yy != 0x10000L )
|
||||
face->transform_flags |= 1;
|
||||
|
||||
if (!delta)
|
||||
if ( !delta )
|
||||
{
|
||||
face->transform_delta.x = 0;
|
||||
face->transform_delta.y = 0;
|
||||
|
@ -390,39 +422,43 @@
|
|||
else
|
||||
face->transform_delta = *delta;
|
||||
|
||||
/* set transform_flags bit flag 1 if delta isn't the null vector */
|
||||
/* set transform_flags bit flag 1 if `delta' isn't the null vector */
|
||||
if ( delta->x | delta->y )
|
||||
face->transform_flags |= 2;
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* <Function>
|
||||
* FT_Done_Glyph
|
||||
*
|
||||
* <Description>
|
||||
* Destroys a given glyph..
|
||||
*
|
||||
* <Input>
|
||||
* glyph :: handle to target glyph object
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
FT_EXPORT_FUNC(void) FT_Done_Glyph( FT_Glyph glyph )
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* <Function> */
|
||||
/* FT_Done_Glyph */
|
||||
/* */
|
||||
/* <Description> */
|
||||
/* Destroys a given glyph. */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* glyph :: A handle to the target glyph object. */
|
||||
/* */
|
||||
FT_EXPORT_FUNC( void ) FT_Done_Glyph( FT_Glyph glyph )
|
||||
{
|
||||
if (glyph)
|
||||
if ( glyph )
|
||||
{
|
||||
FT_Memory memory = glyph->memory;
|
||||
|
||||
|
||||
if ( glyph->glyph_type == ft_glyph_type_bitmap )
|
||||
{
|
||||
FT_BitmapGlyph bit = (FT_BitmapGlyph)glyph;
|
||||
|
||||
|
||||
FREE( bit->bitmap.buffer );
|
||||
}
|
||||
else if ( glyph->glyph_type == ft_glyph_type_outline )
|
||||
{
|
||||
FT_OutlineGlyph out = (FT_OutlineGlyph)glyph;
|
||||
if (out->outline.flags & ft_outline_owner)
|
||||
|
||||
|
||||
if ( out->outline.flags & ft_outline_owner )
|
||||
{
|
||||
FREE( out->outline.points );
|
||||
FREE( out->outline.contours );
|
||||
|
@ -435,41 +471,42 @@
|
|||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* <Function>
|
||||
* FT_Glyph_Get_Box
|
||||
*
|
||||
* <Description>
|
||||
* Returns the glyph image's bounding box in pixels.
|
||||
*
|
||||
* <Input>
|
||||
* glyph :: handle to target glyph object
|
||||
*
|
||||
* <Output>
|
||||
* box :: the glyph bounding box. Coordinates are expressed in
|
||||
* _integer_ pixels, with exclusive max bounds
|
||||
*
|
||||
* <Note>
|
||||
* Coordinates are relative to the glyph origin, using the Y-upwards
|
||||
* convention..
|
||||
*
|
||||
* The width of the box in pixels is box.xMax-box.xMin
|
||||
* The height is box.yMax - box.yMin
|
||||
*
|
||||
***********************************************************************/
|
||||
|
||||
FT_EXPORT_FUNC(void) FT_Glyph_Get_Box( FT_Glyph glyph,
|
||||
FT_BBox *box )
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* <Function> */
|
||||
/* FT_Glyph_Get_Box */
|
||||
/* */
|
||||
/* <Description> */
|
||||
/* Returns the glyph image's bounding box in pixels. */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* glyph :: A handle to the target glyph object. */
|
||||
/* */
|
||||
/* <Output> */
|
||||
/* box :: The glyph bounding box. Coordinates are expressed in */
|
||||
/* _integer_ pixels, with exclusive maximal bounding values. */
|
||||
/* */
|
||||
/* <Note> */
|
||||
/* Coordinates are relative to the glyph origin, using the Y-upwards */
|
||||
/* convention. */
|
||||
/* */
|
||||
/* The width of the box in pixels is `box.xMax-box.xMin'; the height */
|
||||
/* is `box.yMax-box.yMin'. */
|
||||
/* */
|
||||
FT_EXPORT_FUNC( void ) FT_Glyph_Get_Box( FT_Glyph glyph,
|
||||
FT_BBox* box )
|
||||
{
|
||||
box->xMin = box->xMax = 0;
|
||||
box->yMin = box->yMax = 0;
|
||||
|
||||
if (glyph) switch (glyph->glyph_type)
|
||||
if ( glyph )
|
||||
switch ( glyph->glyph_type )
|
||||
{
|
||||
case ft_glyph_type_bitmap:
|
||||
{
|
||||
FT_BitmapGlyph bit = (FT_BitmapGlyph)glyph;
|
||||
|
||||
|
||||
box->xMin = bit->left;
|
||||
box->xMax = box->xMin + bit->bitmap.width;
|
||||
box->yMax = bit->top;
|
||||
|
@ -481,11 +518,12 @@
|
|||
{
|
||||
FT_OutlineGlyph out = (FT_OutlineGlyph)glyph;
|
||||
|
||||
|
||||
FT_Outline_Get_CBox( &out->outline, box );
|
||||
box->xMin >>= 6;
|
||||
box->yMin >>= 6;
|
||||
box->xMax = (box->xMax+63) >> 6;
|
||||
box->yMax = (box->yMax+63) >> 6;
|
||||
box->xMax = ( box->xMax + 63 ) >> 6;
|
||||
box->yMax = ( box->yMax + 63 ) >> 6;
|
||||
}
|
||||
break;
|
||||
|
||||
|
@ -495,29 +533,35 @@
|
|||
}
|
||||
|
||||
|
||||
/***************************************************************************/
|
||||
/***************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/**** ****/
|
||||
/**** EXPERIMENTAL EMBOLDENING/OUTLINING SUPPORT ****/
|
||||
/**** ****/
|
||||
/***************************************************************************/
|
||||
/***************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
#if 0
|
||||
|
||||
/* Compute the norm of a vector */
|
||||
/* Compute the norm of a vector */
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_OLD_CALCS
|
||||
|
||||
static
|
||||
FT_Pos ft_norm( FT_Vector* vec )
|
||||
{
|
||||
FT_Int64 t1, t2;
|
||||
|
||||
|
||||
MUL_64( vec->x, vec->x, t1 );
|
||||
MUL_64( vec->y, vec->y, t2 );
|
||||
ADD_64( t1, t2, t1 );
|
||||
return (FT_Pos)SQRT_64(t1);
|
||||
|
||||
return (FT_Pos)SQRT_64( t1 );
|
||||
}
|
||||
#else
|
||||
|
||||
#else /* FT_CONFIG_OPTION_OLD_CALCS */
|
||||
|
||||
static
|
||||
FT_Pos ft_norm( FT_Vector* vec )
|
||||
{
|
||||
|
@ -525,64 +569,71 @@
|
|||
FT_Int shift;
|
||||
FT_ULong H, L, L2, hi, lo, med;
|
||||
|
||||
u = vec->x; if (u < 0) u = -u;
|
||||
v = vec->y; if (v < 0) v = -v;
|
||||
|
||||
if (u < v)
|
||||
u = vec->x; if ( u < 0 ) u = -u;
|
||||
v = vec->y; if ( v < 0 ) v = -v;
|
||||
|
||||
if ( u < v )
|
||||
{
|
||||
d = u;
|
||||
u = v;
|
||||
v = d;
|
||||
}
|
||||
|
||||
/* check that we're not trying to normalise zero !! */
|
||||
if (u==0) return 0;
|
||||
/* check that we're not trying to normalize zero! */
|
||||
if ( u == 0 )
|
||||
return 0;
|
||||
|
||||
/* compute (u*u+v*v) on 64 bits with two 32-bit registers [H:L] */
|
||||
/* compute (u*u + v*v) on 64 bits with two 32-bit registers [H:L] */
|
||||
hi = (FT_ULong)u >> 16;
|
||||
lo = (FT_ULong)u & 0xFFFF;
|
||||
med = hi*lo;
|
||||
med = hi * lo;
|
||||
|
||||
H = hi*hi + (med >> 15);
|
||||
H = hi * hi + ( med >> 15 );
|
||||
med <<= 17;
|
||||
L = lo*lo + med;
|
||||
if (L < med) H++;
|
||||
L = lo * lo + med;
|
||||
if ( L < med )
|
||||
H++;
|
||||
|
||||
hi = (FT_ULong)v >> 16;
|
||||
lo = (FT_ULong)v & 0xFFFF;
|
||||
med = hi*lo;
|
||||
med = hi * lo;
|
||||
|
||||
H += hi*hi + (med >> 15);
|
||||
H += hi * hi + ( med >> 15 );
|
||||
med <<= 17;
|
||||
L2 = lo*lo + med;
|
||||
if (L2 < med) H++;
|
||||
L2 = lo * lo + med;
|
||||
if ( L2 < med )
|
||||
H++;
|
||||
|
||||
L += L2;
|
||||
if (L < L2) H++;
|
||||
if ( L < L2 )
|
||||
H++;
|
||||
|
||||
/* if the value is smaller than 32-bits */
|
||||
/* if the value is smaller than 32 bits */
|
||||
shift = 0;
|
||||
if (H == 0)
|
||||
if ( H == 0 )
|
||||
{
|
||||
while ((L & 0xC0000000) == 0)
|
||||
while ( ( L & 0xC0000000UL ) == 0 )
|
||||
{
|
||||
L <<= 2;
|
||||
shift++;
|
||||
}
|
||||
return (FT_Sqrt32(L) >> shift);
|
||||
return ( FT_Sqrt32( L ) >> shift );
|
||||
}
|
||||
else
|
||||
{
|
||||
while (H)
|
||||
while ( H )
|
||||
{
|
||||
L = (L >> 2) | (H << 30);
|
||||
L = ( L >> 2 ) | ( H << 30 );
|
||||
H >>= 2;
|
||||
shift++;
|
||||
}
|
||||
return (FT_Sqrt32(L) << shift);
|
||||
return ( FT_Sqrt32( L ) << shift );
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* FT_CONFIG_OPTION_OLD_CALCS */
|
||||
|
||||
|
||||
static
|
||||
int ft_test_extrema( FT_Outline* outline,
|
||||
|
@ -592,8 +643,9 @@
|
|||
FT_Pos product;
|
||||
FT_Int first, last;
|
||||
|
||||
/* we need to compute the "previous" and "next" point */
|
||||
/* for this extrema.. */
|
||||
|
||||
/* we need to compute the `previous' and `next' point */
|
||||
/* for these extrema. */
|
||||
cur = outline->points + n;
|
||||
prev = cur - 1;
|
||||
next = cur + 1;
|
||||
|
@ -614,38 +666,40 @@
|
|||
|
||||
product = FT_MulDiv( cur->x - prev->x, /* in.x */
|
||||
next->y - cur->y, /* out.y */
|
||||
0x40 ) -
|
||||
|
||||
0x40 )
|
||||
-
|
||||
FT_MulDiv( cur->y - prev->y, /* in.y */
|
||||
next->x - cur->x, /* out.x */
|
||||
0x40 );
|
||||
|
||||
if (product)
|
||||
product = ( product > 0 ? 1 : -1 );
|
||||
if ( product )
|
||||
product = product > 0 ? 1 : -1;
|
||||
|
||||
return product;
|
||||
}
|
||||
|
||||
|
||||
/* Compute the orientation of path filling. It differs between TrueType */
|
||||
/* and Type1 formats. We could use the 'ft_outline_reverse_fill' flag, */
|
||||
/* but it's better to re-compute it directly (it seems that this flag */
|
||||
/* isn't correctly set for some weird composite glyphs for now).. */
|
||||
/* */
|
||||
/* We do this by computing bounding box points, and computing their */
|
||||
/* curvature.. the function returns either 1 or -1 */
|
||||
/* */
|
||||
/* Compute the orientation of path filling. It differs between TrueType */
|
||||
/* and Type1 formats. We could use the `ft_outline_reverse_fill' flag, */
|
||||
/* but it's better to re-compute it directly (it seems that this flag */
|
||||
/* isn't correctly set for some weird composite glyphs for now). */
|
||||
/* */
|
||||
/* We do this by computing bounding box points, and computing their */
|
||||
/* curvature. */
|
||||
/* */
|
||||
/* The function returns either 1 or -1. */
|
||||
/* */
|
||||
static
|
||||
int ft_get_orientation( FT_Outline* outline )
|
||||
{
|
||||
FT_BBox box;
|
||||
FT_BBox indexes;
|
||||
FT_BBox indices;
|
||||
int n, last;
|
||||
|
||||
indexes.xMin = -1;
|
||||
indexes.yMin = -1;
|
||||
indexes.xMax = -1;
|
||||
indexes.yMax = -1;
|
||||
indices.xMin = -1;
|
||||
indices.yMin = -1;
|
||||
indices.xMax = -1;
|
||||
indices.yMax = -1;
|
||||
|
||||
box.xMin = box.yMin = 32767;
|
||||
box.xMax = box.yMax = -32768;
|
||||
|
@ -654,45 +708,44 @@
|
|||
if ( outline->n_contours < 1 )
|
||||
return 1;
|
||||
|
||||
last = outline->contours[outline->n_contours-1];
|
||||
last = outline->contours[outline->n_contours - 1];
|
||||
|
||||
for ( n = 0; n <= last; n++ )
|
||||
{
|
||||
FT_Pos x, y;
|
||||
|
||||
|
||||
x = outline->points[n].x;
|
||||
if ( x < box.xMin )
|
||||
{
|
||||
box.xMin = x;
|
||||
indexes.xMin = n;
|
||||
indices.xMin = n;
|
||||
}
|
||||
|
||||
if ( x > box.xMax )
|
||||
{
|
||||
box.xMax = x;
|
||||
indexes.xMax = n;
|
||||
indices.xMax = n;
|
||||
}
|
||||
|
||||
y = outline->points[n].y;
|
||||
if ( y < box.yMin )
|
||||
{
|
||||
box.yMin = y;
|
||||
indexes.yMin = n;
|
||||
indices.yMin = n;
|
||||
}
|
||||
|
||||
if ( y > box.yMax )
|
||||
{
|
||||
box.yMax = y;
|
||||
indexes.yMax = n;
|
||||
indices.yMax = n;
|
||||
}
|
||||
}
|
||||
|
||||
/* test orientation of the xmin */
|
||||
return ft_test_extrema( outline, indexes.xMin ) ||
|
||||
ft_test_extrema( outline, indexes.yMin ) ||
|
||||
ft_test_extrema( outline, indexes.xMax ) ||
|
||||
ft_test_extrema( outline, indexes.yMax ) ||
|
||||
1; /* this is an empty glyph ?? */
|
||||
return ft_test_extrema( outline, indices.xMin ) ||
|
||||
ft_test_extrema( outline, indices.yMin ) ||
|
||||
ft_test_extrema( outline, indices.xMax ) ||
|
||||
ft_test_extrema( outline, indices.yMax ) ||
|
||||
1; /* this is an empty glyph? */
|
||||
}
|
||||
|
||||
|
||||
|
@ -707,10 +760,11 @@
|
|||
FT_Pos distance;
|
||||
int c, n, first, orientation;
|
||||
|
||||
(void)advance;
|
||||
UNUSED( advance );
|
||||
|
||||
|
||||
/* compute control distance */
|
||||
distance = FT_MulFix( original->em_size/60,
|
||||
distance = FT_MulFix( original->em_size / 60,
|
||||
original->size->metrics.y_scale );
|
||||
|
||||
orientation = ft_get_orientation( &original->glyph->outline );
|
||||
|
@ -722,15 +776,17 @@
|
|||
{
|
||||
int last = outline->contours[c];
|
||||
|
||||
|
||||
prev = points[last];
|
||||
|
||||
for ( n = first; n <= last; n++ )
|
||||
{
|
||||
FT_Pos norme, delta, d;
|
||||
FT_Pos norm, delta, d;
|
||||
FT_Vector in, out;
|
||||
|
||||
|
||||
cur = points[n];
|
||||
if ( n < last ) next = points[n+1];
|
||||
if ( n < last ) next = points[n + 1];
|
||||
else next = points[first];
|
||||
|
||||
/* compute the in and out vectors */
|
||||
|
@ -741,13 +797,13 @@
|
|||
out.y = next.y - cur.y;
|
||||
|
||||
/* compute U and V */
|
||||
norme = ft_norm( &in );
|
||||
u.x = orientation * FT_DivFix( in.y, norme );
|
||||
u.y = orientation * - FT_DivFix( in.x, norme );
|
||||
norm = ft_norm( &in );
|
||||
u.x = orientation * FT_DivFix( in.y, norm );
|
||||
u.y = orientation * -FT_DivFix( in.x, norm );
|
||||
|
||||
norme = ft_norm( &out );
|
||||
v.x = orientation * FT_DivFix( out.y, norme );
|
||||
v.y = orientation * - FT_DivFix( out.x, norme );
|
||||
norm = ft_norm( &out );
|
||||
v.x = orientation * FT_DivFix( out.y, norm );
|
||||
v.y = orientation * -FT_DivFix( out.x, norm );
|
||||
|
||||
d = distance;
|
||||
|
||||
|
@ -756,11 +812,12 @@
|
|||
|
||||
/* Check discriminant for parallel vectors */
|
||||
delta = FT_MulFix( u.x, v.y ) - FT_MulFix( u.y, v.x );
|
||||
if ( delta > FT_BOLD_THRESHOLD || delta < - FT_BOLD_THRESHOLD )
|
||||
if ( delta > FT_BOLD_THRESHOLD || delta < -FT_BOLD_THRESHOLD )
|
||||
{
|
||||
/* Move point - compute A and B */
|
||||
/* Move point -- compute A and B */
|
||||
FT_Pos x, y, A, B;
|
||||
|
||||
|
||||
A = d + FT_MulFix( cur.x, u.x ) + FT_MulFix( cur.y, u.y );
|
||||
B = d + FT_MulFix( cur.x, v.x ) + FT_MulFix( cur.y, v.y );
|
||||
|
||||
|
@ -775,8 +832,8 @@
|
|||
/* Vectors are nearly parallel */
|
||||
FT_Pos x, y;
|
||||
|
||||
x = distance + cur.x + FT_MulFix( d, u.x + v.x )/2;
|
||||
y = distance + cur.y + FT_MulFix( d, u.y + v.y )/2;
|
||||
x = distance + cur.x + FT_MulFix( d, u.x + v.x ) / 2;
|
||||
y = distance + cur.y + FT_MulFix( d, u.y + v.y ) / 2;
|
||||
|
||||
outline->points[n].x = x;
|
||||
outline->points[n].y = y;
|
||||
|
@ -785,13 +842,16 @@
|
|||
prev = cur;
|
||||
}
|
||||
|
||||
first = last+1;
|
||||
first = last + 1;
|
||||
}
|
||||
|
||||
if (advance)
|
||||
*advance = (*advance + distance*4) & -64;
|
||||
if ( advance )
|
||||
*advance = ( *advance + distance * 4 ) & -64;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif /* 0 - EXPERIMENTAL STUFF !! */
|
||||
#endif /* 0 -- EXPERIMENTAL STUFF! */
|
||||
|
||||
|
||||
/* END */
|
||||
|
|
Loading…
Reference in New Issue