(***************************************************************************)
(*                                                                         *)
(*  ftimage.h                                                              *)
(*                                                                         *)
(*    FreeType glyph image formats and default raster interface            *)
(*    (specification).                                                     *)
(*                                                                         *)
(*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             *)
(*  David Turner, Robert Wilhelm, and Werner Lemberg.                      *)
(*                                                                         *)
(*  This file is part of the FreeType project, and may only be used,       *)
(*  modified, and distributed under the terms of the FreeType project      *)
(*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     *)
(*  this file you indicate that you have read the license and              *)
(*  understand and accept it fully.                                        *)
(*                                                                         *)
(***************************************************************************)
(***************************************************************************)
(* Pascal port by the UltraStar Deluxe Team                                *)
(***************************************************************************)

  (*************************************************************************)
  (*                                                                       *)
  (* Note: A `raster' is simply a scan-line converter, used to render      *)
  (*       FT_Outlines into FT_Bitmaps.                                    *)
  (*                                                                       *)
  (*************************************************************************)

{$IFDEF TYPE_DECL}
  
  (*************************************************************************)
  (*                                                                       *)
  (* <Type>                                                                *)
  (*    FT_Pos                                                             *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    The type FT_Pos is a 32-bit integer used to store vectorial        *)
  (*    coordinates.  Depending on the context, these can represent        *)
  (*    distances in integer font units, or 16,16, or 26.6 fixed float     *)
  (*    pixel coordinates.                                                 *)
  (*                                                                       *)
  FT_Pos     = cslong;


  (*************************************************************************)
  (*                                                                       *)
  (* <Struct>                                                              *)
  (*    FT_Vector                                                          *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    A simple structure used to store a 2D vector; coordinates are of   *)
  (*    the FT_Pos type.                                                   *)
  (*                                                                       *)
  (* <Fields>                                                              *)
  (*    x :: The horizontal coordinate.                                    *)
  (*    y :: The vertical coordinate.                                      *)
  (*                                                                       *)
  PFT_Vector = ^FT_Vector;
  FT_Vector = record
    x ,
    y : FT_Pos;
  end;

  PFT_VectorArray = ^FT_VectorArray;
  FT_VectorArray = array[0 .. (MaxInt div SizeOf(FT_Vector))-1] of FT_Vector;

  (*************************************************************************)
  (*                                                                       *)
  (* <Struct>                                                              *)
  (*    FT_BBox                                                            *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    A structure used to hold an outline's bounding box, i.e., the      *)
  (*    coordinates of its extrema in the horizontal and vertical          *)
  (*    directions.                                                        *)
  (*                                                                       *)
  (* <Fields>                                                              *)
  (*    xMin :: The horizontal minimum (left-most).                        *)
  (*                                                                       *)
  (*    yMin :: The vertical minimum (bottom-most).                        *)
  (*                                                                       *)
  (*    xMax :: The horizontal maximum (right-most).                       *)
  (*                                                                       *)
  (*    yMax :: The vertical maximum (top-most).                           *)
  (*                                                                       *)
  PFT_BBox = ^FT_BBox;
  FT_BBox = record
    xMin, yMin : FT_Pos;
    xMax, yMax : FT_Pos;
  end;


  (*************************************************************************)
  (*                                                                       *)
  (* <Enum>                                                                *)
  (*    FT_Pixel_Mode                                                      *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    An enumeration type used to describe the format of pixels in a     *)
  (*    given bitmap.  Note that additional formats may be added in the    *)
  (*    future.                                                            *)
  (*                                                                       *)
  (* <Values>                                                              *)
  (*    FT_PIXEL_MODE_NONE ::                                              *)
  (*      Value 0 is reserved.                                             *)
  (*                                                                       *)
  (*    FT_PIXEL_MODE_MONO ::                                              *)
  (*      A monochrome bitmap, using 1 bit per pixel.  Note that pixels    *)
  (*      are stored in most-significant order (MSB), which means that     *)
  (*      the left-most pixel in a byte has value 128.                     *)
  (*                                                                       *)
  (*    FT_PIXEL_MODE_GRAY ::                                              *)
  (*      An 8-bit bitmap, generally used to represent anti-aliased glyph  *)
  (*      images.  Each pixel is stored in one byte.  Note that the number *)
  (*      of value `gray' levels is stored in the `num_bytes' field of     *)
  (*      the @FT_Bitmap structure (it generally is 256).                  *)
  (*                                                                       *)
  (*    FT_PIXEL_MODE_GRAY2 ::                                             *)
  (*      A 2-bit/pixel bitmap, used to represent embedded anti-aliased    *)
  (*      bitmaps in font files according to the OpenType specification.   *)
  (*      We haven't found a single font using this format, however.       *)
  (*                                                                       *)
  (*    FT_PIXEL_MODE_GRAY4 ::                                             *)
  (*      A 4-bit/pixel bitmap, used to represent embedded anti-aliased    *)
  (*      bitmaps in font files according to the OpenType specification.   *)
  (*      We haven't found a single font using this format, however.       *)
  (*                                                                       *)
  (*    FT_PIXEL_MODE_LCD ::                                               *)
  (*      An 8-bit bitmap, used to represent RGB or BGR decimated glyph    *)
  (*      images used for display on LCD displays; the bitmap is three     *)
  (*      times wider than the original glyph image.  See also             *)
  (*      @FT_RENDER_MODE_LCD.                                             *)
  (*                                                                       *)
  (*    FT_PIXEL_MODE_LCD_V ::                                             *)
  (*      An 8-bit bitmap, used to represent RGB or BGR decimated glyph    *)
  (*      images used for display on rotated LCD displays; the bitmap      *)
  (*      is three times taller than the original glyph image.  See also   *)
  (*      @FT_RENDER_MODE_LCD_V.                                           *)
  (*                                                                       *)
  FT_Pixel_Mode = cint;
{$ELSE TYPE_DECL}
const
  FT_PIXEL_MODE_NONE    = 0;
  FT_PIXEL_MODE_MONO    = FT_PIXEL_MODE_NONE  + 1;
  FT_PIXEL_MODE_GRAY    = FT_PIXEL_MODE_MONO  + 1;
  FT_PIXEL_MODE_GRAY2   = FT_PIXEL_MODE_GRAY  + 1;
  FT_PIXEL_MODE_GRAY4   = FT_PIXEL_MODE_GRAY2 + 1;
  FT_PIXEL_MODE_LCD     = FT_PIXEL_MODE_GRAY4 + 1;
  FT_PIXEL_MODE_LCD_V   = FT_PIXEL_MODE_LCD   + 1;

  FT_PIXEL_MODE_MAX     = FT_PIXEL_MODE_LCD_V + 1; (* do not remove *)
{$ENDIF TYPE_DECL}
{$IFDEF TYPE_DECL}

  (*************************************************************************)
  (*                                                                       *)
  (* <Struct>                                                              *)
  (*    FT_Bitmap                                                          *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    A structure used to describe a bitmap or pixmap to the raster.     *)
  (*    Note that we now manage pixmaps of various depths through the      *)
  (*    `pixel_mode' field.                                                *)
  (*                                                                       *)
  (* <Fields>                                                              *)
  (*    rows         :: The number of bitmap rows.                         *)
  (*                                                                       *)
  (*    width        :: The number of pixels in bitmap row.                *)
  (*                                                                       *)
  (*    pitch        :: The pitch's absolute value is the number of bytes  *)
  (*                    taken by one bitmap row, including padding.        *)
  (*                    However, the pitch is positive when the bitmap has *)
  (*                    a `down' flow, and negative when it has an `up'    *)
  (*                    flow.  In all cases, the pitch is an offset to add *)
  (*                    to a bitmap pointer in order to go down one row.   *)
  (*                                                                       *)
  (*    buffer       :: A typeless pointer to the bitmap buffer.  This     *)
  (*                    value should be aligned on 32-bit boundaries in    *)
  (*                    most cases.                                        *)
  (*                                                                       *)
  (*    num_grays    :: This field is only used with                       *)
  (*                    `FT_PIXEL_MODE_GRAY'; it gives the number of gray  *)
  (*                    levels used in the bitmap.                         *)
  (*                                                                       *)
  (*    pixel_mode   :: The pixel mode, i.e., how pixel bits are stored.   *)
  (*                    See @FT_Pixel_Mode for possible values.            *)
  (*                                                                       *)
  (*    palette_mode :: This field is only used with paletted pixel modes; *)
  (*                    it indicates how the palette is stored.            *)
  (*                                                                       *)
  (*    palette      :: A typeless pointer to the bitmap palette; only     *)
  (*                    used for paletted pixel modes.                     *)
  (*                                                                       *)
  (* <Note>                                                                *)
  (*   For now, the only pixel mode supported by FreeType are mono and     *)
  (*   grays.  However, drivers might be added in the future to support    *)
  (*   more `colorful' options.                                            *)
  (*                                                                       *)
  (*   When using pixel modes pal2, pal4 and pal8 with a void `palette'    *)
  (*   field, a gray pixmap with respectively 4, 16, and 256 levels of     *)
  (*   gray is assumed.  This, in order to be compatible with some         *)
  (*   embedded bitmap formats defined in the TrueType specification.      *)
  (*                                                                       *)
  (*   Note that no font was found presenting such embedded bitmaps, so    *)
  (*   this is currently completely unhandled by the library.              *)
  (*                                                                       *)
  PFT_Bitmap = ^FT_Bitmap;
  FT_Bitmap = record
    rows:         FT_Int;
    width:        FT_Int;
    pitch:        FT_Int;
    buffer:       PByteArray;
    num_grays:    FT_Short;
    pixel_mode:   byte;
    palette_mode: byte;
    palette:      pointer;
  end;


  (*************************************************************************)
  (*                                                                       *)
  (* <Section>                                                             *)
  (*    outline_processing                                                 *)
  (*                                                                       *)
  (*************************************************************************)


  (*************************************************************************)
  (*                                                                       *)
  (* <Struct>                                                              *)
  (*    FT_Outline                                                         *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    This structure is used to describe an outline to the scan-line     *)
  (*    converter.                                                         *)
  (*                                                                       *)
  (* <Fields>                                                              *)
  (*    n_contours :: The number of contours in the outline.               *)
  (*                                                                       *)
  (*    n_points   :: The number of points in the outline.                 *)
  (*                                                                       *)
  (*    points     :: A pointer to an array of `n_points' FT_Vector        *)
  (*                  elements, giving the outline's point coordinates.    *)
  (*                                                                       *)
  (*    tags       :: A pointer to an array of `n_points' chars, giving    *)
  (*                  each outline point's type.  If bit 0 is unset, the   *)
  (*                  point is `off' the curve, i.e. a Bezier control      *)
  (*                  point, while it is `on' when set.                    *)
  (*                                                                       *)
  (*                  Bit 1 is meaningful for `off' points only.  If set,  *)
  (*                  it indicates a third-order Bezier arc control point; *)
  (*                  and a second-order control point if unset.           *)
  (*                                                                       *)
  (*    contours   :: An array of `n_contours' shorts, giving the end      *)
  (*                  point of each contour within the outline.  For       *)
  (*                  example, the first contour is defined by the points  *)
  (*                  `0' to `contours[0]', the second one is defined by   *)
  (*                  the points `contours[0]+1' to `contours[1]', etc.    *)
  (*                                                                       *)
  (*    flags      :: A set of bit flags used to characterize the outline  *)
  (*                  and give hints to the scan-converter and hinter on   *)
  (*                  how to convert/grid-fit it.  See FT_Outline_Flags.   *)
  (*                                                                       *)
  PFT_Outline = ^FT_Outline;
  FT_Outline = record
    n_contours: FT_Short;        (* number of contours in glyph        *)
    n_points:   FT_Short;        (* number of points in the glyph      *)

    points:     PFT_VectorArray; (* the outline's points               *)
    tags:       PByteArray;      (* the points flags                   *)
    contours:   PFT_ShortArray;  (* the contour end points             *)

    flags:      FT_Int;          (* outline masks                      *)
  end;

{$ELSE TYPE_DECL}

  (*************************************************************************)
  (*                                                                       *)
  (* @macro:                                                               *)
  (*    FT_CURVE_TAG  ( flag )                                             *)
  (*                                                                       *)
  function  FT_CURVE_TAG(flag: byte): byte;

const
  FT_CURVE_TAG_ON    = 1;
  FT_CURVE_TAG_CONIC = 0;
  FT_CURVE_TAG_CUBIC = 2;

  FT_CURVE_TAG_TOUCH_X   =   8;  // reserved for the TrueType hinter
  FT_CURVE_TAG_TOUCH_Y   =  16;  // reserved for the TrueType hinter

  FT_CURVE_TAG_TOUCH_BOTH  = ( FT_CURVE_TAG_TOUCH_X or
                               FT_CURVE_TAG_TOUCH_Y );
{$ENDIF TYPE_DECL}
{$IFDEF TYPE_DECL}

  (*************************************************************************)
  (*                                                                       *)
  (* <FuncType>                                                            *)
  (*    FT_Outline_MoveToFunc                                              *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    A function pointer type used to describe the signature of a `move  *)
  (*    to' function during outline walking/decomposition.                 *)
  (*                                                                       *)
  (*    A `move to' is emitted to start a new contour in an outline.       *)
  (*                                                                       *)
  (* <Input>                                                               *)
  (*    to   :: A pointer to the target point of the `move to'.            *)
  (*                                                                       *)
  (*    user :: A typeless pointer which is passed from the caller of the  *)
  (*            decomposition function.                                    *)
  (*                                                                       *)
  (* <Return>                                                              *)
  (*    Error code.  0 means success.                                      *)
  (*                                                                       *)
  FT_Outline_MoveToFunc = function(to_: {const} PFT_Vector;
                                   user: Pointer): cint; cdecl;


  (*************************************************************************)
  (*                                                                       *)
  (* <FuncType>                                                            *)
  (*    FT_Outline_LineToFunc                                              *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    A function pointer type used to describe the signature of a `line  *)
  (*    to' function during outline walking/decomposition.                 *)
  (*                                                                       *)
  (*    A `line to' is emitted to indicate a segment in the outline.       *)
  (*                                                                       *)
  (* <Input>                                                               *)
  (*    to   :: A pointer to the target point of the `line to'.            *)
  (*                                                                       *)
  (*    user :: A typeless pointer which is passed from the caller of the  *)
  (*            decomposition function.                                    *)
  (*                                                                       *)
  (* <Return>                                                              *)
  (*    Error code.  0 means success.                                      *)
  (*                                                                       *)
  FT_Outline_LineToFunc = function(to_: {const} PFT_Vector;
                                   user: Pointer): cint; cdecl;


  (*************************************************************************)
  (*                                                                       *)
  (* <FuncType>                                                            *)
  (*    FT_Outline_ConicToFunc                                             *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    A function pointer type use to describe the signature of a `conic  *)
  (*    to' function during outline walking/decomposition.                 *)
  (*                                                                       *)
  (*    A `conic to' is emitted to indicate a second-order Bézier arc in   *)
  (*    the outline.                                                       *)
  (*                                                                       *)
  (* <Input>                                                               *)
  (*    control :: An intermediate control point between the last position *)
  (*               and the new target in `to'.                             *)
  (*                                                                       *)
  (*    to      :: A pointer to the target end point of the conic arc.     *)
  (*                                                                       *)
  (*    user    :: A typeless pointer which is passed from the caller of   *)
  (*               the decomposition function.                             *)
  (*                                                                       *)
  (* <Return>                                                              *)
  (*    Error code.  0 means success.                                      *)
  (*                                                                       *)
  FT_Outline_ConicToFunc = function(control: {const} PFT_Vector;
                             to_:  {const} PFT_Vector;
                             user: Pointer): cint; cdecl;


  (*************************************************************************)
  (*                                                                       *)
  (* <FuncType>                                                            *)
  (*    FT_Outline_CubicToFunc                                             *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    A function pointer type used to describe the signature of a `cubic *)
  (*    to' function during outline walking/decomposition.                 *)
  (*                                                                       *)
  (*    A `cubic to' is emitted to indicate a third-order Bézier arc.      *)
  (*                                                                       *)
  (* <Input>                                                               *)
  (*    control1 :: A pointer to the first Bézier control point.           *)
  (*                                                                       *)
  (*    control2 :: A pointer to the second Bézier control point.          *)
  (*                                                                       *)
  (*    to       :: A pointer to the target end point.                     *)
  (*                                                                       *)
  (*    user     :: A typeless pointer which is passed from the caller of  *)
  (*                the decomposition function.                            *)
  (*                                                                       *)
  (* <Return>                                                              *)
  (*    Error code.  0 means success.                                      *)
  (*                                                                       *)
  FT_Outline_CubicToFunc = function( control1: {const} PFT_Vector;
                             control2: {const} PFT_Vector;
                             to_:      {const} PFT_Vector;
                             user:     Pointer ): cint; cdecl;


  (*************************************************************************)
  (*                                                                       *)
  (* <Struct>                                                              *)
  (*    FT_Outline_Funcs                                                   *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    A structure to hold various function pointers used during outline  *)
  (*    decomposition in order to emit segments, conic, and cubic Béziers, *)
  (*    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 Bézier arc emitter.                   *)
  (*                                                                       *)
  (*    cubic_to :: The third-order Bézier arc emitter.                    *)
  (*                                                                       *)
  (*    shift    :: The shift that is applied to coordinates before they   *)
  (*                are sent to the emitter.                               *)
  (*                                                                       *)
  (*    delta    :: The delta that is applied to coordinates before they   *)
  (*                are sent to the emitter, but after the shift.          *)
  (*                                                                       *)
  (* <Note>                                                                *)
  (*    The point coordinates sent to the emitters are the transformed     *)
  (*    version of the original coordinates (this is important for high    *)
  (*    accuracy during scan-conversion).  The transformation is simple:   *)
  (*                                                                       *)
  (*    {                                                                  *)
  (*      x' = (x << shift) - delta                                        *)
  (*      y' = (x << shift) - delta                                        *)
  (*    }                                                                  *)
  (*                                                                       *)
  (*    Set the value of `shift' and `delta' to 0 to get the original      *)
  (*    point coordinates.                                                 *)
  (*                                                                       *)
  PFT_Outline_Funcs = ^FT_Outline_Funcs;
  FT_Outline_Funcs = record
    move_to:  FT_Outline_MoveToFunc;
    line_to:  FT_Outline_LineToFunc;
    conic_to: FT_Outline_ConicToFunc;
    cubic_to: FT_Outline_CubicToFunc;

    shift:    cint;
    delta:    FT_Pos;
  end;


  (*************************************************************************)
  (*                                                                       *)
  (* <Macro>                                                               *)
  (*    FT_IMAGE_TAG                                                       *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    This macro converts four-letter tags to an unsigned long type.     *)
  (*                                                                       *)
  (* <Note>                                                                *)
  (*    Since many 16-bit compilers don't like 32-bit enumerations, you    *)
  (*    should redefine this macro in case of problems to something like   *)
  (*    this:                                                              *)
  (*                                                                       *)
  (*    {                                                                  *)
  (*      #define FT_IMAGE_TAG( value, _x1, _x2, _x3, _x4 )  value         *)
  (*    }                                                                  *)
  (*                                                                       *)
  (*    to get a simple enumeration without assigning special numbers.     *)
  (*                                                                       *)
  {
  #define FT_IMAGE_TAG( value, _x1, _x2, _x3, _x4 )  \
          value = ( ( (unsigned long)_x1 << 24 ) | \
                    ( (unsigned long)_x2 << 16 ) | \
                    ( (unsigned long)_x3 << 8  ) | \
                      (unsigned long)_x4         )
  }

  (*************************************************************************)
  (*                                                                       *)
  (* <Enum>                                                                *)
  (*    FT_Glyph_Format                                                    *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    An enumeration type used to describe the 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.                                                  *)
  (*                                                                       *)
  (* <Values>                                                              *)
  (*    FT_GLYPH_FORMAT_NONE ::                                            *)
  (*      The value 0 is reserved and does describe a glyph format.        *)
  (*                                                                       *)
  (*    FT_GLYPH_FORMAT_COMPOSITE ::                                       *)
  (*      The glyph image is a composite of several other images.  This    *)
  (*      format is _only_ used with @FT_LOAD_NO_RECURSE, and is used to   *)
  (*      report compound glyphs (like accented characters).               *)
  (*                                                                       *)
  (*    FT_GLYPH_FORMAT_BITMAP ::                                          *)
  (*      The glyph image is a bitmap, and can be described as an          *)
  (*      @FT_Bitmap.  You generally need to access the `bitmap' field of  *)
  (*      the @FT_GlyphSlotRec structure to read it.                       *)
  (*                                                                       *)
  (*    FT_GLYPH_FORMAT_OUTLINE ::                                         *)
  (*      The glyph image is a vertorial outline made of line segments     *)
  (*      and Bezier arcs; it can be described as an @FT_Outline; you      *)
  (*      generally want to access the `outline' field of the              *)
  (*      @FT_GlyphSlotRec structure to read it.                           *)
  (*                                                                       *)
  (*    FT_GLYPH_FORMAT_PLOTTER ::                                         *)
  (*      The glyph image is a vectorial path with no inside/outside       *)
  (*      contours.  Some Type 1 fonts, like those in the Hershey family,  *)
  (*      contain glyphs in this format.  These are described as           *)
  (*      @FT_Outline, but FreeType isn't currently capable of rendering   *)
  (*      them correctly.                                                  *)
  (*                                                                       *)
  // Note: enums are 32 bit on x86 AND x86_64
  FT_Glyph_Format = cuint32;  // 32 bit enum of FT_IMAGE_TAG
{$ELSE TYPE_DECL}
const
  FT_GLYPH_FORMAT_NONE      = (Ord(#0) shl 24) or
                              (Ord(#0) shl 16) or
                              (Ord(#0) shl  8) or
                              (Ord(#0) shl  0);

  FT_GLYPH_FORMAT_COMPOSITE = (Ord('c') shl 24) or
                              (Ord('o') shl 16) or
                              (Ord('m') shl  8) or
                              (Ord('p') shl  0);

  FT_GLYPH_FORMAT_BITMAP    = (Ord('b') shl 24) or
                              (Ord('i') shl 16) or
                              (Ord('t') shl  8) or
                              (Ord('s') shl  0);

  FT_GLYPH_FORMAT_OUTLINE   = (Ord('o') shl 24) or
                              (Ord('u') shl 16) or
                              (Ord('t') shl  8) or
                              (Ord('l') shl  0);

  FT_GLYPH_FORMAT_PLOTTER   = (Ord('p') shl 24) or
                              (Ord('l') shl 16) or
                              (Ord('o') shl  8) or
                              (Ord('t') shl  0);

{$ENDIF TYPE_DECL}

  (*************************************************************************)
  (*************************************************************************)
  (*************************************************************************)
  (*****                                                               *****)
  (*****            R A S T E R   D E F I N I T I O N S                *****)
  (*****                                                               *****)
  (*************************************************************************)
  (*************************************************************************)
  (*************************************************************************)


  (*************************************************************************)
  (*                                                                       *)
  (* A raster is a scan converter, in charge of rendering an outline into  *)
  (* a a bitmap.  This section contains the public API for rasters.        *)
  (*                                                                       *)
  (* Note that in FreeType 2, all rasters are now encapsulated within      *)
  (* specific modules called `renderers'.  See `freetype/ftrender.h' for   *)
  (* more details on renderers.                                            *)
  (*                                                                       *)
  (*************************************************************************)


  (*************************************************************************)
  (*                                                                       *)
  (* <Section>                                                             *)
  (*    raster                                                             *)
  (*                                                                       *)
  (* <Title>                                                               *)
  (*    Scanline Converter                                                 *)
  (*                                                                       *)
  (* <Abstract>                                                            *)
  (*    How vectorial outlines are converted into bitmaps and pixmaps.     *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    This section contains technical definitions.                       *)
  (*                                                                       *)
  (*************************************************************************)

{$IFDEF TYPE_DECL}

  (*************************************************************************)
  (*                                                                       *)
  (* <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.       *)
  (*                                                                       *)
  FT_Raster = Pointer;


  (*************************************************************************)
  (*                                                                       *)
  (* <Struct>                                                              *)
  (*    FT_Span                                                            *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    A structure used to model a single span of gray (or black) pixels  *)
  (*    when rendering a monochrome or anti-aliased bitmap.                *)
  (*                                                                       *)
  (* <Fields>                                                              *)
  (*    x        :: The span's horizontal start position.                  *)
  (*                                                                       *)
  (*    len      :: The span's length in pixels.                           *)
  (*                                                                       *)
  (*    coverage :: The span color/coverage, ranging from 0 (background)   *)
  (*                to 255 (foreground).  Only used for anti-aliased       *)
  (*                rendering.                                             *)
  (*                                                                       *)
  (* <Note>                                                                *)
  (*    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.                    *)
  (*                                                                       *)
  PFT_Span = ^FT_Span;
  FT_Span = record
    x:         cshort;
    len:       cushort;
    coverage:  cuchar;
  end;


  (*************************************************************************)
  (*                                                                       *)
  (* <FuncType>                                                            *)
  (*    FT_SpanFunc                                                        *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    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.                                           *)
  (*                                                                       *)
  (* <Input>                                                               *)
  (*    y     :: The scanline's y-coordinate.                              *)
  (*                                                                       *)
  (*    count :: The number of spans to draw on this scanline.             *)
  (*                                                                       *)
  (*    spans :: A table of `count' spans to draw on the scanline.         *)
  (*                                                                       *)
  (*    user  :: User-supplied data that is passed to the callback.        *)
  (*                                                                       *)
  (* <Note>                                                                *)
  (*    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 is 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.       *)
  (*                                                                       *)
  FT_SpanFunc = procedure(y:      cint;
                  count:          cint;
                  spans:          {const} PFT_Span;
                  user:           Pointer ); cdecl;


  (*************************************************************************)
  (*                                                                       *)
  (* <FuncType>                                                            *)
  (*    FT_Raster_BitTest_Func                                             *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    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.                                          *)
  (*                                                                       *)
  (* <Input>                                                               *)
  (*    y     :: The pixel's y-coordinate.                                 *)
  (*                                                                       *)
  (*    x     :: The pixel's x-coordinate.                                 *)
  (*                                                                       *)
  (*    user  :: User-supplied data that is passed to the callback.        *)
  (*                                                                       *)
  (* <Return>                                                              *)
  (*   1 if the pixel is `set', 0 otherwise.                               *)
  (*                                                                       *)
  FT_Raster_BitTest_Func = function(y: cint;
                             x:    cint;
                             user: Pointer): cint; cdecl;


  (*************************************************************************)
  (*                                                                       *)
  (* <FuncType>                                                            *)
  (*    FT_Raster_BitSet_Func                                              *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    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.          *)
  (*                                                                       *)
  (* <Input>                                                               *)
  (*    y     :: The pixel's y-coordinate.                                 *)
  (*                                                                       *)
  (*    x     :: The pixel's x-coordinate.                                 *)
  (*                                                                       *)
  (*    user  :: User-supplied data that is passed to the callback.        *)
  (*                                                                       *)
  (* <Return>                                                              *)
  (*    1 if the pixel is `set', 0 otherwise.                              *)
  (*                                                                       *)
  FT_Raster_BitSet_Func = procedure(y: cint;
                            x:    cint;
                            user: Pointer ); cdecl;


  (*************************************************************************)
  (*                                                                       *)
  (* <Enum>                                                                *)
  (*    FT_RASTER_FLAG_XXX                                                 *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    A list of bit flag constants as used in the `flags' field of a     *)
  (*    @FT_Raster_Params structure.                                       *)
  (*                                                                       *)
  (* <Values>                                                              *)
  (*    FT_RASTER_FLAG_DEFAULT :: This value is 0.                         *)
  (*                                                                       *)
  (*    FT_RASTER_FLAG_AA      :: This flag is set to indicate that an     *)
  (*                              anti-aliased glyph image should be       *)
  (*                              generated.  Otherwise, it will be        *)
  (*                              monochrome (1-bit).                      *)
  (*                                                                       *)
  (*    FT_RASTER_FLAG_DIRECT  :: This flag is set to indicate direct      *)
  (*                              rendering.  In this mode, client         *)
  (*                              applications must provide their own span *)
  (*                              callback.  This lets them directly       *)
  (*                              draw or compose over an existing bitmap. *)
  (*                              If this bit is not set, the target       *)
  (*                              pixmap's buffer _must_ be zeroed before  *)
  (*                              rendering.                               *)
  (*                                                                       *)
  (*                              Note that for now, direct rendering is   *)
  (*                              only possible with anti-aliased glyphs.  *)
  (*                                                                       *)
  (*    FT_RASTER_FLAG_CLIP    :: This flag is only used in direct         *)
  (*                              rendering mode.  If set, the output will *)
  (*                              be clipped to a box specified in the     *)
  (*                              `clip_box' field of the                  *)
  (*                              @FT_Raster_Params structure.             *)
  (*                                                                       *)
  (*                              Note that by default, the glyph bitmap   *)
  (*                              is clipped to the target pixmap, except  *)
  (*                              in direct rendering mode where all spans *)
  (*                              are generated if no clipping box is set. *)
  (*                                                                       *)
{$ELSE TYPE_DECL}
const
  FT_RASTER_FLAG_DEFAULT  = $0;
  FT_RASTER_FLAG_AA       = $1;
  FT_RASTER_FLAG_DIRECT   = $2;
  FT_RASTER_FLAG_CLIP     = $4;

{$ENDIF TYPE_DECL}
{$IFDEF TYPE_DECL}

  (*************************************************************************)
  (*                                                                       *)
  (* <Struct>                                                              *)
  (*    FT_Raster_Params                                                   *)
  (*                                                                       *)
  (* <Description>                                                         *)
  (*    A structure to hold the arguments used by a raster's render        *)
  (*    function.                                                          *)
  (*                                                                       *)
  (* <Fields>                                                              *)
  (*    target      :: The target bitmap.                                  *)
  (*                                                                       *)
  (*    source      :: A pointer to the source glyph image (e.g., an       *)
  (*                   @FT_Outline).                                       *)
  (*                                                                       *)
  (*    flags       :: The rendering flags.                                *)
  (*                                                                       *)
  (*    gray_spans  :: The gray span drawing callback.                     *)
  (*                                                                       *)
  (*    black_spans :: The black span drawing callback.                    *)
  (*                                                                       *)
  (*    bit_test    :: The bit test callback.  UNIMPLEMENTED!              *)
  (*                                                                       *)
  (*    bit_set     :: The bit set callback.  UNIMPLEMENTED!               *)
  (*                                                                       *)
  (*    user        :: User-supplied data that is passed to each drawing   *)
  (*                   callback.                                           *)
  (*                                                                       *)
  (*    clip_box    :: An optional clipping box.  It is only used in       *)
  (*                   direct rendering mode.  Note that coordinates here  *)
  (*                   should be expressed in _integer_ pixels (and not in *)
  (*                   26.6 fixed-point units).                            *)
  (*                                                                       *)
  (* <Note>                                                                *)
  (*    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 is 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. *)
  (*                                                                       *)
  PFT_Raster_Params = ^FT_Raster_Params;
  FT_Raster_Params = record
    target:        {const} PFT_Bitmap;
    source:        {const} Pointer;
    flags:         cint;
    gray_spans:    FT_SpanFunc;
    black_spans:   FT_SpanFunc;
    bit_test:      FT_Raster_BitTest_Func;     (* doesn't work! *)
    bit_set:       FT_Raster_BitSet_Func;      (* doesn't work! *)
    user:          Pointer;
    clip_box:      FT_BBox;
  end;

{$ENDIF TYPE_DECL}


