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