WebSVN – Kolibri OS – Blame – /contrib/media/updf/include/freetype/ftstroke.h

Rev	Author	Line No.	Line
4680	right-hear	1	/***************************************************************************/
		2	/* */
		3	/* ftstroke.h */
		4	/* */
		5	/* FreeType path stroker (specification). */
		6	/* */
		7	/* Copyright 2002, 2003, 2004, 2005, 2006, 2008, 2009 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
		23	#include FT_OUTLINE_H
		24	#include FT_GLYPH_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; i.e., the two joining lines
		79	* are extended until they intersect.
		80	*
		81	* FT_STROKER_LINEJOIN_MITER ::
		82	* Same as beveled rendering, except that an additional line
		83	* break is added if the angle between the two joining lines
		84	* is too closed (this is useful to avoid unpleasant spikes
		85	* in beveled rendering).
		86	*/
		87	typedef enum FT_Stroker_LineJoin_
		88	{
		89	FT_STROKER_LINEJOIN_ROUND = 0,
		90	FT_STROKER_LINEJOIN_BEVEL,
		91	FT_STROKER_LINEJOIN_MITER
		92
		93	} FT_Stroker_LineJoin;
		94
		95
		96	/**************************************************************
		97	*
		98	* @enum:
		99	* FT_Stroker_LineCap
		100	*
		101	* @description:
		102	* These values determine how the end of opened sub-paths are
		103	* rendered in a stroke.
		104	*
		105	* @values:
		106	* FT_STROKER_LINECAP_BUTT ::
		107	* The end of lines is rendered as a full stop on the last
		108	* point itself.
		109	*
		110	* FT_STROKER_LINECAP_ROUND ::
		111	* The end of lines is rendered as a half-circle around the
		112	* last point.
		113	*
		114	* FT_STROKER_LINECAP_SQUARE ::
		115	* The end of lines is rendered as a square around the
		116	* last point.
		117	*/
		118	typedef enum FT_Stroker_LineCap_
		119	{
		120	FT_STROKER_LINECAP_BUTT = 0,
		121	FT_STROKER_LINECAP_ROUND,
		122	FT_STROKER_LINECAP_SQUARE
		123
		124	} FT_Stroker_LineCap;
		125
		126
		127	/**************************************************************
		128	*
		129	* @enum:
		130	* FT_StrokerBorder
		131	*
		132	* @description:
		133	* These values are used to select a given stroke border
		134	* in @FT_Stroker_GetBorderCounts and @FT_Stroker_ExportBorder.
		135	*
		136	* @values:
		137	* FT_STROKER_BORDER_LEFT ::
		138	* Select the left border, relative to the drawing direction.
		139	*
		140	* FT_STROKER_BORDER_RIGHT ::
		141	* Select the right border, relative to the drawing direction.
		142	*
		143	* @note:
		144	* Applications are generally interested in the `inside' and `outside'
		145	* borders. However, there is no direct mapping between these and the
		146	* `left' and `right' ones, since this really depends on the glyph's
		147	* drawing orientation, which varies between font formats.
		148	*
		149	* You can however use @FT_Outline_GetInsideBorder and
		150	* @FT_Outline_GetOutsideBorder to get these.
		151	*/
		152	typedef enum FT_StrokerBorder_
		153	{
		154	FT_STROKER_BORDER_LEFT = 0,
		155	FT_STROKER_BORDER_RIGHT
		156
		157	} FT_StrokerBorder;
		158
		159
		160	/**************************************************************
		161	*
		162	* @function:
		163	* FT_Outline_GetInsideBorder
		164	*
		165	* @description:
		166	* Retrieve the @FT_StrokerBorder value corresponding to the
		167	* `inside' borders of a given outline.
		168	*
		169	* @input:
		170	* outline ::
		171	* The source outline handle.
		172	*
		173	* @return:
		174	* The border index. @FT_STROKER_BORDER_RIGHT for empty or invalid
		175	* outlines.
		176	*/
		177	FT_EXPORT( FT_StrokerBorder )
		178	FT_Outline_GetInsideBorder( FT_Outline* outline );
		179
		180
		181	/**************************************************************
		182	*
		183	* @function:
		184	* FT_Outline_GetOutsideBorder
		185	*
		186	* @description:
		187	* Retrieve the @FT_StrokerBorder value corresponding to the
		188	* `outside' borders of a given outline.
		189	*
		190	* @input:
		191	* outline ::
		192	* The source outline handle.
		193	*
		194	* @return:
		195	* The border index. @FT_STROKER_BORDER_LEFT for empty or invalid
		196	* outlines.
		197	*/
		198	FT_EXPORT( FT_StrokerBorder )
		199	FT_Outline_GetOutsideBorder( FT_Outline* outline );
		200
		201
		202	/**************************************************************
		203	*
		204	* @function:
		205	* FT_Stroker_New
		206	*
		207	* @description:
		208	* Create a new stroker object.
		209	*
		210	* @input:
		211	* library ::
		212	* FreeType library handle.
		213	*
		214	* @output:
		215	* astroker ::
		216	* A new stroker object handle. NULL in case of error.
		217	*
		218	* @return:
		219	* FreeType error code. 0~means success.
		220	*/
		221	FT_EXPORT( FT_Error )
		222	FT_Stroker_New( FT_Library library,
		223	FT_Stroker *astroker );
		224
		225
		226	/**************************************************************
		227	*
		228	* @function:
		229	* FT_Stroker_Set
		230	*
		231	* @description:
		232	* Reset a stroker object's attributes.
		233	*
		234	* @input:
		235	* stroker ::
		236	* The target stroker handle.
		237	*
		238	* radius ::
		239	* The border radius.
		240	*
		241	* line_cap ::
		242	* The line cap style.
		243	*
		244	* line_join ::
		245	* The line join style.
		246	*
		247	* miter_limit ::
		248	* The miter limit for the FT_STROKER_LINEJOIN_MITER style,
		249	* expressed as 16.16 fixed point value.
		250	*
		251	* @note:
		252	* The radius is expressed in the same units as the outline
		253	* coordinates.
		254	*/
		255	FT_EXPORT( void )
		256	FT_Stroker_Set( FT_Stroker stroker,
		257	FT_Fixed radius,
		258	FT_Stroker_LineCap line_cap,
		259	FT_Stroker_LineJoin line_join,
		260	FT_Fixed miter_limit );
		261
		262
		263	/**************************************************************
		264	*
		265	* @function:
		266	* FT_Stroker_Rewind
		267	*
		268	* @description:
		269	* Reset a stroker object without changing its attributes.
		270	* You should call this function before beginning a new
		271	* series of calls to @FT_Stroker_BeginSubPath or
		272	* @FT_Stroker_EndSubPath.
		273	*
		274	* @input:
		275	* stroker ::
		276	* The target stroker handle.
		277	*/
		278	FT_EXPORT( void )
		279	FT_Stroker_Rewind( FT_Stroker stroker );
		280
		281
		282	/**************************************************************
		283	*
		284	* @function:
		285	* FT_Stroker_ParseOutline
		286	*
		287	* @description:
		288	* A convenience function used to parse a whole outline with
		289	* the stroker. The resulting outline(s) can be retrieved
		290	* later by functions like @FT_Stroker_GetCounts and @FT_Stroker_Export.
		291	*
		292	* @input:
		293	* stroker ::
		294	* The target stroker handle.
		295	*
		296	* outline ::
		297	* The source outline.
		298	*
		299	* opened ::
		300	* A boolean. If~1, the outline is treated as an open path instead
		301	* of a closed one.
		302	*
		303	* @return:
		304	* FreeType error code. 0~means success.
		305	*
		306	* @note:
		307	* If `opened' is~0 (the default), the outline is treated as a closed
		308	* path, and the stroker generates two distinct `border' outlines.
		309	*
		310	* If `opened' is~1, the outline is processed as an open path, and the
		311	* stroker generates a single `stroke' outline.
		312	*
		313	* This function calls @FT_Stroker_Rewind automatically.
		314	*/
		315	FT_EXPORT( FT_Error )
		316	FT_Stroker_ParseOutline( FT_Stroker stroker,
		317	FT_Outline* outline,
		318	FT_Bool opened );
		319
		320
		321	/**************************************************************
		322	*
		323	* @function:
		324	* FT_Stroker_BeginSubPath
		325	*
		326	* @description:
		327	* Start a new sub-path in the stroker.
		328	*
		329	* @input:
		330	* stroker ::
		331	* The target stroker handle.
		332	*
		333	* to ::
		334	* A pointer to the start vector.
		335	*
		336	* open ::
		337	* A boolean. If~1, the sub-path is treated as an open one.
		338	*
		339	* @return:
		340	* FreeType error code. 0~means success.
		341	*
		342	* @note:
		343	* This function is useful when you need to stroke a path that is
		344	* not stored as an @FT_Outline object.
		345	*/
		346	FT_EXPORT( FT_Error )
		347	FT_Stroker_BeginSubPath( FT_Stroker stroker,
		348	FT_Vector* to,
		349	FT_Bool open );
		350
		351
		352	/**************************************************************
		353	*
		354	* @function:
		355	* FT_Stroker_EndSubPath
		356	*
		357	* @description:
		358	* Close the current sub-path in the stroker.
		359	*
		360	* @input:
		361	* stroker ::
		362	* The target stroker handle.
		363	*
		364	* @return:
		365	* FreeType error code. 0~means success.
		366	*
		367	* @note:
		368	* You should call this function after @FT_Stroker_BeginSubPath.
		369	* If the subpath was not `opened', this function `draws' a
		370	* single line segment to the start position when needed.
		371	*/
		372	FT_EXPORT( FT_Error )
		373	FT_Stroker_EndSubPath( FT_Stroker stroker );
		374
		375
		376	/**************************************************************
		377	*
		378	* @function:
		379	* FT_Stroker_LineTo
		380	*
		381	* @description:
		382	* `Draw' a single line segment in the stroker's current sub-path,
		383	* from the last position.
		384	*
		385	* @input:
		386	* stroker ::
		387	* The target stroker handle.
		388	*
		389	* to ::
		390	* A pointer to the destination point.
		391	*
		392	* @return:
		393	* FreeType error code. 0~means success.
		394	*
		395	* @note:
		396	* You should call this function between @FT_Stroker_BeginSubPath and
		397	* @FT_Stroker_EndSubPath.
		398	*/
		399	FT_EXPORT( FT_Error )
		400	FT_Stroker_LineTo( FT_Stroker stroker,
		401	FT_Vector* to );
		402
		403
		404	/**************************************************************
		405	*
		406	* @function:
		407	* FT_Stroker_ConicTo
		408	*
		409	* @description:
		410	* `Draw' a single quadratic Bézier in the stroker's current sub-path,
		411	* from the last position.
		412	*
		413	* @input:
		414	* stroker ::
		415	* The target stroker handle.
		416	*
		417	* control ::
		418	* A pointer to a Bézier control point.
		419	*
		420	* to ::
		421	* A pointer to the destination point.
		422	*
		423	* @return:
		424	* FreeType error code. 0~means success.
		425	*
		426	* @note:
		427	* You should call this function between @FT_Stroker_BeginSubPath and
		428	* @FT_Stroker_EndSubPath.
		429	*/
		430	FT_EXPORT( FT_Error )
		431	FT_Stroker_ConicTo( FT_Stroker stroker,
		432	FT_Vector* control,
		433	FT_Vector* to );
		434
		435
		436	/**************************************************************
		437	*
		438	* @function:
		439	* FT_Stroker_CubicTo
		440	*
		441	* @description:
		442	* `Draw' a single cubic Bézier in the stroker's current sub-path,
		443	* from the last position.
		444	*
		445	* @input:
		446	* stroker ::
		447	* The target stroker handle.
		448	*
		449	* control1 ::
		450	* A pointer to the first Bézier control point.
		451	*
		452	* control2 ::
		453	* A pointer to second Bézier control point.
		454	*
		455	* to ::
		456	* A pointer to the destination point.
		457	*
		458	* @return:
		459	* FreeType error code. 0~means success.
		460	*
		461	* @note:
		462	* You should call this function between @FT_Stroker_BeginSubPath and
		463	* @FT_Stroker_EndSubPath.
		464	*/
		465	FT_EXPORT( FT_Error )
		466	FT_Stroker_CubicTo( FT_Stroker stroker,
		467	FT_Vector* control1,
		468	FT_Vector* control2,
		469	FT_Vector* to );
		470
		471
		472	/**************************************************************
		473	*
		474	* @function:
		475	* FT_Stroker_GetBorderCounts
		476	*
		477	* @description:
		478	* Call this function once you have finished parsing your paths
		479	* with the stroker. It returns the number of points and
		480	* contours necessary to export one of the `border' or `stroke'
		481	* outlines generated by the stroker.
		482	*
		483	* @input:
		484	* stroker ::
		485	* The target stroker handle.
		486	*
		487	* border ::
		488	* The border index.
		489	*
		490	* @output:
		491	* anum_points ::
		492	* The number of points.
		493	*
		494	* anum_contours ::
		495	* The number of contours.
		496	*
		497	* @return:
		498	* FreeType error code. 0~means success.
		499	*
		500	* @note:
		501	* When an outline, or a sub-path, is `closed', the stroker generates
		502	* two independent `border' outlines, named `left' and `right'.
		503	*
		504	* When the outline, or a sub-path, is `opened', the stroker merges
		505	* the `border' outlines with caps. The `left' border receives all
		506	* points, while the `right' border becomes empty.
		507	*
		508	* Use the function @FT_Stroker_GetCounts instead if you want to
		509	* retrieve the counts associated to both borders.
		510	*/
		511	FT_EXPORT( FT_Error )
		512	FT_Stroker_GetBorderCounts( FT_Stroker stroker,
		513	FT_StrokerBorder border,
		514	FT_UInt *anum_points,
		515	FT_UInt *anum_contours );
		516
		517
		518	/**************************************************************
		519	*
		520	* @function:
		521	* FT_Stroker_ExportBorder
		522	*
		523	* @description:
		524	* Call this function after @FT_Stroker_GetBorderCounts to
		525	* export the corresponding border to your own @FT_Outline
		526	* structure.
		527	*
		528	* Note that this function appends the border points and
		529	* contours to your outline, but does not try to resize its
		530	* arrays.
		531	*
		532	* @input:
		533	* stroker ::
		534	* The target stroker handle.
		535	*
		536	* border ::
		537	* The border index.
		538	*
		539	* outline ::
		540	* The target outline handle.
		541	*
		542	* @note:
		543	* Always call this function after @FT_Stroker_GetBorderCounts to
		544	* get sure that there is enough room in your @FT_Outline object to
		545	* receive all new data.
		546	*
		547	* When an outline, or a sub-path, is `closed', the stroker generates
		548	* two independent `border' outlines, named `left' and `right'
		549	*
		550	* When the outline, or a sub-path, is `opened', the stroker merges
		551	* the `border' outlines with caps. The `left' border receives all
		552	* points, while the `right' border becomes empty.
		553	*
		554	* Use the function @FT_Stroker_Export instead if you want to
		555	* retrieve all borders at once.
		556	*/
		557	FT_EXPORT( void )
		558	FT_Stroker_ExportBorder( FT_Stroker stroker,
		559	FT_StrokerBorder border,
		560	FT_Outline* outline );
		561
		562
		563	/**************************************************************
		564	*
		565	* @function:
		566	* FT_Stroker_GetCounts
		567	*
		568	* @description:
		569	* Call this function once you have finished parsing your paths
		570	* with the stroker. It returns the number of points and
		571	* contours necessary to export all points/borders from the stroked
		572	* outline/path.
		573	*
		574	* @input:
		575	* stroker ::
		576	* The target stroker handle.
		577	*
		578	* @output:
		579	* anum_points ::
		580	* The number of points.
		581	*
		582	* anum_contours ::
		583	* The number of contours.
		584	*
		585	* @return:
		586	* FreeType error code. 0~means success.
		587	*/
		588	FT_EXPORT( FT_Error )
		589	FT_Stroker_GetCounts( FT_Stroker stroker,
		590	FT_UInt *anum_points,
		591	FT_UInt *anum_contours );
		592
		593
		594	/**************************************************************
		595	*
		596	* @function:
		597	* FT_Stroker_Export
		598	*
		599	* @description:
		600	* Call this function after @FT_Stroker_GetBorderCounts to
		601	* export all borders to your own @FT_Outline structure.
		602	*
		603	* Note that this function appends the border points and
		604	* contours to your outline, but does not try to resize its
		605	* arrays.
		606	*
		607	* @input:
		608	* stroker ::
		609	* The target stroker handle.
		610	*
		611	* outline ::
		612	* The target outline handle.
		613	*/
		614	FT_EXPORT( void )
		615	FT_Stroker_Export( FT_Stroker stroker,
		616	FT_Outline* outline );
		617
		618
		619	/**************************************************************
		620	*
		621	* @function:
		622	* FT_Stroker_Done
		623	*
		624	* @description:
		625	* Destroy a stroker object.
		626	*
		627	* @input:
		628	* stroker ::
		629	* A stroker handle. Can be NULL.
		630	*/
		631	FT_EXPORT( void )
		632	FT_Stroker_Done( FT_Stroker stroker );
		633
		634
		635	/**************************************************************
		636	*
		637	* @function:
		638	* FT_Glyph_Stroke
		639	*
		640	* @description:
		641	* Stroke a given outline glyph object with a given stroker.
		642	*
		643	* @inout:
		644	* pglyph ::
		645	* Source glyph handle on input, new glyph handle on output.
		646	*
		647	* @input:
		648	* stroker ::
		649	* A stroker handle.
		650	*
		651	* destroy ::
		652	* A Boolean. If~1, the source glyph object is destroyed
		653	* on success.
		654	*
		655	* @return:
		656	* FreeType error code. 0~means success.
		657	*
		658	* @note:
		659	* The source glyph is untouched in case of error.
		660	*/
		661	FT_EXPORT( FT_Error )
		662	FT_Glyph_Stroke( FT_Glyph *pglyph,
		663	FT_Stroker stroker,
		664	FT_Bool destroy );
		665
		666
		667	/**************************************************************
		668	*
		669	* @function:
		670	* FT_Glyph_StrokeBorder
		671	*
		672	* @description:
		673	* Stroke a given outline glyph object with a given stroker, but
		674	* only return either its inside or outside border.
		675	*
		676	* @inout:
		677	* pglyph ::
		678	* Source glyph handle on input, new glyph handle on output.
		679	*
		680	* @input:
		681	* stroker ::
		682	* A stroker handle.
		683	*
		684	* inside ::
		685	* A Boolean. If~1, return the inside border, otherwise
		686	* the outside border.
		687	*
		688	* destroy ::
		689	* A Boolean. If~1, the source glyph object is destroyed
		690	* on success.
		691	*
		692	* @return:
		693	* FreeType error code. 0~means success.
		694	*
		695	* @note:
		696	* The source glyph is untouched in case of error.
		697	*/
		698	FT_EXPORT( FT_Error )
		699	FT_Glyph_StrokeBorder( FT_Glyph *pglyph,
		700	FT_Stroker stroker,
		701	FT_Bool inside,
		702	FT_Bool destroy );
		703
		704	/* */
		705
		706	FT_END_HEADER
		707
		708	#endif /* __FT_STROKE_H__ */
		709
		710
		711	/* END */
		712
		713
		714	/* Local Variables: */
		715	/* coding: utf-8 */
		716	/* End: */

Subversion Repositories Kolibri OS

(root)/contrib/media/updf/include/freetype/ftstroke.h – Rev 4680