1 files changed, 0 insertions, 254 deletions
diff --git a/libraries/eina/src/include/eina_inline_rectangle.x b/libraries/eina/src/include/eina_inline_rectangle.x
deleted file mode 100644
index 29ad24b..0000000
--- a/libraries/eina/src/include/eina_inline_rectangle.x
+++ /dev/null
@@ -1,254 +0,0 @@
-/* EINA - EFL data type library
- * Copyright (C) 2007-2008 Jorge Luis Zapata Muga
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library;
- * if not, see <http://www.gnu.org/licenses/>.
- */
-#ifndef EINA_INLINE_RECTANGLE_H__
-#define EINA_INLINE_RECTANGLE_H__
-/**
- * @addtogroup Eina_Rectangle_Group Rectangle
- *
- * @brief These functions provide rectangle management.
- *
- * @{
- */
-/**
- * @brief Check if the given spans intersect.
- *
- * @param c1 The column of the first span.
- * @param l1 The length of the first span.
- * @param c2 The column of the second span.
- * @param l2 The length of the second span.
- * @return #EINA_TRUE on success, #EINA_FALSE otherwise.
- *
- * This function returns #EINA_TRUE if the  given spans intersect,
- * #EINA_FALSE otherwise.
- */
-static inline int
-eina_spans_intersect(int c1, int l1, int c2, int l2)
-{
-        return (!(((c2 + l2) <= c1) || (c2 >= (c1 + l1))));
-}
-/**
- * @brief Check if the given rectangle is empty.
- *
- * @param r The rectangle to check.
- * @return #EINA_TRUE if the rectangle is empty, #EINA_FALSE otherwise.
- *
- * This function returns #EINA_TRUE if @p r is empty, #EINA_FALSE
- * otherwise. No check is done on @p r, so it must be a valid
- * rectangle.
- */
-static inline Eina_Bool
-eina_rectangle_is_empty(const Eina_Rectangle *r)
-{
-        return ((r->w < 1) || (r->h < 1)) ? EINA_TRUE : EINA_FALSE;
-}
-/**
- * @brief Set the coordinates and size of the given rectangle.
- *
- * @param r The rectangle.
- * @param x The top-left x coordinate of the rectangle.
- * @param y The top-left y coordinate of the rectangle.
- * @param w The width of the rectangle.
- * @param h The height of the rectangle.
- *
- * This function sets its top-left x coordinate to @p x, its top-left
- * y coordinate to @p y, its width to @p w and its height to @p h. No
- * check is done on @p r, so it must be a valid rectangle.
- */
-static inline void
-eina_rectangle_coords_from(Eina_Rectangle *r, int x, int y, int w, int h)
-{
-        r->x = x;
-        r->y = y;
-        r->w = w;
-        r->h = h;
-}
-/**
- * @brief Check if the given rectangles intersect.
- *
- * @param r1 The first rectangle.
- * @param r2 The second rectangle.
- * @return #EINA_TRUE if the rectangles intersect, #EINA_FALSE otherwise.
- *
- * This function returns #EINA_TRUE if @p r1 and @p r2 intersect,
- * #EINA_FALSE otherwise. No check is done on @p r1 and @p r2, so they
- * must be valid rectangles.
- */
-static inline Eina_Bool
-eina_rectangles_intersect(const Eina_Rectangle *r1, const Eina_Rectangle *r2)
-{
-        return (eina_spans_intersect(r1->x, r1->w, r2->x, r2->w) && eina_spans_intersect(r1->y, r1->h, r2->y, r2->h)) ? EINA_TRUE : EINA_FALSE;
-}
-/**
- * @brief Check if the given x-coordinate is in the rectangle .
- *
- * @param r The rectangle.
- * @param x The x coordinate.
- * @return #EINA_TRUE on success, #EINA_FALSE otherwise.
- *
- * This function returns #EINA_TRUE if @p x is in @p r with respect to
- * the horizontal direction, #EINA_FALSE otherwise. No check is done
- * on @p r, so it must be a valid rectangle.
- */
-static inline Eina_Bool
-eina_rectangle_xcoord_inside(const Eina_Rectangle *r, int x)
-{
-        return ((x >= r->x) && (x < (r->x + r->w))) ? EINA_TRUE : EINA_FALSE;
-}
-/**
- * @brief Check if the given y-coordinate is in the rectangle .
- *
- * @param r The rectangle.
- * @param y The y coordinate.
- * @return #EINA_TRUE on success, #EINA_FALSE otherwise.
- *
- * This function returns #EINA_TRUE if @p y is in @p r with respect to
- * the vertical direction, #EINA_FALSE otherwise. No check is done
- * on @p r, so it must be a valid rectangle.
- */
-static inline Eina_Bool
-eina_rectangle_ycoord_inside(const Eina_Rectangle *r, int y)
-{
-        return ((y >= r->y) && (y < (r->y + r->h))) ? EINA_TRUE : EINA_FALSE;
-}
-/**
- * @brief Check if the given point is in the rectangle .
- *
- * @param r The rectangle.
- * @param x The x coordinate of the point.
- * @param y The y coordinate of the point.
- * @return #EINA_TRUE on success, #EINA_FALSE otherwise.
- *
- * This function returns #EINA_TRUE if the point of coordinate (@p x,
- * @p y) is in @p r, #EINA_FALSE otherwise. No check is done on @p r,
- * so it must be a valid rectangle.
- */
-static inline Eina_Bool
-eina_rectangle_coords_inside(const Eina_Rectangle *r, int x, int y)
-{
-        return (eina_rectangle_xcoord_inside(r, x) && eina_rectangle_ycoord_inside(r, y)) ? EINA_TRUE : EINA_FALSE;
-}
-/**
- * @brief Get the union of two rectangles.
- *
- * @param dst The first rectangle.
- * @param src The second rectangle.
- *
- * This function get the union of the rectangles @p dst and @p src. The
- * result is stored in @p dst. No check is done on @p dst or @p src,
- * so they must be valid rectangles.
- */
-static inline void
-eina_rectangle_union(Eina_Rectangle *dst, const Eina_Rectangle *src)
-{
-        /* left */
-        if (dst->x > src->x)
-        {
-                dst->w += dst->x - src->x;
-                dst->x = src->x;
-        }
-        /* right */
-        if ((dst->x + dst->w) < (src->x + src->w))
-                dst->w = src->x + src->w;
-        /* top */
-        if (dst->y > src->y)
-        {
-                dst->h += dst->y - src->y;
-                dst->y = src->y;
-        }
-        /* bottom */
-        if ((dst->y + dst->h) < (src->y + src->h))
-                dst->h = src->y + src->h;
-}
-/**
- * @brief Get the intersection of two rectangles.
- *
- * @param dst The first rectangle.
- * @param src The second rectangle.
- * @return #EINA_TRUE if the rectangles intersect, #EINA_FALSE
- * otherwise.
- *
- * This function get the intersection of the rectangles @p dst and
- * @p src. The result is stored in @p dst. No check is done on @p dst
- * or @p src, so they must be valid rectangles.
- */
-static inline Eina_Bool
-eina_rectangle_intersection(Eina_Rectangle *dst, const Eina_Rectangle *src)
-{
-        if (!(eina_rectangles_intersect(dst, src)))
-                return EINA_FALSE;
-        /* left */
-        if (dst->x < src->x)
-        {
-                dst->w += dst->x - src->x;
-                dst->x = src->x;
-                if (dst->w < 0)
-                        dst->w = 0;
-        }
-        /* right */
-        if ((dst->x + dst->w) > (src->x + src->w))
-                dst->w = src->x + src->w - dst->x;
-        /* top */
-        if (dst->y < src->y)
-        {
-                dst->h += dst->y - src->y;
-                dst->y = src->y;
-                if (dst->h < 0)
-                        dst->h = 0;
-        }
-        /* bottom */
-        if ((dst->y + dst->h) > (src->y + src->h))
-                dst->h = src->y + src->h - dst->y;
-        return EINA_TRUE;
-}
-static inline void
-eina_rectangle_rescale_in(const Eina_Rectangle *out, const Eina_Rectangle *in, Eina_Rectangle *res)
-{
-        res->x = in->x - out->x;
-        res->y = in->y - out->y;
-        res->w = in->w;
-        res->h = in->h;
-}
-static inline void
-eina_rectangle_rescale_out(const Eina_Rectangle *out, const Eina_Rectangle *in, Eina_Rectangle *res)
-{
-        res->x = out->x + in->x;
-        res->y = out->y + in->y;
-        res->w = out->w;
-        res->h = out->h;
-}
-/**
- * @}
- */
-#endif

