mirrors/freetype
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

EXPORT_DEF renamed to FT_EXPORT_DEF +

Browse Source 
reformating/spacing
This commit is contained in:
David Turner 2000-05-24 00:31:14 +00:00
parent f5dcdd5cfb
commit 1fb6eea7d1
29 changed files with 396 additions and 391 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/freetype/config/ftconfig.h
View File

@ -179,16 +179,16 @@
#define BASE_FUNC(x) extern x
#endif
#ifndef EXPORT_DEF
#define EXPORT_DEF(x) extern x
#ifndef FT_EXPORT_DEF
#define FT_EXPORT_DEF(x) extern x
#endif
#ifndef EXPORT_FUNC
#define EXPORT_FUNC(x) extern x
#ifndef FT_EXPORT_FUNC
#define FT_EXPORT_FUNC(x) extern x
#endif
#ifndef EXPORT_VAR
#define EXPORT_VAR(x) extern x
#ifndef FT_EXPORT_VAR
#define FT_EXPORT_VAR(x) extern x
#endif
#endif /* FTCONFIG_H */

20
include/freetype/config/ftoption.h
View File

@ -147,30 +147,30 @@
/* declarations. */
/* */
/* Two macros are used within the FreeType source code to define */
/* exported library functions: EXPORT_DEF and EXPORT_FUNC */
/* exported library functions: FT_EXPORT_DEF and FT_EXPORT_FUNC */
/* */
/* EXPORT_DEF(return_type) is used in a function declaration, as in: */
/* FT_EXPORT_DEF(return_type) is used in a function declaration, as in: */
/* */
/* EXPORT_DEF(FT_Error) FT_Init_FreeType( FT_Library *alibrary ); */
/* FT_EXPORT_DEF(FT_Error) FT_Init_FreeType( FT_Library *alibrary ); */
/* */
/* */
/* */
/* EXPORT_FUNC(return_type) is used in a function definition, as in: */
/* FT_EXPORT_FUNC(return_type) is used in a function definition, as in: */
/* */
/* EXPORT_FUNC(FT_Error) FT_Init_FreeType( FT_Library *alibrary ) */
/* FT_EXPORT_FUNC(FT_Error) FT_Init_FreeType( FT_Library *alibrary ) */
/* { */
/* ... some code ... */
/* return FT_Err_Ok; */
/* } */
/* */
/* */
/* You can provide your own implementation of EXPORT_DEF and EXPORT_FUNC */
/* here if you want. If you leave them undefined, they'll later be */
/* automatically defined as "extern return_type" to allow normal */
/* You can provide your own implementation of FT_EXPORT_DEF and */
/* FT_EXPORT_FUNC here if you want. If you leave them undefined, they'll */
/* later be automatically defined as "extern return_type" to allow normal*/
/* compilation.. */
/* */
#undef EXPORT_DEF
#undef EXPORT_FUNC
#undef FT_EXPORT_DEF
#undef FT_EXPORT_FUNC
/*************************************************************************/

190
include/freetype/freetype.h
View File

