XFA: merge patch from CL 817753002
[pdfium.git] / core / src / fxge / fx_freetype / fxft2.5.01 / include / freetype / ftstroke.h
1 /***************************************************************************/
2 /*                                                                         */
3 /*  ftstroke.h                                                             */
4 /*                                                                         */
5 /*    FreeType path stroker (specification).                               */
6 /*                                                                         */
7 /*  Copyright 2002-2006, 2008, 2009, 2011-2012 by                          */
8 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
9 /*                                                                         */
10 /*  This file is part of the FreeType project, and may only be used,       */
11 /*  modified, and distributed under the terms of the FreeType project      */
12 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
13 /*  this file you indicate that you have read the license and              */
14 /*  understand and accept it fully.                                        */
15 /*                                                                         */
16 /***************************************************************************/
17
18
19 #ifndef __FT_STROKE_H__
20 #define __FT_STROKE_H__
21
22 #include "../ft2build.h"
23 #include "ftoutln.h"
24 #include "ftglyph.h"
25
26
27 FT_BEGIN_HEADER
28
29
30  /************************************************************************
31   *
32   * @section:
33   *    glyph_stroker
34   *
35   * @title:
36   *    Glyph Stroker
37   *
38   * @abstract:
39   *    Generating bordered and stroked glyphs.
40   *
41   * @description:
42   *    This component generates stroked outlines of a given vectorial
43   *    glyph.  It also allows you to retrieve the `outside' and/or the
44   *    `inside' borders of the stroke.
45   *
46   *    This can be useful to generate `bordered' glyph, i.e., glyphs
47   *    displayed with a coloured (and anti-aliased) border around their
48   *    shape.
49   */
50
51
52  /**************************************************************
53   *
54   * @type:
55   *   FT_Stroker
56   *
57   * @description:
58   *   Opaque handler to a path stroker object.
59   */
60   typedef struct FT_StrokerRec_*  FT_Stroker;
61
62
63   /**************************************************************
64    *
65    * @enum:
66    *   FT_Stroker_LineJoin
67    *
68    * @description:
69    *   These values determine how two joining lines are rendered
70    *   in a stroker.
71    *
72    * @values:
73    *   FT_STROKER_LINEJOIN_ROUND ::
74    *     Used to render rounded line joins.  Circular arcs are used
75    *     to join two lines smoothly.
76    *
77    *   FT_STROKER_LINEJOIN_BEVEL ::
78    *     Used to render beveled line joins.  The outer corner of
79    *     the joined lines is filled by enclosing the triangular
80    *     region of the corner with a straight line between the
81    *     outer corners of each stroke.
82    *
83    *   FT_STROKER_LINEJOIN_MITER_FIXED ::
84    *     Used to render mitered line joins, with fixed bevels if the
85    *     miter limit is exceeded.  The outer edges of the strokes
86    *     for the two segments are extended until they meet at an
87    *     angle.  If the segments meet at too sharp an angle (such
88    *     that the miter would extend from the intersection of the
89    *     segments a distance greater than the product of the miter
90    *     limit value and the border radius), then a bevel join (see
91    *     above) is used instead.  This prevents long spikes being
92    *     created.  FT_STROKER_LINEJOIN_MITER_FIXED generates a miter
93    *     line join as used in PostScript and PDF.
94    *
95    *   FT_STROKER_LINEJOIN_MITER_VARIABLE ::
96    *   FT_STROKER_LINEJOIN_MITER ::
97    *     Used to render mitered line joins, with variable bevels if
98    *     the miter limit is exceeded.  The intersection of the
99    *     strokes is clipped at a line perpendicular to the bisector
100    *     of the angle between the strokes, at the distance from the
101    *     intersection of the segments equal to the product of the
102    *     miter limit value and the border radius.  This prevents
103    *     long spikes being created.
104    *     FT_STROKER_LINEJOIN_MITER_VARIABLE generates a mitered line
105    *     join as used in XPS.  FT_STROKER_LINEJOIN_MITER is an alias
106    *     for FT_STROKER_LINEJOIN_MITER_VARIABLE, retained for
107    *     backwards compatibility.
108    */
109   typedef enum  FT_Stroker_LineJoin_
110   {
111     FT_STROKER_LINEJOIN_ROUND          = 0,
112     FT_STROKER_LINEJOIN_BEVEL          = 1,
113     FT_STROKER_LINEJOIN_MITER_VARIABLE = 2,
114     FT_STROKER_LINEJOIN_MITER          = FT_STROKER_LINEJOIN_MITER_VARIABLE,
115     FT_STROKER_LINEJOIN_MITER_FIXED    = 3
116
117   } FT_Stroker_LineJoin;
118
119
120   /**************************************************************
121    *
122    * @enum:
123    *   FT_Stroker_LineCap
124    *
125    * @description:
126    *   These values determine how the end of opened sub-paths are
127    *   rendered in a stroke.
128    *
129    * @values:
130    *   FT_STROKER_LINECAP_BUTT ::
131    *     The end of lines is rendered as a full stop on the last
132    *     point itself.
133    *
134    *   FT_STROKER_LINECAP_ROUND ::
135    *     The end of lines is rendered as a half-circle around the
136    *     last point.
137    *
138    *   FT_STROKER_LINECAP_SQUARE ::
139    *     The end of lines is rendered as a square around the
140    *     last point.
141    */
142   typedef enum  FT_Stroker_LineCap_
143   {
144     FT_STROKER_LINECAP_BUTT = 0,
145     FT_STROKER_LINECAP_ROUND,
146     FT_STROKER_LINECAP_SQUARE
147
148   } FT_Stroker_LineCap;
149
150
151   /**************************************************************
152    *
153    * @enum:
154    *   FT_StrokerBorder
155    *
156    * @description:
157    *   These values are used to select a given stroke border
158    *   in @FT_Stroker_GetBorderCounts and @FT_Stroker_ExportBorder.
159    *
160    * @values:
161    *   FT_STROKER_BORDER_LEFT ::
162    *     Select the left border, relative to the drawing direction.
163    *
164    *   FT_STROKER_BORDER_RIGHT ::
165    *     Select the right border, relative to the drawing direction.
166    *
167    * @note:
168    *   Applications are generally interested in the `inside' and `outside'
169    *   borders.  However, there is no direct mapping between these and the
170    *   `left' and `right' ones, since this really depends on the glyph's
171    *   drawing orientation, which varies between font formats.
172    *
173    *   You can however use @FT_Outline_GetInsideBorder and
174    *   @FT_Outline_GetOutsideBorder to get these.
175    */
176   typedef enum  FT_StrokerBorder_
177   {
178     FT_STROKER_BORDER_LEFT = 0,
179     FT_STROKER_BORDER_RIGHT
180
181   } FT_StrokerBorder;
182
183
184   /**************************************************************
185    *
186    * @function:
187    *   FT_Outline_GetInsideBorder
188    *
189    * @description:
190    *   Retrieve the @FT_StrokerBorder value corresponding to the
191    *   `inside' borders of a given outline.
192    *
193    * @input:
194    *   outline ::
195    *     The source outline handle.
196    *
197    * @return:
198    *   The border index.  @FT_STROKER_BORDER_RIGHT for empty or invalid
199    *   outlines.
200    */
201   FT_EXPORT( FT_StrokerBorder )
202   FT_Outline_GetInsideBorder( FT_Outline*  outline );
203
204
205   /**************************************************************
206    *
207    * @function:
208    *   FT_Outline_GetOutsideBorder
209    *
210    * @description:
211    *   Retrieve the @FT_StrokerBorder value corresponding to the
212    *   `outside' borders of a given outline.
213    *
214    * @input:
215    *   outline ::
216    *     The source outline handle.
217    *
218    * @return:
219    *   The border index.  @FT_STROKER_BORDER_LEFT for empty or invalid
220    *   outlines.
221    */
222   FT_EXPORT( FT_StrokerBorder )
223   FT_Outline_GetOutsideBorder( FT_Outline*  outline );
224
225
226   /**************************************************************
227    *
228    * @function:
229    *   FT_Stroker_New
230    *
231    * @description:
232    *   Create a new stroker object.
233    *
234    * @input:
235    *   library ::
236    *     FreeType library handle.
237    *
238    * @output:
239    *   astroker ::
240    *     A new stroker object handle.  NULL in case of error.
241    *
242    * @return:
243    *    FreeType error code.  0~means success.
244    */
245   FT_EXPORT( FT_Error )
246   FT_Stroker_New( FT_Library   library,
247                   FT_Stroker  *astroker );
248
249
250   /**************************************************************
251    *
252    * @function:
253    *   FT_Stroker_Set
254    *
255    * @description:
256    *   Reset a stroker object's attributes.
257    *
258    * @input:
259    *   stroker ::
260    *     The target stroker handle.
261    *
262    *   radius ::
263    *     The border radius.
264    *
265    *   line_cap ::
266    *     The line cap style.
267    *
268    *   line_join ::
269    *     The line join style.
270    *
271    *   miter_limit ::
272    *     The miter limit for the FT_STROKER_LINEJOIN_MITER_FIXED and
273    *     FT_STROKER_LINEJOIN_MITER_VARIABLE line join styles,
274    *     expressed as 16.16 fixed-point value.
275    *
276    * @note:
277    *   The radius is expressed in the same units as the outline
278    *   coordinates.
279    */
280   FT_EXPORT( void )
281   FT_Stroker_Set( FT_Stroker           stroker,
282                   FT_Fixed             radius,
283                   FT_Stroker_LineCap   line_cap,
284                   FT_Stroker_LineJoin  line_join,
285                   FT_Fixed             miter_limit );
286
287
288   /**************************************************************
289    *
290    * @function:
291    *   FT_Stroker_Rewind
292    *
293    * @description:
294    *   Reset a stroker object without changing its attributes.
295    *   You should call this function before beginning a new
296    *   series of calls to @FT_Stroker_BeginSubPath or
297    *   @FT_Stroker_EndSubPath.
298    *
299    * @input:
300    *   stroker ::
301    *     The target stroker handle.
302    */
303   FT_EXPORT( void )
304   FT_Stroker_Rewind( FT_Stroker  stroker );
305
306
307   /**************************************************************
308    *
309    * @function:
310    *   FT_Stroker_ParseOutline
311    *
312    * @description:
313    *   A convenience function used to parse a whole outline with
314    *   the stroker.  The resulting outline(s) can be retrieved
315    *   later by functions like @FT_Stroker_GetCounts and @FT_Stroker_Export.
316    *
317    * @input:
318    *   stroker ::
319    *     The target stroker handle.
320    *
321    *   outline ::
322    *     The source outline.
323    *
324    *   opened ::
325    *     A boolean.  If~1, the outline is treated as an open path instead
326    *     of a closed one.
327    *
328    * @return:
329    *   FreeType error code.  0~means success.
330    *
331    * @note:
332    *   If `opened' is~0 (the default), the outline is treated as a closed
333    *   path, and the stroker generates two distinct `border' outlines.
334    *
335    *   If `opened' is~1, the outline is processed as an open path, and the
336    *   stroker generates a single `stroke' outline.
337    *
338    *   This function calls @FT_Stroker_Rewind automatically.
339    */
340   FT_EXPORT( FT_Error )
341   FT_Stroker_ParseOutline( FT_Stroker   stroker,
342                            FT_Outline*  outline,
343                            FT_Bool      opened );
344
345
346   /**************************************************************
347    *
348    * @function:
349    *   FT_Stroker_BeginSubPath
350    *
351    * @description:
352    *   Start a new sub-path in the stroker.
353    *
354    * @input:
355    *   stroker ::
356    *     The target stroker handle.
357    *
358    *   to ::
359    *     A pointer to the start vector.
360    *
361    *   open ::
362    *     A boolean.  If~1, the sub-path is treated as an open one.
363    *
364    * @return:
365    *   FreeType error code.  0~means success.
366    *
367    * @note:
368    *   This function is useful when you need to stroke a path that is
369    *   not stored as an @FT_Outline object.
370    */
371   FT_EXPORT( FT_Error )
372   FT_Stroker_BeginSubPath( FT_Stroker  stroker,
373                            FT_Vector*  to,
374                            FT_Bool     open );
375
376
377   /**************************************************************
378    *
379    * @function:
380    *   FT_Stroker_EndSubPath
381    *
382    * @description:
383    *   Close the current sub-path in the stroker.
384    *
385    * @input:
386    *   stroker ::
387    *     The target stroker handle.
388    *
389    * @return:
390    *   FreeType error code.  0~means success.
391    *
392    * @note:
393    *   You should call this function after @FT_Stroker_BeginSubPath.
394    *   If the subpath was not `opened', this function `draws' a
395    *   single line segment to the start position when needed.
396    */
397   FT_EXPORT( FT_Error )
398   FT_Stroker_EndSubPath( FT_Stroker  stroker );
399
400
401   /**************************************************************
402    *
403    * @function:
404    *   FT_Stroker_LineTo
405    *
406    * @description:
407    *   `Draw' a single line segment in the stroker's current sub-path,
408    *   from the last position.
409    *
410    * @input:
411    *   stroker ::
412    *     The target stroker handle.
413    *
414    *   to ::
415    *     A pointer to the destination point.
416    *
417    * @return:
418    *   FreeType error code.  0~means success.
419    *
420    * @note:
421    *   You should call this function between @FT_Stroker_BeginSubPath and
422    *   @FT_Stroker_EndSubPath.
423    */
424   FT_EXPORT( FT_Error )
425   FT_Stroker_LineTo( FT_Stroker  stroker,
426                      FT_Vector*  to );
427
428
429   /**************************************************************
430    *
431    * @function:
432    *   FT_Stroker_ConicTo
433    *
434    * @description:
435    *   `Draw' a single quadratic Bézier in the stroker's current sub-path,
436    *   from the last position.
437    *
438    * @input:
439    *   stroker ::
440    *     The target stroker handle.
441    *
442    *   control ::
443    *     A pointer to a Bézier control point.
444    *
445    *   to ::
446    *     A pointer to the destination point.
447    *
448    * @return:
449    *   FreeType error code.  0~means success.
450    *
451    * @note:
452    *   You should call this function between @FT_Stroker_BeginSubPath and
453    *   @FT_Stroker_EndSubPath.
454    */
455   FT_EXPORT( FT_Error )
456   FT_Stroker_ConicTo( FT_Stroker  stroker,
457                       FT_Vector*  control,
458                       FT_Vector*  to );
459
460
461   /**************************************************************
462    *
463    * @function:
464    *   FT_Stroker_CubicTo
465    *
466    * @description:
467    *   `Draw' a single cubic Bézier in the stroker's current sub-path,
468    *   from the last position.
469    *
470    * @input:
471    *   stroker ::
472    *     The target stroker handle.
473    *
474    *   control1 ::
475    *     A pointer to the first Bézier control point.
476    *
477    *   control2 ::
478    *     A pointer to second Bézier control point.
479    *
480    *   to ::
481    *     A pointer to the destination point.
482    *
483    * @return:
484    *   FreeType error code.  0~means success.
485    *
486    * @note:
487    *   You should call this function between @FT_Stroker_BeginSubPath and
488    *   @FT_Stroker_EndSubPath.
489    */
490   FT_EXPORT( FT_Error )
491   FT_Stroker_CubicTo( FT_Stroker  stroker,
492                       FT_Vector*  control1,
493                       FT_Vector*  control2,
494                       FT_Vector*  to );
495
496
497   /**************************************************************
498    *
499    * @function:
500    *   FT_Stroker_GetBorderCounts
501    *
502    * @description:
503    *   Call this function once you have finished parsing your paths
504    *   with the stroker.  It returns the number of points and
505    *   contours necessary to export one of the `border' or `stroke'
506    *   outlines generated by the stroker.
507    *
508    * @input:
509    *   stroker ::
510    *     The target stroker handle.
511    *
512    *   border ::
513    *     The border index.
514    *
515    * @output:
516    *   anum_points ::
517    *     The number of points.
518    *
519    *   anum_contours ::
520    *     The number of contours.
521    *
522    * @return:
523    *   FreeType error code.  0~means success.
524    *
525    * @note:
526    *   When an outline, or a sub-path, is `closed', the stroker generates
527    *   two independent `border' outlines, named `left' and `right'.
528    *
529    *   When the outline, or a sub-path, is `opened', the stroker merges
530    *   the `border' outlines with caps.  The `left' border receives all
531    *   points, while the `right' border becomes empty.
532    *
533    *   Use the function @FT_Stroker_GetCounts instead if you want to
534    *   retrieve the counts associated to both borders.
535    */
536   FT_EXPORT( FT_Error )
537   FT_Stroker_GetBorderCounts( FT_Stroker        stroker,
538                               FT_StrokerBorder  border,
539                               FT_UInt          *anum_points,
540                               FT_UInt          *anum_contours );
541
542
543   /**************************************************************
544    *
545    * @function:
546    *   FT_Stroker_ExportBorder
547    *
548    * @description:
549    *   Call this function after @FT_Stroker_GetBorderCounts to
550    *   export the corresponding border to your own @FT_Outline
551    *   structure.
552    *
553    *   Note that this function appends the border points and
554    *   contours to your outline, but does not try to resize its
555    *   arrays.
556    *
557    * @input:
558    *   stroker ::
559    *     The target stroker handle.
560    *
561    *   border ::
562    *     The border index.
563    *
564    *   outline ::
565    *     The target outline handle.
566    *
567    * @note:
568    *   Always call this function after @FT_Stroker_GetBorderCounts to
569    *   get sure that there is enough room in your @FT_Outline object to
570    *   receive all new data.
571    *
572    *   When an outline, or a sub-path, is `closed', the stroker generates
573    *   two independent `border' outlines, named `left' and `right'
574    *
575    *   When the outline, or a sub-path, is `opened', the stroker merges
576    *   the `border' outlines with caps. The `left' border receives all
577    *   points, while the `right' border becomes empty.
578    *
579    *   Use the function @FT_Stroker_Export instead if you want to
580    *   retrieve all borders at once.
581    */
582   FT_EXPORT( void )
583   FT_Stroker_ExportBorder( FT_Stroker        stroker,
584                            FT_StrokerBorder  border,
585                            FT_Outline*       outline );
586
587
588   /**************************************************************
589    *
590    * @function:
591    *   FT_Stroker_GetCounts
592    *
593    * @description:
594    *   Call this function once you have finished parsing your paths
595    *   with the stroker.  It returns the number of points and
596    *   contours necessary to export all points/borders from the stroked
597    *   outline/path.
598    *
599    * @input:
600    *   stroker ::
601    *     The target stroker handle.
602    *
603    * @output:
604    *   anum_points ::
605    *     The number of points.
606    *
607    *   anum_contours ::
608    *     The number of contours.
609    *
610    * @return:
611    *   FreeType error code.  0~means success.
612    */
613   FT_EXPORT( FT_Error )
614   FT_Stroker_GetCounts( FT_Stroker  stroker,
615                         FT_UInt    *anum_points,
616                         FT_UInt    *anum_contours );
617
618
619   /**************************************************************
620    *
621    * @function:
622    *   FT_Stroker_Export
623    *
624    * @description:
625    *   Call this function after @FT_Stroker_GetBorderCounts to
626    *   export all borders to your own @FT_Outline structure.
627    *
628    *   Note that this function appends the border points and
629    *   contours to your outline, but does not try to resize its
630    *   arrays.
631    *
632    * @input:
633    *   stroker ::
634    *     The target stroker handle.
635    *
636    *   outline ::
637    *     The target outline handle.
638    */
639   FT_EXPORT( void )
640   FT_Stroker_Export( FT_Stroker   stroker,
641                      FT_Outline*  outline );
642
643
644   /**************************************************************
645    *
646    * @function:
647    *   FT_Stroker_Done
648    *
649    * @description:
650    *   Destroy a stroker object.
651    *
652    * @input:
653    *   stroker ::
654    *     A stroker handle.  Can be NULL.
655    */
656   FT_EXPORT( void )
657   FT_Stroker_Done( FT_Stroker  stroker );
658
659
660   /**************************************************************
661    *
662    * @function:
663    *   FT_Glyph_Stroke
664    *
665    * @description:
666    *   Stroke a given outline glyph object with a given stroker.
667    *
668    * @inout:
669    *   pglyph ::
670    *     Source glyph handle on input, new glyph handle on output.
671    *
672    * @input:
673    *   stroker ::
674    *     A stroker handle.
675    *
676    *   destroy ::
677    *     A Boolean.  If~1, the source glyph object is destroyed
678    *     on success.
679    *
680    * @return:
681    *    FreeType error code.  0~means success.
682    *
683    * @note:
684    *   The source glyph is untouched in case of error.
685    *
686    *   Adding stroke may yield a significantly wider and taller glyph
687    *   depending on how large of a radius was used to stroke the glyph.  You
688    *   may need to manually adjust horizontal and vertical advance amounts
689    *   to account for this added size.
690    */
691   FT_EXPORT( FT_Error )
692   FT_Glyph_Stroke( FT_Glyph    *pglyph,
693                    FT_Stroker   stroker,
694                    FT_Bool      destroy );
695
696
697   /**************************************************************
698    *
699    * @function:
700    *   FT_Glyph_StrokeBorder
701    *
702    * @description:
703    *   Stroke a given outline glyph object with a given stroker, but
704    *   only return either its inside or outside border.
705    *
706    * @inout:
707    *   pglyph ::
708    *     Source glyph handle on input, new glyph handle on output.
709    *
710    * @input:
711    *   stroker ::
712    *     A stroker handle.
713    *
714    *   inside ::
715    *     A Boolean.  If~1, return the inside border, otherwise
716    *     the outside border.
717    *
718    *   destroy ::
719    *     A Boolean.  If~1, the source glyph object is destroyed
720    *     on success.
721    *
722    * @return:
723    *    FreeType error code.  0~means success.
724    *
725    * @note:
726    *   The source glyph is untouched in case of error.
727    *
728    *   Adding stroke may yield a significantly wider and taller glyph
729    *   depending on how large of a radius was used to stroke the glyph.  You
730    *   may need to manually adjust horizontal and vertical advance amounts
731    *   to account for this added size.
732    */
733   FT_EXPORT( FT_Error )
734   FT_Glyph_StrokeBorder( FT_Glyph    *pglyph,
735                          FT_Stroker   stroker,
736                          FT_Bool      inside,
737                          FT_Bool      destroy );
738
739  /* */
740
741 FT_END_HEADER
742
743 #endif /* __FT_STROKE_H__ */
744
745
746 /* END */
747
748
749 /* Local Variables: */
750 /* coding: utf-8    */
751 /* End:             */