diff --git a/libraries/eina/src/include/eina_inline_rectangle.x b/libraries/eina/src/include/eina_inline_rectangle.x deleted file mode 100644 index 29ad24b..0000000 --- a/libraries/eina/src/include/eina_inline_rectangle.x +++ /dev/null
@@ -1,254 +0,0 @@
1	/* EINA - EFL data type library
2	* Copyright (C) 2007-2008 Jorge Luis Zapata Muga
3	*
4	* This library is free software; you can redistribute it and/or
5	* modify it under the terms of the GNU Lesser General Public
6	* License as published by the Free Software Foundation; either
7	* version 2.1 of the License, or (at your option) any later version.
8	*
9	* This library is distributed in the hope that it will be useful,
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12	* Lesser General Public License for more details.
13	*
14	* You should have received a copy of the GNU Lesser General Public
15	* License along with this library;
16	* if not, see <http://www.gnu.org/licenses/>.
17	*/
18
19	#ifndef EINA_INLINE_RECTANGLE_H__
20	#define EINA_INLINE_RECTANGLE_H__
21
22	/**
23	* @addtogroup Eina_Rectangle_Group Rectangle
24	*
25	* @brief These functions provide rectangle management.
26	*
27	* @{
28	*/
29
30	/**
31	* @brief Check if the given spans intersect.
32	*
33	* @param c1 The column of the first span.
34	* @param l1 The length of the first span.
35	* @param c2 The column of the second span.
36	* @param l2 The length of the second span.
37	* @return #EINA_TRUE on success, #EINA_FALSE otherwise.
38	*
39	* This function returns #EINA_TRUE if the given spans intersect,
40	* #EINA_FALSE otherwise.
41	*/
42	static inline int
43	eina_spans_intersect(int c1, int l1, int c2, int l2)
44	{
45	return (!(((c2 + l2) <= c1) \|\| (c2 >= (c1 + l1))));
46	}
47
48	/**
49	* @brief Check if the given rectangle is empty.
50	*
51	* @param r The rectangle to check.
52	* @return #EINA_TRUE if the rectangle is empty, #EINA_FALSE otherwise.
53	*
54	* This function returns #EINA_TRUE if @p r is empty, #EINA_FALSE
55	* otherwise. No check is done on @p r, so it must be a valid
56	* rectangle.
57	*/
58	static inline Eina_Bool
59	eina_rectangle_is_empty(const Eina_Rectangle *r)
60	{
61	return ((r->w < 1) \|\| (r->h < 1)) ? EINA_TRUE : EINA_FALSE;
62	}
63
64	/**
65	* @brief Set the coordinates and size of the given rectangle.
66	*
67	* @param r The rectangle.
68	* @param x The top-left x coordinate of the rectangle.
69	* @param y The top-left y coordinate of the rectangle.
70	* @param w The width of the rectangle.
71	* @param h The height of the rectangle.
72	*
73	* This function sets its top-left x coordinate to @p x, its top-left
74	* y coordinate to @p y, its width to @p w and its height to @p h. No
75	* check is done on @p r, so it must be a valid rectangle.
76	*/
77	static inline void
78	eina_rectangle_coords_from(Eina_Rectangle *r, int x, int y, int w, int h)
79	{
80	r->x = x;
81	r->y = y;
82	r->w = w;
83	r->h = h;
84	}
85
86	/**
87	* @brief Check if the given rectangles intersect.
88	*
89	* @param r1 The first rectangle.
90	* @param r2 The second rectangle.
91	* @return #EINA_TRUE if the rectangles intersect, #EINA_FALSE otherwise.
92	*
93	* This function returns #EINA_TRUE if @p r1 and @p r2 intersect,
94	* #EINA_FALSE otherwise. No check is done on @p r1 and @p r2, so they
95	* must be valid rectangles.
96	*/
97	static inline Eina_Bool
98	eina_rectangles_intersect(const Eina_Rectangle r1, const Eina_Rectangle r2)
99	{
100	return (eina_spans_intersect(r1->x, r1->w, r2->x, r2->w) && eina_spans_intersect(r1->y, r1->h, r2->y, r2->h)) ? EINA_TRUE : EINA_FALSE;
101	}
102
103	/**
104	* @brief Check if the given x-coordinate is in the rectangle .
105	*
106	* @param r The rectangle.
107	* @param x The x coordinate.
108	* @return #EINA_TRUE on success, #EINA_FALSE otherwise.
109	*
110	* This function returns #EINA_TRUE if @p x is in @p r with respect to
111	* the horizontal direction, #EINA_FALSE otherwise. No check is done
112	* on @p r, so it must be a valid rectangle.
113	*/
114	static inline Eina_Bool
115	eina_rectangle_xcoord_inside(const Eina_Rectangle *r, int x)
116	{
117	return ((x >= r->x) && (x < (r->x + r->w))) ? EINA_TRUE : EINA_FALSE;
118	}
119
120	/**
121	* @brief Check if the given y-coordinate is in the rectangle .
122	*
123	* @param r The rectangle.
124	* @param y The y coordinate.
125	* @return #EINA_TRUE on success, #EINA_FALSE otherwise.
126	*
127	* This function returns #EINA_TRUE if @p y is in @p r with respect to
128	* the vertical direction, #EINA_FALSE otherwise. No check is done
129	* on @p r, so it must be a valid rectangle.
130	*/
131	static inline Eina_Bool
132	eina_rectangle_ycoord_inside(const Eina_Rectangle *r, int y)
133	{
134	return ((y >= r->y) && (y < (r->y + r->h))) ? EINA_TRUE : EINA_FALSE;
135	}
136
137	/**
138	* @brief Check if the given point is in the rectangle .
139	*
140	* @param r The rectangle.
141	* @param x The x coordinate of the point.
142	* @param y The y coordinate of the point.
143	* @return #EINA_TRUE on success, #EINA_FALSE otherwise.
144	*
145	* This function returns #EINA_TRUE if the point of coordinate (@p x,
146	* @p y) is in @p r, #EINA_FALSE otherwise. No check is done on @p r,
147	* so it must be a valid rectangle.
148	*/
149	static inline Eina_Bool
150	eina_rectangle_coords_inside(const Eina_Rectangle *r, int x, int y)
151	{
152	return (eina_rectangle_xcoord_inside(r, x) && eina_rectangle_ycoord_inside(r, y)) ? EINA_TRUE : EINA_FALSE;
153	}
154
155	/**
156	* @brief Get the union of two rectangles.
157	*
158	* @param dst The first rectangle.
159	* @param src The second rectangle.
160	*
161	* This function get the union of the rectangles @p dst and @p src. The
162	* result is stored in @p dst. No check is done on @p dst or @p src,
163	* so they must be valid rectangles.
164	*/
165	static inline void
166	eina_rectangle_union(Eina_Rectangle dst, const Eina_Rectangle src)
167	{
168	/* left */
169	if (dst->x > src->x)
170	{
171	dst->w += dst->x - src->x;
172	dst->x = src->x;
173	}
174	/* right */
175	if ((dst->x + dst->w) < (src->x + src->w))
176	dst->w = src->x + src->w;
177	/* top */
178	if (dst->y > src->y)
179	{
180	dst->h += dst->y - src->y;
181	dst->y = src->y;
182	}
183	/* bottom */
184	if ((dst->y + dst->h) < (src->y + src->h))
185	dst->h = src->y + src->h;
186	}
187
188	/**
189	* @brief Get the intersection of two rectangles.
190	*
191	* @param dst The first rectangle.
192	* @param src The second rectangle.
193	* @return #EINA_TRUE if the rectangles intersect, #EINA_FALSE
194	* otherwise.
195	*
196	* This function get the intersection of the rectangles @p dst and
197	* @p src. The result is stored in @p dst. No check is done on @p dst
198	* or @p src, so they must be valid rectangles.
199	*/
200	static inline Eina_Bool
201	eina_rectangle_intersection(Eina_Rectangle dst, const Eina_Rectangle src)
202	{
203	if (!(eina_rectangles_intersect(dst, src)))
204	return EINA_FALSE;
205
206	/* left */
207	if (dst->x < src->x)
208	{
209	dst->w += dst->x - src->x;
210	dst->x = src->x;
211	if (dst->w < 0)
212	dst->w = 0;
213	}
214	/* right */
215	if ((dst->x + dst->w) > (src->x + src->w))
216	dst->w = src->x + src->w - dst->x;
217	/* top */
218	if (dst->y < src->y)
219	{
220	dst->h += dst->y - src->y;
221	dst->y = src->y;
222	if (dst->h < 0)
223	dst->h = 0;
224	}
225	/* bottom */
226	if ((dst->y + dst->h) > (src->y + src->h))
227	dst->h = src->y + src->h - dst->y;
228
229	return EINA_TRUE;
230	}
231
232	static inline void
233	eina_rectangle_rescale_in(const Eina_Rectangle out, const Eina_Rectangle in, Eina_Rectangle *res)
234	{
235	res->x = in->x - out->x;
236	res->y = in->y - out->y;
237	res->w = in->w;
238	res->h = in->h;
239	}
240
241	static inline void
242	eina_rectangle_rescale_out(const Eina_Rectangle out, const Eina_Rectangle in, Eina_Rectangle *res)
243	{
244	res->x = out->x + in->x;
245	res->y = out->y + in->y;
246	res->w = out->w;
247	res->h = out->h;
248	}
249
250	/**
251	* @}
252	*/
253
254	#endif