@ -42,13 +42,13 @@
/*************************************************************************/
/* */
/* To make freetype.h independent from configuration files we check */
/* whether EXPORT_DEF has been defined already. */
/* whether FT_EXPORT_DEF has been defined already. */
/* */
/* On some systems and compilers (Win32 mostly), an extra keyword is */
/* necessary to compile the library as a DLL. */
/* */
#ifndef EXPORT_DEF
#define EXPORT_DEF(x) extern x
#ifndef FT_EXPORT_DEF
#define FT_EXPORT_DEF(x) extern x
#endif
#include <freetype/fterrors.h>
@ -998,7 +998,7 @@
/* <Return> */
/* Error code. 0 means success. */
/* */
EXPORT_DEF(FT_Error) FT_Init_FreeType( FT_Library* library );
FT_EXPORT_DEF(FT_Error) FT_Init_FreeType( FT_Library* library );
/*************************************************************************/
@ -1016,7 +1016,7 @@
/* <Return> */
/* Error code. 0 means success. */
/* */
EXPORT_DEF(FT_Error) FT_Done_FreeType( FT_Library library );
FT_EXPORT_DEF(FT_Error) FT_Done_FreeType( FT_Library library );
/*************************************************************************/
@ -1163,10 +1163,10 @@
/* through the FT_New_GlyphSlot() API function. Slots are linked in */
/* a single list through their `next' field. */
/* */
EXPORT_DEF(FT_Error) FT_New_Face( FT_Library library,
const char* filepathname,
FT_Long face_index,
FT_Face* face );
FT_EXPORT_DEF(FT_Error) FT_New_Face( FT_Library library,
const char* filepathname,
FT_Long face_index,
FT_Face* face );
/*************************************************************************/
@ -1207,11 +1207,11 @@
/* `*face'. Its return value should be 0 if the resource is */
/* recognized, or non-zero if not. */
/* */
EXPORT_DEF(FT_Error) FT_New_Memory_Face( FT_Library library,
void* file_base,
FT_Long file_size,
FT_Long face_index,
FT_Face* face );
FT_EXPORT_DEF(FT_Error) FT_New_Memory_Face( FT_Library library,
void* file_base,
FT_Long file_size,
FT_Long face_index,
FT_Face* face );
/*************************************************************************/
@ -1249,10 +1249,10 @@
/* when the face is destroyed. This means calling the stream's */
/* "close" function. */
/* */
EXPORT_DEF(FT_Error) FT_Open_Face( FT_Library library,
FT_Open_Args* args,
FT_Long face_index,
FT_Face* face );
FT_EXPORT_DEF(FT_Error) FT_Open_Face( FT_Library library,
FT_Open_Args* args,
FT_Long face_index,
FT_Face* face );
/*************************************************************************/
@ -1286,8 +1286,8 @@
/* when invoking this function. Most drivers simply do not implement */
/* file attachments.. */
/* */
EXPORT_DEF(FT_Error) FT_Attach_File( FT_Face face,
const char* filepathname );
FT_EXPORT_DEF(FT_Error) FT_Attach_File( FT_Face face,
const char* filepathname );
/*************************************************************************/
/* */
@ -1314,8 +1314,8 @@
/* when invoking this function. Most drivers simply do not implement */
/* file attachments.. */
/* */
EXPORT_DEF(FT_Error) FT_Attach_Stream( FT_Face face,
FT_Open_Args* parameters );
FT_EXPORT_DEF(FT_Error) FT_Attach_Stream( FT_Face face,
FT_Open_Args* parameters );
/*************************************************************************/
@ -1333,7 +1333,7 @@
/* <Return> */
/* Error code. 0 means success. */
/* */
EXPORT_DEF(FT_Error) FT_Done_Face( FT_Face face );
FT_EXPORT_DEF(FT_Error) FT_Done_Face( FT_Face face );
/*************************************************************************/
@ -1357,11 +1357,11 @@
/* When dealing with fixed-size faces (i.e., non-scalable formats), */
/* use the function FT_Set_Pixel_Sizes(). */
/* */
EXPORT_DEF(FT_Error) FT_Set_Char_Size( FT_Face face,
FT_F26Dot6 char_width,
FT_F26Dot6 char_height,
FT_UInt horz_resolution,
FT_UInt vert_resolution );
FT_EXPORT_DEF(FT_Error) FT_Set_Char_Size( FT_Face face,
FT_F26Dot6 char_width,
FT_F26Dot6 char_height,
FT_UInt horz_resolution,
FT_UInt vert_resolution );
/*************************************************************************/
@ -1381,9 +1381,9 @@
/* <Return> */
/* Error code. 0 means success. */
/* */
EXPORT_DEF(FT_Error) FT_Set_Pixel_Sizes( FT_Face face,
FT_UInt pixel_width,
FT_UInt pixel_height );
FT_EXPORT_DEF(FT_Error) FT_Set_Pixel_Sizes( FT_Face face,
FT_UInt pixel_width,
FT_UInt pixel_height );
/*************************************************************************/
@ -1410,9 +1410,9 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
EXPORT_DEF(FT_Error) FT_Load_Glyph( FT_Face face,
FT_UInt glyph_index,
FT_Int load_flags );
FT_EXPORT_DEF(FT_Error) FT_Load_Glyph( FT_Face face,
FT_UInt glyph_index,
FT_Int load_flags );
/*************************************************************************/
@ -1444,9 +1444,9 @@
/* is not defined in the charmap, this function will return an */
/* error.. */
/* */
EXPORT_DEF(FT_Error) FT_Load_Char( FT_Face face,
FT_ULong char_code,
FT_Int load_flags );
FT_EXPORT_DEF(FT_Error) FT_Load_Char( FT_Face face,
FT_ULong char_code,
FT_Int load_flags );
/*************************************************************************/
/* */
@ -1636,10 +1636,10 @@
/* kernings, are out of the scope of this API function -- they can be */
/* implemented through format-specific interfaces. */
/* */
EXPORT_DEF(FT_Error) FT_Get_Kerning( FT_Face face,
FT_UInt left_glyph,
FT_UInt right_glyph,
FT_Vector* kerning );
FT_EXPORT_DEF(FT_Error) FT_Get_Kerning( FT_Face face,
FT_UInt left_glyph,
FT_UInt right_glyph,
FT_Vector* kerning );
@ -1662,8 +1662,8 @@
/* This function will return an error if no charmap in the face */
/* corresponds to the encoding queried here */
/* */
EXPORT_DEF(FT_Error) FT_Select_Charmap( FT_Face face,
FT_Encoding encoding );
FT_EXPORT_DEF(FT_Error) FT_Select_Charmap( FT_Face face,
FT_Encoding encoding );
/*************************************************************************/
@ -1687,8 +1687,8 @@
/* of the face (i.e. if it is not listed in the face->charmaps[] */
/* table). */
/* */
EXPORT_DEF(FT_Error) FT_Set_Charmap( FT_Face face,
FT_CharMap charmap );
FT_EXPORT_DEF(FT_Error) FT_Set_Charmap( FT_Face face,
FT_CharMap charmap );
/*************************************************************************/
/* */
@ -1706,8 +1706,8 @@
/* <Return> */
/* The glyph index. 0 means `undefined character code'. */
/* */
EXPORT_DEF(FT_UInt) FT_Get_Char_Index( FT_Face face,
FT_ULong charcode );
FT_EXPORT_DEF(FT_UInt) FT_Get_Char_Index( FT_Face face,
FT_ULong charcode );
/*************************************************************************/
@ -1733,9 +1733,9 @@
/* divide by zero, it simply returns `MaxInt' or `MinInt' depending */
/* on the signs of `a' and `b'. */
/* */
EXPORT_DEF(FT_Long) FT_MulDiv( FT_Long a,
FT_Long b,
FT_Long c );
FT_EXPORT_DEF(FT_Long) FT_MulDiv( FT_Long a,
FT_Long b,
FT_Long c );
/*************************************************************************/
@ -1767,8 +1767,8 @@
/* _second_ argument of this function; this can make a great */
/* difference. */
/* */
EXPORT_DEF(FT_Long) FT_MulFix( FT_Long a,
FT_Long b );
FT_EXPORT_DEF(FT_Long) FT_MulFix( FT_Long a,
FT_Long b );
/*************************************************************************/
@ -1794,8 +1794,8 @@
/* in 32 bits, then the division is computed directly. Otherwise, */
/* we use a specialised version of the old FT_MulDiv64 */
/* */
EXPORT_DEF(FT_Long) FT_DivFix( FT_Long a,
FT_Long b );
FT_EXPORT_DEF(FT_Long) FT_DivFix( FT_Long a,
FT_Long b );
/*************************************************************************/
@ -1826,9 +1826,9 @@
/* */
/* It will use the raster correponding to the default glyph format. */
/* */
EXPORT_DEF(FT_Error) FT_Outline_Get_Bitmap( FT_Library library,
FT_Outline* outline,
FT_Bitmap* map );
FT_EXPORT_DEF(FT_Error) FT_Outline_Get_Bitmap( FT_Library library,
FT_Outline* outline,
FT_Bitmap* bitmap );
/*************************************************************************/
/* */
@ -1861,9 +1861,9 @@
/* scan converter is called, which means that the value you give it */
/* is actually ignored.. */
/* */
EXPORT_DEF(FT_Error) FT_Outline_Render( FT_Library library,
FT_Outline* outline,
FT_Raster_Params* params );
FT_EXPORT_DEF(FT_Error) FT_Outline_Render( FT_Library library,
FT_Outline* outline,
FT_Raster_Params* params );
/*************************************************************************/
/* */
@ -1889,9 +1889,9 @@
/* <Return> */
/* Error code. 0 means sucess. */
/* */
EXPORT_DEF(int) FT_Outline_Decompose( FT_Outline* outline,
FT_Outline_Funcs* funcs,
void* user );
FT_EXPORT_DEF(int) FT_Outline_Decompose( FT_Outline* outline,
FT_Outline_Funcs* funcs,
void* user );
/*************************************************************************/
@ -1928,10 +1928,10 @@
/* code of this function, replacing allocations with `malloc()' if */
/* you want to control where the objects go. */
/* */
EXPORT_DEF(FT_Error) FT_Outline_New( FT_Library library,
FT_UInt numPoints,
FT_Int numContours,
FT_Outline* outline );
FT_EXPORT_DEF(FT_Error) FT_Outline_New( FT_Library library,
FT_UInt numPoints,
FT_Int numContours,
FT_Outline* outline );
/*************************************************************************/
@ -1963,7 +1963,7 @@
/* of this function, replacing allocations with `malloc()' in your */
/* application if you want something simpler. */
/* */
EXPORT_DEF(FT_Error) FT_Outline_Done( FT_Library library,
FT_EXPORT_DEF(FT_Error) FT_Outline_Done( FT_Library library,
FT_Outline* outline );
/*************************************************************************/
@ -1992,8 +1992,8 @@
/* <MT-Note> */
/* Yes. */
/* */
EXPORT_DEF(void) FT_Outline_Get_CBox( FT_Outline* outline,
FT_BBox* cbox );
FT_EXPORT_DEF(void) FT_Outline_Get_CBox( FT_Outline* outline,
FT_BBox* cbox );
/*************************************************************************/
@ -2012,9 +2012,9 @@
/* <MT-Note> */
/* Yes. */
/* */
EXPORT_DEF(void) FT_Outline_Translate( FT_Outline* outline,
FT_Pos xOffset,
FT_Pos yOffset );
FT_EXPORT_DEF(void) FT_Outline_Translate( FT_Outline* outline,
FT_Pos xOffset,
FT_Pos yOffset );
/*************************************************************************/
@ -2043,8 +2043,8 @@
/* */
/* - the new raster is registered for the glyph format */
/* */
EXPORT_DEF(FT_Error) FT_Set_Raster( FT_Library library,
FT_Raster_Funcs* raster_funcs );
FT_EXPORT_DEF(FT_Error) FT_Set_Raster( FT_Library library,
FT_Raster_Funcs* raster_funcs );
/*************************************************************************/
@ -2067,8 +2067,8 @@
/* as FT_Set_Raster unregisters the previous raster for a given */
/* glyph format.. */
/* */
EXPORT_DEF(FT_Error) FT_Unset_Raster( FT_Library library,
FT_Raster_Funcs* raster_funcs );
FT_EXPORT_DEF(FT_Error) FT_Unset_Raster( FT_Library library,
FT_Raster_Funcs* raster_funcs );
/*************************************************************************
@ -2093,9 +2093,9 @@
*
*************************************************************************/
EXPORT_DEF(FT_Raster) FT_Get_Raster( FT_Library library,
FT_Glyph_Format glyph_format,
FT_Raster_Funcs *raster_funcs );
FT_EXPORT_DEF(FT_Raster) FT_Get_Raster( FT_Library library,
FT_Glyph_Format glyph_format,
FT_Raster_Funcs *raster_funcs );
/*************************************************************************/
@ -2114,10 +2114,10 @@
/* <Return> */
/* Error code. 0 means success. */
/* */
EXPORT_DEF(FT_Error) FT_Set_Raster_Mode( FT_Library library,
FT_Glyph_Format format,
unsigned long mode,
void* args );
FT_EXPORT_DEF(FT_Error) FT_Set_Raster_Mode( FT_Library library,
FT_Glyph_Format format,
unsigned long mode,
void* args );
/***************************************************************************/
@ -2153,8 +2153,8 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
EXPORT_DEF(FT_Error) FT_Outline_Copy( FT_Outline* source,
FT_Outline* target );
FT_EXPORT_DEF(FT_Error) FT_Outline_Copy( FT_Outline* source,
FT_Outline* target );
@ -2178,8 +2178,8 @@
/* You can use FT_Outline_Translate() if you need to translate the */
/* outline's points. */
/* */
EXPORT_DEF(void) FT_Outline_Transform( FT_Outline* outline,
FT_Matrix* matrix );
FT_EXPORT_DEF(void) FT_Outline_Transform( FT_Outline* outline,
FT_Matrix* matrix );
/*************************************************************************/
/* */
@ -2200,7 +2200,7 @@
/* It shouldn't be used by a normal client application, unless it */
/* knows what it's doing.. */
/* */
EXPORT_DEF(void) FT_Outline_Reverse( FT_Outline* outline );
FT_EXPORT_DEF(void) FT_Outline_Reverse( FT_Outline* outline );
/*************************************************************************/
@ -2220,8 +2220,8 @@
/* <MT-Note> */
/* Yes. */
/* */
EXPORT_DEF(void) FT_Vector_Transform( FT_Vector* vector,
FT_Matrix* matrix );
FT_EXPORT_DEF(void) FT_Vector_Transform( FT_Vector* vector,
FT_Matrix* matrix );
/*************************************************************************/
@ -2241,8 +2241,8 @@
/* <MT-Note> */
/* Yes. */
/* */
EXPORT_DEF(void) FT_Matrix_Multiply( FT_Matrix* a,
FT_Matrix* b );
FT_EXPORT_DEF(void) FT_Matrix_Multiply( FT_Matrix* a,
FT_Matrix* b );
/*************************************************************************/
@ -2263,7 +2263,7 @@
/* <MT-Note> */
/* Yes. */
/* */
EXPORT_DEF(FT_Error) FT_Matrix_Invert( FT_Matrix* matrix );
FT_EXPORT_DEF(FT_Error) FT_Matrix_Invert( FT_Matrix* matrix );
/*************************************************************************/
/* */
@ -2276,7 +2276,7 @@
/* <InOut> */
/* library :: A handle to a new library object. */
/* */
EXPORT_DEF(void) FT_Default_Drivers( FT_Library library );
FT_EXPORT_DEF(void) FT_Default_Drivers( FT_Library library );
#ifdef __cplusplus
}

