ftimage.h

Qt/Embedded是一个多平台的C++图形用户界面应用程序框架

  /* <Struct>                                                              */
  /*    FT_Outline_Funcs                                                   */
  /*                                                                       */
  /* <Description>                                                         */
  /*    A structure to hold various function pointers used during outline  */
  /*    decomposition in order to emit segments, conic, and cubic Beziers, */
  /*    as well as `move to' and `close to' operations.                    */
  /*                                                                       */
  /* <Fields>                                                              */
  /*    move_to  :: The `move to' emitter.                                 */
  /*    line_to  :: The segment emitter.                                   */
  /*    conic_to :: The second-order Bezier arc emitter.                   */
  /*    cubic_to :: The third-order Bezier arc emitter.                    */
  /*                                                                       */
  typedef struct  FT_Outline_Funcs_
  {
    FT_Outline_MoveTo_Func   move_to;
    FT_Outline_LineTo_Func   line_to;
    FT_Outline_ConicTo_Func  conic_to;
    FT_Outline_CubicTo_Func  cubic_to;

  } FT_Outline_Funcs;




  /*************************************************************************/
  /*                                                                       */
  /* <Macro>                                                               */
  /*    FT_IMAGE_TAG                                                       */
  /*                                                                       */
  /* <Description>                                                         */
  /*    This macro converts four letter tags which are used to label       */
  /*    TrueType tables into an unsigned long to be used within FreeType.  */
  /*                                                                       */
