include/regionstr.h

   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 #ifndef REGIONSTRUCT_H
  48 #define REGIONSTRUCT_H
  49
  50 typedef struct pixman_region16 RegionRec, *RegionPtr;
  51
  52 #include "miscstruct.h"
  53
  54 /* Return values from RectIn() */
  55
  56 #define rgnOUT 0
  57 #define rgnIN  1
  58 #define rgnPART 2
  59
  60 #define NullRegion ((RegionPtr)0)
  61
  62 /*
  63  *   clip region
  64  */
  65
  66 typedef struct pixman_region16_data RegDataRec, *RegDataPtr;
  67
  68 extern _X_EXPORT BoxRec RegionEmptyBox;
  69 extern _X_EXPORT RegDataRec RegionEmptyData;
  70 extern _X_EXPORT RegDataRec RegionBrokenData;
  71 static inline Bool
  72 RegionNil(RegionPtr reg)
  73 {
  74     return ((reg)->data && !(reg)->data->numRects);
  75 }
  76
  77 /* not a region */
  78
  79 static inline Bool
  80 RegionNar(RegionPtr reg)
  81 {
  82     return ((reg)->data == &RegionBrokenData);
  83 }
  84
  85 static inline int
  86 RegionNumRects(RegionPtr reg)
  87 {
  88     return ((reg)->data ? (reg)->data->numRects : 1);
  89 }
  90
  91 static inline int
  92 RegionSize(RegionPtr reg)
  93 {
  94     return ((reg)->data ? (reg)->data->size : 0);
  95 }
  96
  97 static inline BoxPtr
  98 RegionRects(RegionPtr reg)
  99 {
 100     return ((reg)->data ? (BoxPtr) ((reg)->data + 1) : &(reg)->extents);
 101 }
 102
 103 static inline BoxPtr
 104 RegionBoxptr(RegionPtr reg)
 105 {
 106     return ((BoxPtr) ((reg)->data + 1));
 107 }
 108
 109 static inline BoxPtr
 110 RegionBox(RegionPtr reg, int i)
 111 {
 112     return (&RegionBoxptr(reg)[i]);
 113 }
 114
 115 static inline BoxPtr
 116 RegionTop(RegionPtr reg)
 117 {
 118     return RegionBox(reg, (reg)->data->numRects);
 119 }
 120
 121 static inline BoxPtr
 122 RegionEnd(RegionPtr reg)
 123 {
 124     return RegionBox(reg, (reg)->data->numRects - 1);
 125 }
 126
 127 static inline size_t
 128 RegionSizeof(int n)
 129 {
 130     return (sizeof(RegDataRec) + ((n) * sizeof(BoxRec)));
 131 }
 132
 133 static inline void
 134 RegionInit(RegionPtr _pReg, BoxPtr _rect, int _size)
 135 {
 136     if ((_rect) != NULL) {
 137         (_pReg)->extents = *(_rect);
 138         (_pReg)->data = (RegDataPtr) NULL;
 139     }
 140     else {
 141         (_pReg)->extents = RegionEmptyBox;
 142         if (((_size) > 1) && ((_pReg)->data =
 143                               (RegDataPtr) malloc(RegionSizeof(_size)))) {
 144             (_pReg)->data->size = (_size);
 145             (_pReg)->data->numRects = 0;
 146         }
 147         else
 148             (_pReg)->data = &RegionEmptyData;
 149     }
 150 }
 151
 152 static inline Bool
 153 RegionInitBoxes(RegionPtr pReg, BoxPtr boxes, int nBoxes)
 154 {
 155     return pixman_region_init_rects(pReg, boxes, nBoxes);
 156 }
 157
 158 static inline void
 159 RegionUninit(RegionPtr _pReg)
 160 {
 161     if ((_pReg)->data && (_pReg)->data->size) {
 162         free((_pReg)->data);
 163         (_pReg)->data = NULL;
 164     }
 165 }
 166
 167 static inline void
 168 RegionReset(RegionPtr _pReg, BoxPtr _pBox)
 169 {
 170     (_pReg)->extents = *(_pBox);
 171     RegionUninit(_pReg);
 172     (_pReg)->data = (RegDataPtr) NULL;
 173 }
 174
 175 static inline Bool
 176 RegionNotEmpty(RegionPtr _pReg)
 177 {
 178     return !RegionNil(_pReg);
 179 }
 180
 181 static inline Bool
 182 RegionBroken(RegionPtr _pReg)
 183 {
 184     return RegionNar(_pReg);
 185 }
 186
 187 static inline void
 188 RegionEmpty(RegionPtr _pReg)
 189 {
 190     RegionUninit(_pReg);
 191     (_pReg)->extents.x2 = (_pReg)->extents.x1;
 192     (_pReg)->extents.y2 = (_pReg)->extents.y1;
 193     (_pReg)->data = &RegionEmptyData;
 194 }
 195
 196 static inline BoxPtr
 197 RegionExtents(RegionPtr _pReg)
 198 {
 199     return (&(_pReg)->extents);
 200 }
 201
 202 static inline void
 203 RegionNull(RegionPtr _pReg)
 204 {
 205     (_pReg)->extents = RegionEmptyBox;
 206     (_pReg)->data = &RegionEmptyData;
 207 }
 208
 209 extern _X_EXPORT void InitRegions(void);
 210
 211 extern _X_EXPORT RegionPtr RegionCreate(BoxPtr /*rect */ ,
 212                                         int /*size */ );
 213
 214 extern _X_EXPORT void RegionDestroy(RegionPtr /*pReg */ );
 215
 216 static inline Bool
 217 RegionCopy(RegionPtr dst, RegionPtr src)
 218 {
 219     return pixman_region_copy(dst, src);
 220 }
 221
 222 static inline Bool
 223 RegionIntersect(RegionPtr newReg,       /* destination Region */
 224                 RegionPtr reg1, RegionPtr reg2  /* source regions     */
 225     )
 226 {
 227     return pixman_region_intersect(newReg, reg1, reg2);
 228 }
 229
 230 static inline Bool
 231 RegionUnion(RegionPtr newReg,   /* destination Region */
 232             RegionPtr reg1, RegionPtr reg2      /* source regions     */
 233     )
 234 {
 235     return pixman_region_union(newReg, reg1, reg2);
 236 }
 237
 238 extern _X_EXPORT Bool RegionAppend(RegionPtr /*dstrgn */ ,
 239                                    RegionPtr /*rgn */ );
 240
 241 extern _X_EXPORT Bool RegionValidate(RegionPtr /*badreg */ ,
 242                                      Bool * /*pOverlap */ );
 243
 244 extern _X_EXPORT RegionPtr RegionFromRects(int /*nrects */ ,
 245                                            xRectanglePtr /*prect */ ,
 246                                            int /*ctype */ );
 247
 248 /*-
 249  *-----------------------------------------------------------------------
 250  * Subtract --
 251  *      Subtract regS from regM and leave the result in regD.
 252  *      S stands for subtrahend, M for minuend and D for difference.
 253  *
 254  * Results:
 255  *      TRUE if successful.
 256  *
 257  * Side Effects:
 258  *      regD is overwritten.
 259  *
 260  *-----------------------------------------------------------------------
 261  */
 262 static inline Bool
 263 RegionSubtract(RegionPtr regD, RegionPtr regM, RegionPtr regS)
 264 {
 265     return pixman_region_subtract(regD, regM, regS);
 266 }
 267
 268 /*-
 269  *-----------------------------------------------------------------------
 270  * Inverse --
 271  *      Take a region and a box and return a region that is everything
 272  *      in the box but not in the region. The careful reader will note
 273  *      that this is the same as subtracting the region from the box...
 274  *
 275  * Results:
 276  *      TRUE.
 277  *
 278  * Side Effects:
 279  *      newReg is overwritten.
 280  *
 281  *-----------------------------------------------------------------------
 282  */
 283
 284 static inline Bool
 285 RegionInverse(RegionPtr newReg, /* Destination region */
 286               RegionPtr reg1,   /* Region to invert */
 287               BoxPtr invRect    /* Bounding box for inversion */
 288     )
 289 {
 290     return pixman_region_inverse(newReg, reg1, invRect);
 291 }
 292
 293 static inline int
 294 RegionContainsRect(RegionPtr region, BoxPtr prect)
 295 {
 296     return pixman_region_contains_rectangle(region, prect);
 297 }
 298
 299 /* TranslateRegion(pReg, x, y)
 300    translates in place
 301 */
 302
 303 static inline void
 304 RegionTranslate(RegionPtr pReg, int x, int y)
 305 {
 306     pixman_region_translate(pReg, x, y);
 307 }
 308
 309 extern _X_EXPORT Bool RegionBreak(RegionPtr /*pReg */ );
 310
 311 static inline Bool
 312 RegionContainsPoint(RegionPtr pReg, int x, int y, BoxPtr box    /* "return" value */
 313     )
 314 {
 315     return pixman_region_contains_point(pReg, x, y, box);
 316 }
 317
 318 static inline Bool
 319 RegionEqual(RegionPtr reg1, RegionPtr reg2)
 320 {
 321     return pixman_region_equal(reg1, reg2);
 322 }
 323
 324 extern _X_EXPORT Bool RegionRectAlloc(RegionPtr /*pRgn */ ,
 325                                       int       /*n */
 326     );
 327
 328 #ifdef DEBUG
 329 extern _X_EXPORT Bool RegionIsValid(RegionPtr   /*prgn */
 330     );
 331 #endif
 332
 333 extern _X_EXPORT void RegionPrint(RegionPtr /*pReg */ );
 334
 335 #define INCLUDE_LEGACY_REGION_DEFINES
 336 #ifdef INCLUDE_LEGACY_REGION_DEFINES
 337
 338 #define REGION_NIL                              RegionNil
 339 #define REGION_NAR                              RegionNar
 340 #define REGION_NUM_RECTS                        RegionNumRects
 341 #define REGION_SIZE                             RegionSize
 342 #define REGION_RECTS                            RegionRects
 343 #define REGION_BOXPTR                           RegionBoxptr
 344 #define REGION_BOX                              RegionBox
 345 #define REGION_TOP                              RegionTop
 346 #define REGION_END                              RegionEnd
 347 #define REGION_SZOF                             RegionSizeof
 348 #define BITMAP_TO_REGION                        BitmapToRegion
 349 #define REGION_CREATE(pScreen, r, s)            RegionCreate(r,s)
 350 #define REGION_COPY(pScreen, d, r)              RegionCopy(d, r)
 351 #define REGION_DESTROY(pScreen, r)              RegionDestroy(r)
 352 #define REGION_INTERSECT(pScreen, res, r1, r2)  RegionIntersect(res, r1, r2)
 353 #define REGION_UNION(pScreen, res, r1, r2)      RegionUnion(res, r1, r2)
 354 #define REGION_SUBTRACT(pScreen, res, r1, r2)   RegionSubtract(res, r1, r2)
 355 #define REGION_INVERSE(pScreen, n, r, b)        RegionInverse(n, r, b)
 356 #define REGION_TRANSLATE(pScreen, r, x, y)      RegionTranslate(r, x, y)
 357 #define RECT_IN_REGION(pScreen, r, b)           RegionContainsRect(r, b)
 358 #define POINT_IN_REGION(pScreen, r, x, y, b)    RegionContainsPoint(r, x, y, b)
 359 #define REGION_EQUAL(pScreen, r1, r2)           RegionEqual(r1, r2)
 360 #define REGION_APPEND(pScreen, d, r)            RegionAppend(d, r)
 361 #define REGION_VALIDATE(pScreen, r, o)          RegionValidate(r, o)
 362 #define RECTS_TO_REGION(pScreen, n, r, c)       RegionFromRects(n, r, c)
 363 #define REGION_BREAK(pScreen, r)                RegionBreak(r)
 364 #define REGION_INIT(pScreen, r, b, s)           RegionInit(r, b, s)
 365 #define REGION_UNINIT(pScreen, r)               RegionUninit(r)
 366 #define REGION_RESET(pScreen, r, b)             RegionReset(r, b)
 367 #define REGION_NOTEMPTY(pScreen, r)             RegionNotEmpty(r)
 368 #define REGION_BROKEN(pScreen, r)               RegionBroken(r)
 369 #define REGION_EMPTY(pScreen, r)                RegionEmpty(r)
 370 #define REGION_EXTENTS(pScreen, r)              RegionExtents(r)
 371 #define REGION_NULL(pScreen, r)                 RegionNull(r)
 372
 373 #endif                          /* INCLUDE_LEGACY_REGION_DEFINES */
 374 #endif                          /* REGIONSTRUCT_H */