4
include/freetype/ftbbox.h
View File

@ -58,8 +58,8 @@
/* <Return> */
/* Error code. 0 means success. */
/* */
EXPORT_DEF(FT_Error) FT_Raster_GetBBox( FT_Outline* outline,
FT_BBox* abbox );
FT_EXPORT_DEF(FT_Error) FT_Raster_GetBBox( FT_Outline* outline,
FT_BBox* abbox );
#ifdef __cplusplus

42
include/freetype/ftglyph.h
View File

@ -101,6 +101,12 @@
* <Field>
* metrics :: the corresponding glyph metrics
* bitmap :: a descriptor for the bitmap.
* left :: left-side bearing, i.e. the horizontal distance from
* the current pen position to the left border of the glyph
* bitmap.
* top :: top-side bearing, i.e. the vertical distance from the
* current pen position to the top border of the glyph bitmap
* this distance is positive for upwards-y !!
*
* <Note>
* the "width" and "height" fields of the metrics are expressed in
@ -166,7 +172,7 @@
* FT_Get_Glyph_Bitmap
*
* <Description>
* A function used to directly return a monochrome bitmap glyph image
* A function used to directly return a bitmap glyph image
* from a face.
*
* <Input>
@ -204,12 +210,12 @@
*
***********************************************************************/
EXPORT_DEF(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_EXPORT_DEF(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 );
/***********************************************************************
@ -218,7 +224,7 @@
* FT_Get_Glyph_Outline
*
* <Description>
* A function used to directly return a bitmap glyph image from a
* A function used to directly return an outline glyph image from a
* face. This is faster than calling FT_Load_Glyph+FT_Get_Outline_Bitmap..
*
* <Input>
@ -241,10 +247,10 @@
*
***********************************************************************/
EXPORT_DEF(FT_Error) FT_Get_Glyph_Outline( FT_Face face,
FT_UInt glyph_index,
FT_UInt load_flags,
FT_OutlineGlyph *vecglyph );
FT_EXPORT_DEF(FT_Error) FT_Get_Glyph_Outline( FT_Face face,
FT_UInt glyph_index,
FT_UInt load_flags,
FT_OutlineGlyph *vecglyph );
/***********************************************************************
@ -268,9 +274,9 @@
*
***********************************************************************/
EXPORT_DEF(void) FT_Set_Transform( FT_Face face,
FT_Matrix* matrix,
FT_Vector* delta );
FT_EXPORT_DEF(void) FT_Set_Transform( FT_Face face,
FT_Matrix* matrix,
FT_Vector* delta );
/***********************************************************************
@ -286,7 +292,7 @@
*
***********************************************************************/
EXPORT_DEF(void) FT_Done_Glyph( FT_Glyph glyph );
FT_EXPORT_DEF(void) FT_Done_Glyph( FT_Glyph glyph );
/***********************************************************************
@ -313,8 +319,8 @@
*
***********************************************************************/
EXPORT_DEF(void) FT_Glyph_Get_Box( FT_Glyph glyph,
FT_BBox *box );
FT_EXPORT_DEF(void) FT_Glyph_Get_Box( FT_Glyph glyph,
FT_BBox *box );
#ifdef __cplusplus
}

8
include/freetype/ftgrays.h
View File

@ -27,16 +27,16 @@
/*************************************************************************/
/* */
/* To make ftgrays.h independent from configuration files we check */
/* whether EXPORT_DEF has been defined already. */
/* whether FT_EXPORT_DEF has been defined already. */
/* */
/* On some systems and compilers (Win32 mostly), an extra keyword is */
/* necessary to compile the library as a DLL. */
/* */
#ifndef EXPORT_VAR
#define EXPORT_VAR(x) extern x
#ifndef FT_EXPORT_VAR
#define FT_EXPORT_VAR(x) extern x
#endif
EXPORT_VAR(FT_Raster_Funcs) ft_grays_raster;
FT_EXPORT_VAR(FT_Raster_Funcs) ft_grays_raster;
#ifdef __cplusplus
}

6
include/freetype/ftraster.h
View File

@ -32,11 +32,11 @@
/* */
/* #define _STANDALONE_ */
#ifndef EXPORT_VAR
#define EXPORT_VAR(x) extern x
#ifndef FT_EXPORT_VAR
#define FT_EXPORT_VAR(x) extern x
#endif
EXPORT_VAR(FT_Raster_Funcs) ft_standard_raster;
FT_EXPORT_VAR(FT_Raster_Funcs) ft_standard_raster;
#ifdef __cplusplus
}

10
include/freetype/internal/ftcalc.h
View File

