From 4c61bf84b11e26e6f22648668c95ea760a379163 Mon Sep 17 00:00:00 2001 From: marha Date: Fri, 11 Jun 2010 12:14:52 +0000 Subject: xserver git update 11/6/2010 --- xorg-server/include/regionstr.h | 429 +++++++++++++++++++++++----------------- 1 file changed, 253 insertions(+), 176 deletions(-) (limited to 'xorg-server/include/regionstr.h') diff --git a/xorg-server/include/regionstr.h b/xorg-server/include/regionstr.h index d67873295..92f4ca9f2 100644 --- a/xorg-server/include/regionstr.h +++ b/xorg-server/include/regionstr.h @@ -66,228 +66,305 @@ typedef struct pixman_region16 RegionRec, *RegionPtr; typedef struct pixman_region16_data RegDataRec, *RegDataPtr; -extern _X_EXPORT BoxRec miEmptyBox; -extern _X_EXPORT RegDataRec miEmptyData; -extern _X_EXPORT RegDataRec miBrokenData; +extern _X_EXPORT BoxRec RegionEmptyBox; +extern _X_EXPORT RegDataRec RegionEmptyData; +extern _X_EXPORT RegDataRec RegionBrokenData; +static inline Bool RegionNil(RegionPtr reg) { + return ((reg)->data && !(reg)->data->numRects); +} -#define REGION_NIL(reg) ((reg)->data && !(reg)->data->numRects) /* not a region */ -#define REGION_NAR(reg) ((reg)->data == &miBrokenData) -#define REGION_NUM_RECTS(reg) ((reg)->data ? (reg)->data->numRects : 1) -#define REGION_SIZE(reg) ((reg)->data ? (reg)->data->size : 0) -#define REGION_RECTS(reg) ((reg)->data ? (BoxPtr)((reg)->data + 1) \ - : &(reg)->extents) -#define REGION_BOXPTR(reg) ((BoxPtr)((reg)->data + 1)) -#define REGION_BOX(reg,i) (®ION_BOXPTR(reg)[i]) -#define REGION_TOP(reg) REGION_BOX(reg, (reg)->data->numRects) -#define REGION_END(reg) REGION_BOX(reg, (reg)->data->numRects - 1) -#define REGION_SZOF(n) (sizeof(RegDataRec) + ((n) * sizeof(BoxRec))) - -#define REGION_CREATE(_pScreen, _rect, _size) \ - miRegionCreate(_rect, _size) - -#define REGION_COPY(_pScreen, dst, src) \ - miRegionCopy(dst, src) - -#define REGION_DESTROY(_pScreen, _pReg) \ - miRegionDestroy(_pReg) - -#define REGION_INTERSECT(_pScreen, newReg, reg1, reg2) \ - miIntersect(newReg, reg1, reg2) - -#define REGION_UNION(_pScreen, newReg, reg1, reg2) \ - miUnion(newReg, reg1, reg2) - -#define REGION_SUBTRACT(_pScreen, newReg, reg1, reg2) \ - miSubtract(newReg, reg1, reg2) - -#define REGION_INVERSE(_pScreen, newReg, reg1, invRect) \ - miInverse(newReg, reg1, invRect) - -#define REGION_TRANSLATE(_pScreen, _pReg, _x, _y) \ - miTranslateRegion(_pReg, _x, _y) - -#define RECT_IN_REGION(_pScreen, _pReg, prect) \ - miRectIn(_pReg, prect) - -#define POINT_IN_REGION(_pScreen, _pReg, _x, _y, prect) \ - miPointInRegion(_pReg, _x, _y, prect) - -#define REGION_APPEND(_pScreen, dstrgn, rgn) \ - miRegionAppend(dstrgn, rgn) - -#define REGION_VALIDATE(_pScreen, badreg, pOverlap) \ - miRegionValidate(badreg, pOverlap) - -#define BITMAP_TO_REGION(_pScreen, pPix) \ - (*(_pScreen)->BitmapToRegion)(pPix) /* no mi version?! */ - -#define RECTS_TO_REGION(_pScreen, nrects, prect, ctype) \ - miRectsToRegion(nrects, prect, ctype) - -#define REGION_EQUAL(_pScreen, _pReg1, _pReg2) \ - miRegionEqual(_pReg1, _pReg2) - -#define REGION_BREAK(_pScreen, _pReg) \ - miRegionBreak(_pReg) - -#define REGION_INIT(_pScreen, _pReg, _rect, _size) \ -{ \ - if ((_rect) != NULL) \ - { \ - (_pReg)->extents = *(_rect); \ - (_pReg)->data = (RegDataPtr)NULL; \ - } \ - else \ - { \ - (_pReg)->extents = miEmptyBox; \ - if (((_size) > 1) && ((_pReg)->data = \ - (RegDataPtr)malloc(REGION_SZOF(_size)))) \ - { \ - (_pReg)->data->size = (_size); \ - (_pReg)->data->numRects = 0; \ - } \ - else \ - (_pReg)->data = &miEmptyData; \ - } \ - } - - -#define REGION_UNINIT(_pScreen, _pReg) \ -{ \ - if ((_pReg)->data && (_pReg)->data->size) { \ - free((_pReg)->data); \ - (_pReg)->data = NULL; \ - } \ + +static inline Bool RegionNar(RegionPtr reg) { + return ((reg)->data == &RegionBrokenData); } -#define REGION_RESET(_pScreen, _pReg, _pBox) \ -{ \ - (_pReg)->extents = *(_pBox); \ - REGION_UNINIT(_pScreen, _pReg); \ - (_pReg)->data = (RegDataPtr)NULL; \ +static inline int RegionNumRects(RegionPtr reg) { + return ((reg)->data ? (reg)->data->numRects : 1); } -#define REGION_NOTEMPTY(_pScreen, _pReg) \ - !REGION_NIL(_pReg) +static inline int RegionSize(RegionPtr reg) { + return ((reg)->data ? (reg)->data->size : 0); +} -#define REGION_BROKEN(_pScreen, _pReg) \ - REGION_NAR(_pReg) +static inline BoxPtr RegionRects(RegionPtr reg) { + return ((reg)->data ? (BoxPtr)((reg)->data + 1) : &(reg)->extents); +} -#define REGION_EMPTY(_pScreen, _pReg) \ -{ \ - REGION_UNINIT(_pScreen, _pReg); \ - (_pReg)->extents.x2 = (_pReg)->extents.x1; \ - (_pReg)->extents.y2 = (_pReg)->extents.y1; \ - (_pReg)->data = &miEmptyData; \ +static inline BoxPtr RegionBoxptr(RegionPtr reg) { + return ((BoxPtr)((reg)->data + 1)); } -#define REGION_EXTENTS(_pScreen, _pReg) \ - (&(_pReg)->extents) +static inline BoxPtr RegionBox(RegionPtr reg, int i) { + return (&RegionBoxptr(reg)[i]); +} -#define REGION_NULL(_pScreen, _pReg) \ -{ \ - (_pReg)->extents = miEmptyBox; \ - (_pReg)->data = &miEmptyData; \ +static inline BoxPtr RegionTop(RegionPtr reg) { + return RegionBox(reg, (reg)->data->numRects); } -#ifndef REGION_NULL -#define REGION_NULL(_pScreen, _pReg) \ - REGION_INIT(_pScreen, _pReg, NullBox, 1) -#endif +static inline BoxPtr RegionEnd(RegionPtr reg) { + return RegionBox(reg, (reg)->data->numRects - 1); +} -/* moved from mi.h */ +static inline size_t RegionSizeof(int n) { + return (sizeof(RegDataRec) + ((n) * sizeof(BoxRec))); +} -extern _X_EXPORT void InitRegions (void); +static inline void RegionInit(RegionPtr _pReg, BoxPtr _rect, int _size) +{ + if ((_rect) != NULL) + { + (_pReg)->extents = *(_rect); + (_pReg)->data = (RegDataPtr)NULL; + } + else + { + (_pReg)->extents = RegionEmptyBox; + if (((_size) > 1) && ((_pReg)->data = + (RegDataPtr)malloc(RegionSizeof(_size)))) + { + (_pReg)->data->size = (_size); + (_pReg)->data->numRects = 0; + } + else + (_pReg)->data = &RegionEmptyData; + } +} -extern _X_EXPORT RegionPtr miRegionCreate( - BoxPtr /*rect*/, - int /*size*/); +static inline void RegionUninit(RegionPtr _pReg) +{ + if ((_pReg)->data && (_pReg)->data->size) { + free((_pReg)->data); + (_pReg)->data = NULL; + } +} + +static inline void RegionReset(RegionPtr _pReg, BoxPtr _pBox) +{ + (_pReg)->extents = *(_pBox); + RegionUninit(_pReg); + (_pReg)->data = (RegDataPtr)NULL; +} + +static inline Bool RegionNotEmpty(RegionPtr _pReg) { + return !RegionNil(_pReg); +} + +static inline Bool RegionBroken(RegionPtr _pReg) { + return RegionNar(_pReg); +} + +static inline void RegionEmpty(RegionPtr _pReg) +{ + RegionUninit(_pReg); + (_pReg)->extents.x2 = (_pReg)->extents.x1; + (_pReg)->extents.y2 = (_pReg)->extents.y1; + (_pReg)->data = &RegionEmptyData; +} + +static inline BoxPtr RegionExtents(RegionPtr _pReg) +{ + return (&(_pReg)->extents); +} -extern _X_EXPORT void miRegionInit( - RegionPtr /*pReg*/, +static inline void RegionNull(RegionPtr _pReg) +{ + (_pReg)->extents = RegionEmptyBox; + (_pReg)->data = &RegionEmptyData; +} + +extern _X_EXPORT void InitRegions(void); + +extern _X_EXPORT RegionPtr RegionCreate( BoxPtr /*rect*/, int /*size*/); -extern _X_EXPORT void miRegionDestroy( +extern _X_EXPORT void RegionDestroy( RegionPtr /*pReg*/); -extern _X_EXPORT void miRegionUninit( - RegionPtr /*pReg*/); - -extern _X_EXPORT Bool miRegionCopy( - RegionPtr /*dst*/, - RegionPtr /*src*/); +static inline Bool +RegionCopy(RegionPtr dst, RegionPtr src) +{ + return pixman_region_copy (dst, src); +} -extern _X_EXPORT Bool miIntersect( - RegionPtr /*newReg*/, - RegionPtr /*reg1*/, - RegionPtr /*reg2*/); +static inline Bool +RegionIntersect( + RegionPtr newReg, /* destination Region */ + RegionPtr reg1, + RegionPtr reg2 /* source regions */ + ) +{ + return pixman_region_intersect (newReg, reg1, reg2); +} -extern _X_EXPORT Bool miUnion( - RegionPtr /*newReg*/, - RegionPtr /*reg1*/, - RegionPtr /*reg2*/); +static inline Bool +RegionUnion( + RegionPtr newReg, /* destination Region */ + RegionPtr reg1, + RegionPtr reg2 /* source regions */ + ) +{ + return pixman_region_union (newReg, reg1, reg2); +} -extern _X_EXPORT Bool miRegionAppend( +extern _X_EXPORT Bool RegionAppend( RegionPtr /*dstrgn*/, RegionPtr /*rgn*/); -extern _X_EXPORT Bool miRegionValidate( +extern _X_EXPORT Bool RegionValidate( RegionPtr /*badreg*/, Bool * /*pOverlap*/); -extern _X_EXPORT RegionPtr miRectsToRegion( +extern _X_EXPORT RegionPtr RegionFromRects( int /*nrects*/, xRectanglePtr /*prect*/, int /*ctype*/); -extern _X_EXPORT Bool miSubtract( - RegionPtr /*regD*/, - RegionPtr /*regM*/, - RegionPtr /*regS*/); +/*- + *----------------------------------------------------------------------- + * Subtract -- + * Subtract regS from regM and leave the result in regD. + * S stands for subtrahend, M for minuend and D for difference. + * + * Results: + * TRUE if successful. + * + * Side Effects: + * regD is overwritten. + * + *----------------------------------------------------------------------- + */ +static inline Bool +RegionSubtract(RegionPtr regD, RegionPtr regM, RegionPtr regS) +{ + return pixman_region_subtract (regD, regM, regS); +} + +/*- + *----------------------------------------------------------------------- + * Inverse -- + * Take a region and a box and return a region that is everything + * in the box but not in the region. The careful reader will note + * that this is the same as subtracting the region from the box... + * + * Results: + * TRUE. + * + * Side Effects: + * newReg is overwritten. + * + *----------------------------------------------------------------------- + */ -extern _X_EXPORT Bool miInverse( - RegionPtr /*newReg*/, - RegionPtr /*reg1*/, - BoxPtr /*invRect*/); +static inline Bool +RegionInverse( + RegionPtr newReg, /* Destination region */ + RegionPtr reg1, /* Region to invert */ + BoxPtr invRect /* Bounding box for inversion */ + ) +{ + return pixman_region_inverse (newReg, reg1, invRect); +} -extern _X_EXPORT int miRectIn( - RegionPtr /*region*/, - BoxPtr /*prect*/); +static inline int +RegionContainsRect(RegionPtr region, BoxPtr prect) +{ + return pixman_region_contains_rectangle (region, prect); +} -extern _X_EXPORT void miTranslateRegion( - RegionPtr /*pReg*/, - int /*x*/, - int /*y*/); +/* TranslateRegion(pReg, x, y) + translates in place +*/ -extern _X_EXPORT void miRegionReset( - RegionPtr /*pReg*/, - BoxPtr /*pBox*/); +static inline void +RegionTranslate(RegionPtr pReg, int x, int y) +{ + pixman_region_translate (pReg, x, y); +} -extern _X_EXPORT Bool miRegionBreak( +extern _X_EXPORT Bool RegionBreak( RegionPtr /*pReg*/); -extern _X_EXPORT Bool miPointInRegion( - RegionPtr /*pReg*/, - int /*x*/, - int /*y*/, - BoxPtr /*box*/); - -extern _X_EXPORT Bool miRegionEqual( - RegionPtr /*pReg1*/, - RegionPtr /*pReg2*/); +static inline Bool +RegionContainsPoint( + RegionPtr pReg, + int x, + int y, + BoxPtr box /* "return" value */ + ) +{ + return pixman_region_contains_point (pReg, x, y, box); +} -extern _X_EXPORT Bool miRegionNotEmpty( - RegionPtr /*pReg*/); +static inline Bool +RegionEqual(RegionPtr reg1, RegionPtr reg2) +{ + return pixman_region_equal (reg1, reg2); +} -extern _X_EXPORT void miRegionEmpty( - RegionPtr /*pReg*/); +extern _X_EXPORT Bool RegionRectAlloc( + RegionPtr /*pRgn*/, + int /*n*/ +); -extern _X_EXPORT BoxPtr miRegionExtents( - RegionPtr /*pReg*/); +#ifdef DEBUG +extern _X_EXPORT Bool RegionIsValid( + RegionPtr /*prgn*/ +); +#endif -extern _X_EXPORT void miPrintRegion( +extern _X_EXPORT void RegionPrint( RegionPtr /*pReg*/); +extern _X_EXPORT int RegionClipSpans( + RegionPtr /*prgnDst*/, + DDXPointPtr /*ppt*/, + int * /*pwidth*/, + int /*nspans*/, + DDXPointPtr /*pptNew*/, + int * /*pwidthNew*/, + int /*fSorted*/ +); + +#define INCLUDE_LEGACY_REGION_DEFINES +#ifdef INCLUDE_LEGACY_REGION_DEFINES + +#define REGION_NIL RegionNil +#define REGION_NAR RegionNar +#define REGION_NUM_RECTS RegionNumRects +#define REGION_SIZE RegionSize +#define REGION_RECTS RegionRects +#define REGION_BOXPTR RegionBoxptr +#define REGION_BOX RegionBox +#define REGION_TOP RegionTop +#define REGION_END RegionEnd +#define REGION_SZOF RegionSizeof +#define BITMAP_TO_REGION BitmapToRegion +#define REGION_CREATE(pScreen, r, s) RegionCreate(r,s) +#define REGION_COPY(pScreen, d, r) RegionCopy(d, r) +#define REGION_DESTROY(pScreen, r) RegionDestroy(r) +#define REGION_INTERSECT(pScreen, res, r1, r2) RegionIntersect(res, r1, r2) +#define REGION_UNION(pScreen, res, r1, r2) RegionUnion(res, r1, r2) +#define REGION_SUBTRACT(pScreen, res, r1, r2) RegionSubtract(res, r1, r2) +#define REGION_INVERSE(pScreen, n, r, b) RegionInverse(n, r, b) +#define REGION_TRANSLATE(pScreen, r, x, y) RegionTranslate(r, x, y) +#define RECT_IN_REGION(pScreen, r, b) RegionContainsRect(r, b) +#define POINT_IN_REGION(pScreen, r, x, y, b) RegionContainsPoint(r, x, y, b) +#define REGION_EQUAL(pScreen, r1, r2) RegionEqual(r1, r2) +#define REGION_APPEND(pScreen, d, r) RegionAppend(d, r) +#define REGION_VALIDATE(pScreen, r, o) RegionValidate(r, o) +#define RECTS_TO_REGION(pScreen, n, r, c) RegionFromRects(n, r, c) +#define REGION_BREAK(pScreen, r) RegionBreak(r) +#define REGION_INIT(pScreen, r, b, s) RegionInit(r, b, s) +#define REGION_UNINIT(pScreen, r) RegionUninit(r) +#define REGION_RESET(pScreen, r, b) RegionReset(r, b) +#define REGION_NOTEMPTY(pScreen, r) RegionNotEmpty(r) +#define REGION_BROKEN(pScreen, r) RegionBroken(r) +#define REGION_EMPTY(pScreen, r) RegionEmpty(r) +#define REGION_EXTENTS(pScreen, r) RegionExtents(r) +#define REGION_NULL(pScreen, r) RegionNull(r) + +#endif /* INCLUDE_LEGACY_REGION_DEFINES */ #endif /* REGIONSTRUCT_H */ -- cgit v1.2.3