#define FT_IMAGE_TAG( _x1, _x2, _x3, _x4 ) \
          (((unsigned long)_x1 << 24) |        \
           ((unsigned long)_x2 << 16) |        \
           ((unsigned long)_x3 << 8)  |        \
            (unsigned long)_x4)


 /***********************************************************************
  *
  * <Enum>
  *    FT_Glyph_Tag
  *
  * <Description>
  *    An enumeration type used to describethe format of a given glyph
  *    image. Note that this version of FreeType only supports two image
  *    formats, even though future font drivers will be able to register
  *    their own format.
  *
  * <Fields>
  *    ft_glyph_format_composite :: the glyph image is a composite of several
  *                                 other images. This glyph format is _only_
  *                                 used with the FT_LOAD_FLAG_NO_RECURSE flag
  *                                 (XXX: Which is currently iunimplemented)
  *
  *    ft_glyph_format_bitmap  :: the glyph image is a bitmap, and can
  *                               be described as a FT_Bitmap
  *
  *    ft_glyph_format_outline :: the glyph image is a vectorial image
  *                               made of bezier control points, and can
  *                               be described as a FT_Outline
  *
  *    ft_glyph_format_plotter :: the glyph image is a vectorial image
  *                               made of plotter lines (some T1 fonts like
  *                               Hershey contain glyph in this format).
  *
  ***********************************************************************/
  
  typedef enum FT_Glyph_Tag_
  {
    ft_glyph_format_none      = 0,
    ft_glyph_format_composite = FT_IMAGE_TAG('c','o','m','p'),
    ft_glyph_format_bitmap    = FT_IMAGE_TAG('b','i','t','s'),
    ft_glyph_format_outline   = FT_IMAGE_TAG('o','u','t','l'),
    ft_glyph_format_plotter   = FT_IMAGE_TAG('p','l','o','t')
  
  } FT_Glyph_Tag;


  /*************************************************************************/
  /*                                                                       */
  /* <Type>                                                                */
  /*    FT_Raster                                                          */
  /*                                                                       */
  /* <Description>                                                         */
  /*    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_RasterRec_*  FT_Raster;


  /*************************************************************************/
  /*                                                                       */
  /* <FuncType>                                                            */
  /*    FT_Raster_Init_Proc                                                */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Initializes a fresh raster object which should have been allocated */
  /*    by client applications.  This function is also used to set the     */
  /*    object's render pool.  It can be used repeatedly on a single       */
  /*    object if one wants to change the pool's address or size.          */
  /*                                                                       */
  /*    Note that the render pool has no state and is only used during a   */
  /*    call to FT_Raster_Render().  It is thus theorically possible to    */
  /*    share it between several non-concurrent components of your         */
  /*    applications when memory is a scarce resource.                     */
  /*                                                                       */
  /* <Input>                                                               */
  /*    raster    :: a handle to the target raster object.                 */
  /*    pool_base :: the render pool's base address in memory              */
  /*    pool_size :: the render pool's size in bytes.  this must be at     */
  /*                 least 4 kByte.                                        */
  /* <Return>                                                              */
  /*    An error condition, used as a FT_Error in the FreeType library.    */
  /*    0 means success.                                                   */
  /*                                                                       */
  typedef int (*FT_Raster_Init_Proc)( FT_Raster    raster,
                                      const char*  pool_base,
                                      long         pool_size );


  /*************************************************************************/
  /*                                                                       */
  /* <FuncType>                                                            */
  /*    FT_Raster_Set_Mode_Proc                                            */
  /*                                                                       */
  /* <Description>                                                         */
  /*    Some raster implementations may have several modes of operation.   */
  /*    This function is used to select one of them, as well as pass some  */
  /*    arguments.                                                         */
  /*                                                                       */
  /* <Input>                                                               */
  /*    raster  :: The target raster object.                               */
  /*                                                                       */
  /*    mode    :: A pointer used to describe the mode to set. This is     */
  /*               completely raster-specific, and could be, for example,  */
  /*               a text string.                                          */
  /*                                                                       */
  /*    args    :: An argument to the set_mode command. This is completely */
  /*               specific to the raster and the mode used.               */
  /*                                                                       */
  /* <Return>                                                              */
  /*    An error code, used as a FT_Error by the FreeType library.         */
  /*    0 means success.                                                   */
  /*                                                                       */
  typedef int (*FT_Raster_Set_Mode_Proc)( FT_Raster    raster,
                                          const char*  mode,
                                          const char*  args );
                        
                                          
  /*************************************************************************
   *                                                                       
   * <FuncType>                                                            
   *    FT_Raster_Render_Proc                                              
   *                                                                       
   * <Description>                                                         
   *    Renders an outline into a target bitmap/pixmap.                    
   *                                                                       
   * <Input>                                                               
   *    raster        :: A handle to a raster object used during rendering.
   *
   *    source_image  :: a typeless pointer to the source glyph image.
   *                     (usually a FT_Outline*).
   *
   *    target_bitmap :: descriptor to the target bitmap.
   *
   * <Return>                                                              
   *    Error code, interpreted as a FT_Error by FreeType library.         
   *    0 means success.                                                   
   *                                                                       
   *************************************************************************/
   
  typedef int  (*FT_Raster_Render_Proc)( FT_Raster       raster,
                                         void*           source_image,
                                         FT_Bitmap*      target_bitmap );


 /**************************************************************************
  *
  * <Struct>
  *    FT_Raster_Interface
  *
  * <Description>
  *    A structure used to model the default raster interface. A raster
  *    is a module in charge of converting a glyph image into a bitmap.
  * 
  * <Fields>
  *    size      :: the size in bytes of the given raster object. This
  *                 is used to allocate a new raster when calling
  *                 `FT_Set_Raster'.
  *
  *    format    :: the source glyph image format this raster is able to
  *                 handle.
  *
  *    init      :: the raster's initialisation routine
  *
  *    set_mode  :: the raster's mode set routine
  *
  *    render    :: the raster's rendering routine
  *
  **************************************************************************/
  
  typedef struct FT_Raster_Interface_
  {
    long                     size;
    FT_Glyph_Tag             format_tag;
    FT_Raster_Init_Proc      init;
    FT_Raster_Set_Mode_Proc  set_mode;
    FT_Raster_Render_Proc    render;
    
  
  } FT_Raster_Interface;

 
#endif /* FTIMAGE_H */