@ -41,7 +41,7 @@
#define SQRT_64( z ) FT_Sqrt64( z )
EXPORT_DEF(FT_Int32) FT_Sqrt64( FT_Int64 x );
FT_EXPORT_DEF(FT_Int32) FT_Sqrt64( FT_Int64 x );
#endif /* OLD_CALCS */
@ -58,17 +58,17 @@
#define MUL_64( x, y, z ) FT_MulTo64( x, y, &z )
#define DIV_64( x, y ) FT_Div64by32( &x, y )
EXPORT_DEF(void) FT_Add64 ( FT_Int64* x, FT_Int64* y, FT_Int64* z );
FT_EXPORT_DEF(void) FT_Add64 ( FT_Int64* x, FT_Int64* y, FT_Int64* z );
EXPORT_DEF(void) FT_MulTo64 ( FT_Int32 x, FT_Int32 y, FT_Int64* z );
FT_EXPORT_DEF(void) FT_MulTo64 ( FT_Int32 x, FT_Int32 y, FT_Int64* z );
EXPORT_DEF(FT_Int32) FT_Div64by32( FT_Int64* x, FT_Int32 y );
FT_EXPORT_DEF(FT_Int32) FT_Div64by32( FT_Int64* x, FT_Int32 y );
#ifdef FT_CONFIG_OPTION_OLD_CALCS
#define SQRT_64( z ) FT_Sqrt64( &z )
EXPORT_DEF(FT_Int32) FT_Sqrt64( FT_Int64* x );
FT_EXPORT_DEF(FT_Int32) FT_Sqrt64( FT_Int64* x );
#endif /* OLD_CALC */

8
include/freetype/internal/ftdebug.h
View File

@ -120,8 +120,8 @@
} while ( 0 )
EXPORT_DEF(void) FT_SetTraceLevel( FT_Trace component,
char level );
FT_EXPORT_DEF(void) FT_SetTraceLevel( FT_Trace component,
char level );
#elif defined( FT_DEBUG_LEVEL_ERROR )
@ -165,10 +165,10 @@
} while ( 0 )
/* print a message */
EXPORT_DEF(void) FT_Message( const char* fmt, ... );
FT_EXPORT_DEF(void) FT_Message( const char* fmt, ... );
/* print a message and exit */
EXPORT_DEF(void) FT_Panic ( const char* fmt, ... );
FT_EXPORT_DEF(void) FT_Panic ( const char* fmt, ... );
#define FT_ERROR(varformat) do { FT_XCAT( FT_Message, varformat ) } while(0)

10
include/freetype/internal/ftextend.h
View File

@ -120,8 +120,8 @@
} FT_Extension_Class;
EXPORT_DEF(FT_Error) FT_Register_Extension( FT_Driver driver,
FT_Extension_Class* clazz );
FT_EXPORT_DEF(FT_Error) FT_Register_Extension( FT_Driver driver,
FT_Extension_Class* clazz );
#ifdef FT_CONFIG_OPTION_EXTEND_ENGINE
@ -150,9 +150,9 @@
/* Returns an extension's data & interface according to its ID */
EXPORT_DEF(void*) FT_Get_Extension( FT_Face face,
const char* extension_id,
void* *extension_interface );
FT_EXPORT_DEF(void*) FT_Get_Extension( FT_Face face,
const char* extension_id,
void* *extension_interface );
#ifdef __cplusplus
}

34
include/freetype/internal/ftlist.h
View File

@ -33,20 +33,20 @@
#endif
EXPORT_DEF(FT_ListNode) FT_List_Find( FT_List list,
void* data );
FT_EXPORT_DEF(FT_ListNode) FT_List_Find( FT_List list,
void* data );
EXPORT_DEF(void) FT_List_Add( FT_List list,
FT_ListNode node );
EXPORT_DEF(void) FT_List_Insert( FT_List list,
FT_EXPORT_DEF(void) FT_List_Add( FT_List list,
FT_ListNode node );
EXPORT_DEF(void) FT_List_Remove( FT_List list,
FT_ListNode node );
FT_EXPORT_DEF(void) FT_List_Insert( FT_List list,
FT_ListNode node );
EXPORT_DEF(void) FT_List_Up( FT_List list,
FT_ListNode node );
FT_EXPORT_DEF(void) FT_List_Remove( FT_List list,
FT_ListNode node );
FT_EXPORT_DEF(void) FT_List_Up( FT_List list,
FT_ListNode node );
/*************************************************************************/
@ -67,9 +67,9 @@
void* user );
EXPORT_DEF(FT_Error) FT_List_Iterate( FT_List list,
FT_List_Iterator iterator,
void* user );
FT_EXPORT_DEF(FT_Error) FT_List_Iterate( FT_List list,
FT_List_Iterator iterator,
void* user );
/*************************************************************************/
@ -93,10 +93,10 @@
void* user );
EXPORT_DEF(void) FT_List_Finalize( FT_List list,
FT_List_Destructor destroy,
FT_Memory memory,
void* user );
FT_EXPORT_DEF(void) FT_List_Finalize( FT_List list,
FT_List_Destructor destroy,
FT_Memory memory,
void* user );
#ifdef __cplusplus

44
include/freetype/internal/ftobjs.h
View File

@ -68,15 +68,15 @@
EXPORT_DEF(FT_Error) FT_New_Size( FT_Face face,
FT_Size* size );
FT_EXPORT_DEF(FT_Error) FT_New_Size( FT_Face face,
FT_Size* size );
EXPORT_DEF(FT_Error) FT_Done_Size( FT_Size size );
FT_EXPORT_DEF(FT_Error) FT_Done_Size( FT_Size size );
EXPORT_DEF(FT_Error) FT_New_GlyphSlot( FT_Face face,
FT_GlyphSlot* aslot );
FT_EXPORT_DEF(FT_Error) FT_New_GlyphSlot( FT_Face face,
FT_GlyphSlot* aslot );
EXPORT_DEF(void) FT_Done_GlyphSlot( FT_GlyphSlot slot );
FT_EXPORT_DEF(void) FT_Done_GlyphSlot( FT_GlyphSlot slot );
@ -281,37 +281,37 @@
} FT_LibraryRec;
EXPORT_DEF(FT_Error) FT_New_Library( FT_Memory memory,
FT_Library* library );
FT_EXPORT_DEF(FT_Error) FT_New_Library( FT_Memory memory,
FT_Library* library );
EXPORT_DEF(FT_Error) FT_Done_Library( FT_Library library );
FT_EXPORT_DEF(FT_Error) FT_Done_Library( FT_Library library );
EXPORT_DEF(void) FT_Set_Debug_Hook( FT_Library library,
FT_UInt hook_index,
FT_DebugHook_Func debug_hook );
FT_EXPORT_DEF(void) FT_Set_Debug_Hook( FT_Library library,
FT_UInt hook_index,
FT_DebugHook_Func debug_hook );
EXPORT_DEF(FT_Error) FT_Add_Driver( FT_Library library,
const FT_DriverInterface* driver_interface );
FT_EXPORT_DEF(FT_Error) FT_Add_Driver( FT_Library library,
const FT_DriverInterface* driver_interface );
EXPORT_DEF(FT_Error) FT_Remove_Driver( FT_Driver driver );
FT_EXPORT_DEF(FT_Error) FT_Remove_Driver( FT_Driver driver );
EXPORT_DEF(FT_Driver) FT_Get_Driver( FT_Library library,
char* driver_name );
FT_EXPORT_DEF(FT_Driver) FT_Get_Driver( FT_Library library,
char* driver_name );
#ifndef FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM
EXPORT_DEF(FT_Error) FT_New_Stream( const char* filepathname,
FT_Stream astream );
FT_EXPORT_DEF(FT_Error) FT_New_Stream( const char* filepathname,
FT_Stream astream );
EXPORT_DEF(void) FT_Done_Stream( FT_Stream stream );
FT_EXPORT_DEF(void) FT_Done_Stream( FT_Stream stream );
EXPORT_DEF(FT_Memory) FT_New_Memory( void );
FT_EXPORT_DEF(FT_Memory) FT_New_Memory( void );
#endif
@ -320,7 +320,7 @@
/* Client applications can register new rasters through the FT_Set_Raster API.. */
/* */
#ifndef FT_NO_DEFAULT_RASTER
EXPORT_VAR(FT_Raster_Funcs) ft_default_raster;
FT_EXPORT_VAR(FT_Raster_Funcs) ft_default_raster;
#endif

