< prev index next >
src/java.desktop/share/native/libfreetype/include/freetype/ftimage.h
Print this page
*** 1,29 ****
! /***************************************************************************/
! /* */
! /* ftimage.h */
! /* */
! /* FreeType glyph image formats and default raster interface */
! /* (specification). */
! /* */
! /* Copyright 1996-2018 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. */
! /* */
! /***************************************************************************/
!
! /*************************************************************************/
! /* */
! /* Note: A `raster' is simply a scan-line converter, used to render */
! /* FT_Outlines into FT_Bitmaps. */
! /* */
! /*************************************************************************/
#ifndef FTIMAGE_H_
#define FTIMAGE_H_
--- 1,29 ----
! /****************************************************************************
! *
! * ftimage.h
! *
! * FreeType glyph image formats and default raster interface
! * (specification).
! *
! * Copyright (C) 1996-2019 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.
! *
! */
!
! /**************************************************************************
! *
! * Note: A 'raster' is simply a scan-line converter, used to render
! * FT_Outlines into FT_Bitmaps.
! *
! */
#ifndef FTIMAGE_H_
#define FTIMAGE_H_
*** 35,184 ****
FT_BEGIN_HEADER
! /*************************************************************************/
! /* */
! /* <Section> */
! /* basic_types */
! /* */
! /*************************************************************************/
!
!
! /*************************************************************************/
! /* */
! /* <Type> */
! /* FT_Pos */
! /* */
! /* <Description> */
! /* The type FT_Pos is used to store vectorial coordinates. Depending */
! /* on the context, these can represent distances in integer font */
! /* units, or 16.16, or 26.6 fixed-point pixel coordinates. */
! /* */
typedef signed long FT_Pos;
! /*************************************************************************/
! /* */
! /* <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. */
! /* */
typedef struct FT_Vector_
{
FT_Pos x;
FT_Pos y;
} 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). */
! /* */
! /* <Note> */
! /* The bounding box is specified with the coordinates of the lower */
! /* left and the upper right corner. In PostScript, those values are */
! /* often called (llx,lly) and (urx,ury), respectively. */
! /* */
! /* If `yMin' is negative, this value gives the glyph's descender. */
! /* Otherwise, the glyph doesn't descend below the baseline. */
! /* Similarly, if `ymax' is positive, this value gives the glyph's */
! /* ascender. */
! /* */
! /* `xMin' gives the horizontal distance from the glyph's origin to */
! /* the left edge of the glyph's bounding box. If `xMin' is negative, */
! /* the glyph extends to the left of the origin. */
! /* */
typedef struct FT_BBox_
{
FT_Pos xMin, yMin;
FT_Pos xMax, yMax;
} FT_BBox;
! /*************************************************************************/
! /* */
! /* <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 `gray' levels is stored in the `num_grays' field of the */
! /* @FT_Bitmap structure (it generally is 256). */
! /* */
! /* FT_PIXEL_MODE_GRAY2 :: */
! /* A 2-bit per 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 per pixel bitmap, representing 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, representing 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, representing 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_BGRA :: */
! /* [Since 2.5] An image with four 8-bit channels per pixel, */
! /* representing a color image (such as emoticons) with alpha */
! /* channel. For each pixel, the format is BGRA, which means, the */
! /* blue channel comes first in memory. The color channels are */
! /* pre-multiplied and in the sRGB colorspace. For example, full */
! /* red at half-translucent opacity will be represented as */
! /* `00,00,80,80', not `00,00,FF,80'. See also @FT_LOAD_COLOR. */
! /* */
typedef enum FT_Pixel_Mode_
{
FT_PIXEL_MODE_NONE = 0,
FT_PIXEL_MODE_MONO,
FT_PIXEL_MODE_GRAY,
--- 35,185 ----
FT_BEGIN_HEADER
! /**************************************************************************
! *
! * @section:
! * basic_types
! *
! */
!
!
! /**************************************************************************
! *
! * @type:
! * FT_Pos
! *
! * @description:
! * The type FT_Pos is used to store vectorial coordinates. Depending on
! * the context, these can represent distances in integer font units, or
! * 16.16, or 26.6 fixed-point pixel coordinates.
! */
typedef signed long FT_Pos;
! /**************************************************************************
! *
! * @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.
! */
typedef struct FT_Vector_
{
FT_Pos x;
FT_Pos y;
} 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).
! *
! * @note:
! * The bounding box is specified with the coordinates of the lower left
! * and the upper right corner. In PostScript, those values are often
! * called (llx,lly) and (urx,ury), respectively.
! *
! * If `yMin` is negative, this value gives the glyph's descender.
! * Otherwise, the glyph doesn't descend below the baseline. Similarly,
! * if `ymax` is positive, this value gives the glyph's ascender.
! *
! * `xMin` gives the horizontal distance from the glyph's origin to the
! * left edge of the glyph's bounding box. If `xMin` is negative, the
! * glyph extends to the left of the origin.
! */
typedef struct FT_BBox_
{
FT_Pos xMin, yMin;
FT_Pos xMax, yMax;
} FT_BBox;
! /**************************************************************************
! *
! * @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
! * 'gray' levels is stored in the `num_grays` field of the @FT_Bitmap
! * structure (it generally is 256).
! *
! * FT_PIXEL_MODE_GRAY2 ::
! * A 2-bit per 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 per pixel bitmap, representing 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, representing 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, representing 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_BGRA ::
! * [Since 2.5] An image with four 8-bit channels per pixel,
! * representing a color image (such as emoticons) with alpha channel.
! * For each pixel, the format is BGRA, which means, the blue channel
! * comes first in memory. The color channels are pre-multiplied and in
! * the sRGB colorspace. For example, full red at half-translucent
! * opacity will be represented as '00,00,80,80', not '00,00,FF,80'.
! * See also @FT_LOAD_COLOR.
! */
typedef enum FT_Pixel_Mode_
{
FT_PIXEL_MODE_NONE = 0,
FT_PIXEL_MODE_MONO,
FT_PIXEL_MODE_GRAY,
*** 191,265 ****
FT_PIXEL_MODE_MAX /* do not remove */
} FT_Pixel_Mode;
! /* these constants are deprecated; use the corresponding `FT_Pixel_Mode' */
/* values instead. */
#define ft_pixel_mode_none FT_PIXEL_MODE_NONE
#define ft_pixel_mode_mono FT_PIXEL_MODE_MONO
#define ft_pixel_mode_grays FT_PIXEL_MODE_GRAY
#define ft_pixel_mode_pal2 FT_PIXEL_MODE_GRAY2
#define ft_pixel_mode_pal4 FT_PIXEL_MODE_GRAY4
! /*************************************************************************/
! /* */
! /* <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. */
! /* */
! /* Note that `padding' means the alignment of a */
! /* bitmap to a byte border, and FreeType functions */
! /* normally align to the smallest possible integer */
! /* value. */
! /* */
! /* For the B/W rasterizer, `pitch' is always an even */
! /* number. */
! /* */
! /* To change the pitch of a bitmap (say, to make it a */
! /* multiple of 4), use @FT_Bitmap_Convert. */
! /* Alternatively, you might use callback functions to */
! /* directly render to the application's surface; see */
! /* the file `example2.cpp' in the tutorial for a */
! /* demonstration. */
! /* */
! /* 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 intended for paletted pixel modes; */
! /* it indicates how the palette is stored. Not */
! /* used currently. */
! /* */
! /* palette :: A typeless pointer to the bitmap palette; this */
! /* field is intended for paletted pixel modes. Not */
! /* used currently. */
! /* */
typedef struct FT_Bitmap_
{
unsigned int rows;
unsigned int width;
int pitch;
--- 192,265 ----
FT_PIXEL_MODE_MAX /* do not remove */
} FT_Pixel_Mode;
! /* these constants are deprecated; use the corresponding `FT_Pixel_Mode` */
/* values instead. */
#define ft_pixel_mode_none FT_PIXEL_MODE_NONE
#define ft_pixel_mode_mono FT_PIXEL_MODE_MONO
#define ft_pixel_mode_grays FT_PIXEL_MODE_GRAY
#define ft_pixel_mode_pal2 FT_PIXEL_MODE_GRAY2
#define ft_pixel_mode_pal4 FT_PIXEL_MODE_GRAY4
! /**************************************************************************
! *
! * @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.
! *
! * Note that 'padding' means the alignment of a bitmap to a byte
! * border, and FreeType functions normally align to the smallest
! * possible integer value.
! *
! * For the B/W rasterizer, `pitch` is always an even number.
! *
! * To change the pitch of a bitmap (say, to make it a multiple of 4),
! * use @FT_Bitmap_Convert. Alternatively, you might use callback
! * functions to directly render to the application's surface; see the
! * file `example2.cpp` in the tutorial for a demonstration.
! *
! * 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 intended for paletted pixel modes; it indicates how
! * the palette is stored. Not used currently.
! *
! * palette ::
! * A typeless pointer to the bitmap palette; this field is intended for
! * paletted pixel modes. Not used currently.
! */
typedef struct FT_Bitmap_
{
unsigned int rows;
unsigned int width;
int pitch;
*** 270,338 ****
void* palette;
} FT_Bitmap;
! /*************************************************************************/
! /* */
! /* <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' if */
! /* 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. */
! /* */
! /* If bit~2 is set, bits 5-7 contain the drop-out mode */
! /* (as defined in the OpenType specification; the value */
! /* is the same as the argument to the SCANMODE */
! /* instruction). */
! /* */
! /* Bits 3 and~4 are reserved for internal purposes. */
! /* */
! /* 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_XXX. */
! /* */
! /* <Note> */
! /* The B/W rasterizer only checks bit~2 in the `tags' array for the */
! /* first point of each contour. The drop-out mode as given with */
! /* @FT_OUTLINE_IGNORE_DROPOUTS, @FT_OUTLINE_SMART_DROPOUTS, and */
! /* @FT_OUTLINE_INCLUDE_STUBS in `flags' is then overridden. */
! /* */
typedef struct FT_Outline_
{
short n_contours; /* number of contours in glyph */
short n_points; /* number of points in the glyph */
--- 270,341 ----
void* palette;
} FT_Bitmap;
! /**************************************************************************
! *
! * @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' if 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.
! *
! * If bit~2 is set, bits 5-7 contain the drop-out mode (as defined in
! * the OpenType specification; the value is the same as the argument to
! * the 'SCANMODE' instruction).
! *
! * Bits 3 and~4 are reserved for internal purposes.
! *
! * 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_XXX.
! *
! * @note:
! * The B/W rasterizer only checks bit~2 in the `tags` array for the first
! * point of each contour. The drop-out mode as given with
! * @FT_OUTLINE_IGNORE_DROPOUTS, @FT_OUTLINE_SMART_DROPOUTS, and
! * @FT_OUTLINE_INCLUDE_STUBS in `flags` is then overridden.
! */
typedef struct FT_Outline_
{
short n_contours; /* number of contours in glyph */
short n_points; /* number of points in the glyph */
*** 350,431 ****
/* FT_Outline.{n_contours,n_points} */
#define FT_OUTLINE_CONTOURS_MAX SHRT_MAX
#define FT_OUTLINE_POINTS_MAX SHRT_MAX
! /*************************************************************************/
! /* */
! /* <Enum> */
! /* FT_OUTLINE_XXX */
! /* */
! /* <Description> */
! /* A list of bit-field constants use for the flags in an outline's */
! /* `flags' field. */
! /* */
! /* <Values> */
! /* FT_OUTLINE_NONE :: */
! /* Value~0 is reserved. */
! /* */
! /* FT_OUTLINE_OWNER :: */
! /* If set, this flag indicates that the outline's field arrays */
! /* (i.e., `points', `flags', and `contours') are `owned' by the */
! /* outline object, and should thus be freed when it is destroyed. */
! /* */
! /* FT_OUTLINE_EVEN_ODD_FILL :: */
! /* By default, outlines are filled using the non-zero winding rule. */
! /* If set to 1, the outline will be filled using the even-odd fill */
! /* rule (only works with the smooth rasterizer). */
! /* */
! /* FT_OUTLINE_REVERSE_FILL :: */
! /* By default, outside contours of an outline are oriented in */
! /* clock-wise direction, as defined in the TrueType specification. */
! /* This flag is set if the outline uses the opposite direction */
! /* (typically for Type~1 fonts). This flag is ignored by the scan */
! /* converter. */
! /* */
! /* FT_OUTLINE_IGNORE_DROPOUTS :: */
! /* By default, the scan converter will try to detect drop-outs in */
! /* an outline and correct the glyph bitmap to ensure consistent */
! /* shape continuity. If set, this flag hints the scan-line */
! /* converter to ignore such cases. See below for more information. */
! /* */
! /* FT_OUTLINE_SMART_DROPOUTS :: */
! /* Select smart dropout control. If unset, use simple dropout */
! /* control. Ignored if @FT_OUTLINE_IGNORE_DROPOUTS is set. See */
! /* below for more information. */
! /* */
! /* FT_OUTLINE_INCLUDE_STUBS :: */
! /* If set, turn pixels on for `stubs', otherwise exclude them. */
! /* Ignored if @FT_OUTLINE_IGNORE_DROPOUTS is set. See below for */
! /* more information. */
! /* */
! /* FT_OUTLINE_HIGH_PRECISION :: */
! /* This flag indicates that the scan-line converter should try to */
! /* convert this outline to bitmaps with the highest possible */
! /* quality. It is typically set for small character sizes. Note */
! /* that this is only a hint that might be completely ignored by a */
! /* given scan-converter. */
! /* */
! /* FT_OUTLINE_SINGLE_PASS :: */
! /* This flag is set to force a given scan-converter to only use a */
! /* single pass over the outline to render a bitmap glyph image. */
! /* Normally, it is set for very large character sizes. It is only */
! /* a hint that might be completely ignored by a given */
! /* scan-converter. */
! /* */
! /* <Note> */
! /* The flags @FT_OUTLINE_IGNORE_DROPOUTS, @FT_OUTLINE_SMART_DROPOUTS, */
! /* and @FT_OUTLINE_INCLUDE_STUBS are ignored by the smooth */
! /* rasterizer. */
! /* */
! /* There exists a second mechanism to pass the drop-out mode to the */
! /* B/W rasterizer; see the `tags' field in @FT_Outline. */
! /* */
! /* Please refer to the description of the `SCANTYPE' instruction in */
! /* the OpenType specification (in file `ttinst1.doc') how simple */
! /* drop-outs, smart drop-outs, and stubs are defined. */
! /* */
#define FT_OUTLINE_NONE 0x0
#define FT_OUTLINE_OWNER 0x1
#define FT_OUTLINE_EVEN_ODD_FILL 0x2
#define FT_OUTLINE_REVERSE_FILL 0x4
#define FT_OUTLINE_IGNORE_DROPOUTS 0x8
--- 353,432 ----
/* FT_Outline.{n_contours,n_points} */
#define FT_OUTLINE_CONTOURS_MAX SHRT_MAX
#define FT_OUTLINE_POINTS_MAX SHRT_MAX
! /**************************************************************************
! *
! * @enum:
! * FT_OUTLINE_XXX
! *
! * @description:
! * A list of bit-field constants used for the flags in an outline's
! * `flags` field.
! *
! * @values:
! * FT_OUTLINE_NONE ::
! * Value~0 is reserved.
! *
! * FT_OUTLINE_OWNER ::
! * If set, this flag indicates that the outline's field arrays (i.e.,
! * `points`, `flags`, and `contours`) are 'owned' by the outline
! * object, and should thus be freed when it is destroyed.
! *
! * FT_OUTLINE_EVEN_ODD_FILL ::
! * By default, outlines are filled using the non-zero winding rule. If
! * set to 1, the outline will be filled using the even-odd fill rule
! * (only works with the smooth rasterizer).
! *
! * FT_OUTLINE_REVERSE_FILL ::
! * By default, outside contours of an outline are oriented in
! * clock-wise direction, as defined in the TrueType specification.
! * This flag is set if the outline uses the opposite direction
! * (typically for Type~1 fonts). This flag is ignored by the scan
! * converter.
! *
! * FT_OUTLINE_IGNORE_DROPOUTS ::
! * By default, the scan converter will try to detect drop-outs in an
! * outline and correct the glyph bitmap to ensure consistent shape
! * continuity. If set, this flag hints the scan-line converter to
! * ignore such cases. See below for more information.
! *
! * FT_OUTLINE_SMART_DROPOUTS ::
! * Select smart dropout control. If unset, use simple dropout control.
! * Ignored if @FT_OUTLINE_IGNORE_DROPOUTS is set. See below for more
! * information.
! *
! * FT_OUTLINE_INCLUDE_STUBS ::
! * If set, turn pixels on for 'stubs', otherwise exclude them. Ignored
! * if @FT_OUTLINE_IGNORE_DROPOUTS is set. See below for more
! * information.
! *
! * FT_OUTLINE_HIGH_PRECISION ::
! * This flag indicates that the scan-line converter should try to
! * convert this outline to bitmaps with the highest possible quality.
! * It is typically set for small character sizes. Note that this is
! * only a hint that might be completely ignored by a given
! * scan-converter.
! *
! * FT_OUTLINE_SINGLE_PASS ::
! * This flag is set to force a given scan-converter to only use a
! * single pass over the outline to render a bitmap glyph image.
! * Normally, it is set for very large character sizes. It is only a
! * hint that might be completely ignored by a given scan-converter.
! *
! * @note:
! * The flags @FT_OUTLINE_IGNORE_DROPOUTS, @FT_OUTLINE_SMART_DROPOUTS, and
! * @FT_OUTLINE_INCLUDE_STUBS are ignored by the smooth rasterizer.
! *
! * There exists a second mechanism to pass the drop-out mode to the B/W
! * rasterizer; see the `tags` field in @FT_Outline.
! *
! * Please refer to the description of the 'SCANTYPE' instruction in the
! * OpenType specification (in file `ttinst1.doc`) how simple drop-outs,
! * smart drop-outs, and stubs are defined.
! */
#define FT_OUTLINE_NONE 0x0
#define FT_OUTLINE_OWNER 0x1
#define FT_OUTLINE_EVEN_ODD_FILL 0x2
#define FT_OUTLINE_REVERSE_FILL 0x4
#define FT_OUTLINE_IGNORE_DROPOUTS 0x8
*** 435,632 ****
#define FT_OUTLINE_HIGH_PRECISION 0x100
#define FT_OUTLINE_SINGLE_PASS 0x200
/* these constants are deprecated; use the corresponding */
! /* `FT_OUTLINE_XXX' values instead */
#define ft_outline_none FT_OUTLINE_NONE
#define ft_outline_owner FT_OUTLINE_OWNER
#define ft_outline_even_odd_fill FT_OUTLINE_EVEN_ODD_FILL
#define ft_outline_reverse_fill FT_OUTLINE_REVERSE_FILL
#define ft_outline_ignore_dropouts FT_OUTLINE_IGNORE_DROPOUTS
#define ft_outline_high_precision FT_OUTLINE_HIGH_PRECISION
#define ft_outline_single_pass FT_OUTLINE_SINGLE_PASS
/* */
! #define FT_CURVE_TAG( flag ) ( flag & 3 )
! #define FT_CURVE_TAG_ON 1
! #define FT_CURVE_TAG_CONIC 0
! #define FT_CURVE_TAG_CUBIC 2
! #define FT_CURVE_TAG_HAS_SCANMODE 4
! #define FT_CURVE_TAG_TOUCH_X 8 /* reserved for the TrueType hinter */
! #define FT_CURVE_TAG_TOUCH_Y 16 /* reserved for the TrueType hinter */
#define FT_CURVE_TAG_TOUCH_BOTH ( FT_CURVE_TAG_TOUCH_X | \
FT_CURVE_TAG_TOUCH_Y )
#define FT_Curve_Tag_On FT_CURVE_TAG_ON
#define FT_Curve_Tag_Conic FT_CURVE_TAG_CONIC
#define FT_Curve_Tag_Cubic FT_CURVE_TAG_CUBIC
#define FT_Curve_Tag_Touch_X FT_CURVE_TAG_TOUCH_X
#define FT_Curve_Tag_Touch_Y FT_CURVE_TAG_TOUCH_Y
! /*************************************************************************/
! /* */
! /* <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. */
! /* */
typedef int
(*FT_Outline_MoveToFunc)( const FT_Vector* to,
void* user );
#define FT_Outline_MoveTo_Func FT_Outline_MoveToFunc
! /*************************************************************************/
! /* */
! /* <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. */
! /* */
typedef int
(*FT_Outline_LineToFunc)( const FT_Vector* to,
void* user );
#define FT_Outline_LineTo_Func FT_Outline_LineToFunc
! /*************************************************************************/
! /* */
! /* <FuncType> */
! /* FT_Outline_ConicToFunc */
! /* */
! /* <Description> */
! /* A function pointer type used to describe the signature of a `conic */
! /* to' function during outline walking or decomposition. */
! /* */
! /* A `conic to' is emitted to indicate a second-order Bezier 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. */
! /* */
typedef int
(*FT_Outline_ConicToFunc)( const FT_Vector* control,
const FT_Vector* to,
void* user );
#define FT_Outline_ConicTo_Func FT_Outline_ConicToFunc
! /*************************************************************************/
! /* */
! /* <FuncType> */
! /* FT_Outline_CubicToFunc */
! /* */
! /* <Description> */
! /* A function pointer type used to describe the signature of a `cubic */
! /* to' function during outline walking or decomposition. */
! /* */
! /* A `cubic to' is emitted to indicate a third-order Bezier arc. */
! /* */
! /* <Input> */
! /* control1 :: A pointer to the first Bezier control point. */
! /* */
! /* control2 :: A pointer to the second Bezier 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. */
! /* */
typedef int
(*FT_Outline_CubicToFunc)( const FT_Vector* control1,
const FT_Vector* control2,
const FT_Vector* to,
void* user );
#define FT_Outline_CubicTo_Func FT_Outline_CubicToFunc
! /*************************************************************************/
! /* */
! /* <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. */
! /* */
! /* <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. */
! /* */
! /* 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' = (y << shift) - delta */
! /* } */
! /* */
! /* Set the values of `shift' and `delta' to~0 to get the original */
! /* point coordinates. */
! /* */
typedef struct FT_Outline_Funcs_
{
FT_Outline_MoveToFunc move_to;
FT_Outline_LineToFunc line_to;
FT_Outline_ConicToFunc conic_to;
--- 436,655 ----
#define FT_OUTLINE_HIGH_PRECISION 0x100
#define FT_OUTLINE_SINGLE_PASS 0x200
/* these constants are deprecated; use the corresponding */
! /* `FT_OUTLINE_XXX` values instead */
#define ft_outline_none FT_OUTLINE_NONE
#define ft_outline_owner FT_OUTLINE_OWNER
#define ft_outline_even_odd_fill FT_OUTLINE_EVEN_ODD_FILL
#define ft_outline_reverse_fill FT_OUTLINE_REVERSE_FILL
#define ft_outline_ignore_dropouts FT_OUTLINE_IGNORE_DROPOUTS
#define ft_outline_high_precision FT_OUTLINE_HIGH_PRECISION
#define ft_outline_single_pass FT_OUTLINE_SINGLE_PASS
/* */
! #define FT_CURVE_TAG( flag ) ( flag & 0x03 )
! /* see the `tags` field in `FT_Outline` for a description of the values */
! #define FT_CURVE_TAG_ON 0x01
! #define FT_CURVE_TAG_CONIC 0x00
! #define FT_CURVE_TAG_CUBIC 0x02
! #define FT_CURVE_TAG_HAS_SCANMODE 0x04
! #define FT_CURVE_TAG_TOUCH_X 0x08 /* reserved for TrueType hinter */
! #define FT_CURVE_TAG_TOUCH_Y 0x10 /* reserved for TrueType hinter */
#define FT_CURVE_TAG_TOUCH_BOTH ( FT_CURVE_TAG_TOUCH_X | \
FT_CURVE_TAG_TOUCH_Y )
+ /* values 0x20, 0x40, and 0x80 are reserved */
+
+ /* these constants are deprecated; use the corresponding */
+ /* `FT_CURVE_TAG_XXX` values instead */
#define FT_Curve_Tag_On FT_CURVE_TAG_ON
#define FT_Curve_Tag_Conic FT_CURVE_TAG_CONIC
#define FT_Curve_Tag_Cubic FT_CURVE_TAG_CUBIC
#define FT_Curve_Tag_Touch_X FT_CURVE_TAG_TOUCH_X
#define FT_Curve_Tag_Touch_Y FT_CURVE_TAG_TOUCH_Y
! /**************************************************************************
! *
! * @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.
! */
typedef int
(*FT_Outline_MoveToFunc)( const FT_Vector* to,
void* user );
#define FT_Outline_MoveTo_Func FT_Outline_MoveToFunc
! /**************************************************************************
! *
! * @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.
! */
typedef int
(*FT_Outline_LineToFunc)( const FT_Vector* to,
void* user );
#define FT_Outline_LineTo_Func FT_Outline_LineToFunc
! /**************************************************************************
! *
! * @functype:
! * FT_Outline_ConicToFunc
! *
! * @description:
! * A function pointer type used to describe the signature of a 'conic to'
! * function during outline walking or decomposition.
! *
! * A 'conic to' is emitted to indicate a second-order Bezier 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.
! */
typedef int
(*FT_Outline_ConicToFunc)( const FT_Vector* control,
const FT_Vector* to,
void* user );
#define FT_Outline_ConicTo_Func FT_Outline_ConicToFunc
! /**************************************************************************
! *
! * @functype:
! * FT_Outline_CubicToFunc
! *
! * @description:
! * A function pointer type used to describe the signature of a 'cubic to'
! * function during outline walking or decomposition.
! *
! * A 'cubic to' is emitted to indicate a third-order Bezier arc.
! *
! * @input:
! * control1 ::
! * A pointer to the first Bezier control point.
! *
! * control2 ::
! * A pointer to the second Bezier 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.
! */
typedef int
(*FT_Outline_CubicToFunc)( const FT_Vector* control1,
const FT_Vector* control2,
const FT_Vector* to,
void* user );
#define FT_Outline_CubicTo_Func FT_Outline_CubicToFunc
! /**************************************************************************
! *
! * @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.
! *
! * @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.
! *
! * 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' = (y << shift) - delta
! * ```
! *
! * Set the values of `shift` and `delta` to~0 to get the original point
! * coordinates.
! */
typedef struct FT_Outline_Funcs_
{
FT_Outline_MoveToFunc move_to;
FT_Outline_LineToFunc line_to;
FT_Outline_ConicToFunc conic_to;
*** 636,719 ****
FT_Pos delta;
} FT_Outline_Funcs;
! /*************************************************************************/
! /* */
! /* <Section> */
! /* basic_types */
! /* */
! /*************************************************************************/
!
!
! /*************************************************************************/
! /* */
! /* <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. */
! /* */
#ifndef FT_IMAGE_TAG
#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 )
#endif /* FT_IMAGE_TAG */
! /*************************************************************************/
! /* */
! /* <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. */
! /* */
! /* 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 vectorial 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 and 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. */
! /* */
typedef enum FT_Glyph_Format_
{
FT_IMAGE_TAG( FT_GLYPH_FORMAT_NONE, 0, 0, 0, 0 ),
FT_IMAGE_TAG( FT_GLYPH_FORMAT_COMPOSITE, 'c', 'o', 'm', 'p' ),
--- 659,740 ----
FT_Pos delta;
} FT_Outline_Funcs;
! /**************************************************************************
! *
! * @section:
! * basic_types
! *
! */
!
!
! /**************************************************************************
! *
! * @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.
! */
#ifndef FT_IMAGE_TAG
#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 )
#endif /* FT_IMAGE_TAG */
! /**************************************************************************
! *
! * @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.
! *
! * 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 vectorial 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 and 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.
! */
typedef enum FT_Glyph_Format_
{
FT_IMAGE_TAG( FT_GLYPH_FORMAT_NONE, 0, 0, 0, 0 ),
FT_IMAGE_TAG( FT_GLYPH_FORMAT_COMPOSITE, 'c', 'o', 'm', 'p' ),
*** 723,733 ****
} FT_Glyph_Format;
/* these constants are deprecated; use the corresponding */
! /* `FT_Glyph_Format' values instead. */
#define ft_glyph_format_none FT_GLYPH_FORMAT_NONE
#define ft_glyph_format_composite FT_GLYPH_FORMAT_COMPOSITE
#define ft_glyph_format_bitmap FT_GLYPH_FORMAT_BITMAP
#define ft_glyph_format_outline FT_GLYPH_FORMAT_OUTLINE
#define ft_glyph_format_plotter FT_GLYPH_FORMAT_PLOTTER
--- 744,754 ----
} FT_Glyph_Format;
/* these constants are deprecated; use the corresponding */
! /* `FT_Glyph_Format` values instead. */
#define ft_glyph_format_none FT_GLYPH_FORMAT_NONE
#define ft_glyph_format_composite FT_GLYPH_FORMAT_COMPOSITE
#define ft_glyph_format_bitmap FT_GLYPH_FORMAT_BITMAP
#define ft_glyph_format_outline FT_GLYPH_FORMAT_OUTLINE
#define ft_glyph_format_plotter FT_GLYPH_FORMAT_PLOTTER
*** 742,1001 ****
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
! /*************************************************************************/
! /* */
! /* A raster is a scan converter, in charge of rendering an outline into */
! /* 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 `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. */
! /* */
! /* <Order> */
! /* FT_Raster */
! /* FT_Span */
! /* FT_SpanFunc */
! /* */
! /* FT_Raster_Params */
! /* FT_RASTER_FLAG_XXX */
! /* */
! /* FT_Raster_NewFunc */
! /* FT_Raster_DoneFunc */
! /* FT_Raster_ResetFunc */
! /* FT_Raster_SetModeFunc */
! /* FT_Raster_RenderFunc */
! /* FT_Raster_Funcs */
! /* */
! /*************************************************************************/
!
!
! /*************************************************************************/
! /* */
! /* <Type> */
! /* FT_Raster */
! /* */
! /* <Description> */
! /* An opaque 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;
! /*************************************************************************/
! /* */
! /* <Struct> */
! /* FT_Span */
! /* */
! /* <Description> */
! /* A structure used to model a single span of gray pixels when */
! /* rendering an 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). */
! /* */
! /* <Note> */
! /* This structure is used by the span drawing callback type named */
! /* @FT_SpanFunc that takes the y~coordinate of the span as a */
! /* parameter. */
! /* */
! /* The coverage value is always between 0 and 255. If you want less */
! /* gray values, the callback function has to reduce them. */
! /* */
typedef struct FT_Span_
{
short x;
unsigned short len;
unsigned char coverage;
} FT_Span;
! /*************************************************************************/
! /* */
! /* <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. */
! /* */
typedef void
(*FT_SpanFunc)( int y,
int count,
const FT_Span* spans,
void* user );
#define FT_Raster_Span_Func FT_SpanFunc
! /*************************************************************************/
! /* */
! /* <FuncType> */
! /* FT_Raster_BitTest_Func */
! /* */
! /* <Description> */
! /* Deprecated, unimplemented. */
! /* */
typedef int
(*FT_Raster_BitTest_Func)( int y,
int x,
void* user );
! /*************************************************************************/
! /* */
! /* <FuncType> */
! /* FT_Raster_BitSet_Func */
! /* */
! /* <Description> */
! /* Deprecated, unimplemented. */
! /* */
typedef void
(*FT_Raster_BitSet_Func)( int y,
int x,
void* user );
! /*************************************************************************/
! /* */
! /* <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. */
! /* */
! /* 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. */
! /* */
#define FT_RASTER_FLAG_DEFAULT 0x0
#define FT_RASTER_FLAG_AA 0x1
#define FT_RASTER_FLAG_DIRECT 0x2
#define FT_RASTER_FLAG_CLIP 0x4
/* these constants are deprecated; use the corresponding */
! /* `FT_RASTER_FLAG_XXX' values instead */
#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
! /*************************************************************************/
! /* */
! /* <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 :: Unused. */
! /* */
! /* bit_test :: Unused. */
! /* */
! /* bit_set :: Unused. */
! /* */
! /* 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. This allows direct composition over a pre-existing bitmap */
! /* through user-provided callbacks to perform the span drawing and */
! /* composition. Not supported by the monochrome rasterizer. */
! /* */
typedef struct FT_Raster_Params_
{
const FT_Bitmap* target;
const void* source;
int flags;
--- 763,1028 ----
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
! /**************************************************************************
! *
! * A raster is a scan converter, in charge of rendering an outline into 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 `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.
! *
! * @order:
! * FT_Raster
! * FT_Span
! * FT_SpanFunc
! *
! * FT_Raster_Params
! * FT_RASTER_FLAG_XXX
! *
! * FT_Raster_NewFunc
! * FT_Raster_DoneFunc
! * FT_Raster_ResetFunc
! * FT_Raster_SetModeFunc
! * FT_Raster_RenderFunc
! * FT_Raster_Funcs
! *
! */
!
!
! /**************************************************************************
! *
! * @type:
! * FT_Raster
! *
! * @description:
! * An opaque 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;
! /**************************************************************************
! *
! * @struct:
! * FT_Span
! *
! * @description:
! * A structure used to model a single span of gray pixels when rendering
! * an 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).
! *
! * @note:
! * This structure is used by the span drawing callback type named
! * @FT_SpanFunc that takes the y~coordinate of the span as a parameter.
! *
! * The coverage value is always between 0 and 255. If you want less gray
! * values, the callback function has to reduce them.
! */
typedef struct FT_Span_
{
short x;
unsigned short len;
unsigned char coverage;
} FT_Span;
! /**************************************************************************
! *
! * @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.
! */
typedef void
(*FT_SpanFunc)( int y,
int count,
const FT_Span* spans,
void* user );
#define FT_Raster_Span_Func FT_SpanFunc
! /**************************************************************************
! *
! * @functype:
! * FT_Raster_BitTest_Func
! *
! * @description:
! * Deprecated, unimplemented.
! */
typedef int
(*FT_Raster_BitTest_Func)( int y,
int x,
void* user );
! /**************************************************************************
! *
! * @functype:
! * FT_Raster_BitSet_Func
! *
! * @description:
! * Deprecated, unimplemented.
! */
typedef void
(*FT_Raster_BitSet_Func)( int y,
int x,
void* user );
! /**************************************************************************
! *
! * @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.
! *
! * 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.
! */
#define FT_RASTER_FLAG_DEFAULT 0x0
#define FT_RASTER_FLAG_AA 0x1
#define FT_RASTER_FLAG_DIRECT 0x2
#define FT_RASTER_FLAG_CLIP 0x4
/* these constants are deprecated; use the corresponding */
! /* `FT_RASTER_FLAG_XXX` values instead */
#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
! /**************************************************************************
! *
! * @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 ::
! * Unused.
! *
! * bit_test ::
! * Unused.
! *
! * bit_set ::
! * Unused.
! *
! * 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. This
! * allows direct composition over a pre-existing bitmap through
! * user-provided callbacks to perform the span drawing and composition.
! * Not supported by the monochrome rasterizer.
! */
typedef struct FT_Raster_Params_
{
const FT_Bitmap* target;
const void* source;
int flags;
*** 1007,1184 ****
FT_BBox clip_box;
} FT_Raster_Params;
! /*************************************************************************/
! /* */
! /* <FuncType> */
! /* FT_Raster_NewFunc */
! /* */
! /* <Description> */
! /* A function used to create a new raster object. */
! /* */
! /* <Input> */
! /* memory :: A handle to the memory allocator. */
! /* */
! /* <Output> */
! /* raster :: A handle to the new raster object. */
! /* */
! /* <Return> */
! /* Error code. 0~means success. */
! /* */
! /* <Note> */
! /* 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 an @FT_Memory object, i.e., a handle to the */
! /* standard FreeType memory allocator. However, this field can be */
! /* completely ignored by a given raster implementation. */
! /* */
typedef int
(*FT_Raster_NewFunc)( void* memory,
FT_Raster* raster );
#define FT_Raster_New_Func FT_Raster_NewFunc
! /*************************************************************************/
! /* */
! /* <FuncType> */
! /* FT_Raster_DoneFunc */
! /* */
! /* <Description> */
! /* A function used to destroy a given raster object. */
! /* */
! /* <Input> */
! /* raster :: A handle to the raster object. */
! /* */
typedef void
(*FT_Raster_DoneFunc)( FT_Raster raster );
#define FT_Raster_Done_Func FT_Raster_DoneFunc
! /*************************************************************************/
! /* */
! /* <FuncType> */
! /* FT_Raster_ResetFunc */
! /* */
! /* <Description> */
! /* FreeType used to provide an area of memory called the `render */
! /* pool' available to all registered rasterizers. This was not */
! /* thread safe, however, and now FreeType never allocates this pool. */
! /* */
! /* This function is called after a new raster object is created. */
! /* */
! /* <Input> */
! /* raster :: A handle to the new raster object. */
! /* */
! /* pool_base :: Previously, the address in memory of the render pool. */
! /* Set this to NULL. */
! /* */
! /* pool_size :: Previously, the size in bytes of the render pool. */
! /* Set this to 0. */
! /* */
! /* <Note> */
! /* Rasterizers should rely on dynamic or stack allocation if they */
! /* want to (a handle to the memory allocator is passed to the */
! /* rasterizer constructor). */
! /* */
typedef void
(*FT_Raster_ResetFunc)( FT_Raster raster,
unsigned char* pool_base,
unsigned long pool_size );
#define FT_Raster_Reset_Func FT_Raster_ResetFunc
! /*************************************************************************/
! /* */
! /* <FuncType> */
! /* FT_Raster_SetModeFunc */
! /* */
! /* <Description> */
! /* 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. */
! /* */
! /* <Input> */
! /* raster :: A handle to the new raster object. */
! /* */
! /* mode :: A 4-byte tag used to name the mode or property. */
! /* */
! /* args :: A pointer to the new mode/property to use. */
! /* */
typedef int
(*FT_Raster_SetModeFunc)( FT_Raster raster,
unsigned long mode,
void* args );
#define FT_Raster_Set_Mode_Func FT_Raster_SetModeFunc
! /*************************************************************************/
! /* */
! /* <FuncType> */
! /* FT_Raster_RenderFunc */
! /* */
! /* <Description> */
! /* Invoke a given raster to scan-convert a given glyph image into a */
! /* target bitmap. */
! /* */
! /* <Input> */
! /* raster :: A handle to the raster object. */
! /* */
! /* params :: A pointer to an @FT_Raster_Params structure used to */
! /* store the rendering parameters. */
! /* */
! /* <Return> */
! /* Error code. 0~means success. */
! /* */
! /* <Note> */
! /* 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 that support direct */
! /* composition). */
! /* */
typedef int
(*FT_Raster_RenderFunc)( FT_Raster raster,
const FT_Raster_Params* params );
#define FT_Raster_Render_Func FT_Raster_RenderFunc
! /*************************************************************************/
! /* */
! /* <Struct> */
! /* FT_Raster_Funcs */
! /* */
! /* <Description> */
! /* A structure used to describe a given raster class to the library. */
! /* */
! /* <Fields> */
! /* glyph_format :: The supported glyph format for this raster. */
! /* */
! /* raster_new :: The raster constructor. */
! /* */
! /* raster_reset :: Used to reset the render pool within the raster. */
! /* */
! /* raster_render :: A function to render a glyph into a given bitmap. */
! /* */
! /* raster_done :: The raster destructor. */
! /* */
typedef struct FT_Raster_Funcs_
{
FT_Glyph_Format glyph_format;
FT_Raster_NewFunc raster_new;
--- 1034,1219 ----
FT_BBox clip_box;
} FT_Raster_Params;
! /**************************************************************************
! *
! * @functype:
! * FT_Raster_NewFunc
! *
! * @description:
! * A function used to create a new raster object.
! *
! * @input:
! * memory ::
! * A handle to the memory allocator.
! *
! * @output:
! * raster ::
! * A handle to the new raster object.
! *
! * @return:
! * Error code. 0~means success.
! *
! * @note:
! * 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 an @FT_Memory object, i.e., a handle to the standard FreeType
! * memory allocator. However, this field can be completely ignored by a
! * given raster implementation.
! */
typedef int
(*FT_Raster_NewFunc)( void* memory,
FT_Raster* raster );
#define FT_Raster_New_Func FT_Raster_NewFunc
! /**************************************************************************
! *
! * @functype:
! * FT_Raster_DoneFunc
! *
! * @description:
! * A function used to destroy a given raster object.
! *
! * @input:
! * raster ::
! * A handle to the raster object.
! */
typedef void
(*FT_Raster_DoneFunc)( FT_Raster raster );
#define FT_Raster_Done_Func FT_Raster_DoneFunc
! /**************************************************************************
! *
! * @functype:
! * FT_Raster_ResetFunc
! *
! * @description:
! * FreeType used to provide an area of memory called the 'render pool'
! * available to all registered rasterizers. This was not thread safe,
! * however, and now FreeType never allocates this pool.
! *
! * This function is called after a new raster object is created.
! *
! * @input:
! * raster ::
! * A handle to the new raster object.
! *
! * pool_base ::
! * Previously, the address in memory of the render pool. Set this to
! * `NULL`.
! *
! * pool_size ::
! * Previously, the size in bytes of the render pool. Set this to 0.
! *
! * @note:
! * Rasterizers should rely on dynamic or stack allocation if they want to
! * (a handle to the memory allocator is passed to the rasterizer
! * constructor).
! */
typedef void
(*FT_Raster_ResetFunc)( FT_Raster raster,
unsigned char* pool_base,
unsigned long pool_size );
#define FT_Raster_Reset_Func FT_Raster_ResetFunc
! /**************************************************************************
! *
! * @functype:
! * FT_Raster_SetModeFunc
! *
! * @description:
! * 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.
! *
! * @input:
! * raster ::
! * A handle to the new raster object.
! *
! * mode ::
! * A 4-byte tag used to name the mode or property.
! *
! * args ::
! * A pointer to the new mode/property to use.
! */
typedef int
(*FT_Raster_SetModeFunc)( FT_Raster raster,
unsigned long mode,
void* args );
#define FT_Raster_Set_Mode_Func FT_Raster_SetModeFunc
! /**************************************************************************
! *
! * @functype:
! * FT_Raster_RenderFunc
! *
! * @description:
! * Invoke a given raster to scan-convert a given glyph image into a
! * target bitmap.
! *
! * @input:
! * raster ::
! * A handle to the raster object.
! *
! * params ::
! * A pointer to an @FT_Raster_Params structure used to store the
! * rendering parameters.
! *
! * @return:
! * Error code. 0~means success.
! *
! * @note:
! * 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.
! */
typedef int
(*FT_Raster_RenderFunc)( FT_Raster raster,
const FT_Raster_Params* params );
#define FT_Raster_Render_Func FT_Raster_RenderFunc
! /**************************************************************************
! *
! * @struct:
! * FT_Raster_Funcs
! *
! * @description:
! * A structure used to describe a given raster class to the library.
! *
! * @fields:
! * glyph_format ::
! * The supported glyph format for this raster.
! *
! * raster_new ::
! * The raster constructor.
! *
! * raster_reset ::
! * Used to reset the render pool within the raster.
! *
! * raster_render ::
! * A function to render a glyph into a given bitmap.
! *
! * raster_done ::
! * The raster destructor.
! */
typedef struct FT_Raster_Funcs_
{
FT_Glyph_Format glyph_format;
FT_Raster_NewFunc raster_new;
< prev index next >