diff --git a/include/freetype/config/ftconfig.h b/include/freetype/config/ftconfig.h
index cd598d817..ab1966363 100644
--- a/include/freetype/config/ftconfig.h
+++ b/include/freetype/config/ftconfig.h
@@ -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
diff --git a/src/base/ftcalc.c b/src/base/ftcalc.c
index d51669506..b370a8a43 100644
--- a/src/base/ftcalc.c
+++ b/src/base/ftcalc.c
@@ -260,7 +260,7 @@
/* bytecode interpreter. */
/* */
/* */
/* The 32-bit square-root. */
diff --git a/src/base/ftextend.c b/src/base/ftextend.c
index 46198c34c..14e908719 100644
--- a/src/base/ftextend.c
+++ b/src/base/ftextend.c
@@ -24,6 +24,7 @@
/* */
/*************************************************************************/
+
#include
/* required by the tracing mode */
@@ -114,8 +115,9 @@
/* */
/* FreeType error code. 0 means success. */
/* */
- FT_EXPORT_FUNC(FT_Error) FT_Register_Extension( FT_Driver driver,
- FT_Extension_Class* class )
+ FT_EXPORT_FUNC( FT_Error ) FT_Register_Extension(
+ FT_Driver driver,
+ FT_Extension_Class* class )
{
FT_Extension_Registry* registry;
@@ -162,9 +164,10 @@
/* */
/* A pointer to the extension block. */
/* */
- FT_EXPORT_FUNC(void*) FT_Get_Extension( FT_Face face,
- const char* extension_id,
- void* *extension_interface )
+ FT_EXPORT_FUNC( void* ) FT_Get_Extension(
+ FT_Face face,
+ const char* extension_id,
+ void* *extension_interface )
{
FT_Extension_Registry* registry;
diff --git a/src/base/ftglyph.c b/src/base/ftglyph.c
index 877d36d0f..c21c84af2 100644
--- a/src/base/ftglyph.c
+++ b/src/base/ftglyph.c
@@ -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,31 +13,38 @@
/* 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
#include
+
static
- void ft_prepare_glyph( FT_Glyph glyph,
- FT_Face face,
- FT_Bool vertical )
+ void ft_prepare_glyph( FT_Glyph glyph,
+ FT_Face face,
+ FT_Bool vertical )
{
FT_Glyph_Metrics* metrics = &face->glyph->metrics;
- glyph->memory = face->memory;
- glyph->width = metrics->width;
- glyph->height = metrics->height;
- if (vertical)
+ glyph->memory = face->memory;
+ glyph->width = metrics->width;
+ glyph->height = metrics->height;
+
+ if ( vertical )
{
glyph->bearingX = metrics->vertBearingX;
glyph->bearingY = metrics->vertBearingY;
@@ -51,74 +58,80 @@
}
}
- /***********************************************************************
- *
- *
- * FT_Get_Glyph_Bitmap
- *
- *
- * A function used to directly return a monochrome bitmap glyph image
- * from a face.
- *
- *
- * bitglyph :: pointer to the new bitmap glyph
- *
- *
- * Error code. 0 means success.
- *
- *
- * 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,
- FT_UInt glyph_index,
- FT_UInt load_flags,
- FT_Int grays,
- FT_Vector* origin,
- FT_BitmapGlyph *abitglyph )
+ /*************************************************************************/
+ /* */
+ /* */
+ /* FT_Get_Glyph_Bitmap */
+ /* */
+ /* */
+ /* A function used to directly return a monochrome bitmap glyph image */
+ /* from a face. */
+ /* */
+ /* */
+ /* abitglyph :: A pointer to the new bitmap glyph. */
+ /* */
+ /* */
+ /* FreeType error code. 0 means success. */
+ /* */
+ /* */
+ /* 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_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,104 +150,115 @@
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;
switch ( face->glyph->format )
{
- case ft_glyph_format_bitmap:
+ case ft_glyph_format_bitmap:
+ {
+ FT_Long size;
+ FT_Bitmap* source;
+
+
+ if ( ALLOC( bitglyph, sizeof ( *bitglyph ) ) )
+ goto Exit;
+
+ glyph = (FT_Glyph)bitglyph;
+ glyph->glyph_type = ft_glyph_type_bitmap;
+ ft_prepare_glyph( glyph, face, 0 );
+
+ source = &face->glyph->bitmap;
+ size = source->rows * source->pitch;
+ if ( size < 0 )
+ size = -size;
+
+ bitglyph->bitmap = *source;
+ if ( ALLOC( bitglyph->bitmap.buffer, size ) )
+ goto Fail;
+
+ /* copy the content of the source glyph */
+ MEM_Copy( bitglyph->bitmap.buffer, source->buffer, size );
+ }
+ break;
+
+ case ft_glyph_format_outline:
+ {
+ FT_BBox cbox;
+ 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 );
+ FT_Outline_Translate( &face->glyph->outline,
+ face->transform_delta.x + origin_x,
+ face->transform_delta.y + origin_y );
+
+ /* compute the size in pixels of the outline */
+ 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;
+
+ width = ( cbox.xMax - cbox.xMin ) >> 6;
+ height = ( cbox.yMax - cbox.yMin ) >> 6;
+
+ /* allocate the pixel buffer for the glyph bitmap */
+ if ( grays )
+ /* some raster implementation need this */
+ pitch = ( width + 3 ) & -4;
+ else
+ pitch = ( width + 7 ) >> 3;
+
+ size = pitch * height;
+ if ( ALLOC( bitglyph, sizeof ( *bitglyph ) ) )
+ goto Exit;
+
+ glyph = (FT_Glyph)bitglyph;
+ glyph->glyph_type = ft_glyph_type_bitmap;
+ ft_prepare_glyph( glyph, face, 0 );
+
+ if ( ALLOC( bitglyph->bitmap.buffer, size ) )
+ goto Fail;
+
+ bitglyph->bitmap.width = width;
+ bitglyph->bitmap.rows = height;
+ bitglyph->bitmap.pitch = pitch;
+ bitglyph->bitmap.pixel_mode = grays ? ft_pixel_mode_grays
+ : ft_pixel_mode_mono;
+ bitglyph->bitmap.num_grays = (short)grays;
+
+ 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 );
+ error = FT_Outline_Get_Bitmap( face->driver->library,
+ &face->glyph->outline,
+ &bitglyph->bitmap );
+ if ( error )
{
- FT_Long size;
- FT_Bitmap* source;
-
- if ( ALLOC( bitglyph, sizeof(*bitglyph) ) )
- goto Exit;
-
- glyph = (FT_Glyph)bitglyph;
- glyph->glyph_type = ft_glyph_type_bitmap;
- ft_prepare_glyph( glyph, face, 0 );
-
- source = &face->glyph->bitmap;
- size = source->rows * source->pitch;
- if (size < 0) size = -size;
-
- bitglyph->bitmap = *source;
- if ( ALLOC( bitglyph->bitmap.buffer, size ) )
- goto Fail;
-
- /* copy the content of the source glyph */
- MEM_Copy( bitglyph->bitmap.buffer, source->buffer, size );
+ FREE( bitglyph->bitmap.buffer );
+ goto Fail;
}
- break;
+ }
+ break;
- case ft_glyph_format_outline:
- {
- FT_BBox cbox;
- 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 );
- FT_Outline_Translate( &face->glyph->outline,
- face->transform_delta.x + origin_x,
- face->transform_delta.y + origin_y );
-
- /* compute the size in pixels of the outline */
- 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;
-
- 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;
-
- size = pitch * height;
- if ( ALLOC( bitglyph, sizeof(*bitglyph) ) )
- goto Exit;
-
- glyph = (FT_Glyph)bitglyph;
- glyph->glyph_type = ft_glyph_type_bitmap;
- ft_prepare_glyph( glyph, face, 0 );
-
- if ( ALLOC( bitglyph->bitmap.buffer, size ) )
- goto Fail;
-
- bitglyph->bitmap.width = width;
- bitglyph->bitmap.rows = height;
- bitglyph->bitmap.pitch = pitch;
- bitglyph->bitmap.pixel_mode = grays ? ft_pixel_mode_grays
- : ft_pixel_mode_mono;
- bitglyph->bitmap.num_grays = (short)grays;
-
- 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 );
- error = FT_Outline_Get_Bitmap( face->driver->library,
- &face->glyph->outline,
- &bitglyph->bitmap );
- if (error)
- {
- FREE( bitglyph->bitmap.buffer );
- goto Fail;
- }
- }
- break;
-
- default:
- error = FT_Err_Invalid_Glyph_Index;
- goto Exit;
+ default:
+ error = FT_Err_Invalid_Glyph_Index;
+ goto Exit;
}
*abitglyph = bitglyph;
+
Exit:
return error;
@@ -244,45 +268,46 @@
}
- /***********************************************************************
- *
- *
- * FT_Get_Glyph_Outline
- *
- *
- * 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..
- *
- *
- * vecglyph :: pointer to the new outline glyph
- *
- *
- * Error code. 0 means success.
- *
- *
- * 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_Get_Glyph_Outline */
+ /* */
+ /* */
+ /* 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(). */
+ /* */
+ /* */
+ /* vecglyph :: A pointer to the new outline glyph. */
+ /* */
+ /* */
+ /* FreeType error code. 0 means success. */
+ /* */
+ /* */
+ /* 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_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;
}
- /***********************************************************************
- *
- *
- * FT_Set_Transform
- *
- *
- * 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
- *
- *
- * 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,
- FT_Matrix* matrix,
- FT_Vector* delta )
+ /*************************************************************************/
+ /* */
+ /* */
+ /* FT_Set_Transform */
+ /* */
+ /* */
+ /* 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(). */
+ /* */
+ /* */
+ /* face :: A handle to the source face object. */
+ /* */
+ /* */
+ /* 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) ||
- matrix->xx != 0x10000L ||
- matrix->yy != 0x10000L )
+ /* 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;
}
- /***********************************************************************
- *
- *
- * FT_Done_Glyph
- *
- *
- * Destroys a given glyph..
- *
- * */
+ /* FT_Done_Glyph */
+ /* */
+ /* */
+ /* Destroys a given glyph. */
+ /* */
+ /*
- * FT_Glyph_Get_Box
- *
- *
- * Returns the glyph image's bounding box in pixels.
- *
- *
- * box :: the glyph bounding box. Coordinates are expressed in
- * _integer_ pixels, with exclusive max bounds
- *
- *
- * 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 )
+ /*************************************************************************/
+ /* */
+ /* */
+ /* FT_Glyph_Get_Box */
+ /* */
+ /* */
+ /* Returns the glyph image's bounding box in pixels. */
+ /* */
+ /* */
+ /* box :: The glyph bounding box. Coordinates are expressed in */
+ /* _integer_ pixels, with exclusive maximal bounding values. */
+ /* */
+ /* */
+ /* 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 ****/
- /**** ****/
- /***************************************************************************/
- /***************************************************************************/
+ /*************************************************************************/
+ /*************************************************************************/
+ /**** ****/
+ /**** EXPERIMENTAL EMBOLDENING/OUTLINING SUPPORT ****/
+ /**** ****/
+ /*************************************************************************/
+ /*************************************************************************/
#if 0
-/* Compute the norm of a vector */
-#ifdef FT_CONFIG_OPTION_OLD_CALCS
- static
- FT_Pos ft_norm( FT_Vector* vec )
- {
- FT_Int64 t1, t2;
+ /* Compute the norm of a vector */
- 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);
+#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 );
}
-#else
+
+#else /* FT_CONFIG_OPTION_OLD_CALCS */
+
static
FT_Pos ft_norm( FT_Vector* vec )
{
@@ -525,76 +569,84 @@
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,
int n )
{
- FT_Vector *prev, *cur, *next;
- FT_Pos product;
+ FT_Vector *prev, *cur, *next;
+ FT_Pos product;
FT_Int first, last;
- /* we need to compute the "previous" and "next" point */
- /* for this extrema.. */
- cur = outline->points + n;
+
+ /* we need to compute the `previous' and `next' point */
+ /* for these extrema. */
+ cur = outline->points + n;
prev = cur - 1;
next = cur + 1;
@@ -612,186 +664,194 @@
first = last + 1;
}
- product = FT_MulDiv( cur->x - prev->x, /* in.x */
+ 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;
+ 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;
- int n, last;
+ FT_BBox box;
+ 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;
+ box.xMin = box.yMin = 32767;
+ box.xMax = box.yMax = -32768;
- /* is it empty ? */
- if ( outline->n_contours < 1 )
- return 1;
+ /* is it empty ? */
+ 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;
+ 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;
- }
- if ( x > box.xMax )
- {
- box.xMax = x;
- indexes.xMax = n;
- }
+ x = outline->points[n].x;
+ if ( x < box.xMin )
+ {
+ box.xMin = x;
+ indices.xMin = n;
+ }
+ if ( x > box.xMax )
+ {
+ box.xMax = x;
+ indices.xMax = n;
+ }
- y = outline->points[n].y;
- if ( y < box.yMin )
- {
- box.yMin = y;
- indexes.yMin = n;
- }
+ y = outline->points[n].y;
+ if ( y < box.yMin )
+ {
+ box.yMin = y;
+ indices.yMin = n;
+ }
+ if ( y > box.yMax )
+ {
+ box.yMax = y;
+ indices.yMax = n;
+ }
+ }
- if ( y > box.yMax )
- {
- box.yMax = y;
- indexes.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 ?? */
+ /* test orientation of the xmin */
+ 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? */
}
static
- FT_Error ft_embolden( FT_Face original,
- FT_Outline* outline,
- FT_Pos* advance )
+ FT_Error ft_embolden( FT_Face original,
+ FT_Outline* outline,
+ FT_Pos* advance )
{
- FT_Vector u, v;
- FT_Vector* points;
- FT_Vector cur, prev, next;
- FT_Pos distance;
- int c, n, first, orientation;
+ FT_Vector u, v;
+ FT_Vector* points;
+ FT_Vector cur, prev, next;
+ FT_Pos distance;
+ int c, n, first, orientation;
- (void)advance;
+ UNUSED( advance );
- /* compute control distance */
- distance = FT_MulFix( original->em_size/60,
- original->size->metrics.y_scale );
- orientation = ft_get_orientation( &original->glyph->outline );
+ /* compute control distance */
+ distance = FT_MulFix( original->em_size / 60,
+ original->size->metrics.y_scale );
- points = original->glyph->outline.points;
+ orientation = ft_get_orientation( &original->glyph->outline );
- first = 0;
- for ( c = 0; c < outline->n_contours; c++ )
- {
- int last = outline->contours[c];
+ points = original->glyph->outline.points;
- prev = points[last];
+ first = 0;
+ for ( c = 0; c < outline->n_contours; c++ )
+ {
+ int last = outline->contours[c];
- for ( n = first; n <= last; n++ )
- {
- FT_Pos norme, delta, d;
- FT_Vector in, out;
- cur = points[n];
- if ( n < last ) next = points[n+1];
- else next = points[first];
+ prev = points[last];
- /* compute the in and out vectors */
- in.x = cur.x - prev.x;
- in.y = cur.y - prev.y;
+ for ( n = first; n <= last; n++ )
+ {
+ FT_Pos norm, delta, d;
+ FT_Vector in, out;
- out.x = next.x - cur.x;
- 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 );
+ cur = points[n];
+ if ( n < last ) next = points[n + 1];
+ else next = points[first];
- norme = ft_norm( &out );
- v.x = orientation * FT_DivFix( out.y, norme );
- v.y = orientation * - FT_DivFix( out.x, norme );
+ /* compute the in and out vectors */
+ in.x = cur.x - prev.x;
+ in.y = cur.y - prev.y;
- d = distance;
+ out.x = next.x - cur.x;
+ out.y = next.y - cur.y;
- if ( (outline->flags[n] & FT_Curve_Tag_On) == 0 )
- d *= 2;
+ /* compute U and V */
+ norm = ft_norm( &in );
+ u.x = orientation * FT_DivFix( in.y, norm );
+ u.y = orientation * -FT_DivFix( in.x, norm );
- /* 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 )
- {
- /* Move point - compute A and B */
- FT_Pos x, y, A, B;
+ norm = ft_norm( &out );
+ v.x = orientation * FT_DivFix( out.y, norm );
+ v.y = orientation * -FT_DivFix( out.x, norm );
- 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 );
+ d = distance;
- x = FT_MulFix( A, v.y ) - FT_MulFix( B, u.y );
- y = FT_MulFix( B, u.x ) - FT_MulFix( A, v.x );
+ if ( (outline->flags[n] & FT_Curve_Tag_On) == 0 )
+ d *= 2;
- outline->points[n].x = distance + FT_DivFix( x, delta );
- outline->points[n].y = distance + FT_DivFix( y, delta );
- }
- else
- {
- /* Vectors are nearly parallel */
- FT_Pos x, y;
+ /* 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 )
+ {
+ /* Move point -- compute A and B */
+ FT_Pos x, y, A, B;
- 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;
- }
+ 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 );
- prev = cur;
- }
+ x = FT_MulFix( A, v.y ) - FT_MulFix( B, u.y );
+ y = FT_MulFix( B, u.x ) - FT_MulFix( A, v.x );
- first = last+1;
- }
+ outline->points[n].x = distance + FT_DivFix( x, delta );
+ outline->points[n].y = distance + FT_DivFix( y, delta );
+ }
+ else
+ {
+ /* Vectors are nearly parallel */
+ FT_Pos x, y;
- if (advance)
- *advance = (*advance + distance*4) & -64;
+ x = distance + cur.x + FT_MulFix( d, u.x + v.x ) / 2;
+ y = distance + cur.y + FT_MulFix( d, u.y + v.y ) / 2;
- return 0;
+ outline->points[n].x = x;
+ outline->points[n].y = y;
+ }
+
+ prev = cur;
+ }
+
+ first = last + 1;
+ }
+
+ if ( advance )
+ *advance = ( *advance + distance * 4 ) & -64;
+
+ return 0;
}
-#endif /* 0 - EXPERIMENTAL STUFF !! */
+#endif /* 0 -- EXPERIMENTAL STUFF! */
+
+
+/* END */