regionstr.h revision c1d44f47 
1/***********************************************************
2
3Copyright 1987, 1998  The Open Group
4
5Permission to use, copy, modify, distribute, and sell this software and its
6documentation for any purpose is hereby granted without fee, provided that
7the above copyright notice appear in all copies and that both that
8copyright notice and this permission notice appear in supporting
9documentation.
10
11The above copyright notice and this permission notice shall be included in
12all copies or substantial portions of the Software.
13
14THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
17OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
18AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
20
21Except as contained in this notice, the name of The Open Group shall not be
22used in advertising or otherwise to promote the sale, use or other dealings
23in this Software without prior written authorization from The Open Group.
24
25
26Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
27
28                        All Rights Reserved
29
30Permission to use, copy, modify, and distribute this software and its
31documentation for any purpose and without fee is hereby granted,
32provided that the above copyright notice appear in all copies and that
33both that copyright notice and this permission notice appear in
34supporting documentation, and that the name of Digital not be
35used in advertising or publicity pertaining to distribution of the
36software without specific, written prior permission.
37
38DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
39ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
40DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
41ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
42WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
43ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
44SOFTWARE.
45
46******************************************************************/
47
48#ifndef REGIONSTRUCT_H
49#define REGIONSTRUCT_H
50
51typedef struct pixman_region16 RegionRec, *RegionPtr;
52
53#include "miscstruct.h"
54
55/* Return values from RectIn() */
56
57#define rgnOUT 0
58#define rgnIN  1
59#define rgnPART 2
60
61#define NullRegion ((RegionPtr)0)
62
63/*
64 *   clip region
65 */
66
67typedef struct pixman_region16_data RegDataRec, *RegDataPtr;
68
69extern _X_EXPORT BoxRec RegionEmptyBox;
70extern _X_EXPORT RegDataRec RegionEmptyData;
71extern _X_EXPORT RegDataRec RegionBrokenData;
72static inline Bool RegionNil(RegionPtr reg) {
73    return ((reg)->data && !(reg)->data->numRects);
74}
75
76/* not a region */
77
78static inline Bool RegionNar(RegionPtr reg) {
79    return ((reg)->data == &RegionBrokenData);
80}
81
82static inline int RegionNumRects(RegionPtr reg) {
83    return ((reg)->data ? (reg)->data->numRects : 1);
84}
85
86static inline int RegionSize(RegionPtr reg) {
87    return ((reg)->data ? (reg)->data->size : 0);
88}
89
90static inline BoxPtr RegionRects(RegionPtr reg) {
91    return ((reg)->data ? (BoxPtr)((reg)->data + 1) : &(reg)->extents);
92}
93
94static inline BoxPtr RegionBoxptr(RegionPtr reg) {
95    return ((BoxPtr)((reg)->data + 1));
96}
97
98static inline BoxPtr RegionBox(RegionPtr reg, int i) {
99    return (&RegionBoxptr(reg)[i]);
100}
101
102static inline BoxPtr RegionTop(RegionPtr reg) {
103    return RegionBox(reg, (reg)->data->numRects);
104}
105
106static inline BoxPtr RegionEnd(RegionPtr reg) {
107    return RegionBox(reg, (reg)->data->numRects - 1);
108}
109
110static inline size_t RegionSizeof(int n) {
111    if (n < 0 || (size_t)n < ((INT_MAX - sizeof(RegDataRec)) / sizeof(BoxRec)))
112        return (sizeof(RegDataRec) + ((n) * sizeof(BoxRec)));
113    else
114        return 0;
115}
116
117static inline void RegionInit(RegionPtr _pReg, BoxPtr _rect, int _size)
118{
119    if ((_rect) != NULL)
120    {
121        (_pReg)->extents = *(_rect);
122        (_pReg)->data = (RegDataPtr)NULL;
123    }
124    else
125    {
126        size_t rgnSize;
127        (_pReg)->extents = RegionEmptyBox;
128        if (((_size) > 1) && ((rgnSize = RegionSizeof(_size)) > 0) &&
129            (((_pReg)->data = malloc(rgnSize)) != NULL)) {
130            (_pReg)->data->size = (_size);
131            (_pReg)->data->numRects = 0;
132        }
133        else
134            (_pReg)->data = &RegionEmptyData;
135    }
136}
137
138static inline void RegionUninit(RegionPtr _pReg)
139{
140    if ((_pReg)->data && (_pReg)->data->size) {
141	free((_pReg)->data);
142	(_pReg)->data = NULL;
143    }
144}
145
146static inline void RegionReset(RegionPtr _pReg, BoxPtr _pBox)
147{
148    (_pReg)->extents = *(_pBox);
149    RegionUninit(_pReg);
150    (_pReg)->data = (RegDataPtr)NULL;
151}
152
153static inline Bool RegionNotEmpty(RegionPtr _pReg) {
154    return !RegionNil(_pReg);
155}
156
157static inline Bool RegionBroken(RegionPtr _pReg) {
158    return RegionNar(_pReg);
159}
160
161static inline void RegionEmpty(RegionPtr _pReg)
162{
163    RegionUninit(_pReg);
164    (_pReg)->extents.x2 = (_pReg)->extents.x1;
165    (_pReg)->extents.y2 = (_pReg)->extents.y1;
166    (_pReg)->data = &RegionEmptyData;
167}
168
169static inline BoxPtr RegionExtents(RegionPtr _pReg)
170{
171    return (&(_pReg)->extents);
172}
173
174static inline void RegionNull(RegionPtr _pReg)
175{
176    (_pReg)->extents = RegionEmptyBox;
177    (_pReg)->data = &RegionEmptyData;
178}
179
180extern _X_EXPORT void InitRegions(void);
181
182extern _X_EXPORT RegionPtr RegionCreate(
183    BoxPtr /*rect*/,
184    int /*size*/);
185
186extern _X_EXPORT void RegionDestroy(
187    RegionPtr /*pReg*/);
188
189static inline Bool
190RegionCopy(RegionPtr dst, RegionPtr src)
191{
192    return pixman_region_copy (dst, src);
193}
194
195static inline Bool
196RegionIntersect(
197    RegionPtr	newReg,     /* destination Region */
198    RegionPtr	reg1,
199    RegionPtr	reg2        /* source regions     */
200    )
201{
202    return pixman_region_intersect (newReg, reg1, reg2);
203}
204
205static inline Bool
206RegionUnion(
207    RegionPtr	newReg,          /* destination Region */
208    RegionPtr	reg1,
209    RegionPtr	reg2             /* source regions     */
210    )
211{
212    return pixman_region_union (newReg, reg1, reg2);
213}
214
215extern _X_EXPORT Bool RegionAppend(
216    RegionPtr /*dstrgn*/,
217    RegionPtr /*rgn*/);
218
219extern _X_EXPORT Bool RegionValidate(
220    RegionPtr /*badreg*/,
221    Bool * /*pOverlap*/);
222
223extern _X_EXPORT RegionPtr RegionFromRects(
224    int /*nrects*/,
225    xRectanglePtr /*prect*/,
226    int /*ctype*/);
227
228/*-
229 *-----------------------------------------------------------------------
230 * Subtract --
231 *	Subtract regS from regM and leave the result in regD.
232 *	S stands for subtrahend, M for minuend and D for difference.
233 *
234 * Results:
235 *	TRUE if successful.
236 *
237 * Side Effects:
238 *	regD is overwritten.
239 *
240 *-----------------------------------------------------------------------
241 */
242static inline Bool
243RegionSubtract(RegionPtr regD, RegionPtr regM, RegionPtr regS)
244{
245    return pixman_region_subtract (regD, regM, regS);
246}
247
248/*-
249 *-----------------------------------------------------------------------
250 * Inverse --
251 *	Take a region and a box and return a region that is everything
252 *	in the box but not in the region. The careful reader will note
253 *	that this is the same as subtracting the region from the box...
254 *
255 * Results:
256 *	TRUE.
257 *
258 * Side Effects:
259 *	newReg is overwritten.
260 *
261 *-----------------------------------------------------------------------
262 */
263
264static inline Bool
265RegionInverse(
266    RegionPtr	  newReg,       /* Destination region */
267    RegionPtr	  reg1,         /* Region to invert */
268    BoxPtr	  invRect	/* Bounding box for inversion */
269    )
270{
271    return pixman_region_inverse (newReg, reg1, invRect);
272}
273
274static inline int
275RegionContainsRect(RegionPtr region, BoxPtr prect)
276{
277    return pixman_region_contains_rectangle (region, prect);
278}
279
280/* TranslateRegion(pReg, x, y)
281   translates in place
282*/
283
284static inline void
285RegionTranslate(RegionPtr pReg, int x, int y)
286{
287    pixman_region_translate (pReg, x, y);
288}
289
290extern _X_EXPORT Bool RegionBreak(
291    RegionPtr /*pReg*/);
292
293static inline Bool
294RegionContainsPoint(
295    RegionPtr pReg,
296    int x,
297    int y,
298    BoxPtr box      /* "return" value */
299    )
300{
301    return pixman_region_contains_point (pReg, x, y, box);
302}
303
304static inline Bool
305RegionEqual(RegionPtr reg1, RegionPtr reg2)
306{
307    return pixman_region_equal (reg1, reg2);
308}
309
310extern _X_EXPORT Bool RegionRectAlloc(
311    RegionPtr /*pRgn*/,
312    int /*n*/
313);
314
315#ifdef DEBUG
316extern _X_EXPORT Bool RegionIsValid(
317    RegionPtr /*prgn*/
318);
319#endif
320
321extern _X_EXPORT void RegionPrint(
322    RegionPtr /*pReg*/);
323
324extern _X_EXPORT int RegionClipSpans(
325    RegionPtr /*prgnDst*/,
326    DDXPointPtr /*ppt*/,
327    int * /*pwidth*/,
328    int /*nspans*/,
329    DDXPointPtr /*pptNew*/,
330    int * /*pwidthNew*/,
331    int /*fSorted*/
332);
333
334#define INCLUDE_LEGACY_REGION_DEFINES
335#ifdef INCLUDE_LEGACY_REGION_DEFINES
336
337#define REGION_NIL				RegionNil
338#define REGION_NAR				RegionNar
339#define REGION_NUM_RECTS			RegionNumRects
340#define REGION_SIZE				RegionSize
341#define REGION_RECTS				RegionRects
342#define REGION_BOXPTR				RegionBoxptr
343#define REGION_BOX				RegionBox
344#define REGION_TOP				RegionTop
345#define REGION_END				RegionEnd
346#define REGION_SZOF				RegionSizeof
347#define BITMAP_TO_REGION			BitmapToRegion
348#define REGION_CREATE(pScreen, r, s)		RegionCreate(r,s)
349#define REGION_COPY(pScreen, d, r)		RegionCopy(d, r)
350#define REGION_DESTROY(pScreen, r)		RegionDestroy(r)
351#define REGION_INTERSECT(pScreen, res, r1, r2)	RegionIntersect(res, r1, r2)
352#define REGION_UNION(pScreen, res, r1, r2)	RegionUnion(res, r1, r2)
353#define REGION_SUBTRACT(pScreen, res, r1, r2)	RegionSubtract(res, r1, r2)
354#define REGION_INVERSE(pScreen, n, r, b)	RegionInverse(n, r, b)
355#define REGION_TRANSLATE(pScreen, r, x, y)	RegionTranslate(r, x, y)
356#define RECT_IN_REGION(pScreen, r, b) 		RegionContainsRect(r, b)
357#define POINT_IN_REGION(pScreen, r, x, y, b) 	RegionContainsPoint(r, x, y, b)
358#define REGION_EQUAL(pScreen, r1, r2)		RegionEqual(r1, r2)
359#define REGION_APPEND(pScreen, d, r)		RegionAppend(d, r)
360#define REGION_VALIDATE(pScreen, r, o)		RegionValidate(r, o)
361#define RECTS_TO_REGION(pScreen, n, r, c)	RegionFromRects(n, r, c)
362#define REGION_BREAK(pScreen, r)		RegionBreak(r)
363#define REGION_INIT(pScreen, r, b, s)		RegionInit(r, b, s)
364#define REGION_UNINIT(pScreen, r)		RegionUninit(r)
365#define REGION_RESET(pScreen, r, b)		RegionReset(r, b)
366#define REGION_NOTEMPTY(pScreen, r)		RegionNotEmpty(r)
367#define REGION_BROKEN(pScreen, r)		RegionBroken(r)
368#define REGION_EMPTY(pScreen, r)		RegionEmpty(r)
369#define REGION_EXTENTS(pScreen, r)		RegionExtents(r)
370#define REGION_NULL(pScreen, r)			RegionNull(r)
371
372#endif /* INCLUDE_LEGACY_REGION_DEFINES */
373#endif /* REGIONSTRUCT_H */
374