WebSVN – Kolibri OS – Blame – /programs/develop/libraries/pixman/pixman.h

Rev	Author	Line No.	Line
1891	serge	1	/***********************************************************
		2
		3	Copyright 1987, 1998 The Open Group
		4
		5	Permission to use, copy, modify, distribute, and sell this software and its
		6	documentation for any purpose is hereby granted without fee, provided that
		7	the above copyright notice appear in all copies and that both that
		8	copyright notice and this permission notice appear in supporting
		9	documentation.
		10
		11	The above copyright notice and this permission notice shall be included in
		12	all copies or substantial portions of the Software.
		13
		14	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		15	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		16	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
		17	OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
		18	AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
		19	CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
		20
		21	Except as contained in this notice, the name of The Open Group shall not be
		22	used in advertising or otherwise to promote the sale, use or other dealings
		23	in this Software without prior written authorization from The Open Group.
		24
		25	Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
		26
		27	All Rights Reserved
		28
		29	Permission to use, copy, modify, and distribute this software and its
		30	documentation for any purpose and without fee is hereby granted,
		31	provided that the above copyright notice appear in all copies and that
		32	both that copyright notice and this permission notice appear in
		33	supporting documentation, and that the name of Digital not be
		34	used in advertising or publicity pertaining to distribution of the
		35	software without specific, written prior permission.
		36
		37	DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
		38	ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
		39	DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
		40	ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
		41	WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
		42	ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
		43	SOFTWARE.
		44
		45	******************************************************************/
		46	/*
		47	* Copyright © 1998, 2004 Keith Packard
		48	* Copyright 2007 Red Hat, Inc.
		49	*
		50	* Permission to use, copy, modify, distribute, and sell this software and its
		51	* documentation for any purpose is hereby granted without fee, provided that
		52	* the above copyright notice appear in all copies and that both that
		53	* copyright notice and this permission notice appear in supporting
		54	* documentation, and that the name of Keith Packard not be used in
		55	* advertising or publicity pertaining to distribution of the software without
		56	* specific, written prior permission. Keith Packard makes no
		57	* representations about the suitability of this software for any purpose. It
		58	* is provided "as is" without express or implied warranty.
		59	*
		60	* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
		61	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
		62	* EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
		63	* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
		64	* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
		65	* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
		66	* PERFORMANCE OF THIS SOFTWARE.
		67	*/
		68
		69	#ifndef PIXMAN_H__
		70	#define PIXMAN_H__
		71
		72	#include
		73
		74	#ifdef __cplusplus
		75	#define PIXMAN_BEGIN_DECLS extern "C" {
		76	#define PIXMAN_END_DECLS }
		77	#else
		78	#define PIXMAN_BEGIN_DECLS
		79	#define PIXMAN_END_DECLS
		80	#endif
		81
		82	PIXMAN_BEGIN_DECLS
		83
		84	/*
		85	* Standard integers
		86	*/
		87
		88	#if !defined (PIXMAN_DONT_DEFINE_STDINT)
		89
		90	#if defined (_SVR4) \|\| defined (SVR4) \|\| defined (__OpenBSD__) \|\| defined (_sgi) \|\| defined (__sun) \|\| defined (sun) \|\| defined (__digital__) \|\| defined (__HP_cc)
		91	# include
		92	/* VS 2010 (_MSC_VER 1600) has stdint.h */
		93	#elif defined (_MSC_VER) && _MSC_VER < 1600
		94	typedef __int8 int8_t;
		95	typedef unsigned __int8 uint8_t;
		96	typedef __int16 int16_t;
		97	typedef unsigned __int16 uint16_t;
		98	typedef __int32 int32_t;
		99	typedef unsigned __int32 uint32_t;
		100	typedef __int64 int64_t;
		101	typedef unsigned __int64 uint64_t;
		102	#elif defined (_AIX)
		103	# include
		104	#else
		105	# include
		106	#endif
		107
		108	#endif
		109
		110	/*
		111	* Boolean
		112	*/
		113	typedef int pixman_bool_t;
		114
		115	/*
		116	* Fixpoint numbers
		117	*/
		118	typedef int64_t pixman_fixed_32_32_t;
		119	typedef pixman_fixed_32_32_t pixman_fixed_48_16_t;
		120	typedef uint32_t pixman_fixed_1_31_t;
		121	typedef uint32_t pixman_fixed_1_16_t;
		122	typedef int32_t pixman_fixed_16_16_t;
		123	typedef pixman_fixed_16_16_t pixman_fixed_t;
		124
		125	#define pixman_fixed_e ((pixman_fixed_t) 1)
		126	#define pixman_fixed_1 (pixman_int_to_fixed(1))
		127	#define pixman_fixed_1_minus_e (pixman_fixed_1 - pixman_fixed_e)
		128	#define pixman_fixed_minus_1 (pixman_int_to_fixed(-1))
		129	#define pixman_fixed_to_int(f) ((int) ((f) >> 16))
		130	#define pixman_int_to_fixed(i) ((pixman_fixed_t) ((i) << 16))
		131	#define pixman_fixed_to_double(f) (double) ((f) / (double) pixman_fixed_1)
		132	#define pixman_double_to_fixed(d) ((pixman_fixed_t) ((d) * 65536.0))
		133	#define pixman_fixed_frac(f) ((f) & pixman_fixed_1_minus_e)
		134	#define pixman_fixed_floor(f) ((f) & ~pixman_fixed_1_minus_e)
		135	#define pixman_fixed_ceil(f) pixman_fixed_floor ((f) + pixman_fixed_1_minus_e)
		136	#define pixman_fixed_fraction(f) ((f) & pixman_fixed_1_minus_e)
		137	#define pixman_fixed_mod_2(f) ((f) & (pixman_fixed1 \| pixman_fixed_1_minus_e))
		138	#define pixman_max_fixed_48_16 ((pixman_fixed_48_16_t) 0x7fffffff)
		139	#define pixman_min_fixed_48_16 (-((pixman_fixed_48_16_t) 1 << 31))
		140
		141	/*
		142	* Misc structs
		143	*/
		144	typedef struct pixman_color pixman_color_t;
		145	typedef struct pixman_point_fixed pixman_point_fixed_t;
		146	typedef struct pixman_line_fixed pixman_line_fixed_t;
		147	typedef struct pixman_vector pixman_vector_t;
		148	typedef struct pixman_transform pixman_transform_t;
		149
		150	struct pixman_color
		151	{
		152	uint16_t red;
		153	uint16_t green;
		154	uint16_t blue;
		155	uint16_t alpha;
		156	};
		157
		158	struct pixman_point_fixed
		159	{
		160	pixman_fixed_t x;
		161	pixman_fixed_t y;
		162	};
		163
		164	struct pixman_line_fixed
		165	{
		166	pixman_point_fixed_t p1, p2;
		167	};
		168
		169	/*
		170	* Fixed point matrices
		171	*/
		172
		173	struct pixman_vector
		174	{
		175	pixman_fixed_t vector[3];
		176	};
		177
		178	struct pixman_transform
		179	{
		180	pixman_fixed_t matrix[3][3];
		181	};
		182
		183	/* forward declaration (sorry) */
		184	struct pixman_box16;
		185	typedef union pixman_image pixman_image_t;
		186
		187	void pixman_transform_init_identity (struct pixman_transform *matrix);
		188	pixman_bool_t pixman_transform_point_3d (const struct pixman_transform *transform,
		189	struct pixman_vector *vector);
		190	pixman_bool_t pixman_transform_point (const struct pixman_transform *transform,
		191	struct pixman_vector *vector);
		192	pixman_bool_t pixman_transform_multiply (struct pixman_transform *dst,
		193	const struct pixman_transform *l,
		194	const struct pixman_transform *r);
		195	void pixman_transform_init_scale (struct pixman_transform *t,
		196	pixman_fixed_t sx,
		197	pixman_fixed_t sy);
		198	pixman_bool_t pixman_transform_scale (struct pixman_transform *forward,
		199	struct pixman_transform *reverse,
		200	pixman_fixed_t sx,
		201	pixman_fixed_t sy);
		202	void pixman_transform_init_rotate (struct pixman_transform *t,
		203	pixman_fixed_t cos,
		204	pixman_fixed_t sin);
		205	pixman_bool_t pixman_transform_rotate (struct pixman_transform *forward,
		206	struct pixman_transform *reverse,
		207	pixman_fixed_t c,
		208	pixman_fixed_t s);
		209	void pixman_transform_init_translate (struct pixman_transform *t,
		210	pixman_fixed_t tx,
		211	pixman_fixed_t ty);
		212	pixman_bool_t pixman_transform_translate (struct pixman_transform *forward,
		213	struct pixman_transform *reverse,
		214	pixman_fixed_t tx,
		215	pixman_fixed_t ty);
		216	pixman_bool_t pixman_transform_bounds (const struct pixman_transform *matrix,
		217	struct pixman_box16 *b);
		218	pixman_bool_t pixman_transform_invert (struct pixman_transform *dst,
		219	const struct pixman_transform *src);
		220	pixman_bool_t pixman_transform_is_identity (const struct pixman_transform *t);
		221	pixman_bool_t pixman_transform_is_scale (const struct pixman_transform *t);
		222	pixman_bool_t pixman_transform_is_int_translate (const struct pixman_transform *t);
		223	pixman_bool_t pixman_transform_is_inverse (const struct pixman_transform *a,
		224	const struct pixman_transform *b);
		225
		226	/*
		227	* Floating point matrices
		228	*/
		229	struct pixman_f_vector
		230	{
		231	double v[3];
		232	};
		233
		234	struct pixman_f_transform
		235	{
		236	double m[3][3];
		237	};
		238
		239	pixman_bool_t pixman_transform_from_pixman_f_transform (struct pixman_transform *t,
		240	const struct pixman_f_transform *ft);
		241	void pixman_f_transform_from_pixman_transform (struct pixman_f_transform *ft,
		242	const struct pixman_transform *t);
		243	pixman_bool_t pixman_f_transform_invert (struct pixman_f_transform *dst,
		244	const struct pixman_f_transform *src);
		245	pixman_bool_t pixman_f_transform_point (const struct pixman_f_transform *t,
		246	struct pixman_f_vector *v);
		247	void pixman_f_transform_point_3d (const struct pixman_f_transform *t,
		248	struct pixman_f_vector *v);
		249	void pixman_f_transform_multiply (struct pixman_f_transform *dst,
		250	const struct pixman_f_transform *l,
		251	const struct pixman_f_transform *r);
		252	void pixman_f_transform_init_scale (struct pixman_f_transform *t,
		253	double sx,
		254	double sy);
		255	pixman_bool_t pixman_f_transform_scale (struct pixman_f_transform *forward,
		256	struct pixman_f_transform *reverse,
		257	double sx,
		258	double sy);
		259	void pixman_f_transform_init_rotate (struct pixman_f_transform *t,
		260	double cos,
		261	double sin);
		262	pixman_bool_t pixman_f_transform_rotate (struct pixman_f_transform *forward,
		263	struct pixman_f_transform *reverse,
		264	double c,
		265	double s);
		266	void pixman_f_transform_init_translate (struct pixman_f_transform *t,
		267	double tx,
		268	double ty);
		269	pixman_bool_t pixman_f_transform_translate (struct pixman_f_transform *forward,
		270	struct pixman_f_transform *reverse,
		271	double tx,
		272	double ty);
		273	pixman_bool_t pixman_f_transform_bounds (const struct pixman_f_transform *t,
		274	struct pixman_box16 *b);
		275	void pixman_f_transform_init_identity (struct pixman_f_transform *t);
		276
		277	typedef enum
		278	{
		279	PIXMAN_REPEAT_NONE,
		280	PIXMAN_REPEAT_NORMAL,
		281	PIXMAN_REPEAT_PAD,
		282	PIXMAN_REPEAT_REFLECT
		283	} pixman_repeat_t;
		284
		285	typedef enum
		286	{
		287	PIXMAN_FILTER_FAST,
		288	PIXMAN_FILTER_GOOD,
		289	PIXMAN_FILTER_BEST,
		290	PIXMAN_FILTER_NEAREST,
		291	PIXMAN_FILTER_BILINEAR,
		292	PIXMAN_FILTER_CONVOLUTION
		293	} pixman_filter_t;
		294
		295	typedef enum
		296	{
		297	PIXMAN_OP_CLEAR = 0x00,
		298	PIXMAN_OP_SRC = 0x01,
		299	PIXMAN_OP_DST = 0x02,
		300	PIXMAN_OP_OVER = 0x03,
		301	PIXMAN_OP_OVER_REVERSE = 0x04,
		302	PIXMAN_OP_IN = 0x05,
		303	PIXMAN_OP_IN_REVERSE = 0x06,
		304	PIXMAN_OP_OUT = 0x07,
		305	PIXMAN_OP_OUT_REVERSE = 0x08,
		306	PIXMAN_OP_ATOP = 0x09,
		307	PIXMAN_OP_ATOP_REVERSE = 0x0a,
		308	PIXMAN_OP_XOR = 0x0b,
		309	PIXMAN_OP_ADD = 0x0c,
		310	PIXMAN_OP_SATURATE = 0x0d,
		311
		312	PIXMAN_OP_DISJOINT_CLEAR = 0x10,
		313	PIXMAN_OP_DISJOINT_SRC = 0x11,
		314	PIXMAN_OP_DISJOINT_DST = 0x12,
		315	PIXMAN_OP_DISJOINT_OVER = 0x13,
		316	PIXMAN_OP_DISJOINT_OVER_REVERSE = 0x14,
		317	PIXMAN_OP_DISJOINT_IN = 0x15,
		318	PIXMAN_OP_DISJOINT_IN_REVERSE = 0x16,
		319	PIXMAN_OP_DISJOINT_OUT = 0x17,
		320	PIXMAN_OP_DISJOINT_OUT_REVERSE = 0x18,
		321	PIXMAN_OP_DISJOINT_ATOP = 0x19,
		322	PIXMAN_OP_DISJOINT_ATOP_REVERSE = 0x1a,
		323	PIXMAN_OP_DISJOINT_XOR = 0x1b,
		324
		325	PIXMAN_OP_CONJOINT_CLEAR = 0x20,
		326	PIXMAN_OP_CONJOINT_SRC = 0x21,
		327	PIXMAN_OP_CONJOINT_DST = 0x22,
		328	PIXMAN_OP_CONJOINT_OVER = 0x23,
		329	PIXMAN_OP_CONJOINT_OVER_REVERSE = 0x24,
		330	PIXMAN_OP_CONJOINT_IN = 0x25,
		331	PIXMAN_OP_CONJOINT_IN_REVERSE = 0x26,
		332	PIXMAN_OP_CONJOINT_OUT = 0x27,
		333	PIXMAN_OP_CONJOINT_OUT_REVERSE = 0x28,
		334	PIXMAN_OP_CONJOINT_ATOP = 0x29,
		335	PIXMAN_OP_CONJOINT_ATOP_REVERSE = 0x2a,
		336	PIXMAN_OP_CONJOINT_XOR = 0x2b,
		337
		338	PIXMAN_OP_MULTIPLY = 0x30,
		339	PIXMAN_OP_SCREEN = 0x31,
		340	PIXMAN_OP_OVERLAY = 0x32,
		341	PIXMAN_OP_DARKEN = 0x33,
		342	PIXMAN_OP_LIGHTEN = 0x34,
		343	PIXMAN_OP_COLOR_DODGE = 0x35,
		344	PIXMAN_OP_COLOR_BURN = 0x36,
		345	PIXMAN_OP_HARD_LIGHT = 0x37,
		346	PIXMAN_OP_SOFT_LIGHT = 0x38,
		347	PIXMAN_OP_DIFFERENCE = 0x39,
		348	PIXMAN_OP_EXCLUSION = 0x3a,
		349	PIXMAN_OP_HSL_HUE = 0x3b,
		350	PIXMAN_OP_HSL_SATURATION = 0x3c,
		351	PIXMAN_OP_HSL_COLOR = 0x3d,
		352	PIXMAN_OP_HSL_LUMINOSITY = 0x3e
		353
		354	#ifdef PIXMAN_USE_INTERNAL_API
		355	,
		356	PIXMAN_N_OPERATORS,
		357	PIXMAN_OP_NONE = PIXMAN_N_OPERATORS
		358	#endif
		359	} pixman_op_t;
		360
		361	/*
		362	* Regions
		363	*/
		364	typedef struct pixman_region16_data pixman_region16_data_t;
		365	typedef struct pixman_box16 pixman_box16_t;
		366	typedef struct pixman_rectangle16 pixman_rectangle16_t;
		367	typedef struct pixman_region16 pixman_region16_t;
		368
		369	struct pixman_region16_data {
		370	long size;
		371	long numRects;
		372	/* pixman_box16_t rects[size]; in memory but not explicitly declared */
		373	};
		374
		375	struct pixman_rectangle16
		376	{
		377	int16_t x, y;
		378	uint16_t width, height;
		379	};
		380
		381	struct pixman_box16
		382	{
		383	int16_t x1, y1, x2, y2;
		384	};
		385
		386	struct pixman_region16
		387	{
		388	pixman_box16_t extents;
		389	pixman_region16_data_t *data;
		390	};
		391
		392	typedef enum
		393	{
		394	PIXMAN_REGION_OUT,
		395	PIXMAN_REGION_IN,
		396	PIXMAN_REGION_PART
		397	} pixman_region_overlap_t;
		398
		399	/* This function exists only to make it possible to preserve
		400	* the X ABI - it should go away at first opportunity.
		401	*/
		402	void pixman_region_set_static_pointers (pixman_box16_t *empty_box,
		403	pixman_region16_data_t *empty_data,
		404	pixman_region16_data_t *broken_data);
		405
		406	/* creation/destruction */
		407	void pixman_region_init (pixman_region16_t *region);
		408	void pixman_region_init_rect (pixman_region16_t *region,
		409	int x,
		410	int y,
		411	unsigned int width,
		412	unsigned int height);
		413	pixman_bool_t pixman_region_init_rects (pixman_region16_t *region,
		414	const pixman_box16_t *boxes,
		415	int count);
		416	void pixman_region_init_with_extents (pixman_region16_t *region,
		417	pixman_box16_t *extents);
		418	void pixman_region_init_from_image (pixman_region16_t *region,
		419	pixman_image_t *image);
		420	void pixman_region_fini (pixman_region16_t *region);
		421
		422
		423	/* manipulation */
		424	void pixman_region_translate (pixman_region16_t *region,
		425	int x,
		426	int y);
		427	pixman_bool_t pixman_region_copy (pixman_region16_t *dest,
		428	pixman_region16_t *source);
		429	pixman_bool_t pixman_region_intersect (pixman_region16_t *new_reg,
		430	pixman_region16_t *reg1,
		431	pixman_region16_t *reg2);
		432	pixman_bool_t pixman_region_union (pixman_region16_t *new_reg,
		433	pixman_region16_t *reg1,
		434	pixman_region16_t *reg2);
		435	pixman_bool_t pixman_region_union_rect (pixman_region16_t *dest,
		436	pixman_region16_t *source,
		437	int x,
		438	int y,
		439	unsigned int width,
		440	unsigned int height);
		441	pixman_bool_t pixman_region_intersect_rect (pixman_region16_t *dest,
		442	pixman_region16_t *source,
		443	int x,
		444	int y,
		445	unsigned int width,
		446	unsigned int height);
		447	pixman_bool_t pixman_region_subtract (pixman_region16_t *reg_d,
		448	pixman_region16_t *reg_m,
		449	pixman_region16_t *reg_s);
		450	pixman_bool_t pixman_region_inverse (pixman_region16_t *new_reg,
		451	pixman_region16_t *reg1,
		452	pixman_box16_t *inv_rect);
		453	pixman_bool_t pixman_region_contains_point (pixman_region16_t *region,
		454	int x,
		455	int y,
		456	pixman_box16_t *box);
		457	pixman_region_overlap_t pixman_region_contains_rectangle (pixman_region16_t *region,
		458	pixman_box16_t *prect);
		459	pixman_bool_t pixman_region_not_empty (pixman_region16_t *region);
		460	pixman_box16_t * pixman_region_extents (pixman_region16_t *region);
		461	int pixman_region_n_rects (pixman_region16_t *region);
		462	pixman_box16_t * pixman_region_rectangles (pixman_region16_t *region,
		463	int *n_rects);
		464	pixman_bool_t pixman_region_equal (pixman_region16_t *region1,
		465	pixman_region16_t *region2);
		466	pixman_bool_t pixman_region_selfcheck (pixman_region16_t *region);
		467	void pixman_region_reset (pixman_region16_t *region,
		468	pixman_box16_t *box);
		469	/*
		470	* 32 bit regions
		471	*/
		472	typedef struct pixman_region32_data pixman_region32_data_t;
		473	typedef struct pixman_box32 pixman_box32_t;
		474	typedef struct pixman_rectangle32 pixman_rectangle32_t;
		475	typedef struct pixman_region32 pixman_region32_t;
		476
		477	struct pixman_region32_data {
		478	long size;
		479	long numRects;
		480	/* pixman_box32_t rects[size]; in memory but not explicitly declared */
		481	};
		482
		483	struct pixman_rectangle32
		484	{
		485	int32_t x, y;
		486	uint32_t width, height;
		487	};
		488
		489	struct pixman_box32
		490	{
		491	int32_t x1, y1, x2, y2;
		492	};
		493
		494	struct pixman_region32
		495	{
		496	pixman_box32_t extents;
		497	pixman_region32_data_t *data;
		498	};
		499
		500	/* creation/destruction */
		501	void pixman_region32_init (pixman_region32_t *region);
		502	void pixman_region32_init_rect (pixman_region32_t *region,
		503	int x,
		504	int y,
		505	unsigned int width,
		506	unsigned int height);
		507	pixman_bool_t pixman_region32_init_rects (pixman_region32_t *region,
		508	const pixman_box32_t *boxes,
		509	int count);
		510	void pixman_region32_init_with_extents (pixman_region32_t *region,
		511	pixman_box32_t *extents);
		512	void pixman_region32_init_from_image (pixman_region32_t *region,
		513	pixman_image_t *image);
		514	void pixman_region32_fini (pixman_region32_t *region);
		515
		516
		517	/* manipulation */
		518	void pixman_region32_translate (pixman_region32_t *region,
		519	int x,
		520	int y);
		521	pixman_bool_t pixman_region32_copy (pixman_region32_t *dest,
		522	pixman_region32_t *source);
		523	pixman_bool_t pixman_region32_intersect (pixman_region32_t *new_reg,
		524	pixman_region32_t *reg1,
		525	pixman_region32_t *reg2);
		526	pixman_bool_t pixman_region32_union (pixman_region32_t *new_reg,
		527	pixman_region32_t *reg1,
		528	pixman_region32_t *reg2);
		529	pixman_bool_t pixman_region32_intersect_rect (pixman_region32_t *dest,
		530	pixman_region32_t *source,
		531	int x,
		532	int y,
		533	unsigned int width,
		534	unsigned int height);
		535	pixman_bool_t pixman_region32_union_rect (pixman_region32_t *dest,
		536	pixman_region32_t *source,
		537	int x,
		538	int y,
		539	unsigned int width,
		540	unsigned int height);
		541	pixman_bool_t pixman_region32_subtract (pixman_region32_t *reg_d,
		542	pixman_region32_t *reg_m,
		543	pixman_region32_t *reg_s);
		544	pixman_bool_t pixman_region32_inverse (pixman_region32_t *new_reg,
		545	pixman_region32_t *reg1,
		546	pixman_box32_t *inv_rect);
		547	pixman_bool_t pixman_region32_contains_point (pixman_region32_t *region,
		548	int x,
		549	int y,
		550	pixman_box32_t *box);
		551	pixman_region_overlap_t pixman_region32_contains_rectangle (pixman_region32_t *region,
		552	pixman_box32_t *prect);
		553	pixman_bool_t pixman_region32_not_empty (pixman_region32_t *region);
		554	pixman_box32_t * pixman_region32_extents (pixman_region32_t *region);
		555	int pixman_region32_n_rects (pixman_region32_t *region);
		556	pixman_box32_t * pixman_region32_rectangles (pixman_region32_t *region,
		557	int *n_rects);
		558	pixman_bool_t pixman_region32_equal (pixman_region32_t *region1,
		559	pixman_region32_t *region2);
		560	pixman_bool_t pixman_region32_selfcheck (pixman_region32_t *region);
		561	void pixman_region32_reset (pixman_region32_t *region,
		562	pixman_box32_t *box);
		563
		564
		565	/* Copy / Fill / Misc */
		566	pixman_bool_t pixman_blt (uint32_t *src_bits,
		567	uint32_t *dst_bits,
		568	int src_stride,
		569	int dst_stride,
		570	int src_bpp,
		571	int dst_bpp,
		572	int src_x,
		573	int src_y,
		574	int dst_x,
		575	int dst_y,
		576	int width,
		577	int height);
		578	pixman_bool_t pixman_fill (uint32_t *bits,
		579	int stride,
		580	int bpp,
		581	int x,
		582	int y,
		583	int width,
		584	int height,
		585	uint32_t _xor);
		586
		587	int pixman_version (void);
		588	const char* pixman_version_string (void);
		589
		590	/*
		591	* Images
		592	*/
		593	typedef struct pixman_indexed pixman_indexed_t;
		594	typedef struct pixman_gradient_stop pixman_gradient_stop_t;
		595
		596	typedef uint32_t (* pixman_read_memory_func_t) (const void *src, int size);
		597	typedef void (* pixman_write_memory_func_t) (void *dst, uint32_t value, int size);
		598
		599	typedef void (* pixman_image_destroy_func_t) (pixman_image_t image, void data);
		600
		601	struct pixman_gradient_stop {
		602	pixman_fixed_t x;
		603	pixman_color_t color;
		604	};
		605
		606	#define PIXMAN_MAX_INDEXED 256 /* XXX depth must be <= 8 */
		607
		608	#if PIXMAN_MAX_INDEXED <= 256
		609	typedef uint8_t pixman_index_type;
		610	#endif
		611
		612	struct pixman_indexed
		613	{
		614	pixman_bool_t color;
		615	uint32_t rgba[PIXMAN_MAX_INDEXED];
		616	pixman_index_type ent[32768];
		617	};
		618
		619	/*
		620	* While the protocol is generous in format support, the
		621	* sample implementation allows only packed RGB and GBR
		622	* representations for data to simplify software rendering,
		623	*/
		624	#define PIXMAN_FORMAT(bpp,type,a,r,g,b) (((bpp) << 24) \| \
		625	((type) << 16) \| \
		626	((a) << 12) \| \
		627	((r) << 8) \| \
		628	((g) << 4) \| \
		629	((b)))
		630
		631	#define PIXMAN_FORMAT_BPP(f) (((f) >> 24) )
		632	#define PIXMAN_FORMAT_TYPE(f) (((f) >> 16) & 0xff)
		633	#define PIXMAN_FORMAT_A(f) (((f) >> 12) & 0x0f)
		634	#define PIXMAN_FORMAT_R(f) (((f) >> 8) & 0x0f)
		635	#define PIXMAN_FORMAT_G(f) (((f) >> 4) & 0x0f)
		636	#define PIXMAN_FORMAT_B(f) (((f) ) & 0x0f)
		637	#define PIXMAN_FORMAT_RGB(f) (((f) ) & 0xfff)
		638	#define PIXMAN_FORMAT_VIS(f) (((f) ) & 0xffff)
		639	#define PIXMAN_FORMAT_DEPTH(f) (PIXMAN_FORMAT_A(f) + \
		640	PIXMAN_FORMAT_R(f) + \
		641	PIXMAN_FORMAT_G(f) + \
		642	PIXMAN_FORMAT_B(f))
		643
		644	#define PIXMAN_TYPE_OTHER 0
		645	#define PIXMAN_TYPE_A 1
		646	#define PIXMAN_TYPE_ARGB 2
		647	#define PIXMAN_TYPE_ABGR 3
		648	#define PIXMAN_TYPE_COLOR 4
		649	#define PIXMAN_TYPE_GRAY 5
		650	#define PIXMAN_TYPE_YUY2 6
		651	#define PIXMAN_TYPE_YV12 7
		652	#define PIXMAN_TYPE_BGRA 8
		653
		654	#define PIXMAN_FORMAT_COLOR(f) \
		655	(PIXMAN_FORMAT_TYPE(f) == PIXMAN_TYPE_ARGB \|\| \
		656	PIXMAN_FORMAT_TYPE(f) == PIXMAN_TYPE_ABGR \|\| \
		657	PIXMAN_FORMAT_TYPE(f) == PIXMAN_TYPE_BGRA)
		658
		659	/* 32bpp formats */
		660	typedef enum {
		661	PIXMAN_a8r8g8b8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,8,8,8,8),
		662	PIXMAN_x8r8g8b8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,0,8,8,8),
		663	PIXMAN_a8b8g8r8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,8,8,8,8),
		664	PIXMAN_x8b8g8r8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,0,8,8,8),
		665	PIXMAN_b8g8r8a8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_BGRA,8,8,8,8),
		666	PIXMAN_b8g8r8x8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_BGRA,0,8,8,8),
		667	PIXMAN_x14r6g6b6 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,0,6,6,6),
		668	PIXMAN_x2r10g10b10 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,0,10,10,10),
		669	PIXMAN_a2r10g10b10 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,2,10,10,10),
		670	PIXMAN_x2b10g10r10 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,0,10,10,10),
		671	PIXMAN_a2b10g10r10 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,2,10,10,10),
		672
		673	/* 24bpp formats */
		674	PIXMAN_r8g8b8 = PIXMAN_FORMAT(24,PIXMAN_TYPE_ARGB,0,8,8,8),
		675	PIXMAN_b8g8r8 = PIXMAN_FORMAT(24,PIXMAN_TYPE_ABGR,0,8,8,8),
		676
		677	/* 16bpp formats */
		678	PIXMAN_r5g6b5 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,0,5,6,5),
		679	PIXMAN_b5g6r5 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,0,5,6,5),
		680
		681	PIXMAN_a1r5g5b5 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,1,5,5,5),
		682	PIXMAN_x1r5g5b5 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,0,5,5,5),
		683	PIXMAN_a1b5g5r5 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,1,5,5,5),
		684	PIXMAN_x1b5g5r5 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,0,5,5,5),
		685	PIXMAN_a4r4g4b4 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,4,4,4,4),
		686	PIXMAN_x4r4g4b4 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,0,4,4,4),
		687	PIXMAN_a4b4g4r4 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,4,4,4,4),
		688	PIXMAN_x4b4g4r4 = PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,0,4,4,4),
		689
		690	/* 8bpp formats */
		691	PIXMAN_a8 = PIXMAN_FORMAT(8,PIXMAN_TYPE_A,8,0,0,0),
		692	PIXMAN_r3g3b2 = PIXMAN_FORMAT(8,PIXMAN_TYPE_ARGB,0,3,3,2),
		693	PIXMAN_b2g3r3 = PIXMAN_FORMAT(8,PIXMAN_TYPE_ABGR,0,3,3,2),
		694	PIXMAN_a2r2g2b2 = PIXMAN_FORMAT(8,PIXMAN_TYPE_ARGB,2,2,2,2),
		695	PIXMAN_a2b2g2r2 = PIXMAN_FORMAT(8,PIXMAN_TYPE_ABGR,2,2,2,2),
		696
		697	PIXMAN_c8 = PIXMAN_FORMAT(8,PIXMAN_TYPE_COLOR,0,0,0,0),
		698	PIXMAN_g8 = PIXMAN_FORMAT(8,PIXMAN_TYPE_GRAY,0,0,0,0),
		699
		700	PIXMAN_x4a4 = PIXMAN_FORMAT(8,PIXMAN_TYPE_A,4,0,0,0),
		701
		702	PIXMAN_x4c4 = PIXMAN_FORMAT(8,PIXMAN_TYPE_COLOR,0,0,0,0),
		703	PIXMAN_x4g4 = PIXMAN_FORMAT(8,PIXMAN_TYPE_GRAY,0,0,0,0),
		704
		705	/* 4bpp formats */
		706	PIXMAN_a4 = PIXMAN_FORMAT(4,PIXMAN_TYPE_A,4,0,0,0),
		707	PIXMAN_r1g2b1 = PIXMAN_FORMAT(4,PIXMAN_TYPE_ARGB,0,1,2,1),
		708	PIXMAN_b1g2r1 = PIXMAN_FORMAT(4,PIXMAN_TYPE_ABGR,0,1,2,1),
		709	PIXMAN_a1r1g1b1 = PIXMAN_FORMAT(4,PIXMAN_TYPE_ARGB,1,1,1,1),
		710	PIXMAN_a1b1g1r1 = PIXMAN_FORMAT(4,PIXMAN_TYPE_ABGR,1,1,1,1),
		711
		712	PIXMAN_c4 = PIXMAN_FORMAT(4,PIXMAN_TYPE_COLOR,0,0,0,0),
		713	PIXMAN_g4 = PIXMAN_FORMAT(4,PIXMAN_TYPE_GRAY,0,0,0,0),
		714
		715	/* 1bpp formats */
		716	PIXMAN_a1 = PIXMAN_FORMAT(1,PIXMAN_TYPE_A,1,0,0,0),
		717
		718	PIXMAN_g1 = PIXMAN_FORMAT(1,PIXMAN_TYPE_GRAY,0,0,0,0),
		719
		720	/* YUV formats */
		721	PIXMAN_yuy2 = PIXMAN_FORMAT(16,PIXMAN_TYPE_YUY2,0,0,0,0),
		722	PIXMAN_yv12 = PIXMAN_FORMAT(12,PIXMAN_TYPE_YV12,0,0,0,0)
		723	} pixman_format_code_t;
		724
		725	/* Querying supported format values. */
		726	pixman_bool_t pixman_format_supported_destination (pixman_format_code_t format);
		727	pixman_bool_t pixman_format_supported_source (pixman_format_code_t format);
		728
		729	/* Constructors */
		730	pixman_image_t pixman_image_create_solid_fill (pixman_color_t color);
		731	pixman_image_t pixman_image_create_linear_gradient (pixman_point_fixed_t p1,
		732	pixman_point_fixed_t *p2,
		733	const pixman_gradient_stop_t *stops,
		734	int n_stops);
		735	pixman_image_t pixman_image_create_radial_gradient (pixman_point_fixed_t inner,
		736	pixman_point_fixed_t *outer,
		737	pixman_fixed_t inner_radius,
		738	pixman_fixed_t outer_radius,
		739	const pixman_gradient_stop_t *stops,
		740	int n_stops);
		741	pixman_image_t pixman_image_create_conical_gradient (pixman_point_fixed_t center,
		742	pixman_fixed_t angle,
		743	const pixman_gradient_stop_t *stops,
		744	int n_stops);
		745	pixman_image_t *pixman_image_create_bits (pixman_format_code_t format,
		746	int width,
		747	int height,
		748	uint32_t *bits,
		749	int rowstride_bytes);
		750
		751	/* Destructor */
		752	pixman_image_t pixman_image_ref (pixman_image_t image);
		753	pixman_bool_t pixman_image_unref (pixman_image_t *image);
		754
		755	void pixman_image_set_destroy_function (pixman_image_t *image,
		756	pixman_image_destroy_func_t function,
		757	void *data);
		758	void * pixman_image_get_destroy_data (pixman_image_t *image);
		759
		760	/* Set properties */
		761	pixman_bool_t pixman_image_set_clip_region (pixman_image_t *image,
		762	pixman_region16_t *region);
		763	pixman_bool_t pixman_image_set_clip_region32 (pixman_image_t *image,
		764	pixman_region32_t *region);
		765	void pixman_image_set_has_client_clip (pixman_image_t *image,
		766	pixman_bool_t clien_clip);
		767	pixman_bool_t pixman_image_set_transform (pixman_image_t *image,
		768	const pixman_transform_t *transform);
		769	void pixman_image_set_repeat (pixman_image_t *image,
		770	pixman_repeat_t repeat);
		771	pixman_bool_t pixman_image_set_filter (pixman_image_t *image,
		772	pixman_filter_t filter,
		773	const pixman_fixed_t *filter_params,
		774	int n_filter_params);
		775	void pixman_image_set_source_clipping (pixman_image_t *image,
		776	pixman_bool_t source_clipping);
		777	void pixman_image_set_alpha_map (pixman_image_t *image,
		778	pixman_image_t *alpha_map,
		779	int16_t x,
		780	int16_t y);
		781	void pixman_image_set_component_alpha (pixman_image_t *image,
		782	pixman_bool_t component_alpha);
		783	pixman_bool_t pixman_image_get_component_alpha (pixman_image_t *image);
		784	void pixman_image_set_accessors (pixman_image_t *image,
		785	pixman_read_memory_func_t read_func,
		786	pixman_write_memory_func_t write_func);
		787	void pixman_image_set_indexed (pixman_image_t *image,
		788	const pixman_indexed_t *indexed);
		789	uint32_t pixman_image_get_data (pixman_image_t image);
		790	int pixman_image_get_width (pixman_image_t *image);
		791	int pixman_image_get_height (pixman_image_t *image);
		792	int pixman_image_get_stride (pixman_image_t image); / in bytes */
		793	int pixman_image_get_depth (pixman_image_t *image);
		794	pixman_format_code_t pixman_image_get_format (pixman_image_t *image);
		795	pixman_bool_t pixman_image_fill_rectangles (pixman_op_t op,
		796	pixman_image_t *image,
		797	pixman_color_t *color,
		798	int n_rects,
		799	const pixman_rectangle16_t *rects);
		800	pixman_bool_t pixman_image_fill_boxes (pixman_op_t op,
		801	pixman_image_t *dest,
		802	pixman_color_t *color,
		803	int n_boxes,
		804	const pixman_box32_t *boxes);
		805
		806	/* Composite */
		807	pixman_bool_t pixman_compute_composite_region (pixman_region16_t *region,
		808	pixman_image_t *src_image,
		809	pixman_image_t *mask_image,
		810	pixman_image_t *dst_image,
		811	int16_t src_x,
		812	int16_t src_y,
		813	int16_t mask_x,
		814	int16_t mask_y,
		815	int16_t dest_x,
		816	int16_t dest_y,
		817	uint16_t width,
		818	uint16_t height);
		819	void pixman_image_composite (pixman_op_t op,
		820	pixman_image_t *src,
		821	pixman_image_t *mask,
		822	pixman_image_t *dest,
		823	int16_t src_x,
		824	int16_t src_y,
		825	int16_t mask_x,
		826	int16_t mask_y,
		827	int16_t dest_x,
		828	int16_t dest_y,
		829	uint16_t width,
		830	uint16_t height);
		831	void pixman_image_composite32 (pixman_op_t op,
		832	pixman_image_t *src,
		833	pixman_image_t *mask,
		834	pixman_image_t *dest,
		835	int32_t src_x,
		836	int32_t src_y,
		837	int32_t mask_x,
		838	int32_t mask_y,
		839	int32_t dest_x,
		840	int32_t dest_y,
		841	int32_t width,
		842	int32_t height);
		843
		844	/* Old X servers rely on out-of-bounds accesses when they are asked
		845	* to composite with a window as the source. They create a pixman image
		846	* pointing to some bogus position in memory, but then they set a clip
		847	* region to the position where the actual bits are.
		848	*
		849	* Due to a bug in old versions of pixman, where it would not clip
		850	* against the image bounds when a clip region was set, this would
		851	* actually work. So by default we allow certain out-of-bound access
		852	* to happen unless explicitly disabled.
		853	*
		854	* Fixed X servers should call this function to disable the workaround.
		855	*/
		856	void pixman_disable_out_of_bounds_workaround (void);
		857
		858	/*
		859	* Trapezoids
		860	*/
		861	typedef struct pixman_edge pixman_edge_t;
		862	typedef struct pixman_trapezoid pixman_trapezoid_t;
		863	typedef struct pixman_trap pixman_trap_t;
		864	typedef struct pixman_span_fix pixman_span_fix_t;
		865
		866	/*
		867	* An edge structure. This represents a single polygon edge
		868	* and can be quickly stepped across small or large gaps in the
		869	* sample grid
		870	*/
		871	struct pixman_edge
		872	{
		873	pixman_fixed_t x;
		874	pixman_fixed_t e;
		875	pixman_fixed_t stepx;
		876	pixman_fixed_t signdx;
		877	pixman_fixed_t dy;
		878	pixman_fixed_t dx;
		879
		880	pixman_fixed_t stepx_small;
		881	pixman_fixed_t stepx_big;
		882	pixman_fixed_t dx_small;
		883	pixman_fixed_t dx_big;
		884	};
		885
		886	struct pixman_trapezoid
		887	{
		888	pixman_fixed_t top, bottom;
		889	pixman_line_fixed_t left, right;
		890	};
		891
		892
		893	/* whether 't' is a well defined not obviously empty trapezoid */
		894	#define pixman_trapezoid_valid(t) \
		895	((t)->left.p1.y != (t)->left.p2.y && \
		896	(t)->right.p1.y != (t)->right.p2.y && \
		897	(int) ((t)->bottom - (t)->top) > 0)
		898
		899	struct pixman_span_fix
		900	{
		901	pixman_fixed_t l, r, y;
		902	};
		903
		904	struct pixman_trap
		905	{
		906	pixman_span_fix_t top, bot;
		907	};
		908
		909	pixman_fixed_t pixman_sample_ceil_y (pixman_fixed_t y,
		910	int bpp);
		911	pixman_fixed_t pixman_sample_floor_y (pixman_fixed_t y,
		912	int bpp);
		913	void pixman_edge_step (pixman_edge_t *e,
		914	int n);
		915	void pixman_edge_init (pixman_edge_t *e,
		916	int bpp,
		917	pixman_fixed_t y_start,
		918	pixman_fixed_t x_top,
		919	pixman_fixed_t y_top,
		920	pixman_fixed_t x_bot,
		921	pixman_fixed_t y_bot);
		922	void pixman_line_fixed_edge_init (pixman_edge_t *e,
		923	int bpp,
		924	pixman_fixed_t y,
		925	const pixman_line_fixed_t *line,
		926	int x_off,
		927	int y_off);
		928	void pixman_rasterize_edges (pixman_image_t *image,
		929	pixman_edge_t *l,
		930	pixman_edge_t *r,
		931	pixman_fixed_t t,
		932	pixman_fixed_t b);
		933	void pixman_add_traps (pixman_image_t *image,
		934	int16_t x_off,
		935	int16_t y_off,
		936	int ntrap,
		937	pixman_trap_t *traps);
		938	void pixman_add_trapezoids (pixman_image_t *image,
		939	int16_t x_off,
		940	int y_off,
		941	int ntraps,
		942	const pixman_trapezoid_t *traps);
		943	void pixman_rasterize_trapezoid (pixman_image_t *image,
		944	const pixman_trapezoid_t *trap,
		945	int x_off,
		946	int y_off);
		947
		948	PIXMAN_END_DECLS
		949
		950	#endif /* PIXMAN_H__ */

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/pixman/pixman.h @ 1907 – Rev