]>
Commit | Line | Data |
---|---|---|
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-point 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: */ |