source: trunk/poppler/freetype2/include/freetype/ftimage.h @ 274

Last change on this file since 274 was 274, checked in by rbri, 12 years ago

PDF plugin: freetype library updated to version 2.3.11

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