XFA: merge patch from CL 817753002
[pdfium.git] / core / src / fxge / fx_freetype / fxft2.5.01 / include / freetype / ftimage.h
1 /***************************************************************************/
2 /*                                                                         */
3 /*  ftimage.h                                                              */
4 /*                                                                         */
5 /*    FreeType glyph image formats and default raster interface            */
6 /*    (specification).                                                     */
7 /*                                                                         */
8 /*  Copyright 1996-2010, 2013 by                                           */
9 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
10 /*                                                                         */
11 /*  This file is part of the FreeType project, and may only be used,       */
12 /*  modified, and distributed under the terms of the FreeType project      */
13 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
14 /*  this file you indicate that you have read the license and              */
15 /*  understand and accept it fully.                                        */
16 /*                                                                         */
17 /***************************************************************************/
18
19   /*************************************************************************/
20   /*                                                                       */
21   /* Note: A `raster' is simply a scan-line converter, used to render      */
22   /*       FT_Outlines into FT_Bitmaps.                                    */
23   /*                                                                       */
24   /*************************************************************************/
25
26
27 #ifndef __FTIMAGE_H__
28 #define __FTIMAGE_H__
29
30
31   /* _STANDALONE_ is from ftgrays.c */
32 #ifndef _STANDALONE_
33 #include "../ft2build.h"
34 #endif
35
36
37 FT_BEGIN_HEADER
38
39
40   /*************************************************************************/
41   /*                                                                       */
42   /* <Section>                                                             */
43   /*    basic_types                                                        */
44   /*                                                                       */
45   /*************************************************************************/
46
47
48   /*************************************************************************/
49   /*                                                                       */
50   /* <Type>                                                                */
51   /*    FT_Pos                                                             */
52   /*                                                                       */
53   /* <Description>                                                         */
54   /*    The type FT_Pos is used to store vectorial coordinates.  Depending */
55   /*    on the context, these can represent distances in integer font      */
56   /*    units, or 16.16, or 26.6 fixed-point pixel coordinates.            */
57   /*                                                                       */
58   typedef signed long  FT_Pos;
59
60
61   /*************************************************************************/
62   /*                                                                       */
63   /* <Struct>                                                              */
64   /*    FT_Vector                                                          */
65   /*                                                                       */
66   /* <Description>                                                         */
67   /*    A simple structure used to store a 2D vector; coordinates are of   */
68   /*    the FT_Pos type.                                                   */
69   /*                                                                       */
70   /* <Fields>                                                              */
71   /*    x :: The horizontal coordinate.                                    */
72   /*    y :: The vertical coordinate.                                      */
73   /*                                                                       */
74   typedef struct  FT_Vector_
75   {
76     FT_Pos  x;
77     FT_Pos  y;
78
79   } FT_Vector;
80
81
82   /*************************************************************************/
83   /*                                                                       */
84   /* <Struct>                                                              */
85   /*    FT_BBox                                                            */
86   /*                                                                       */
87   /* <Description>                                                         */
88   /*    A structure used to hold an outline's bounding box, i.e., the      */
89   /*    coordinates of its extrema in the horizontal and vertical          */
90   /*    directions.                                                        */
91   /*                                                                       */
92   /* <Fields>                                                              */
93   /*    xMin :: The horizontal minimum (left-most).                        */
94   /*                                                                       */
95   /*    yMin :: The vertical minimum (bottom-most).                        */
96   /*                                                                       */
97   /*    xMax :: The horizontal maximum (right-most).                       */
98   /*                                                                       */
99   /*    yMax :: The vertical maximum (top-most).                           */
100   /*                                                                       */
101   /* <Note>                                                                */
102   /*    The bounding box is specified with the coordinates of the lower    */
103   /*    left and the upper right corner.  In PostScript, those values are  */
104   /*    often called (llx,lly) and (urx,ury), respectively.                */
105   /*                                                                       */
106   /*    If `yMin' is negative, this value gives the glyph's descender.     */
107   /*    Otherwise, the glyph doesn't descend below the baseline.           */
108   /*    Similarly, if `ymax' is positive, this value gives the glyph's     */
109   /*    ascender.                                                          */
110   /*                                                                       */
111   /*    `xMin' gives the horizontal distance from the glyph's origin to    */
112   /*    the left edge of the glyph's bounding box.  If `xMin' is negative, */
113   /*    the glyph extends to the left of the origin.                       */
114   /*                                                                       */
115   typedef struct  FT_BBox_
116   {
117     FT_Pos  xMin, yMin;
118     FT_Pos  xMax, yMax;
119
120   } FT_BBox;
121
122
123   /*************************************************************************/
124   /*                                                                       */
125   /* <Enum>                                                                */
126   /*    FT_Pixel_Mode                                                      */
127   /*                                                                       */
128   /* <Description>                                                         */
129   /*    An enumeration type used to describe the format of pixels in a     */
130   /*    given bitmap.  Note that additional formats may be added in the    */
131   /*    future.                                                            */
132   /*                                                                       */
133   /* <Values>                                                              */
134   /*    FT_PIXEL_MODE_NONE ::                                              */
135   /*      Value~0 is reserved.                                             */
136   /*                                                                       */
137   /*    FT_PIXEL_MODE_MONO ::                                              */
138   /*      A monochrome bitmap, using 1~bit per pixel.  Note that pixels    */
139   /*      are stored in most-significant order (MSB), which means that     */
140   /*      the left-most pixel in a byte has value 128.                     */
141   /*                                                                       */
142   /*    FT_PIXEL_MODE_GRAY ::                                              */
143   /*      An 8-bit bitmap, generally used to represent anti-aliased glyph  */
144   /*      images.  Each pixel is stored in one byte.  Note that the number */
145   /*      of `gray' levels is stored in the `num_grays' field of the       */
146   /*      @FT_Bitmap structure (it generally is 256).                      */
147   /*                                                                       */
148   /*    FT_PIXEL_MODE_GRAY2 ::                                             */
149   /*      A 2-bit per pixel bitmap, used to represent embedded             */
150   /*      anti-aliased bitmaps in font files according to the OpenType     */
151   /*      specification.  We haven't found a single font using this        */
152   /*      format, however.                                                 */
153   /*                                                                       */
154   /*    FT_PIXEL_MODE_GRAY4 ::                                             */
155   /*      A 4-bit per pixel bitmap, representing embedded anti-aliased     */
156   /*      bitmaps in font files according to the OpenType specification.   */
157   /*      We haven't found a single font using this format, however.       */
158   /*                                                                       */
159   /*    FT_PIXEL_MODE_LCD ::                                               */
160   /*      An 8-bit bitmap, representing RGB or BGR decimated glyph images  */
161   /*      used for display on LCD displays; the bitmap is three times      */
162   /*      wider than the original glyph image.  See also                   */
163   /*      @FT_RENDER_MODE_LCD.                                             */
164   /*                                                                       */
165   /*    FT_PIXEL_MODE_LCD_V ::                                             */
166   /*      An 8-bit bitmap, representing RGB or BGR decimated glyph images  */
167   /*      used for display on rotated LCD displays; the bitmap is three    */
168   /*      times taller than the original glyph image.  See also            */
169   /*      @FT_RENDER_MODE_LCD_V.                                           */
170   /*                                                                       */
171   /*    FT_PIXEL_MODE_BGRA ::                                              */
172   /*      An image with four 8-bit channels per pixel, representing a      */
173   /*      color image (such as emoticons) with alpha channel.  For each    */
174   /*      pixel, the format is BGRA, which means, the blue channel comes   */
175   /*      first in memory.  The color channels are pre-multiplied and in   */
176   /*      the sRGB colorspace.  For example, full red at half-translucent  */
177   /*      opacity will be represented as `00,00,80,80', not `00,00,FF,80'. */
178   /*      See also @FT_LOAD_COLOR.                                         */
179   /*                                                                       */
180   typedef enum  FT_Pixel_Mode_
181   {
182     FT_PIXEL_MODE_NONE = 0,
183     FT_PIXEL_MODE_MONO,
184     FT_PIXEL_MODE_GRAY,
185     FT_PIXEL_MODE_GRAY2,
186     FT_PIXEL_MODE_GRAY4,
187     FT_PIXEL_MODE_LCD,
188     FT_PIXEL_MODE_LCD_V,
189     FT_PIXEL_MODE_BGRA,
190
191     FT_PIXEL_MODE_MAX      /* do not remove */
192
193   } FT_Pixel_Mode;
194
195
196   /*************************************************************************/
197   /*                                                                       */
198   /* <Enum>                                                                */
199   /*    ft_pixel_mode_xxx                                                  */
200   /*                                                                       */
201   /* <Description>                                                         */
202   /*    A list of deprecated constants.  Use the corresponding             */
203   /*    @FT_Pixel_Mode values instead.                                     */
204   /*                                                                       */
205   /* <Values>                                                              */
206   /*    ft_pixel_mode_none  :: See @FT_PIXEL_MODE_NONE.                    */
207   /*    ft_pixel_mode_mono  :: See @FT_PIXEL_MODE_MONO.                    */
208   /*    ft_pixel_mode_grays :: See @FT_PIXEL_MODE_GRAY.                    */
209   /*    ft_pixel_mode_pal2  :: See @FT_PIXEL_MODE_GRAY2.                   */
210   /*    ft_pixel_mode_pal4  :: See @FT_PIXEL_MODE_GRAY4.                   */
211   /*                                                                       */
212 #define ft_pixel_mode_none   FT_PIXEL_MODE_NONE
213 #define ft_pixel_mode_mono   FT_PIXEL_MODE_MONO
214 #define ft_pixel_mode_grays  FT_PIXEL_MODE_GRAY
215 #define ft_pixel_mode_pal2   FT_PIXEL_MODE_GRAY2
216 #define ft_pixel_mode_pal4   FT_PIXEL_MODE_GRAY4
217
218  /* */
219
220 #if 0
221
222   /*************************************************************************/
223   /*                                                                       */
224   /* <Enum>                                                                */
225   /*    FT_Palette_Mode                                                    */
226   /*                                                                       */
227   /* <Description>                                                         */
228   /*    THIS TYPE IS DEPRECATED.  DO NOT USE IT!                           */
229   /*                                                                       */
230   /*    An enumeration type to describe the format of a bitmap palette,    */
231   /*    used with ft_pixel_mode_pal4 and ft_pixel_mode_pal8.               */
232   /*                                                                       */
233   /* <Values>                                                              */
234   /*    ft_palette_mode_rgb  :: The palette is an array of 3-byte RGB      */
235   /*                            records.                                   */
236   /*                                                                       */
237   /*    ft_palette_mode_rgba :: The palette is an array of 4-byte RGBA     */
238   /*                            records.                                   */
239   /*                                                                       */
240   /* <Note>                                                                */
241   /*    As ft_pixel_mode_pal2, pal4 and pal8 are currently unused by       */
242   /*    FreeType, these types are not handled by the library itself.       */
243   /*                                                                       */
244   typedef enum  FT_Palette_Mode_
245   {
246     ft_palette_mode_rgb = 0,
247     ft_palette_mode_rgba,
248
249     ft_palette_mode_max   /* do not remove */
250
251   } FT_Palette_Mode;
252
253   /* */
254
255 #endif
256
257
258   /*************************************************************************/
259   /*                                                                       */
260   /* <Struct>                                                              */
261   /*    FT_Bitmap                                                          */
262   /*                                                                       */
263   /* <Description>                                                         */
264   /*    A structure used to describe a bitmap or pixmap to the raster.     */
265   /*    Note that we now manage pixmaps of various depths through the      */
266   /*    `pixel_mode' field.                                                */
267   /*                                                                       */
268   /* <Fields>                                                              */
269   /*    rows         :: The number of bitmap rows.                         */
270   /*                                                                       */
271   /*    width        :: The number of pixels in bitmap row.                */
272   /*                                                                       */
273   /*    pitch        :: The pitch's absolute value is the number of bytes  */
274   /*                    taken by one bitmap row, including padding.        */
275   /*                    However, the pitch is positive when the bitmap has */
276   /*                    a `down' flow, and negative when it has an `up'    */
277   /*                    flow.  In all cases, the pitch is an offset to add */
278   /*                    to a bitmap pointer in order to go down one row.   */
279   /*                                                                       */
280   /*                    Note that `padding' means the alignment of a       */
281   /*                    bitmap to a byte border, and FreeType functions    */
282   /*                    normally align to the smallest possible integer    */
283   /*                    value.                                             */
284   /*                                                                       */
285   /*                    For the B/W rasterizer, `pitch' is always an even  */
286   /*                    number.                                            */
287   /*                                                                       */
288   /*                    To change the pitch of a bitmap (say, to make it a */
289   /*                    multiple of 4), use @FT_Bitmap_Convert.            */
290   /*                    Alternatively, you might use callback functions to */
291   /*                    directly render to the application's surface; see  */
292   /*                    the file `example2.cpp' in the tutorial for a      */
293   /*                    demonstration.                                     */
294   /*                                                                       */
295   /*    buffer       :: A typeless pointer to the bitmap buffer.  This     */
296   /*                    value should be aligned on 32-bit boundaries in    */
297   /*                    most cases.                                        */
298   /*                                                                       */
299   /*    num_grays    :: This field is only used with                       */
300   /*                    @FT_PIXEL_MODE_GRAY; it gives the number of gray   */
301   /*                    levels used in the bitmap.                         */
302   /*                                                                       */
303   /*    pixel_mode   :: The pixel mode, i.e., how pixel bits are stored.   */
304   /*                    See @FT_Pixel_Mode for possible values.            */
305   /*                                                                       */
306   /*    palette_mode :: This field is intended for paletted pixel modes;   */
307   /*                    it indicates how the palette is stored.  Not       */
308   /*                    used currently.                                    */
309   /*                                                                       */
310   /*    palette      :: A typeless pointer to the bitmap palette; this     */
311   /*                    field is intended for paletted pixel modes.  Not   */
312   /*                    used currently.                                    */
313   /*                                                                       */
314   /* <Note>                                                                */
315   /*   For now, the only pixel modes supported by FreeType are mono and    */
316   /*   grays.  However, drivers might be added in the future to support    */
317   /*   more `colorful' options.                                            */
318   /*                                                                       */
319   typedef struct  FT_Bitmap_
320   {
321     int             rows;
322     int             width;
323     int             pitch;
324     unsigned char*  buffer;
325     short           num_grays;
326     char            pixel_mode;
327     char            palette_mode;
328     void*           palette;
329
330   } FT_Bitmap;
331
332
333   /*************************************************************************/
334   /*                                                                       */
335   /* <Section>                                                             */
336   /*    outline_processing                                                 */
337   /*                                                                       */
338   /*************************************************************************/
339
340
341   /*************************************************************************/
342   /*                                                                       */
343   /* <Struct>                                                              */
344   /*    FT_Outline                                                         */
345   /*                                                                       */
346   /* <Description>                                                         */
347   /*    This structure is used to describe an outline to the scan-line     */
348   /*    converter.                                                         */
349   /*                                                                       */
350   /* <Fields>                                                              */
351   /*    n_contours :: The number of contours in the outline.               */
352   /*                                                                       */
353   /*    n_points   :: The number of points in the outline.                 */
354   /*                                                                       */
355   /*    points     :: A pointer to an array of `n_points' @FT_Vector       */
356   /*                  elements, giving the outline's point coordinates.    */
357   /*                                                                       */
358   /*    tags       :: A pointer to an array of `n_points' chars, giving    */
359   /*                  each outline point's type.                           */
360   /*                                                                       */
361   /*                  If bit~0 is unset, the point is `off' the curve,     */
362   /*                  i.e., a Bézier control point, while it is `on' if    */
363   /*                  set.                                                 */
364   /*                                                                       */
365   /*                  Bit~1 is meaningful for `off' points only.  If set,  */
366   /*                  it indicates a third-order Bézier arc control point; */
367   /*                  and a second-order control point if unset.           */
368   /*                                                                       */
369   /*                  If bit~2 is set, bits 5-7 contain the drop-out mode  */
370   /*                  (as defined in the OpenType specification; the value */
371   /*                  is the same as the argument to the SCANMODE          */
372   /*                  instruction).                                        */
373   /*                                                                       */
374   /*                  Bits 3 and~4 are reserved for internal purposes.     */
375   /*                                                                       */
376   /*    contours   :: An array of `n_contours' shorts, giving the end      */
377   /*                  point of each contour within the outline.  For       */
378   /*                  example, the first contour is defined by the points  */
379   /*                  `0' to `contours[0]', the second one is defined by   */
380   /*                  the points `contours[0]+1' to `contours[1]', etc.    */
381   /*                                                                       */
382   /*    flags      :: A set of bit flags used to characterize the outline  */
383   /*                  and give hints to the scan-converter and hinter on   */
384   /*                  how to convert/grid-fit it.  See @FT_OUTLINE_FLAGS.  */
385   /*                                                                       */
386   /* <Note>                                                                */
387   /*    The B/W rasterizer only checks bit~2 in the `tags' array for the   */
388   /*    first point of each contour.  The drop-out mode as given with      */
389   /*    @FT_OUTLINE_IGNORE_DROPOUTS, @FT_OUTLINE_SMART_DROPOUTS, and       */
390   /*    @FT_OUTLINE_INCLUDE_STUBS in `flags' is then overridden.           */
391   /*                                                                       */
392   typedef struct  FT_Outline_
393   {
394     short       n_contours;      /* number of contours in glyph        */
395     short       n_points;        /* number of points in the glyph      */
396
397     FT_Vector*  points;          /* the outline's points               */
398     char*       tags;            /* the points flags                   */
399     short*      contours;        /* the contour end points             */
400
401     int         flags;           /* outline masks                      */
402
403   } FT_Outline;
404
405   /* Following limits must be consistent with */
406   /* FT_Outline.{n_contours,n_points}         */
407 #define FT_OUTLINE_CONTOURS_MAX  SHRT_MAX
408 #define FT_OUTLINE_POINTS_MAX    SHRT_MAX
409
410
411   /*************************************************************************/
412   /*                                                                       */
413   /* <Enum>                                                                */
414   /*    FT_OUTLINE_FLAGS                                                   */
415   /*                                                                       */
416   /* <Description>                                                         */
417   /*    A list of bit-field constants use for the flags in an outline's    */
418   /*    `flags' field.                                                     */
419   /*                                                                       */
420   /* <Values>                                                              */
421   /*    FT_OUTLINE_NONE ::                                                 */
422   /*      Value~0 is reserved.                                             */
423   /*                                                                       */
424   /*    FT_OUTLINE_OWNER ::                                                */
425   /*      If set, this flag indicates that the outline's field arrays      */
426   /*      (i.e., `points', `flags', and `contours') are `owned' by the     */
427   /*      outline object, and should thus be freed when it is destroyed.   */
428   /*                                                                       */
429   /*    FT_OUTLINE_EVEN_ODD_FILL ::                                        */
430   /*      By default, outlines are filled using the non-zero winding rule. */
431   /*      If set to 1, the outline will be filled using the even-odd fill  */
432   /*      rule (only works with the smooth rasterizer).                    */
433   /*                                                                       */
434   /*    FT_OUTLINE_REVERSE_FILL ::                                         */
435   /*      By default, outside contours of an outline are oriented in       */
436   /*      clock-wise direction, as defined in the TrueType specification.  */
437   /*      This flag is set if the outline uses the opposite direction      */
438   /*      (typically for Type~1 fonts).  This flag is ignored by the scan  */
439   /*      converter.                                                       */
440   /*                                                                       */
441   /*    FT_OUTLINE_IGNORE_DROPOUTS ::                                      */
442   /*      By default, the scan converter will try to detect drop-outs in   */
443   /*      an outline and correct the glyph bitmap to ensure consistent     */
444   /*      shape continuity.  If set, this flag hints the scan-line         */
445   /*      converter to ignore such cases.  See below for more information. */
446   /*                                                                       */
447   /*    FT_OUTLINE_SMART_DROPOUTS ::                                       */
448   /*      Select smart dropout control.  If unset, use simple dropout      */
449   /*      control.  Ignored if @FT_OUTLINE_IGNORE_DROPOUTS is set.  See    */
450   /*      below for more information.                                      */
451   /*                                                                       */
452   /*    FT_OUTLINE_INCLUDE_STUBS ::                                        */
453   /*      If set, turn pixels on for `stubs', otherwise exclude them.      */
454   /*      Ignored if @FT_OUTLINE_IGNORE_DROPOUTS is set.  See below for    */
455   /*      more information.                                                */
456   /*                                                                       */
457   /*    FT_OUTLINE_HIGH_PRECISION ::                                       */
458   /*      This flag indicates that the scan-line converter should try to   */
459   /*      convert this outline to bitmaps with the highest possible        */
460   /*      quality.  It is typically set for small character sizes.  Note   */
461   /*      that this is only a hint that might be completely ignored by a   */
462   /*      given scan-converter.                                            */
463   /*                                                                       */
464   /*    FT_OUTLINE_SINGLE_PASS ::                                          */
465   /*      This flag is set to force a given scan-converter to only use a   */
466   /*      single pass over the outline to render a bitmap glyph image.     */
467   /*      Normally, it is set for very large character sizes.  It is only  */
468   /*      a hint that might be completely ignored by a given               */
469   /*      scan-converter.                                                  */
470   /*                                                                       */
471   /* <Note>                                                                */
472   /*    The flags @FT_OUTLINE_IGNORE_DROPOUTS, @FT_OUTLINE_SMART_DROPOUTS, */
473   /*    and @FT_OUTLINE_INCLUDE_STUBS are ignored by the smooth            */
474   /*    rasterizer.                                                        */
475   /*                                                                       */
476   /*    There exists a second mechanism to pass the drop-out mode to the   */
477   /*    B/W rasterizer; see the `tags' field in @FT_Outline.               */
478   /*                                                                       */
479   /*    Please refer to the description of the `SCANTYPE' instruction in   */
480   /*    the OpenType specification (in file `ttinst1.doc') how simple      */
481   /*    drop-outs, smart drop-outs, and stubs are defined.                 */
482   /*                                                                       */
483 #define FT_OUTLINE_NONE             0x0
484 #define FT_OUTLINE_OWNER            0x1
485 #define FT_OUTLINE_EVEN_ODD_FILL    0x2
486 #define FT_OUTLINE_REVERSE_FILL     0x4
487 #define FT_OUTLINE_IGNORE_DROPOUTS  0x8
488 #define FT_OUTLINE_SMART_DROPOUTS   0x10
489 #define FT_OUTLINE_INCLUDE_STUBS    0x20
490
491 #define FT_OUTLINE_HIGH_PRECISION   0x100
492 #define FT_OUTLINE_SINGLE_PASS      0x200
493
494
495  /*************************************************************************
496   *
497   * @enum:
498   *   ft_outline_flags
499   *
500   * @description:
501   *   These constants are deprecated.  Please use the corresponding
502   *   @FT_OUTLINE_FLAGS values.
503   *
504   * @values:
505   *   ft_outline_none            :: See @FT_OUTLINE_NONE.
506   *   ft_outline_owner           :: See @FT_OUTLINE_OWNER.
507   *   ft_outline_even_odd_fill   :: See @FT_OUTLINE_EVEN_ODD_FILL.
508   *   ft_outline_reverse_fill    :: See @FT_OUTLINE_REVERSE_FILL.
509   *   ft_outline_ignore_dropouts :: See @FT_OUTLINE_IGNORE_DROPOUTS.
510   *   ft_outline_high_precision  :: See @FT_OUTLINE_HIGH_PRECISION.
511   *   ft_outline_single_pass     :: See @FT_OUTLINE_SINGLE_PASS.
512   */
513 #define ft_outline_none             FT_OUTLINE_NONE
514 #define ft_outline_owner            FT_OUTLINE_OWNER
515 #define ft_outline_even_odd_fill    FT_OUTLINE_EVEN_ODD_FILL
516 #define ft_outline_reverse_fill     FT_OUTLINE_REVERSE_FILL
517 #define ft_outline_ignore_dropouts  FT_OUTLINE_IGNORE_DROPOUTS
518 #define ft_outline_high_precision   FT_OUTLINE_HIGH_PRECISION
519 #define ft_outline_single_pass      FT_OUTLINE_SINGLE_PASS
520
521   /* */
522
523 #define FT_CURVE_TAG( flag )  ( flag & 3 )
524
525 #define FT_CURVE_TAG_ON            1
526 #define FT_CURVE_TAG_CONIC         0
527 #define FT_CURVE_TAG_CUBIC         2
528
529 #define FT_CURVE_TAG_HAS_SCANMODE  4
530
531 #define FT_CURVE_TAG_TOUCH_X       8  /* reserved for the TrueType hinter */
532 #define FT_CURVE_TAG_TOUCH_Y      16  /* reserved for the TrueType hinter */
533
534 #define FT_CURVE_TAG_TOUCH_BOTH    ( FT_CURVE_TAG_TOUCH_X | \
535                                      FT_CURVE_TAG_TOUCH_Y )
536
537 #define FT_Curve_Tag_On       FT_CURVE_TAG_ON
538 #define FT_Curve_Tag_Conic    FT_CURVE_TAG_CONIC
539 #define FT_Curve_Tag_Cubic    FT_CURVE_TAG_CUBIC
540 #define FT_Curve_Tag_Touch_X  FT_CURVE_TAG_TOUCH_X
541 #define FT_Curve_Tag_Touch_Y  FT_CURVE_TAG_TOUCH_Y
542
543
544   /*************************************************************************/
545   /*                                                                       */
546   /* <FuncType>                                                            */
547   /*    FT_Outline_MoveToFunc                                              */
548   /*                                                                       */
549   /* <Description>                                                         */
550   /*    A function pointer type used to describe the signature of a `move  */
551   /*    to' function during outline walking/decomposition.                 */
552   /*                                                                       */
553   /*    A `move to' is emitted to start a new contour in an outline.       */
554   /*                                                                       */
555   /* <Input>                                                               */
556   /*    to   :: A pointer to the target point of the `move to'.            */
557   /*                                                                       */
558   /*    user :: A typeless pointer which is passed from the caller of the  */
559   /*            decomposition function.                                    */
560   /*                                                                       */
561   /* <Return>                                                              */
562   /*    Error code.  0~means success.                                      */
563   /*                                                                       */
564   typedef int
565   (*FT_Outline_MoveToFunc)( const FT_Vector*  to,
566                             void*             user );
567
568 #define FT_Outline_MoveTo_Func  FT_Outline_MoveToFunc
569
570
571   /*************************************************************************/
572   /*                                                                       */
573   /* <FuncType>                                                            */
574   /*    FT_Outline_LineToFunc                                              */
575   /*                                                                       */
576   /* <Description>                                                         */
577   /*    A function pointer type used to describe the signature of a `line  */
578   /*    to' function during outline walking/decomposition.                 */
579   /*                                                                       */
580   /*    A `line to' is emitted to indicate a segment in the outline.       */
581   /*                                                                       */
582   /* <Input>                                                               */
583   /*    to   :: A pointer to the target point of the `line to'.            */
584   /*                                                                       */
585   /*    user :: A typeless pointer which is passed from the caller of the  */
586   /*            decomposition function.                                    */
587   /*                                                                       */
588   /* <Return>                                                              */
589   /*    Error code.  0~means success.                                      */
590   /*                                                                       */
591   typedef int
592   (*FT_Outline_LineToFunc)( const FT_Vector*  to,
593                             void*             user );
594
595 #define FT_Outline_LineTo_Func  FT_Outline_LineToFunc
596
597
598   /*************************************************************************/
599   /*                                                                       */
600   /* <FuncType>                                                            */
601   /*    FT_Outline_ConicToFunc                                             */
602   /*                                                                       */
603   /* <Description>                                                         */
604   /*    A function pointer type used to describe the signature of a `conic */
605   /*    to' function during outline walking or decomposition.              */
606   /*                                                                       */
607   /*    A `conic to' is emitted to indicate a second-order Bézier arc in   */
608   /*    the outline.                                                       */
609   /*                                                                       */
610   /* <Input>                                                               */
611   /*    control :: An intermediate control point between the last position */
612   /*               and the new target in `to'.                             */
613   /*                                                                       */
614   /*    to      :: A pointer to the target end point of the conic arc.     */
615   /*                                                                       */
616   /*    user    :: A typeless pointer which is passed from the caller of   */
617   /*               the decomposition function.                             */
618   /*                                                                       */
619   /* <Return>                                                              */
620   /*    Error code.  0~means success.                                      */
621   /*                                                                       */
622   typedef int
623   (*FT_Outline_ConicToFunc)( const FT_Vector*  control,
624                              const FT_Vector*  to,
625                              void*             user );
626
627 #define FT_Outline_ConicTo_Func  FT_Outline_ConicToFunc
628
629
630   /*************************************************************************/
631   /*                                                                       */
632   /* <FuncType>                                                            */
633   /*    FT_Outline_CubicToFunc                                             */
634   /*                                                                       */
635   /* <Description>                                                         */
636   /*    A function pointer type used to describe the signature of a `cubic */
637   /*    to' function during outline walking or decomposition.              */
638   /*                                                                       */
639   /*    A `cubic to' is emitted to indicate a third-order Bézier arc.      */
640   /*                                                                       */
641   /* <Input>                                                               */
642   /*    control1 :: A pointer to the first Bézier control point.           */
643   /*                                                                       */
644   /*    control2 :: A pointer to the second Bézier control point.          */
645   /*                                                                       */
646   /*    to       :: A pointer to the target end point.                     */
647   /*                                                                       */
648   /*    user     :: A typeless pointer which is passed from the caller of  */
649   /*                the decomposition function.                            */
650   /*                                                                       */
651   /* <Return>                                                              */
652   /*    Error code.  0~means success.                                      */
653   /*                                                                       */
654   typedef int
655   (*FT_Outline_CubicToFunc)( const FT_Vector*  control1,
656                              const FT_Vector*  control2,
657                              const FT_Vector*  to,
658                              void*             user );
659
660 #define FT_Outline_CubicTo_Func  FT_Outline_CubicToFunc
661
662
663   /*************************************************************************/
664   /*                                                                       */
665   /* <Struct>                                                              */
666   /*    FT_Outline_Funcs                                                   */
667   /*                                                                       */
668   /* <Description>                                                         */
669   /*    A structure to hold various function pointers used during outline  */
670   /*    decomposition in order to emit segments, conic, and cubic Béziers. */
671   /*                                                                       */
672   /* <Fields>                                                              */
673   /*    move_to  :: The `move to' emitter.                                 */
674   /*                                                                       */
675   /*    line_to  :: The segment emitter.                                   */
676   /*                                                                       */
677   /*    conic_to :: The second-order Bézier arc emitter.                   */
678   /*                                                                       */
679   /*    cubic_to :: The third-order Bézier arc emitter.                    */
680   /*                                                                       */
681   /*    shift    :: The shift that is applied to coordinates before they   */
682   /*                are sent to the emitter.                               */
683   /*                                                                       */
684   /*    delta    :: The delta that is applied to coordinates before they   */
685   /*                are sent to the emitter, but after the shift.          */
686   /*                                                                       */
687   /* <Note>                                                                */
688   /*    The point coordinates sent to the emitters are the transformed     */
689   /*    version of the original coordinates (this is important for high    */
690   /*    accuracy during scan-conversion).  The transformation is simple:   */
691   /*                                                                       */
692   /*    {                                                                  */
693   /*      x' = (x << shift) - delta                                        */
694   /*      y' = (x << shift) - delta                                        */
695   /*    }                                                                  */
696   /*                                                                       */
697   /*    Set the values of `shift' and `delta' to~0 to get the original     */
698   /*    point coordinates.                                                 */
699   /*                                                                       */
700   typedef struct  FT_Outline_Funcs_
701   {
702     FT_Outline_MoveToFunc   move_to;
703     FT_Outline_LineToFunc   line_to;
704     FT_Outline_ConicToFunc  conic_to;
705     FT_Outline_CubicToFunc  cubic_to;
706
707     int                     shift;
708     FT_Pos                  delta;
709
710   } FT_Outline_Funcs;
711
712
713   /*************************************************************************/
714   /*                                                                       */
715   /* <Section>                                                             */
716   /*    basic_types                                                        */
717   /*                                                                       */
718   /*************************************************************************/
719
720
721   /*************************************************************************/
722   /*                                                                       */
723   /* <Macro>                                                               */
724   /*    FT_IMAGE_TAG                                                       */
725   /*                                                                       */
726   /* <Description>                                                         */
727   /*    This macro converts four-letter tags to an unsigned long type.     */
728   /*                                                                       */
729   /* <Note>                                                                */
730   /*    Since many 16-bit compilers don't like 32-bit enumerations, you    */
731   /*    should redefine this macro in case of problems to something like   */
732   /*    this:                                                              */
733   /*                                                                       */
734   /*    {                                                                  */
735   /*      #define FT_IMAGE_TAG( value, _x1, _x2, _x3, _x4 )  value         */
736   /*    }                                                                  */
737   /*                                                                       */
738   /*    to get a simple enumeration without assigning special numbers.     */
739   /*                                                                       */
740 #ifndef FT_IMAGE_TAG
741 #define FT_IMAGE_TAG( value, _x1, _x2, _x3, _x4 )  \
742           value = ( ( (unsigned long)_x1 << 24 ) | \
743                     ( (unsigned long)_x2 << 16 ) | \
744                     ( (unsigned long)_x3 << 8  ) | \
745                       (unsigned long)_x4         )
746 #endif /* FT_IMAGE_TAG */
747
748
749   /*************************************************************************/
750   /*                                                                       */
751   /* <Enum>                                                                */
752   /*    FT_Glyph_Format                                                    */
753   /*                                                                       */
754   /* <Description>                                                         */
755   /*    An enumeration type used to describe the format of a given glyph   */
756   /*    image.  Note that this version of FreeType only supports two image */
757   /*    formats, even though future font drivers will be able to register  */
758   /*    their own format.                                                  */
759   /*                                                                       */
760   /* <Values>                                                              */
761   /*    FT_GLYPH_FORMAT_NONE ::                                            */
762   /*      The value~0 is reserved.                                         */
763   /*                                                                       */
764   /*    FT_GLYPH_FORMAT_COMPOSITE ::                                       */
765   /*      The glyph image is a composite of several other images.  This    */
766   /*      format is _only_ used with @FT_LOAD_NO_RECURSE, and is used to   */
767   /*      report compound glyphs (like accented characters).               */
768   /*                                                                       */
769   /*    FT_GLYPH_FORMAT_BITMAP ::                                          */
770   /*      The glyph image is a bitmap, and can be described as an          */
771   /*      @FT_Bitmap.  You generally need to access the `bitmap' field of  */
772   /*      the @FT_GlyphSlotRec structure to read it.                       */
773   /*                                                                       */
774   /*    FT_GLYPH_FORMAT_OUTLINE ::                                         */
775   /*      The glyph image is a vectorial outline made of line segments     */
776   /*      and Bézier arcs; it can be described as an @FT_Outline; you      */
777   /*      generally want to access the `outline' field of the              */
778   /*      @FT_GlyphSlotRec structure to read it.                           */
779   /*                                                                       */
780   /*    FT_GLYPH_FORMAT_PLOTTER ::                                         */
781   /*      The glyph image is a vectorial path with no inside and outside   */
782   /*      contours.  Some Type~1 fonts, like those in the Hershey family,  */
783   /*      contain glyphs in this format.  These are described as           */
784   /*      @FT_Outline, but FreeType isn't currently capable of rendering   */
785   /*      them correctly.                                                  */
786   /*                                                                       */
787   typedef enum  FT_Glyph_Format_
788   {
789     FT_IMAGE_TAG( FT_GLYPH_FORMAT_NONE, 0, 0, 0, 0 ),
790
791     FT_IMAGE_TAG( FT_GLYPH_FORMAT_COMPOSITE, 'c', 'o', 'm', 'p' ),
792     FT_IMAGE_TAG( FT_GLYPH_FORMAT_BITMAP,    'b', 'i', 't', 's' ),
793     FT_IMAGE_TAG( FT_GLYPH_FORMAT_OUTLINE,   'o', 'u', 't', 'l' ),
794     FT_IMAGE_TAG( FT_GLYPH_FORMAT_PLOTTER,   'p', 'l', 'o', 't' )
795
796   } FT_Glyph_Format;
797
798
799   /*************************************************************************/
800   /*                                                                       */
801   /* <Enum>                                                                */
802   /*    ft_glyph_format_xxx                                                */
803   /*                                                                       */
804   /* <Description>                                                         */
805   /*    A list of deprecated constants.  Use the corresponding             */
806   /*    @FT_Glyph_Format values instead.                                   */
807   /*                                                                       */
808   /* <Values>                                                              */
809   /*    ft_glyph_format_none      :: See @FT_GLYPH_FORMAT_NONE.            */
810   /*    ft_glyph_format_composite :: See @FT_GLYPH_FORMAT_COMPOSITE.       */
811   /*    ft_glyph_format_bitmap    :: See @FT_GLYPH_FORMAT_BITMAP.          */
812   /*    ft_glyph_format_outline   :: See @FT_GLYPH_FORMAT_OUTLINE.         */
813   /*    ft_glyph_format_plotter   :: See @FT_GLYPH_FORMAT_PLOTTER.         */
814   /*                                                                       */
815 #define ft_glyph_format_none       FT_GLYPH_FORMAT_NONE
816 #define ft_glyph_format_composite  FT_GLYPH_FORMAT_COMPOSITE
817 #define ft_glyph_format_bitmap     FT_GLYPH_FORMAT_BITMAP
818 #define ft_glyph_format_outline    FT_GLYPH_FORMAT_OUTLINE
819 #define ft_glyph_format_plotter    FT_GLYPH_FORMAT_PLOTTER
820
821
822   /*************************************************************************/
823   /*************************************************************************/
824   /*************************************************************************/
825   /*****                                                               *****/
826   /*****            R A S T E R   D E F I N I T I O N S                *****/
827   /*****                                                               *****/
828   /*************************************************************************/
829   /*************************************************************************/
830   /*************************************************************************/
831
832
833   /*************************************************************************/
834   /*                                                                       */
835   /* A raster is a scan converter, in charge of rendering an outline into  */
836   /* a a bitmap.  This section contains the public API for rasters.        */
837   /*                                                                       */
838   /* Note that in FreeType 2, all rasters are now encapsulated within      */
839   /* specific modules called `renderers'.  See `freetype/ftrender.h' for   */
840   /* more details on renderers.                                            */
841   /*                                                                       */
842   /*************************************************************************/
843
844
845   /*************************************************************************/
846   /*                                                                       */
847   /* <Section>                                                             */
848   /*    raster                                                             */
849   /*                                                                       */
850   /* <Title>                                                               */
851   /*    Scanline Converter                                                 */
852   /*                                                                       */
853   /* <Abstract>                                                            */
854   /*    How vectorial outlines are converted into bitmaps and pixmaps.     */
855   /*                                                                       */
856   /* <Description>                                                         */
857   /*    This section contains technical definitions.                       */
858   /*                                                                       */
859   /*************************************************************************/
860
861
862   /*************************************************************************/
863   /*                                                                       */
864   /* <Type>                                                                */
865   /*    FT_Raster                                                          */
866   /*                                                                       */
867   /* <Description>                                                         */
868   /*    A handle (pointer) to a raster object.  Each object can be used    */
869   /*    independently to convert an outline into a bitmap or pixmap.       */
870   /*                                                                       */
871   typedef struct FT_RasterRec_*  FT_Raster;
872
873
874   /*************************************************************************/
875   /*                                                                       */
876   /* <Struct>                                                              */
877   /*    FT_Span                                                            */
878   /*                                                                       */
879   /* <Description>                                                         */
880   /*    A structure used to model a single span of gray (or black) pixels  */
881   /*    when rendering a monochrome or anti-aliased bitmap.                */
882   /*                                                                       */
883   /* <Fields>                                                              */
884   /*    x        :: The span's horizontal start position.                  */
885   /*                                                                       */
886   /*    len      :: The span's length in pixels.                           */
887   /*                                                                       */
888   /*    coverage :: The span color/coverage, ranging from 0 (background)   */
889   /*                to 255 (foreground).  Only used for anti-aliased       */
890   /*                rendering.                                             */
891   /*                                                                       */
892   /* <Note>                                                                */
893   /*    This structure is used by the span drawing callback type named     */
894   /*    @FT_SpanFunc which takes the y~coordinate of the span as a         */
895   /*    a parameter.                                                       */
896   /*                                                                       */
897   /*    The coverage value is always between 0 and 255.  If you want less  */
898   /*    gray values, the callback function has to reduce them.             */
899   /*                                                                       */
900   typedef struct  FT_Span_
901   {
902     short           x;
903     unsigned short  len;
904     unsigned char   coverage;
905
906   } FT_Span;
907
908
909   /*************************************************************************/
910   /*                                                                       */
911   /* <FuncType>                                                            */
912   /*    FT_SpanFunc                                                        */
913   /*                                                                       */
914   /* <Description>                                                         */
915   /*    A function used as a call-back by the anti-aliased renderer in     */
916   /*    order to let client applications draw themselves the gray pixel    */
917   /*    spans on each scan line.                                           */
918   /*                                                                       */
919   /* <Input>                                                               */
920   /*    y     :: The scanline's y~coordinate.                              */
921   /*                                                                       */
922   /*    count :: The number of spans to draw on this scanline.             */
923   /*                                                                       */
924   /*    spans :: A table of `count' spans to draw on the scanline.         */
925   /*                                                                       */
926   /*    user  :: User-supplied data that is passed to the callback.        */
927   /*                                                                       */
928   /* <Note>                                                                */
929   /*    This callback allows client applications to directly render the    */
930   /*    gray spans of the anti-aliased bitmap to any kind of surfaces.     */
931   /*                                                                       */
932   /*    This can be used to write anti-aliased outlines directly to a      */
933   /*    given background bitmap, and even perform translucency.            */
934   /*                                                                       */
935   /*    Note that the `count' field cannot be greater than a fixed value   */
936   /*    defined by the `FT_MAX_GRAY_SPANS' configuration macro in          */
937   /*    `ftoption.h'.  By default, this value is set to~32, which means    */
938   /*    that if there are more than 32~spans on a given scanline, the      */
939   /*    callback is called several times with the same `y' parameter in    */
940   /*    order to draw all callbacks.                                       */
941   /*                                                                       */
942   /*    Otherwise, the callback is only called once per scan-line, and     */
943   /*    only for those scanlines that do have `gray' pixels on them.       */
944   /*                                                                       */
945   typedef void
946   (*FT_SpanFunc)( int             y,
947                   int             count,
948                   const FT_Span*  spans,
949                   void*           user );
950
951 #define FT_Raster_Span_Func  FT_SpanFunc
952
953
954   /*************************************************************************/
955   /*                                                                       */
956   /* <FuncType>                                                            */
957   /*    FT_Raster_BitTest_Func                                             */
958   /*                                                                       */
959   /* <Description>                                                         */
960   /*    THIS TYPE IS DEPRECATED.  DO NOT USE IT.                           */
961   /*                                                                       */
962   /*    A function used as a call-back by the monochrome scan-converter    */
963   /*    to test whether a given target pixel is already set to the drawing */
964   /*    `color'.  These tests are crucial to implement drop-out control    */
965   /*    per-se the TrueType spec.                                          */
966   /*                                                                       */
967   /* <Input>                                                               */
968   /*    y     :: The pixel's y~coordinate.                                 */
969   /*                                                                       */
970   /*    x     :: The pixel's x~coordinate.                                 */
971   /*                                                                       */
972   /*    user  :: User-supplied data that is passed to the callback.        */
973   /*                                                                       */
974   /* <Return>                                                              */
975   /*   1~if the pixel is `set', 0~otherwise.                               */
976   /*                                                                       */
977   typedef int
978   (*FT_Raster_BitTest_Func)( int    y,
979                              int    x,
980                              void*  user );
981
982
983   /*************************************************************************/
984   /*                                                                       */
985   /* <FuncType>                                                            */
986   /*    FT_Raster_BitSet_Func                                              */
987   /*                                                                       */
988   /* <Description>                                                         */
989   /*    THIS TYPE IS DEPRECATED.  DO NOT USE IT.                           */
990   /*                                                                       */
991   /*    A function used as a call-back by the monochrome scan-converter    */
992   /*    to set an individual target pixel.  This is crucial to implement   */
993   /*    drop-out control according to the TrueType specification.          */
994   /*                                                                       */
995   /* <Input>                                                               */
996   /*    y     :: The pixel's y~coordinate.                                 */
997   /*                                                                       */
998   /*    x     :: The pixel's x~coordinate.                                 */
999   /*                                                                       */
1000   /*    user  :: User-supplied data that is passed to the callback.        */
1001   /*                                                                       */
1002   /* <Return>                                                              */
1003   /*    1~if the pixel is `set', 0~otherwise.                              */
1004   /*                                                                       */
1005   typedef void
1006   (*FT_Raster_BitSet_Func)( int    y,
1007                             int    x,
1008                             void*  user );
1009
1010
1011   /*************************************************************************/
1012   /*                                                                       */
1013   /* <Enum>                                                                */
1014   /*    FT_RASTER_FLAG_XXX                                                 */
1015   /*                                                                       */
1016   /* <Description>                                                         */
1017   /*    A list of bit flag constants as used in the `flags' field of a     */
1018   /*    @FT_Raster_Params structure.                                       */
1019   /*                                                                       */
1020   /* <Values>                                                              */
1021   /*    FT_RASTER_FLAG_DEFAULT :: This value is 0.                         */
1022   /*                                                                       */
1023   /*    FT_RASTER_FLAG_AA      :: This flag is set to indicate that an     */
1024   /*                              anti-aliased glyph image should be       */
1025   /*                              generated.  Otherwise, it will be        */
1026   /*                              monochrome (1-bit).                      */
1027   /*                                                                       */
1028   /*    FT_RASTER_FLAG_DIRECT  :: This flag is set to indicate direct      */
1029   /*                              rendering.  In this mode, client         */
1030   /*                              applications must provide their own span */
1031   /*                              callback.  This lets them directly       */
1032   /*                              draw or compose over an existing bitmap. */
1033   /*                              If this bit is not set, the target       */
1034   /*                              pixmap's buffer _must_ be zeroed before  */
1035   /*                              rendering.                               */
1036   /*                                                                       */
1037   /*                              Note that for now, direct rendering is   */
1038   /*                              only possible with anti-aliased glyphs.  */
1039   /*                                                                       */
1040   /*    FT_RASTER_FLAG_CLIP    :: This flag is only used in direct         */
1041   /*                              rendering mode.  If set, the output will */
1042   /*                              be clipped to a box specified in the     */
1043   /*                              `clip_box' field of the                  */
1044   /*                              @FT_Raster_Params structure.             */
1045   /*                                                                       */
1046   /*                              Note that by default, the glyph bitmap   */
1047   /*                              is clipped to the target pixmap, except  */
1048   /*                              in direct rendering mode where all spans */
1049   /*                              are generated if no clipping box is set. */
1050   /*                                                                       */
1051 #define FT_RASTER_FLAG_DEFAULT  0x0
1052 #define FT_RASTER_FLAG_AA       0x1
1053 #define FT_RASTER_FLAG_DIRECT   0x2
1054 #define FT_RASTER_FLAG_CLIP     0x4
1055
1056   /* deprecated */
1057 #define ft_raster_flag_default  FT_RASTER_FLAG_DEFAULT
1058 #define ft_raster_flag_aa       FT_RASTER_FLAG_AA
1059 #define ft_raster_flag_direct   FT_RASTER_FLAG_DIRECT
1060 #define ft_raster_flag_clip     FT_RASTER_FLAG_CLIP
1061
1062
1063   /*************************************************************************/
1064   /*                                                                       */
1065   /* <Struct>                                                              */
1066   /*    FT_Raster_Params                                                   */
1067   /*                                                                       */
1068   /* <Description>                                                         */
1069   /*    A structure to hold the arguments used by a raster's render        */
1070   /*    function.                                                          */
1071   /*                                                                       */
1072   /* <Fields>                                                              */
1073   /*    target      :: The target bitmap.                                  */
1074   /*                                                                       */
1075   /*    source      :: A pointer to the source glyph image (e.g., an       */
1076   /*                   @FT_Outline).                                       */
1077   /*                                                                       */
1078   /*    flags       :: The rendering flags.                                */
1079   /*                                                                       */
1080   /*    gray_spans  :: The gray span drawing callback.                     */
1081   /*                                                                       */
1082   /*    black_spans :: The black span drawing callback.  UNIMPLEMENTED!    */
1083   /*                                                                       */
1084   /*    bit_test    :: The bit test callback.  UNIMPLEMENTED!              */
1085   /*                                                                       */
1086   /*    bit_set     :: The bit set callback.  UNIMPLEMENTED!               */
1087   /*                                                                       */
1088   /*    user        :: User-supplied data that is passed to each drawing   */
1089   /*                   callback.                                           */
1090   /*                                                                       */
1091   /*    clip_box    :: An optional clipping box.  It is only used in       */
1092   /*                   direct rendering mode.  Note that coordinates here  */
1093   /*                   should be expressed in _integer_ pixels (and not in */
1094   /*                   26.6 fixed-point units).                            */
1095   /*                                                                       */
1096   /* <Note>                                                                */
1097   /*    An anti-aliased glyph bitmap is drawn if the @FT_RASTER_FLAG_AA    */
1098   /*    bit flag is set in the `flags' field, otherwise a monochrome       */
1099   /*    bitmap is generated.                                               */
1100   /*                                                                       */
1101   /*    If the @FT_RASTER_FLAG_DIRECT bit flag is set in `flags', the      */
1102   /*    raster will call the `gray_spans' callback to draw gray pixel      */
1103   /*    spans, in the case of an aa glyph bitmap, it will call             */
1104   /*    `black_spans', and `bit_test' and `bit_set' in the case of a       */
1105   /*    monochrome bitmap.  This allows direct composition over a          */
1106   /*    pre-existing bitmap through user-provided callbacks to perform the */
1107   /*    span drawing/composition.                                          */
1108   /*                                                                       */
1109   /*    Note that the `bit_test' and `bit_set' callbacks are required when */
1110   /*    rendering a monochrome bitmap, as they are crucial to implement    */
1111   /*    correct drop-out control as defined in the TrueType specification. */
1112   /*                                                                       */
1113   typedef struct  FT_Raster_Params_
1114   {
1115     const FT_Bitmap*        target;
1116     const void*             source;
1117     int                     flags;
1118     FT_SpanFunc             gray_spans;
1119     FT_SpanFunc             black_spans;  /* doesn't work! */
1120     FT_Raster_BitTest_Func  bit_test;     /* doesn't work! */
1121     FT_Raster_BitSet_Func   bit_set;      /* doesn't work! */
1122     void*                   user;
1123     FT_BBox                 clip_box;
1124
1125   } FT_Raster_Params;
1126
1127
1128   /*************************************************************************/
1129   /*                                                                       */
1130   /* <FuncType>                                                            */
1131   /*    FT_Raster_NewFunc                                                  */
1132   /*                                                                       */
1133   /* <Description>                                                         */
1134   /*    A function used to create a new raster object.                     */
1135   /*                                                                       */
1136   /* <Input>                                                               */
1137   /*    memory :: A handle to the memory allocator.                        */
1138   /*                                                                       */
1139   /* <Output>                                                              */
1140   /*    raster :: A handle to the new raster object.                       */
1141   /*                                                                       */
1142   /* <Return>                                                              */
1143   /*    Error code.  0~means success.                                      */
1144   /*                                                                       */
1145   /* <Note>                                                                */
1146   /*    The `memory' parameter is a typeless pointer in order to avoid     */
1147   /*    un-wanted dependencies on the rest of the FreeType code.  In       */
1148   /*    practice, it is an @FT_Memory object, i.e., a handle to the        */
1149   /*    standard FreeType memory allocator.  However, this field can be    */
1150   /*    completely ignored by a given raster implementation.               */
1151   /*                                                                       */
1152   typedef int
1153   (*FT_Raster_NewFunc)( void*       memory,
1154                         FT_Raster*  raster );
1155
1156 #define FT_Raster_New_Func  FT_Raster_NewFunc
1157
1158
1159   /*************************************************************************/
1160   /*                                                                       */
1161   /* <FuncType>                                                            */
1162   /*    FT_Raster_DoneFunc                                                 */
1163   /*                                                                       */
1164   /* <Description>                                                         */
1165   /*    A function used to destroy a given raster object.                  */
1166   /*                                                                       */
1167   /* <Input>                                                               */
1168   /*    raster :: A handle to the raster object.                           */
1169   /*                                                                       */
1170   typedef void
1171   (*FT_Raster_DoneFunc)( FT_Raster  raster );
1172
1173 #define FT_Raster_Done_Func  FT_Raster_DoneFunc
1174
1175
1176   /*************************************************************************/
1177   /*                                                                       */
1178   /* <FuncType>                                                            */
1179   /*    FT_Raster_ResetFunc                                                */
1180   /*                                                                       */
1181   /* <Description>                                                         */
1182   /*    FreeType provides an area of memory called the `render pool',      */
1183   /*    available to all registered rasters.  This pool can be freely used */
1184   /*    during a given scan-conversion but is shared by all rasters.  Its  */
1185   /*    content is thus transient.                                         */
1186   /*                                                                       */
1187   /*    This function is called each time the render pool changes, or just */
1188   /*    after a new raster object is created.                              */
1189   /*                                                                       */
1190   /* <Input>                                                               */
1191   /*    raster    :: A handle to the new raster object.                    */
1192   /*                                                                       */
1193   /*    pool_base :: The address in memory of the render pool.             */
1194   /*                                                                       */
1195   /*    pool_size :: The size in bytes of the render pool.                 */
1196   /*                                                                       */
1197   /* <Note>                                                                */
1198   /*    Rasters can ignore the render pool and rely on dynamic memory      */
1199   /*    allocation if they want to (a handle to the memory allocator is    */
1200   /*    passed to the raster constructor).  However, this is not           */
1201   /*    recommended for efficiency purposes.                               */
1202   /*                                                                       */
1203   typedef void
1204   (*FT_Raster_ResetFunc)( FT_Raster       raster,
1205                           unsigned char*  pool_base,
1206                           unsigned long   pool_size );
1207
1208 #define FT_Raster_Reset_Func  FT_Raster_ResetFunc
1209
1210
1211   /*************************************************************************/
1212   /*                                                                       */
1213   /* <FuncType>                                                            */
1214   /*    FT_Raster_SetModeFunc                                              */
1215   /*                                                                       */
1216   /* <Description>                                                         */
1217   /*    This function is a generic facility to change modes or attributes  */
1218   /*    in a given raster.  This can be used for debugging purposes, or    */
1219   /*    simply to allow implementation-specific `features' in a given      */
1220   /*    raster module.                                                     */
1221   /*                                                                       */
1222   /* <Input>                                                               */
1223   /*    raster :: A handle to the new raster object.                       */
1224   /*                                                                       */
1225   /*    mode   :: A 4-byte tag used to name the mode or property.          */
1226   /*                                                                       */
1227   /*    args   :: A pointer to the new mode/property to use.               */
1228   /*                                                                       */
1229   typedef int
1230   (*FT_Raster_SetModeFunc)( FT_Raster      raster,
1231                             unsigned long  mode,
1232                             void*          args );
1233
1234 #define FT_Raster_Set_Mode_Func  FT_Raster_SetModeFunc
1235
1236
1237   /*************************************************************************/
1238   /*                                                                       */
1239   /* <FuncType>                                                            */
1240   /*    FT_Raster_RenderFunc                                               */
1241   /*                                                                       */
1242   /* <Description>                                                         */
1243   /*    Invoke a given raster to scan-convert a given glyph image into a   */
1244   /*    target bitmap.                                                     */
1245   /*                                                                       */
1246   /* <Input>                                                               */
1247   /*    raster :: A handle to the raster object.                           */
1248   /*                                                                       */
1249   /*    params :: A pointer to an @FT_Raster_Params structure used to      */
1250   /*              store the rendering parameters.                          */
1251   /*                                                                       */
1252   /* <Return>                                                              */
1253   /*    Error code.  0~means success.                                      */
1254   /*                                                                       */
1255   /* <Note>                                                                */
1256   /*    The exact format of the source image depends on the raster's glyph */
1257   /*    format defined in its @FT_Raster_Funcs structure.  It can be an    */
1258   /*    @FT_Outline or anything else in order to support a large array of  */
1259   /*    glyph formats.                                                     */
1260   /*                                                                       */
1261   /*    Note also that the render function can fail and return a           */
1262   /*    `FT_Err_Unimplemented_Feature' error code if the raster used does  */
1263   /*    not support direct composition.                                    */
1264   /*                                                                       */
1265   /*    XXX: For now, the standard raster doesn't support direct           */
1266   /*         composition but this should change for the final release (see */
1267   /*         the files `demos/src/ftgrays.c' and `demos/src/ftgrays2.c'    */
1268   /*         for examples of distinct implementations which support direct */
1269   /*         composition).                                                 */
1270   /*                                                                       */
1271   typedef int
1272   (*FT_Raster_RenderFunc)( FT_Raster                raster,
1273                            const FT_Raster_Params*  params );
1274
1275 #define FT_Raster_Render_Func  FT_Raster_RenderFunc
1276
1277
1278   /*************************************************************************/
1279   /*                                                                       */
1280   /* <Struct>                                                              */
1281   /*    FT_Raster_Funcs                                                    */
1282   /*                                                                       */
1283   /* <Description>                                                         */
1284   /*   A structure used to describe a given raster class to the library.   */
1285   /*                                                                       */
1286   /* <Fields>                                                              */
1287   /*    glyph_format  :: The supported glyph format for this raster.       */
1288   /*                                                                       */
1289   /*    raster_new    :: The raster constructor.                           */
1290   /*                                                                       */
1291   /*    raster_reset  :: Used to reset the render pool within the raster.  */
1292   /*                                                                       */
1293   /*    raster_render :: A function to render a glyph into a given bitmap. */
1294   /*                                                                       */
1295   /*    raster_done   :: The raster destructor.                            */
1296   /*                                                                       */
1297   typedef struct  FT_Raster_Funcs_
1298   {
1299     FT_Glyph_Format        glyph_format;
1300     FT_Raster_NewFunc      raster_new;
1301     FT_Raster_ResetFunc    raster_reset;
1302     FT_Raster_SetModeFunc  raster_set_mode;
1303     FT_Raster_RenderFunc   raster_render;
1304     FT_Raster_DoneFunc     raster_done;
1305
1306   } FT_Raster_Funcs;
1307
1308
1309   /* */
1310
1311
1312 FT_END_HEADER
1313
1314 #endif /* __FTIMAGE_H__ */
1315
1316
1317 /* END */
1318
1319
1320 /* Local Variables: */
1321 /* coding: utf-8    */
1322 /* End:             */