4
include/freetype/tttables.h
View File

@ -558,8 +558,8 @@
*
***************************************************************************/
EXPORT_DEF(void*) FT_Get_Sfnt_Table( FT_Face face,
FT_Sfnt_Tag tag );
FT_EXPORT_DEF(void*) FT_Get_Sfnt_Table( FT_Face face,
FT_Sfnt_Tag tag );
#ifdef __cplusplus
}

50
src/base/ftcalc.c
View File

@ -69,7 +69,7 @@
/* <Return> */
/* The result of `sqrt(x)'. */
/* */
EXPORT_FUNC(FT_Int32) FT_Sqrt32( FT_Int32 x )
FT_EXPORT_FUNC(FT_Int32) FT_Sqrt32( FT_Int32 x )
{
FT_ULong val, root, newroot, mask;
@ -122,9 +122,9 @@
/* divide by zero, it simply returns `MaxInt' or `MinInt' depending */
/* on the signs of `a' and `b'. */
/* */
EXPORT_FUNC(FT_Long) FT_MulDiv( FT_Long a,
FT_Long b,
FT_Long c )
FT_EXPORT_FUNC(FT_Long) FT_MulDiv( FT_Long a,
FT_Long b,
FT_Long c )
{
FT_Int s;
@ -167,8 +167,8 @@
/* _second_ argument of this function; this can make a great */
/* difference. */
/* */
EXPORT_FUNC(FT_Long) FT_MulFix( FT_Long a,
FT_Long b )
FT_EXPORT_FUNC(FT_Long) FT_MulFix( FT_Long a,
FT_Long b )
{
FT_Int s;
@ -204,8 +204,8 @@
/* 32 bits, then the division is computed directly. Otherwise, we */
/* use a specialized version of the old FT_MulDiv64(). */
/* */
EXPORT_FUNC(FT_Long) FT_DivFix( FT_Long a,
FT_Long b )
FT_EXPORT_FUNC(FT_Long) FT_DivFix( FT_Long a,
FT_Long b )
{
FT_Int32 s;
FT_Word32 q;
@ -258,7 +258,7 @@
}
EXPORT_FUNC(FT_Int32) FT_Sqrt64( FT_Int64 l )
FT_EXPORT_FUNC(FT_Int32) FT_Sqrt64( FT_Int64 l )
{
FT_Int64 r, s;
@ -322,9 +322,9 @@
/* */
/* and 2*0x157F0 = 176096. */
/* */
EXPORT_FUNC(FT_Long) FT_MulDiv( FT_Long a,
FT_Long b,
FT_Long c )
FT_EXPORT_FUNC(FT_Long) FT_MulDiv( FT_Long a,
FT_Long b,
FT_Long c )
{
long s;
@ -387,8 +387,8 @@
/* idea is to use bounds like 2048 and 1048576 (=floor((2^31-1)/2048) */
/* for `a' and `b', respectively. */
/* */
EXPORT_FUNC(FT_Long) FT_MulFix( FT_Long a,
FT_Long b )
FT_EXPORT_FUNC(FT_Long) FT_MulFix( FT_Long a,
FT_Long b )
{
FT_Long s;
FT_ULong ua, ub;
@ -441,8 +441,8 @@
/* 32 bits, then the division is computed directly. Otherwise, we */
/* use a specialized version of the old FT_MulDiv64(). */
/* */
EXPORT_FUNC(FT_Long) FT_DivFix( FT_Long a,
FT_Long b )
FT_EXPORT_FUNC(FT_Long) FT_DivFix( FT_Long a,
FT_Long b )
{
FT_Int32 s;
FT_Word32 q;
@ -502,9 +502,9 @@
/* <Note> */
/* Will be wrapped by the ADD_64() macro. */
/* */
EXPORT_FUNC(void) FT_Add64( FT_Int64* x,
FT_Int64* y,
FT_Int64* z )
FT_EXPORT_FUNC(void) FT_Add64( FT_Int64* x,
FT_Int64* y,
FT_Int64* z )
{
register FT_Word32 lo, hi;
@ -534,9 +534,9 @@
/* <Note> */
/* Will be wrapped by the MUL_64() macro. */
/* */
EXPORT_FUNC(void) FT_MulTo64( FT_Int32 x,
FT_Int32 y,
FT_Int64* z )
FT_EXPORT_FUNC(void) FT_MulTo64( FT_Int32 x,
FT_Int32 y,
FT_Int64* z )
{
FT_Int32 s;
@ -599,8 +599,8 @@
/* <Note> */
/* Will be wrapped by the DIV_64() macro. */
/* */
EXPORT_FUNC(FT_Int32) FT_Div64by32( FT_Int64* x,
FT_Int32 y )
FT_EXPORT_FUNC(FT_Int32) FT_Div64by32( FT_Int64* x,
FT_Int32 y )
{
FT_Int32 s;
FT_Word32 q, r, i, lo;
@ -701,7 +701,7 @@
return j-1;
}
EXPORT_FUNC(FT_Int32) FT_Sqrt64( FT_Int64* l )
FT_EXPORT_FUNC(FT_Int32) FT_Sqrt64( FT_Int64* l )
{
FT_Int64 l2;
FT_Int32 r, s;

8
src/base/ftdebug.c
View File

@ -31,7 +31,7 @@
#include <string.h>
EXPORT_FUNC(void) FT_Message( const char* fmt, ... )
FT_EXPORT_FUNC(void) FT_Message( const char* fmt, ... )
{
va_list ap;
@ -42,7 +42,7 @@
}
EXPORT_FUNC(void) FT_Panic( const char* fmt, ... )
FT_EXPORT_FUNC(void) FT_Panic( const char* fmt, ... )
{
va_list ap;
@ -72,8 +72,8 @@
/* components will be traced. */
/* level :: The tracing level. */
/* */
EXPORT_FUNC(void) FT_SetTraceLevel( FT_Trace component,
char level )
FT_EXPORT_FUNC(void) FT_SetTraceLevel( FT_Trace component,
char level )
{
if ( component >= trace_max )
return;

10
src/base/ftextend.c
View File

@ -114,8 +114,8 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
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 +162,9 @@
/* <Return> */
/* A pointer to the extension block. */
/* */
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;

34
src/base/ftglyph.c
View File

@ -30,7 +30,7 @@
void ft_prepare_glyph( FT_Glyph glyph,
FT_Face face,
FT_Bool vertical )
{
{
FT_Glyph_Metrics* metrics = &face->glyph->metrics;
glyph->memory = face->memory;
@ -95,12 +95,12 @@
*
***********************************************************************/
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_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;
@ -270,10 +270,10 @@
*
***********************************************************************/
EXPORT_FUNC(FT_Error) FT_Get_Glyph_Outline( FT_Face face,
FT_UInt glyph_index,
FT_UInt load_flags,
FT_OutlineGlyph *vecglyph )
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;
@ -358,9 +358,9 @@
*
***********************************************************************/
EXPORT_FUNC(void) FT_Set_Transform( FT_Face face,
FT_Matrix* matrix,
FT_Vector* delta )
FT_EXPORT_FUNC(void) FT_Set_Transform( FT_Face face,
FT_Matrix* matrix,
FT_Vector* delta )
{
face->transform_flags = 0;
@ -408,7 +408,7 @@
*
***********************************************************************/
EXPORT_FUNC(void) FT_Done_Glyph( FT_Glyph glyph )
FT_EXPORT_FUNC(void) FT_Done_Glyph( FT_Glyph glyph )
{
if (glyph)
{
@ -459,8 +459,8 @@
*
***********************************************************************/
EXPORT_FUNC(void) FT_Glyph_Get_Box( FT_Glyph glyph,
FT_BBox *box )
FT_EXPORT_FUNC(void) FT_Glyph_Get_Box( FT_Glyph glyph,
FT_BBox *box )
{
box->xMin = box->xMax = 0;
box->yMin = box->yMax = 0;

4
src/base/ftinit.c
View File

@ -76,7 +76,7 @@ const FT_DriverInterface* ft_default_drivers[] =
/* <InOut> */
/* library :: A handle to a new library object. */
/* */
EXPORT_FUNC(void) FT_Default_Drivers( FT_Library library )
FT_EXPORT_FUNC(void) FT_Default_Drivers( FT_Library library )
{
FT_Error error;
const FT_DriverInterface* *cur;
@ -112,7 +112,7 @@ const FT_DriverInterface* ft_default_drivers[] =
/* <Return> */
/* FreeTyoe error code. 0 means success. */
/* */
EXPORT_FUNC(FT_Error) FT_Init_FreeType( FT_Library* library )
FT_EXPORT_FUNC(FT_Error) FT_Init_FreeType( FT_Library* library )
{
FT_Error error;
FT_Memory memory;

147
src/base/ftobjs.c
View File

@ -271,7 +271,7 @@
/* <Description> */
/* Closes and destroys a stream object. */
/* */
EXPORT_FUNC(void) FT_Done_Stream( FT_Stream stream )
FT_EXPORT_FUNC(void) FT_Done_Stream( FT_Stream stream )
{
if ( stream->close )
stream->close( stream );
@ -409,9 +409,9 @@
*
*************************************************************************/
EXPORT_FUNC(FT_Raster) FT_Get_Raster( FT_Library library,
FT_Glyph_Format glyph_format,
FT_Raster_Funcs *raster_funcs )
FT_EXPORT_FUNC(FT_Raster) FT_Get_Raster( FT_Library library,
FT_Glyph_Format glyph_format,
FT_Raster_Funcs *raster_funcs )
{
FT_Int n;
@ -454,8 +454,8 @@
/* */
/* - the new raster is registered for the glyph format */
/* */
EXPORT_FUNC(FT_Error) FT_Set_Raster( FT_Library library,
FT_Raster_Funcs* raster_funcs )
FT_EXPORT_FUNC(FT_Error) FT_Set_Raster( FT_Library library,
FT_Raster_Funcs* raster_funcs )
{
FT_Glyph_Format glyph_format = raster_funcs->glyph_format;
FT_Raster_Funcs* funcs;
@ -528,8 +528,8 @@
/* <Return> */
/* Error code. 0 means success. */
/* */
EXPORT_DEF(FT_Error) FT_Unset_Raster( FT_Library library,
FT_Raster_Funcs* raster_funcs )
FT_EXPORT_DEF(FT_Error) FT_Unset_Raster( FT_Library library,
FT_Raster_Funcs* raster_funcs )
{
FT_Glyph_Format glyph_format = raster_funcs->glyph_format;
FT_Error error;
@ -574,10 +574,10 @@
/* <Return> */
/* Error code. 0 means success. */
/* */
EXPORT_FUNC(FT_Error) FT_Set_Raster_Mode( FT_Library library,
FT_Glyph_Format format,
unsigned long mode,
void* args )
FT_EXPORT_FUNC(FT_Error) FT_Set_Raster_Mode( FT_Library library,
FT_Glyph_Format format,
unsigned long mode,
void* args )
{
FT_Raster_Funcs funcs;
FT_Raster raster;
@ -609,7 +609,7 @@
/* Currently, four debug hook slots are available, but only two (for */
/* the TrueType and the Type 1 interpreter) are defined. */
/* */
EXPORT_FUNC(void) FT_Set_Debug_Hook( FT_Library library,
FT_EXPORT_FUNC(void) FT_Set_Debug_Hook( FT_Library library,
FT_UInt hook_index,
FT_DebugHook_Func debug_hook )
{
@ -637,8 +637,8 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
EXPORT_FUNC(FT_Error) FT_New_Library( FT_Memory memory,
FT_Library* alibrary )
FT_EXPORT_FUNC(FT_Error) FT_New_Library( FT_Memory memory,
FT_Library* alibrary )
{
FT_Library library = 0;
FT_Error error;
@ -684,7 +684,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
EXPORT_FUNC(FT_Error) FT_Done_Library( FT_Library library )
FT_EXPORT_FUNC(FT_Error) FT_Done_Library( FT_Library library )
{
FT_Memory memory;
FT_Int n;
@ -761,8 +761,8 @@
/* This function doesn't check whether the driver is already */
/* installed! */
/* */
EXPORT_FUNC(FT_Error) FT_Add_Driver( FT_Library library,
const FT_DriverInterface* driver_interface )
FT_EXPORT_FUNC(FT_Error) FT_Add_Driver( FT_Library library,
const FT_DriverInterface* driver_interface )
{
FT_Error error;
FT_Driver driver;
@ -822,7 +822,7 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
EXPORT_FUNC(FT_Error) FT_Remove_Driver( FT_Driver driver )
FT_EXPORT_FUNC(FT_Error) FT_Remove_Driver( FT_Driver driver )
{
FT_Library library;
FT_Memory memory;
@ -885,8 +885,8 @@
/* <Return> */
/* A handle to the driver object, 0 otherwise. */
/* */
EXPORT_FUNC(FT_Driver) FT_Get_Driver( FT_Library library,
char* driver_name )
FT_EXPORT_FUNC(FT_Driver) FT_Get_Driver( FT_Library library,
char* driver_name )
{
FT_Driver *cur, *limit;
@ -994,10 +994,10 @@
/* `*face'. Its return value should be 0 if the resource is */
/* recognized, or non-zero if not. */
/* */
EXPORT_FUNC(FT_Error) FT_New_Face( FT_Library library,
const char* pathname,
FT_Long face_index,
FT_Face* aface )
FT_EXPORT_FUNC(FT_Error) FT_New_Face( FT_Library library,
const char* pathname,
FT_Long face_index,
FT_Face* aface )
{
FT_Open_Args args;
@ -1045,11 +1045,11 @@
/* `*face'. Its return value should be 0 if the resource is */
/* recognized, or non-zero if not. */
/* */
EXPORT_FUNC(FT_Error) FT_New_Memory_Face( FT_Library library,
void* file_base,
FT_Long file_size,
FT_Long face_index,
FT_Face* face )
FT_EXPORT_FUNC(FT_Error) FT_New_Memory_Face( FT_Library library,
void* file_base,
FT_Long file_size,
FT_Long face_index,
FT_Face* face )
{
FT_Open_Args args;
@ -1099,10 +1099,10 @@
/* `*face'. Its return value should be 0 if the resource is */
/* recognized, or non-zero if not. */
/* */
EXPORT_FUNC(FT_Error) FT_Open_Face( FT_Library library,
FT_Open_Args* args,
FT_Long face_index,
FT_Face* aface )
FT_EXPORT_FUNC(FT_Error) FT_Open_Face( FT_Library library,
FT_Open_Args* args,
FT_Long face_index,
FT_Face* aface )
{
FT_Error error;
FT_Driver driver;
@ -1273,8 +1273,8 @@
/* when invoking this function. Most drivers simply do not implement */
/* file attachments. */
/* */
EXPORT_FUNC(FT_Error) FT_Attach_File( FT_Face face,
const char* filepathname )
FT_EXPORT_FUNC(FT_Error) FT_Attach_File( FT_Face face,
const char* filepathname )
{
FT_Open_Args open;
@ -1309,8 +1309,8 @@
/* when invoking this function. Most drivers simply do not implement */
/* file attachments.. */
/* */
EXPORT_FUNC(FT_Error) FT_Attach_Stream( FT_Face face,
FT_Open_Args* parameters )
FT_EXPORT_FUNC(FT_Error) FT_Attach_Stream( FT_Face face,
FT_Open_Args* parameters )
{
FT_Stream stream;
FT_Error error;
@ -1363,7 +1363,7 @@
/* <Return> */
/* Error code. 0 means success. */
/* */
EXPORT_FUNC(FT_Error) FT_Done_Face( FT_Face face )
FT_EXPORT_FUNC(FT_Error) FT_Done_Face( FT_Face face )
{
FT_Error error;
FT_Driver driver;
@ -1415,8 +1415,8 @@
/* <Return> */
/* Error code. 0 means success. */
/* */
EXPORT_FUNC(FT_Error) FT_New_Size( FT_Face face,
FT_Size* asize )
FT_EXPORT_FUNC(FT_Error) FT_New_Size( FT_Face face,
FT_Size* asize )
{
FT_Error error;
FT_Memory memory;
@ -1480,7 +1480,7 @@
/* <Return> */
/* Error code. 0 means success. */
/* */
EXPORT_FUNC(FT_Error) FT_Done_Size( FT_Size size )
FT_EXPORT_FUNC(FT_Error) FT_Done_Size( FT_Size size )
{
FT_Error error;
FT_Driver driver;
@ -1543,11 +1543,11 @@
/* When dealing with fixed-size faces (i.e., non-scalable formats), */
/* use the function FT_Set_Pixel_Sizes(). */
/* */
EXPORT_FUNC(FT_Error) FT_Set_Char_Size( FT_Face face,
FT_F26Dot6 char_width,
FT_F26Dot6 char_height,
FT_UInt horz_resolution,
FT_UInt vert_resolution )
FT_EXPORT_FUNC(FT_Error) FT_Set_Char_Size( FT_Face face,
FT_F26Dot6 char_width,
FT_F26Dot6 char_height,
FT_UInt horz_resolution,
FT_UInt vert_resolution )
{
FT_Error error;
FT_Driver driver;
@ -1620,9 +1620,9 @@
/* <Return> */
/* Error code. 0 means success. */
/* */
EXPORT_FUNC(FT_Error) FT_Set_Pixel_Sizes( FT_Face face,
FT_UInt pixel_width,
FT_UInt pixel_height )
FT_EXPORT_FUNC(FT_Error) FT_Set_Pixel_Sizes( FT_Face face,
FT_UInt pixel_width,
FT_UInt pixel_height )
{
FT_Error error;
FT_Driver driver;
@ -1680,8 +1680,8 @@
/* <Return> */
/* Error code. 0 means success. */
/* */
EXPORT_FUNC(FT_Error) FT_New_GlyphSlot( FT_Face face,
FT_GlyphSlot* aslot )
FT_EXPORT_FUNC(FT_Error) FT_New_GlyphSlot( FT_Face face,
FT_GlyphSlot* aslot )
{
FT_Error error;
FT_Driver driver;
@ -1740,7 +1740,7 @@
/* <Input> */
/* slot :: A handle to a target glyph slot. */
/* */
EXPORT_FUNC(void) FT_Done_GlyphSlot( FT_GlyphSlot slot )
FT_EXPORT_FUNC(void) FT_Done_GlyphSlot( FT_GlyphSlot slot )
{
if (slot)
{
@ -1803,9 +1803,9 @@
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
EXPORT_FUNC(FT_Error) FT_Load_Glyph( FT_Face face,
FT_UInt glyph_index,
FT_Int load_flags )
FT_EXPORT_FUNC(FT_Error) FT_Load_Glyph( FT_Face face,
FT_UInt glyph_index,
FT_Int load_flags )
{
FT_Error error;
FT_Driver driver;
@ -1828,9 +1828,9 @@
}
EXPORT_FUNC(FT_Error) FT_Load_Char( FT_Face face,
FT_ULong char_code,
FT_Int load_flags )
FT_EXPORT_FUNC(FT_Error) FT_Load_Char( FT_Face face,
FT_ULong char_code,
FT_Int load_flags )
{
FT_Error error;
FT_Driver driver;
@ -1881,10 +1881,10 @@
/* kernings, are out of the scope of this API function -- they can be */
/* implemented through format-specific interfaces. */
/* */
EXPORT_FUNC(FT_Error) FT_Get_Kerning( FT_Face face,
FT_UInt left_glyph,
FT_UInt right_glyph,
FT_Vector* kerning )
FT_EXPORT_FUNC(FT_Error) FT_Get_Kerning( FT_Face face,
FT_UInt left_glyph,
FT_UInt right_glyph,
FT_Vector* kerning )
{
FT_Error error;
FT_Driver driver;
@ -1935,8 +1935,8 @@
/* This function will return an error if no charmap in the face */
/* corresponds to the encoding queried here */
/* */
EXPORT_FUNC(FT_Error) FT_Select_Charmap( FT_Face face,
FT_Encoding encoding )
FT_EXPORT_FUNC(FT_Error) FT_Select_Charmap( FT_Face face,
FT_Encoding encoding )
{
FT_CharMap* cur = face->charmaps;
FT_CharMap* limit = cur + face->num_charmaps;
@ -1974,8 +1974,8 @@
/* of the face (i.e. if it is not listed in the face->charmaps[] */
/* table). */
/* */
EXPORT_FUNC(FT_Error) FT_Set_Charmap( FT_Face face,
FT_CharMap charmap )
FT_EXPORT_FUNC(FT_Error) FT_Set_Charmap( FT_Face face,
FT_CharMap charmap )
{
FT_CharMap* cur = face->charmaps;
FT_CharMap* limit = cur + face->num_charmaps;
@ -2007,8 +2007,8 @@
/* <Return> */
/* The glyph index. 0 means `undefined character code'. */
/* */
EXPORT_FUNC(FT_UInt) FT_Get_Char_Index( FT_Face face,
FT_ULong charcode )
FT_EXPORT_FUNC(FT_UInt) FT_Get_Char_Index( FT_Face face,
FT_ULong charcode )
{
FT_UInt result;
FT_Driver driver;
@ -2050,8 +2050,8 @@
***************************************************************************/
EXPORT_FUNC(void*) FT_Get_Sfnt_Table( FT_Face face,
FT_Sfnt_Tag tag )
FT_EXPORT_FUNC(void*) FT_Get_Sfnt_Table( FT_Face face,
FT_Sfnt_Tag tag )
{
void* table = 0;
FT_Get_Sfnt_Table_Func func;
@ -2061,7 +2061,8 @@
goto Exit;
driver = face->driver;
func = (FT_Get_Sfnt_Table_Func)driver->interface.get_interface( driver, "get_sfnt" );
func = (FT_Get_Sfnt_Table_Func)driver->interface.get_interface(
driver, "get_sfnt" );
if (func)
table = func(face,tag);
@ -2086,7 +2087,7 @@
/* <Return> */
/* Error code. 0 means success. */
/* */
EXPORT_FUNC(FT_Error) FT_Done_FreeType( FT_Library library )
FT_EXPORT_FUNC(FT_Error) FT_Done_FreeType( FT_Library library )
{
/* Discard the library object */
FT_Done_Library( library );

115
src/base/ftoutln.c
View File

@ -54,9 +54,9 @@
/* <Return> */
/* Error code. 0 means sucess. */
/* */
EXPORT_FUNC(int) FT_Outline_Decompose( FT_Outline* outline,
FT_Outline_Funcs* interface,
void* user )
FT_EXPORT_FUNC(int) FT_Outline_Decompose( FT_Outline* outline,
FT_Outline_Funcs* interface,
void* user )
{
#undef SCALED
#define SCALED( x ) ( ((x) << shift) - delta )
@ -674,9 +674,9 @@
/* */
/* It will use the raster correponding to the default glyph format. */
/* */
EXPORT_FUNC(FT_Error) FT_Outline_Get_Bitmap( FT_Library library,
FT_Outline* outline,
FT_Bitmap* map )
FT_EXPORT_FUNC(FT_Error) FT_Outline_Get_Bitmap( FT_Library library,
FT_Outline* outline,
FT_Bitmap* bitmap )
{
FT_Error error;
FT_Raster raster;
@ -687,10 +687,10 @@
raster = FT_Get_Raster( library, ft_glyph_format_outline, &funcs );
if (!raster) goto Exit;
params.target = map;
params.target = bitmap;
params.source = outline;
params.flags = 0;
if (map->pixel_mode == ft_pixel_mode_grays)
if (bitmap->pixel_mode == ft_pixel_mode_grays)
params.flags |= ft_raster_flag_aa;
error = funcs.raster_render( raster, &params );
@ -729,9 +729,9 @@
/* scan converter is called, which means that the value you give it */
/* is actually ignored.. */
/* */
EXPORT_FUNC(FT_Error) FT_Outline_Render( FT_Library library,
FT_Outline* outline,
FT_Raster_Params* params )
FT_EXPORT_FUNC(FT_Error) FT_Outline_Render( FT_Library library,
FT_Outline* outline,
FT_Raster_Params* params )
{
FT_Error error;
FT_Raster raster;
@ -748,6 +748,50 @@
}
/*************************************************************************/
/* */
/* <Function> */
/* FT_Outline_Transform */
/* */
/* <Description> */
/* Applies a simple 2x2 matrix to all of an outline's points. Useful */
/* for applying rotations, slanting, flipping, etc. */
/* */
/* <Input> */
/* outline :: A pointer to the target outline descriptor. */
/* matrix :: A pointer to the transformation matrix. */
/* */
/* <MT-Note> */
/* Yes. */
/* */
/* <Note> */
/* You can use FT_Outline_Translate() if you need to translate the */
/* outline's points. */
/* */
BASE_FUNC(void) FT_Outline_Transform( FT_Outline* outline,
FT_Matrix* matrix )
{
FT_UShort n;
FT_Vector* vec;
vec = outline->points;
for ( n = 0; n < outline->n_points; n++ )
{
FT_Pos x, y;
x = FT_MulFix( vec->x, matrix->xx ) +
FT_MulFix( vec->y, matrix->xy );
y = FT_MulFix( vec->x, matrix->yx ) +
FT_MulFix( vec->y, matrix->yy );
vec->x = x;
vec->y = y;
vec++;
}
}
@ -813,51 +857,6 @@
}
/*************************************************************************/
/* */
/* <Function> */
/* FT_Outline_Transform */
/* */
/* <Description> */
/* Applies a simple 2x2 matrix to all of an outline's points. Useful */
/* for applying rotations, slanting, flipping, etc. */
/* */
/* <Input> */
/* outline :: A pointer to the target outline descriptor. */
/* matrix :: A pointer to the transformation matrix. */
/* */
/* <MT-Note> */
/* Yes. */
/* */
/* <Note> */
/* You can use FT_Outline_Translate() if you need to translate the */
/* outline's points. */
/* */
BASE_FUNC(void) FT_Outline_Transform( FT_Outline* outline,
FT_Matrix* matrix )
{
FT_UShort n;
FT_Vector* vec;
vec = outline->points;
for ( n = 0; n < outline->n_points; n++ )
{
FT_Pos x, y;
x = FT_MulFix( vec->x, matrix->xx ) +
FT_MulFix( vec->y, matrix->xy );
y = FT_MulFix( vec->x, matrix->yx ) +
FT_MulFix( vec->y, matrix->yy );
vec->x = x;
vec->y = y;
vec++;
}
}
/*************************************************************************/
/* */
/* <Function> */
@ -875,8 +874,8 @@
/* <MT-Note> */
/* Yes. */
/* */
EXPORT_FUNC(void) FT_Vector_Transform( FT_Vector* vector,
FT_Matrix* matrix )
FT_EXPORT_FUNC(void) FT_Vector_Transform( FT_Vector* vector,
FT_Matrix* matrix )
{
FT_Pos xz, yz;

6
src/base/ftsystem.c
View File

@ -173,8 +173,8 @@
}
EXPORT_FUNC(int) FT_New_Stream( const char* filepathname,
FT_Stream stream )
FT_EXPORT_FUNC(int) FT_New_Stream( const char* filepathname,
FT_Stream stream )
{
FILE* file;
@ -196,7 +196,7 @@
}
EXPORT_FUNC(FT_Memory) FT_New_Memory( void )
FT_EXPORT_FUNC(FT_Memory) FT_New_Memory( void )
{
FT_Memory memory;

3
src/macfond/fonddrvr.c
View File

@ -575,8 +575,7 @@ error:
/* */
#ifdef FT_CONFIG_OPTION_DYNAMIC_DRIVERS
EXPORT_FUNC
FT_DriverInterface* getDriverInterface( void )
FT_EXPORT_FUNC(FT_DriverInterface*) getDriverInterface( void )
{
return &fond_driver_interface;
}

2
src/psnames/psdriver.h
View File

@ -21,7 +21,7 @@
#include <freetype/internal/ftdriver.h>
EXPORT_VAR(const FT_DriverInterface) psnames_driver_interface;
FT_EXPORT_VAR(const FT_DriverInterface) psnames_driver_interface;
#endif /* PSDRIVER_H */

2
src/sfnt/sfdriver.h
View File

@ -22,7 +22,7 @@
#include <freetype/internal/ftdriver.h>
#include <freetype/internal/ftobjs.h>
EXPORT_VAR(const FT_DriverInterface) sfnt_driver_interface;
FT_EXPORT_VAR(const FT_DriverInterface) sfnt_driver_interface;
#endif /* SFDRIVER_H */

2
src/truetype/ttdriver.h
View File

@ -25,7 +25,7 @@
#include <tterrors.h>
EXPORT_VAR(const FT_DriverInterface) tt_driver_interface;
FT_EXPORT_VAR(const FT_DriverInterface) tt_driver_interface;
#endif /* TTDRIVER_H */

4
src/truetype/ttinterp.c
View File

@ -762,7 +762,7 @@
/* <Note> */
/* Only the glyph loader and debugger should call this function. */
/* */
EXPORT_FUNC(TT_ExecContext) TT_New_Context( TT_Face face )
FT_EXPORT_FUNC(TT_ExecContext) TT_New_Context( TT_Face face )
{
TT_Driver driver = (TT_Driver)face->root.driver;
TT_ExecContext exec;
@ -6667,7 +6667,7 @@
/*************************************************************************/
EXPORT_FUNC(TT_Error) TT_RunIns( TT_ExecContext exc )
FT_EXPORT_FUNC(TT_Error) TT_RunIns( TT_ExecContext exc )
{
TT_Long ins_counter = 0; /* executed instructions counter */

4
src/truetype/ttinterp.h
View File

@ -317,7 +317,7 @@
/* This function is publicly exported because it is directly */
/* invoked by the TrueType debugger.. */
/* */
EXPORT_DEF(TT_ExecContext) TT_New_Context( TT_Face face );
FT_EXPORT_DEF(TT_ExecContext) TT_New_Context( TT_Face face );
/*************************************************************************/
@ -461,7 +461,7 @@
/* This function is publicly exported because it is directly */
/* invoked by the TrueType debugger.. */
/* */
EXPORT_DEF(TT_Error) TT_RunIns( TT_ExecContext exec );
FT_EXPORT_DEF(TT_Error) TT_RunIns( TT_ExecContext exec );
#ifdef __cplusplus

2
src/type1/t1driver.h
View File

@ -21,7 +21,7 @@
#include <t1objs.h>
#include <t1errors.h>
EXPORT_VAR(const FT_DriverInterface) t1_driver_interface;
FT_EXPORT_VAR(const FT_DriverInterface) t1_driver_interface;
#endif /* T1DRIVER_H */

2
src/type1z/t1driver.h
View File

@ -21,7 +21,7 @@
#include <t1objs.h>
#include <t1errors.h>
EXPORT_VAR(const FT_DriverInterface) t1z_driver_interface;
FT_EXPORT_VAR(const FT_DriverInterface) t1z_driver_interface;
#endif /* T1DRIVER_H */