typedef struct FT_RasterRec_*  FT_Raster;

A handle (pointer) to a raster object. Each object can be used independently to convert an outline into a bitmap or pixmap.

  typedef struct  FT_Span_
  {
    short           x;
    unsigned short  len;
    unsigned char   coverage;

  } FT_Span;

A structure used to model a single span of gray (or black) pixels when rendering a monochrome or anti-aliased bitmap.

This structure is used by the span drawing callback type named FT_SpanFunc which takes the y-coordinate of the span as a a parameter.

The coverage value is always between 0 and 255, even if the number of gray levels have been set through FT_Set_Gray_Levels().

  typedef void
  (*FT_SpanFunc)( int       y,
                  int       count,
                  FT_Span*  spans,
                  void*     user );

#define FT_Raster_Span_Func   FT_SpanFunc

A function used as a call-back by the anti-aliased renderer in order to let client applications draw themselves the gray pixel spans on each scan line.

This callback allows client applications to directly render the gray spans of the anti-aliased bitmap to any kind of surfaces.

This can be used to write anti-aliased outlines directly to a given background bitmap, and even perform translucency.

Note that the `count' field cannot be greater than a fixed value defined by the FT_MAX_GRAY_SPANS configuration macro in ftoption.h. By default, this value is set to 32, which means that if there are more than 32 spans on a given scanline, the callback will be called several times with the same `y' parameter in order to draw all callbacks.

Otherwise, the callback is only called once per scan-line, and only for those scanlines that do have `gray' pixels on them.

  typedef int
  (*FT_Raster_BitTest_Func)( int    y,
                             int    x,
                             void*  user );

THIS TYPE IS DEPRECATED. DO NOT USE IT.

A function used as a call-back by the monochrome scan-converter to test whether a given target pixel is already set to the drawing `color'. These tests are crucial to implement drop-out control per-se the TrueType spec.

1 if the pixel is `set', 0 otherwise.

  typedef void
  (*FT_Raster_BitSet_Func)( int    y,
                            int    x,
                            void*  user );

THIS TYPE IS DEPRECATED. DO NOT USE IT.

A function used as a call-back by the monochrome scan-converter to set an individual target pixel. This is crucial to implement drop-out control according to the TrueType specification.

1 if the pixel is `set', 0 otherwise.

#define FT_RASTER_FLAG_DEFAULT  0x0
#define FT_RASTER_FLAG_AA       0x1
#define FT_RASTER_FLAG_DIRECT   0x2
#define FT_RASTER_FLAG_CLIP     0x4

  /* deprecated */
#define ft_raster_flag_default  FT_RASTER_FLAG_DEFAULT
#define ft_raster_flag_aa       FT_RASTER_FLAG_AA
#define ft_raster_flag_direct   FT_RASTER_FLAG_DIRECT
#define ft_raster_flag_clip     FT_RASTER_FLAG_CLIP

A list of bit flag constants as used in the `flags' field of a FT_Raster_Params structure.

  typedef struct  FT_Raster_Params_
  {
    const FT_Bitmap*        target;
    const void*             source;
    int                     flags;
    FT_SpanFunc             gray_spans;
    FT_SpanFunc             black_spans;
    FT_Raster_BitTest_Func  bit_test;     /* doesn't work! */
    FT_Raster_BitSet_Func   bit_set;      /* doesn't work! */
    void*                   user;
    FT_BBox                 clip_box;

  } FT_Raster_Params;

A structure to hold the arguments used by a raster's render function.

An anti-aliased glyph bitmap is drawn if the FT_RASTER_FLAG_AA bit flag is set in the `flags' field, otherwise a monochrome bitmap will be generated.

If the FT_RASTER_FLAG_DIRECT bit flag is set in `flags', the raster will call the `gray_spans' callback to draw gray pixel spans, in the case of an aa glyph bitmap, it will call `black_spans', and `bit_test' and `bit_set' in the case of a monochrome bitmap. This allows direct composition over a pre-existing bitmap through user-provided callbacks to perform the span drawing/composition.

Note that the `bit_test' and `bit_set' callbacks are required when rendering a monochrome bitmap, as they are crucial to implement correct drop-out control as defined in the TrueType specification.

  typedef int
  (*FT_Raster_NewFunc)( void*       memory,
                        FT_Raster*  raster );

#define  FT_Raster_New_Func    FT_Raster_NewFunc

A function used to create a new raster object.

Error code. 0 means success.

The `memory' parameter is a typeless pointer in order to avoid un-wanted dependencies on the rest of the FreeType code. In practice, it is a FT_Memory, i.e., a handle to the standard FreeType memory allocator. However, this field can be completely ignored by a given raster implementation.

  typedef void
  (*FT_Raster_DoneFunc)( FT_Raster  raster );

#define  FT_Raster_Done_Func   FT_Raster_DoneFunc

A function used to destroy a given raster object.

  typedef void
  (*FT_Raster_ResetFunc)( FT_Raster       raster,
                          unsigned char*  pool_base,
                          unsigned long   pool_size );

#define  FT_Raster_Reset_Func   FT_Raster_ResetFunc

FreeType provides an area of memory called the `render pool', available to all registered rasters. This pool can be freely used during a given scan-conversion but is shared by all rasters. Its content is thus transient.

This function is called each time the render pool changes, or just after a new raster object is created.

Rasters can ignore the render pool and rely on dynamic memory allocation if they want to (a handle to the memory allocator is passed to the raster constructor). However, this is not recommended for efficiency purposes.

  typedef int
  (*FT_Raster_SetModeFunc)( FT_Raster      raster,
                            unsigned long  mode,
                            void*          args );

#define  FT_Raster_Set_Mode_Func  FT_Raster_SetModeFunc

