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