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 extern _X_EXPORT RegionPtr RegionDuplicate(RegionPtr /* pOld */);
 217
 218 static inline Bool
 219 RegionCopy(RegionPtr dst, RegionPtr src)
 220 {
 221     return pixman_region_copy(dst, src);
 222 }
 223
 224 static inline Bool
 225 RegionIntersect(RegionPtr newReg,       /* destination Region */
 226                 RegionPtr reg1, RegionPtr reg2  /* source regions     */
 227     )
 228 {
 229     return pixman_region_intersect(newReg, reg1, reg2);
 230 }
 231
 232 static inline Bool
 233 RegionUnion(RegionPtr newReg,   /* destination Region */
 234             RegionPtr reg1, RegionPtr reg2      /* source regions     */
 235     )
 236 {
 237     return pixman_region_union(newReg, reg1, reg2);
 238 }
 239
 240 extern _X_EXPORT Bool RegionAppend(RegionPtr /*dstrgn */ ,
 241                                    RegionPtr /*rgn */ );
 242
 243 extern _X_EXPORT Bool RegionValidate(RegionPtr /*badreg */ ,
 244                                      Bool * /*pOverlap */ );
 245
 246 extern _X_EXPORT RegionPtr RegionFromRects(int /*nrects */ ,
 247                                            xRectanglePtr /*prect */ ,
 248                                            int /*ctype */ );
 249
 250 /*-
 251  *-----------------------------------------------------------------------
 252  * Subtract --
 253  *      Subtract regS from regM and leave the result in regD.
 254  *      S stands for subtrahend, M for minuend and D for difference.
 255  *
 256  * Results:
 257  *      TRUE if successful.
 258  *
 259  * Side Effects:
 260  *      regD is overwritten.
 261  *
 262  *-----------------------------------------------------------------------
 263  */
 264 static inline Bool
 265 RegionSubtract(RegionPtr regD, RegionPtr regM, RegionPtr regS)
 266 {
 267     return pixman_region_subtract(regD, regM, regS);
 268 }
 269
 270 /*-
 271  *-----------------------------------------------------------------------
 272  * Inverse --
 273  *      Take a region and a box and return a region that is everything
 274  *      in the box but not in the region. The careful reader will note
 275  *      that this is the same as subtracting the region from the box...
 276  *
 277  * Results:
 278  *      TRUE.
 279  *
 280  * Side Effects:
 281  *      newReg is overwritten.
 282  *
 283  *-----------------------------------------------------------------------
 284  */
 285
 286 static inline Bool
 287 RegionInverse(RegionPtr newReg, /* Destination region */
 288               RegionPtr reg1,   /* Region to invert */
 289               BoxPtr invRect    /* Bounding box for inversion */
 290     )
 291 {
 292     return pixman_region_inverse(newReg, reg1, invRect);
 293 }
 294
 295 static inline int
 296 RegionContainsRect(RegionPtr region, BoxPtr prect)
 297 {
 298     return pixman_region_contains_rectangle(region, prect);
 299 }
 300
 301 /* TranslateRegion(pReg, x, y)
 302    translates in place
 303 */
 304
 305 static inline void
 306 RegionTranslate(RegionPtr pReg, int x, int y)
 307 {
 308     pixman_region_translate(pReg, x, y);
 309 }
 310
 311 extern _X_EXPORT Bool RegionBreak(RegionPtr /*pReg */ );
 312
 313 static inline Bool
 314 RegionContainsPoint(RegionPtr pReg, int x, int y, BoxPtr box    /* "return" value */
 315     )
 316 {
 317     return pixman_region_contains_point(pReg, x, y, box);
 318 }
 319
 320 static inline Bool
 321 RegionEqual(RegionPtr reg1, RegionPtr reg2)
 322 {
 323     return pixman_region_equal(reg1, reg2);
 324 }
 325
 326 extern _X_EXPORT Bool RegionRectAlloc(RegionPtr /*pRgn */ ,
 327                                       int       /*n */
 328     );
 329
 330 #ifdef DEBUG
 331 extern _X_EXPORT Bool RegionIsValid(RegionPtr   /*prgn */
 332     );
 333 #endif
 334
 335 extern _X_EXPORT void RegionPrint(RegionPtr /*pReg */ );
 336
 337 #define INCLUDE_LEGACY_REGION_DEFINES
 338 #ifdef INCLUDE_LEGACY_REGION_DEFINES
 339
 340 #define REGION_NIL                              RegionNil
 341 #define REGION_NAR                              RegionNar
 342 #define REGION_NUM_RECTS                        RegionNumRects
 343 #define REGION_SIZE                             RegionSize
 344 #define REGION_RECTS                            RegionRects
 345 #define REGION_BOXPTR                           RegionBoxptr
 346 #define REGION_BOX                              RegionBox
 347 #define REGION_TOP                              RegionTop
 348 #define REGION_END                              RegionEnd
 349 #define REGION_SZOF                             RegionSizeof
 350 #define BITMAP_TO_REGION                        BitmapToRegion
 351 #define REGION_CREATE(pScreen, r, s)            RegionCreate(r,s)
 352 #define REGION_COPY(pScreen, d, r)              RegionCopy(d, r)
 353 #define REGION_DESTROY(pScreen, r)              RegionDestroy(r)
 354 #define REGION_INTERSECT(pScreen, res, r1, r2)  RegionIntersect(res, r1, r2)
 355 #define REGION_UNION(pScreen, res, r1, r2)      RegionUnion(res, r1, r2)
 356 #define REGION_SUBTRACT(pScreen, res, r1, r2)   RegionSubtract(res, r1, r2)
 357 #define REGION_INVERSE(pScreen, n, r, b)        RegionInverse(n, r, b)
 358 #define REGION_TRANSLATE(pScreen, r, x, y)      RegionTranslate(r, x, y)
 359 #define RECT_IN_REGION(pScreen, r, b)           RegionContainsRect(r, b)
 360 #define POINT_IN_REGION(pScreen, r, x, y, b)    RegionContainsPoint(r, x, y, b)
 361 #define REGION_EQUAL(pScreen, r1, r2)           RegionEqual(r1, r2)
 362 #define REGION_APPEND(pScreen, d, r)            RegionAppend(d, r)
 363 #define REGION_VALIDATE(pScreen, r, o)          RegionValidate(r, o)
 364 #define RECTS_TO_REGION(pScreen, n, r, c)       RegionFromRects(n, r, c)
 365 #define REGION_BREAK(pScreen, r)                RegionBreak(r)
 366 #define REGION_INIT(pScreen, r, b, s)           RegionInit(r, b, s)
 367 #define REGION_UNINIT(pScreen, r)               RegionUninit(r)
 368 #define REGION_RESET(pScreen, r, b)             RegionReset(r, b)
 369 #define REGION_NOTEMPTY(pScreen, r)             RegionNotEmpty(r)
 370 #define REGION_BROKEN(pScreen, r)               RegionBroken(r)
 371 #define REGION_EMPTY(pScreen, r)                RegionEmpty(r)
 372 #define REGION_EXTENTS(pScreen, r)              RegionExtents(r)
 373 #define REGION_NULL(pScreen, r)                 RegionNull(r)
 374
 375 #endif                          /* INCLUDE_LEGACY_REGION_DEFINES */
 376 #endif                          /* REGIONSTRUCT_H */