This function is a generic facility to change modes or attributes in a given raster. This can be used for debugging purposes, or simply to allow implementation-specific `features' in a given raster module.

  typedef int
  (*FT_Raster_RenderFunc)( FT_Raster          raster,
                           FT_Raster_Params*  params );

#define  FT_Raster_Render_Func    FT_Raster_RenderFunc

Invokes a given raster to scan-convert a given glyph image into a target bitmap.

Error code. 0 means success.

The exact format of the source image depends on the raster's glyph format defined in its FT_Raster_Funcs structure. It can be an FT_Outline or anything else in order to support a large array of glyph formats.

Note also that the render function can fail and return a FT_Err_Unimplemented_Feature error code if the raster used does not support direct composition.

XXX: For now, the standard raster doesn't support direct composition but this should change for the final release (see the files demos/src/ftgrays.c and demos/src/ftgrays2.c for examples of distinct implementations which support direct composition).

  typedef struct  FT_Raster_Funcs_
  {
    FT_Glyph_Format         glyph_format;
    FT_Raster_NewFunc       raster_new;
    FT_Raster_ResetFunc     raster_reset;
    FT_Raster_SetModeFunc   raster_set_mode;
    FT_Raster_RenderFunc    raster_render;
    FT_Raster_DoneFunc      raster_done;

  } FT_Raster_Funcs;

A structure used to describe a given raster class to the library.

  typedef struct FT_IncrementalRec_*  FT_Incremental;

An opaque type describing a user-provided object used to implement "incremental" glyph loading within FreeType. This is used to support embedded fonts in certain environments (e.g. Postscript interpreters), where the glyph data isn't in the font file, or must be overridden by different values.

It is up to client applications to create and implement FT_Incremental objects, as long as they provide implementations for the methods FT_Incremental_GetGlyphDataFunc, FT_Incremental_FreeGlyphDataFunc and FT_Incremental_GetGlyphMetricsFunc.

See the description of FT_Incremental_InterfaceRec to understand how to use incremental objects with FreeType.

  typedef struct  FT_Incremental_MetricsRec_
  {
    FT_Long  bearing_x;
    FT_Long  bearing_y;
    FT_Long  advance;

  } FT_Incremental_MetricsRec, *FT_Incremental_Metrics;

A small structure used to contain the basic glyph metrics returned by the FT_Incremental_GetGlyphMetricsFunc method.

These correspond to horizontal or vertical metrics depending on the value of the 'vertical' argument to the function FT_Incremental_GetGlyphMetricsFunc.

  typedef FT_Error
  (*FT_Incremental_GetGlyphDataFunc)( FT_Incremental  incremental,
                                      FT_UInt         glyph_index,
                                      FT_Data*        adata );

A function called by FreeType to access a given glyph's data bytes during FT_Load_Glyph or FT_Load_Char if incremental loading is enabled.

Note that the format of the glyph's data bytes depends on the font file format. For TrueType, it must correspond to the raw bytes within the 'glyf' table. For Postscript formats, it must correspond to the unencrypted charstring bytes, without any 'lenIV' header. It is undefined for any other format.

FreeType error code. 0 means success.

If this function returns succesfully the method FT_Incremental_FreeGlyphDataFunc will be called later to release the data bytes.

Nested calls to FT_Incremental_GetGlyphDataFunc can happen for compound glyphs.

  typedef void
  (*FT_Incremental_FreeGlyphDataFunc)( FT_Incremental  incremental,
                                       FT_Data*        data );

A function used to release the glyph data bytes returned by a successful call to FT_Incremental_GetGlyphDataFunc.

  typedef FT_Error
  (*FT_Incremental_GetGlyphMetricsFunc)
                      ( FT_Incremental              incremental,
                        FT_UInt                     glyph_index,
                        FT_Bool                     vertical,
                        FT_Incremental_MetricsRec  *ametrics );

A function used to retrieve the basic metrics of a given glyph index before accessing its data. This is necessary because, in certain formats like TrueType, the metrics are stored in a different place from the glyph images proper.

  typedef struct  FT_Incremental_FuncsRec_
  {
    FT_Incremental_GetGlyphDataFunc     get_glyph_data;
    FT_Incremental_FreeGlyphDataFunc    free_glyph_data;
    FT_Incremental_GetGlyphMetricsFunc  get_glyph_metrics;

  } FT_Incremental_FuncsRec;

A table of functions for accessing fonts that load data incrementally. Used in FT_Incremental_InterfaceRec.

  typedef struct  FT_Incremental_InterfaceRec_
  {
    const FT_Incremental_FuncsRec*  funcs;
    FT_Incremental                  object;
  
  } FT_Incremental_InterfaceRec;

A structure to be used with FT_Open_Face to indicate that the user wants to support incremental glyph loading. You should use it with FT_PARAM_TAG_INCREMENTAL as in the following example:

  FT_Incremental_InterfaceRec  inc_int;
  FT_Parameter                 parameter;
  FT_Open_Args                 open_args;


  // set up incremental descriptor
  inc_int.funcs  = my_funcs;
  inc_int.object = my_object;

  // set up optional parameter
  parameter.tag  = FT_PARAM_TAG_INCREMENTAL;
  parameter.data = &inc_int;

  // set up FT_Open_Args structure
  open_args.flags      = FT_OPEN_PATHNAME | FT_OPEN_PARAMS;
  open_args.pathname   = my_font_pathname;
  open_args.num_params = 1;
  open_args.params     = &parameter; // we use one optional argument

  // open the font
  error = FT_Open_Face( library, &open_args, index, &face );
  ...

#define FT_PARAM_TAG_INCREMENTAL  FT_MAKE_TAG( 'i', 'n', 'c', 'r' )

A constant used as the tag of FT_Parameter structures to indicate an incremental loading object to be used by FreeType.