Chiebot-Mirror
/
freetype
mirror of https://github.com/freetype/freetype.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

EXPORT_DEF renamed to FT_EXPORT_DEF +

Browse Source 
reformating/spacing
VER-2-0-4-PATCH
David Turner 25 years ago
parent f5dcdd5cfb
commit 1fb6eea7d1
29 changed files with 396 additions and 391 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 12
      include/freetype/config/ftconfig.h
  2. 20
      include/freetype/config/ftoption.h
  3. 190
      include/freetype/freetype.h
  4. 4
      include/freetype/ftbbox.h
  5. 42
      include/freetype/ftglyph.h
  6. 8
      include/freetype/ftgrays.h
  7. 6
      include/freetype/ftraster.h
  8. 10
      include/freetype/internal/ftcalc.h
  9. 8
      include/freetype/internal/ftdebug.h
  10. 10
      include/freetype/internal/ftextend.h
  11. 34
      include/freetype/internal/ftlist.h
  12. 44
      include/freetype/internal/ftobjs.h
  13. 4
      include/freetype/tttables.h
  14. 50
      src/base/ftcalc.c
  15. 8
      src/base/ftdebug.c
  16. 10
      src/base/ftextend.c
  17. 34
      src/base/ftglyph.c
  18. 4
      src/base/ftinit.c
  19. 147
      src/base/ftobjs.c
  20. 115
      src/base/ftoutln.c
  21. 6
      src/base/ftsystem.c
  22. 3
      src/macfond/fonddrvr.c
  23. 2
      src/psnames/psdriver.h
  24. 2
      src/sfnt/sfdriver.h
  25. 2
      src/truetype/ttdriver.h
  26. 4
      src/truetype/ttinterp.c
  27. 4
      src/truetype/ttinterp.h
  28. 2
      src/type1/t1driver.h
  29. 2
      src/type1z/t1driver.h

12
include/freetype/config/ftconfig.h
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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 );
FT_EXPORT_DEF(void) FT_List_Remove( FT_List list,
FT_ListNode node );
EXPORT_DEF(void) FT_List_Up( 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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 */

Write Preview
Loading…
Cancel
Save