region.c File Reference

#include <win32k.h>
#include <suppress.h>
#include <debug.h>

Include dependency graph for region.c:

Go to the source code of this file.

Classes
struct	BRESINFO
struct	_EDGE_TABLE_ENTRY
struct	_SCANLINE_LIST
struct	EDGE_TABLE
struct	_SCANLINE_LISTBLOCK
struct	_POINTBLOCK

Macros
#define	NDEBUG
#define	COPY_RECTS(dest, src, nRects)
#define	EMPTY_REGION(pReg)
#define	REGION_NOT_EMPTY(pReg)   pReg->rdh.nCount
#define	INRECT(r, x, y)
#define	EXTENTCHECK(r1, r2)
#define	BRESINITPGON(dy, x1, x2, xStart, d, m, m1, incr1, incr2)
#define	BRESINCRPGON(d, minval, m, m1, incr1, incr2)
#define	BRESINITPGONSTRUCT(dmaj, min1, min2, bres)
#define	BRESINCRPGONSTRUCT(bres)   BRESINCRPGON(bres.d, bres.minor_axis, bres.m, bres.m1, bres.incr1, bres.incr2)
#define	CLOCKWISE   1
#define	COUNTERCLOCKWISE   -1
#define	SLLSPERBLOCK   25
#define	EVALUATEEDGEWINDING(pAET, pPrevAET, y, fixWAET)
#define	EVALUATEEDGEEVENODD(pAET, pPrevAET, y)
#define	LARGE_COORDINATE   INT_MAX
#define	SMALL_COORDINATE   INT_MIN
#define	NUMPTSTOBUFFER   200
#define	RGN_DEFAULT_RECTS   2

Typedefs
typedef struct _EDGE_TABLE_ENTRY	EDGE_TABLE_ENTRY
typedef struct _SCANLINE_LIST	SCANLINE_LIST
typedef struct _SCANLINE_LISTBLOCK	SCANLINE_LISTBLOCK
typedef BOOL(FASTCALL *	overlapProcp) (PREGION, PRECT, PRECT, PRECT, PRECT, INT, INT)
typedef BOOL(FASTCALL *	nonOverlapProcp) (PREGION, PRECT, PRECT, INT, INT)
typedef struct _POINTBLOCK	POINTBLOCK

Functions
static BOOL	REGION_bGrowBufferSize (_Inout_ PREGION prgn, _In_ UINT cRects)
static __inline BOOL	REGION_bEnsureBufferSize (_Inout_ PREGION prgn, _In_ UINT cRects)
FORCEINLINE VOID	REGION_vAddRect (_Inout_ PREGION prgn, _In_ LONG left, _In_ LONG top, _In_ LONG right, _In_ LONG bottom)
static __inline BOOL	REGION_bAddRect (_Inout_ PREGION prgn, _In_ LONG left, _In_ LONG top, _In_ LONG right, _In_ LONG bottom)
INT FASTCALL	REGION_Complexity (PREGION prgn)
static BOOL FASTCALL	REGION_CopyRegion (PREGION dst, PREGION src)
static VOID FASTCALL	REGION_SetExtents (PREGION pReg)
INT FASTCALL	REGION_CropRegion (PREGION rgnDst, PREGION rgnSrc, const RECTL *rect)
static INT FASTCALL	REGION_Coalesce (PREGION pReg, INT prevStart, INT curStart)
static BOOL FASTCALL	REGION_RegionOp (PREGION newReg, PREGION reg1, PREGION reg2, overlapProcp overlapFunc, nonOverlapProcp nonOverlap1Func, nonOverlapProcp nonOverlap2Func)
static BOOL FASTCALL	REGION_IntersectO (PREGION pReg, PRECTL r1, PRECTL r1End, PRECTL r2, PRECTL r2End, INT top, INT bottom)
static BOOL FASTCALL	REGION_IntersectRegion (PREGION newReg, PREGION reg1, PREGION reg2)
static BOOL FASTCALL	REGION_UnionNonO (PREGION pReg, PRECTL r, PRECTL rEnd, INT top, INT bottom)
static __inline BOOL	REGION_bMergeRect (_Inout_ PREGION prgn, _In_ LONG left, _In_ LONG top, _In_ LONG right, _In_ LONG bottom)
static BOOL FASTCALL	REGION_UnionO (PREGION pReg, PRECTL r1, PRECTL r1End, PRECTL r2, PRECTL r2End, INT top, INT bottom)
static BOOL FASTCALL	REGION_UnionRegion (PREGION newReg, PREGION reg1, PREGION reg2)
static BOOL FASTCALL	REGION_SubtractNonO1 (PREGION pReg, PRECTL r, PRECTL rEnd, INT top, INT bottom)
static BOOL FASTCALL	REGION_SubtractO (PREGION pReg, PRECTL r1, PRECTL r1End, PRECTL r2, PRECTL r2End, INT top, INT bottom)
static BOOL FASTCALL	REGION_SubtractRegion (PREGION regD, PREGION regM, PREGION regS)
static BOOL FASTCALL	REGION_XorRegion (PREGION dr, PREGION sra, PREGION srb)
BOOL FASTCALL	REGION_UnionRectWithRgn (PREGION rgn, const RECTL *rect)
INT FASTCALL	REGION_SubtractRectFromRgn (PREGION prgnDest, PREGION prgnSrc, const RECTL *prcl)
BOOL FASTCALL	REGION_bCopy (PREGION dst, PREGION src)
BOOL FASTCALL	REGION_bIntersectRegion (PREGION newReg, PREGION reg1, PREGION reg2)
static BOOL	REGION_bMakeSimpleFrameRgn (_Inout_ PREGION prgn, _In_ PRECTL prclSrc, _In_ INT cx, _In_ INT cy)
static BOOL	REGION_bMakeFrameRegion (_Inout_ PREGION prgnDest, _Inout_ PREGION prgnSrc, _In_ INT cx, _In_ INT cy)
HRGN FASTCALL	GreCreateFrameRgn (HRGN hrgn, INT cx, INT cy)
BOOL FASTCALL	REGION_bXformRgn (_Inout_ PREGION prgn, _In_ PMATRIX pmx)
PREGION FASTCALL	REGION_AllocRgnWithHandle (INT nReg)
BOOL NTAPI	REGION_bAllocRgnAttr (PREGION prgn)
PREGION FASTCALL	REGION_AllocUserRgnWithHandle (INT nRgn)
static VOID	REGION_vSyncRegion (_In_ PREGION prgn)
PREGION FASTCALL	REGION_LockRgn (_In_ HRGN hrgn)
VOID FASTCALL	REGION_UnlockRgn (_In_ PREGION prgn)
PREGION FASTCALL	IntSysCreateRectpRgn (INT LeftRect, INT TopRect, INT RightRect, INT BottomRect)
VOID NTAPI	REGION_vCleanup (PVOID ObjectBody)
VOID FASTCALL	REGION_Delete (PREGION pRgn)
BOOL FASTCALL	IntGdiSetRegionOwner (HRGN hRgn, DWORD OwnerMask)
INT FASTCALL	IntGdiCombineRgn (PREGION prgnDest, PREGION prgnSrc1, PREGION prgnSrc2, INT iCombineMode)
INT FASTCALL	REGION_GetRgnBox (PREGION Rgn, PRECTL pRect)
INT APIENTRY	IntGdiGetRgnBox (HRGN hRgn, PRECTL pRect)
BOOL FASTCALL	REGION_PtInRegion (PREGION prgn, INT X, INT Y)
BOOL FASTCALL	REGION_RectInRegion (PREGION Rgn, const RECTL *rect)
VOID FASTCALL	REGION_SetRectRgn (PREGION rgn, INT LeftRect, INT TopRect, INT RightRect, INT BottomRect)
BOOL FASTCALL	REGION_bOffsetRgn (_Inout_ PREGION prgn, _In_ INT cx, _In_ INT cy)
static VOID FASTCALL	REGION_InsertEdgeInET (EDGE_TABLE *ET, EDGE_TABLE_ENTRY *ETE, INT scanline, SCANLINE_LISTBLOCK **SLLBlock, INT *iSLLBlock)
static VOID FASTCALL	REGION_loadAET (EDGE_TABLE_ENTRY *AET, EDGE_TABLE_ENTRY *ETEs)
static VOID FASTCALL	REGION_computeWAET (EDGE_TABLE_ENTRY *AET)
static BOOL FASTCALL	REGION_InsertionSort (EDGE_TABLE_ENTRY *AET)
static VOID FASTCALL	REGION_FreeStorage (SCANLINE_LISTBLOCK *pSLLBlock)
static INT FASTCALL	REGION_PtsToRegion (INT numFullPtBlocks, INT iCurPtBlock, POINTBLOCK *FirstPtBlock, PREGION reg)
static VOID FASTCALL	REGION_CreateETandAET (const ULONG *Count, INT nbpolygons, const POINT *pts, EDGE_TABLE *ET, EDGE_TABLE_ENTRY *AET, EDGE_TABLE_ENTRY *pETEs, SCANLINE_LISTBLOCK *pSLLBlock)
BOOL FASTCALL	REGION_SetPolyPolygonRgn (_Inout_ PREGION prgn, _In_ const POINT *ppt, _In_ const ULONG *pcPoints, _In_ ULONG cPolygons, _In_ INT iMode)
HRGN NTAPI	GreCreatePolyPolygonRgn (_In_ const POINT *ppt, _In_ const ULONG *pcPoints, _In_ ULONG cPolygons, _In_ INT iMode)
BOOL FASTCALL	IntRectInRegion (HRGN hRgn, LPRECTL rc)
INT APIENTRY	NtGdiCombineRgn (IN HRGN hrgnDst, IN HRGN hrgnSrc1, IN HRGN hrgnSrc2, IN INT iMode)
HRGN APIENTRY	NtGdiCreateEllipticRgn (INT Left, INT Top, INT Right, INT Bottom)
HRGN APIENTRY	NtGdiCreateRectRgn (INT LeftRect, INT TopRect, INT RightRect, INT BottomRect)
HRGN APIENTRY	NtGdiCreateRoundRectRgn (INT left, INT top, INT right, INT bottom, INT ellipse_width, INT ellipse_height)
BOOL APIENTRY	NtGdiEqualRgn (HRGN hSrcRgn1, HRGN hSrcRgn2)
HRGN APIENTRY	NtGdiExtCreateRegion (OPTIONAL LPXFORM Xform, DWORD Count, LPRGNDATA RgnData)
INT APIENTRY	NtGdiGetRgnBox (HRGN hRgn, PRECTL pRect)
INT APIENTRY	NtGdiOffsetRgn (_In_ HRGN hrgn, _In_ INT cx, _In_ INT cy)
BOOL APIENTRY	NtGdiPtInRegion (_In_ HRGN hrgn, _In_ INT x, _In_ INT y)
__kernel_entry BOOL APIENTRY	NtGdiRectInRegion (_In_ HRGN hrgn, _Inout_ LPRECT prclUnsafe)
BOOL APIENTRY	NtGdiSetRectRgn (_In_ HRGN hrgn, _In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom)
	_Success_ (return!=0)

Variables
PREGION	prgnDefault = NULL
HRGN	hrgnDefault = NULL

Macro Definition Documentation

BRESINCRPGON

#define BRESINCRPGON	(		d,
			minval,
			m,
			m1,
			incr1,
			incr2
	)

Value:

{ \
    if (m1 > 0) { \
        if (d > 0) { \
            minval += m1; \
            d += incr1; \
        } \
        else { \
            minval += m; \
            d += incr2; \
        } \
    } else {\
        if (d >= 0) { \
            minval += m1; \
            d += incr1; \
        } \
        else { \
            minval += m; \
            d += incr2; \
        } \
    } \
}

Definition at line 218 of file region.c.

BRESINCRPGONSTRUCT

#define BRESINCRPGONSTRUCT

(

bres

)

BRESINCRPGON(bres.d, bres.minor_axis, bres.m, bres.m1, bres.incr1, bres.incr2)

Definition at line 260 of file region.c.

BRESINITPGON

#define BRESINITPGON	(		dy,
			x1,
			x2,
			xStart,
			d,
			m,
			m1,
			incr1,
			incr2
	)

Value:

{ \
    int dx;      /* Local storage */ \
\
    /* \
     *  If the edge is horizontal, then it is ignored \
     *  and assumed not to be processed.  Otherwise, do this stuff. \
     */ \
    if ((dy) != 0) { \
        xStart = (x1); \
        dx = (x2) - xStart; \
        if (dx < 0) { \
            m = dx / (dy); \
            m1 = m - 1; \
            incr1 = -2 * dx + 2 * (dy) * m1; \
            incr2 = -2 * dx + 2 * (dy) * m; \
            d = 2 * m * (dy) - 2 * dx - 2 * (dy); \
        } else { \
            m = dx / (dy); \
            m1 = m + 1; \
            incr1 = 2 * dx - 2 * (dy) * m1; \
            incr2 = 2 * dx - 2 * (dy) * m; \
            d = -2 * m * (dy) + 2 * dx; \
        } \
    } \
}

Definition at line 192 of file region.c.

BRESINITPGONSTRUCT

#define BRESINITPGONSTRUCT	(		dmaj,
			min1,
			min2,
			bres
	)

Value:

BRESINITPGON(dmaj, min1, min2, bres.minor_axis, bres.d, \
                     bres.m, bres.m1, bres.incr1, bres.incr2)

Definition at line 256 of file region.c.

CLOCKWISE

#define CLOCKWISE   1

Definition at line 314 of file region.c.

COPY_RECTS

#define COPY_RECTS	(		dest,
			src,
			nRects
	)

Value:

do {                                \
    PRECTL xDest = (dest);            \
    PRECTL xSrc = (src);              \
    UINT xRects = (nRects);           \
    while (xRects-- > 0) {            \
      *(xDest++) = *(xSrc++);         \
    }                                 \
  } while (0)

Definition at line 136 of file region.c.

COUNTERCLOCKWISE

#define COUNTERCLOCKWISE   -1

Definition at line 315 of file region.c.

EMPTY_REGION

#define EMPTY_REGION

(

pReg

)

Value:

{ \
  (pReg)->rdh.nCount = 0; \
  (pReg)->rdh.rcBound.left = (pReg)->rdh.rcBound.top = 0; \
  (pReg)->rdh.rcBound.right = (pReg)->rdh.rcBound.bottom = 0; \
  (pReg)->rdh.iType = RDH_RECTANGLES; \
}

Definition at line 149 of file region.c.

EVALUATEEDGEEVENODD

#define EVALUATEEDGEEVENODD	(		pAET,
			pPrevAET,
			y
	)

Value:

{ \
   if (pAET->ymax == y) {          /* Leaving this edge */ \
      pPrevAET->next = pAET->next; \
      pAET = pPrevAET->next; \
      if (pAET) \
         pAET->back = pPrevAET; \
   } \
   else { \
      BRESINCRPGONSTRUCT(pAET->bres); \
      pPrevAET = pAET; \
      pAET = pAET->next; \
   } \
}

Definition at line 393 of file region.c.

EVALUATEEDGEWINDING

#define EVALUATEEDGEWINDING	(		pAET,
			pPrevAET,
			y,
			fixWAET
	)

Value:

{ \
   if (pAET->ymax == y) {          /* Leaving this edge */ \
      pPrevAET->next = pAET->next; \
      pAET = pPrevAET->next; \
      fixWAET = 1; \
      if (pAET) \
         pAET->back = pPrevAET; \
   } \
   else { \
      BRESINCRPGONSTRUCT(pAET->bres); \
      pPrevAET = pAET; \
      pAET = pAET->next; \
   } \
}

Definition at line 370 of file region.c.

EXTENTCHECK

#define EXTENTCHECK	(		r1,
			r2
	)

Value:

((r1)->right > (r2)->left && \
     (r1)->left < (r2)->right && \
     (r1)->bottom > (r2)->top && \
     (r1)->top < (r2)->bottom)

Definition at line 167 of file region.c.

INRECT

#define INRECT	(		r,
			x,
			y
	)

Value:

( ( ((r).right >  x)) && \
        ( ((r).left <= x)) && \
        ( ((r).bottom >  y)) && \
        ( ((r).top <= y)) )

Definition at line 158 of file region.c.

LARGE_COORDINATE

#define LARGE_COORDINATE   INT_MAX

Definition at line 413 of file region.c.

NDEBUG

#define NDEBUG

Definition at line 127 of file region.c.

NUMPTSTOBUFFER

#define NUMPTSTOBUFFER   200

Definition at line 524 of file region.c.

REGION_NOT_EMPTY

#define REGION_NOT_EMPTY

(

pReg

)

pReg->rdh.nCount

Definition at line 156 of file region.c.

RGN_DEFAULT_RECTS

#define RGN_DEFAULT_RECTS   2

Definition at line 526 of file region.c.

SLLSPERBLOCK

#define SLLSPERBLOCK   25

Definition at line 349 of file region.c.

SMALL_COORDINATE

#define SMALL_COORDINATE   INT_MIN

Definition at line 414 of file region.c.

Typedef Documentation

EDGE_TABLE_ENTRY

typedef struct _EDGE_TABLE_ENTRY EDGE_TABLE_ENTRY

nonOverlapProcp

typedef BOOL(FASTCALL * nonOverlapProcp) (PREGION, PRECT, PRECT, INT, INT)

Definition at line 521 of file region.c.

overlapProcp

typedef BOOL(FASTCALL * overlapProcp) (PREGION, PRECT, PRECT, PRECT, PRECT, INT, INT)

Definition at line 520 of file region.c.

POINTBLOCK

typedef struct _POINTBLOCK POINTBLOCK

SCANLINE_LIST

typedef struct _SCANLINE_LIST SCANLINE_LIST

SCANLINE_LISTBLOCK

typedef struct _SCANLINE_LISTBLOCK SCANLINE_LISTBLOCK

Function Documentation

_Success_()

_Success_

(

return!

= 0

)

MSDN: GetRegionData, Return Values:

"If the function succeeds and dwCount specifies an adequate number of bytes, the return value is always dwCount. If dwCount is too small or the function fails, the return value is 0. If lpRgnData is NULL, the return value is the required number of bytes.

If the function fails, the return value is zero."

Definition at line 4104 of file region.c.

{
    ULONG cjRects, cjSize;
    PREGION prgn;

    /* Lock the region */
    prgn = REGION_LockRgn(hrgn);
    if (prgn == NULL)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return 0;
    }

    /* Calculate the region sizes */
    cjRects = prgn->rdh.nCount * sizeof(RECT);
    cjSize = cjRects + sizeof(RGNDATAHEADER);

    /* Check if region data is requested */
    if (lpRgnData)
    {
        /* Check if the buffer is large enough */
        if (cjBuffer >= cjSize)
        {
            /* Probe the buffer and copy the data */
            _SEH2_TRY
            {
                ProbeForWrite(lpRgnData, cjSize, sizeof(ULONG));
                RtlCopyMemory(lpRgnData, &prgn->rdh, sizeof(RGNDATAHEADER));
                RtlCopyMemory(lpRgnData->Buffer, prgn->Buffer, cjRects);
                lpRgnData->rdh.iType = RDH_RECTANGLES;
                lpRgnData->rdh.nRgnSize = cjRects;
            }
            _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
            {
                EngSetLastError(ERROR_INVALID_PARAMETER);
                cjSize = 0;
            }
            _SEH2_END;
        }
        else
        {
            /* Buffer is too small */
            EngSetLastError(ERROR_INVALID_PARAMETER);
            cjSize = 0;
        }
    }

    /* Unlock the region and return the size */
    REGION_UnlockRgn(prgn);
    return cjSize;
}

GreCreateFrameRgn()

HRGN FASTCALL GreCreateFrameRgn	(	HRGN	hrgn,
		INT	cx,
		INT	cy
	)

Definition at line 2041 of file region.c.

{
    PREGION prgnFrame, prgnSrc;
    HRGN hrgnFrame;

    /* Allocate a new region */
    prgnFrame = REGION_AllocUserRgnWithHandle(1);
    if (prgnFrame == NULL)
    {
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return NULL;
    }

    /* Lock the source region */
    prgnSrc = REGION_LockRgn(hrgn);
    if (prgnSrc == NULL)
    {
        REGION_Delete(prgnFrame);
        return FALSE;
    }

    if (REGION_bMakeFrameRegion(prgnFrame, prgnSrc, cx, cy))
    {
        hrgnFrame = prgnFrame->BaseObject.hHmgr;
        REGION_UnlockRgn(prgnFrame);
    }
    else
    {
        REGION_Delete(prgnFrame);
        hrgnFrame = NULL;
    }

    REGION_UnlockRgn(prgnSrc);
    return hrgnFrame;
}

Referenced by NtGdiFrameRgn().

GreCreatePolyPolygonRgn()

HRGN NTAPI GreCreatePolyPolygonRgn	(	_In_ const POINT *	ppt,
		_In_ const ULONG *	pcPoints,
		_In_ ULONG	cPolygons,
		_In_ INT	iMode
	)

Definition at line 3473 of file region.c.

{
    PREGION prgn;
    HRGN hrgn;

    /* Allocate a new region */
    prgn = REGION_AllocUserRgnWithHandle(0);
    if (prgn == NULL)
    {
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return NULL;
    }

    /* Call the internal function and check for success */
    if (REGION_SetPolyPolygonRgn(prgn, ppt, pcPoints, cPolygons, iMode))
    {
        /* Success, get the handle and unlock the region */
        hrgn = prgn->BaseObject.hHmgr;
        REGION_UnlockRgn(prgn);
    }
    else
    {
        /* Failure, delete the region */
        REGION_Delete(prgn);
        hrgn = NULL;
    }

    return hrgn;
}

Referenced by NtGdiPolyPolyDraw().

IntGdiCombineRgn()

INT FASTCALL IntGdiCombineRgn	(	PREGION	prgnDest,
		PREGION	prgnSrc1,
		PREGION	prgnSrc2,
		INT	iCombineMode
	)

Definition at line 2506 of file region.c.

{
    BOOL Ret = TRUE;

    if (prgnDest == NULL)
    {
        DPRINT("IntGdiCombineRgn: hDest unavailable\n");
        return ERROR;
    }

    if (prgnSrc1 == NULL)
    {
        DPRINT("IntGdiCombineRgn: hSrc1 unavailable\n");
        return ERROR;
    }

    if (iCombineMode == RGN_COPY)
    {
        if (!REGION_CopyRegion(prgnDest, prgnSrc1))
            return ERROR;

        return REGION_Complexity(prgnDest);
    }

    if (prgnSrc2 == NULL)
    {
        DPRINT1("IntGdiCombineRgn requires hSrc2 != NULL for combine mode %d!\n", iCombineMode);
        ASSERT(FALSE);
        return ERROR;
    }

    switch (iCombineMode)
    {
        case RGN_AND:
            Ret = REGION_IntersectRegion(prgnDest, prgnSrc1, prgnSrc2);
            break;
        case RGN_OR:
            Ret = REGION_UnionRegion(prgnDest, prgnSrc1, prgnSrc2);
            break;
        case RGN_XOR:
            Ret = REGION_XorRegion(prgnDest, prgnSrc1, prgnSrc2);
            break;
        case RGN_DIFF:
            Ret = REGION_SubtractRegion(prgnDest, prgnSrc1, prgnSrc2);
            break;
    }

    return Ret ? REGION_Complexity(prgnDest) : ERROR;
}

Referenced by _Success_(), co_IntGetUpdateRgn(), co_UserRedrawWindow(), co_VIS_WindowLayoutChanged(), co_WinPosSetWindowPos(), DC_vCopyState(), DceUpdateVisRgn(), ForceNCPaintErase(), IntGdiBitBltRgn(), IntGdiFillRgn(), IntInvalidateWindows(), IntScrollWindowEx(), IntValidateParents(), NtGdiCombineRgn(), NtGdiGetRandomRgn(), REGION_LPTODP(), UserScrollDC(), and VIS_ComputeVisibleRegion().

IntGdiGetRgnBox()

INT APIENTRY IntGdiGetRgnBox	(	HRGN	hRgn,
		PRECTL	pRect
	)

Definition at line 2580 of file region.c.

{
    PREGION Rgn;
    DWORD ret;

    Rgn = REGION_LockRgn(hRgn);
    if (Rgn == NULL)
    {
        return ERROR;
    }

    ret = REGION_GetRgnBox(Rgn, pRect);
    REGION_UnlockRgn(Rgn);

    return ret;
}

Referenced by co_UserGetUpdateRect(), and IntGetNCUpdateRgn().

IntGdiSetRegionOwner()

BOOL FASTCALL IntGdiSetRegionOwner	(	HRGN	hRgn,
		DWORD	OwnerMask
	)

Definition at line 2478 of file region.c.

{
    PREGION prgn;
    PRGN_ATTR prgnattr;
    PPROCESSINFO ppi;

    prgn = REGION_LockRgn(hRgn);
    if (prgn == NULL)
    {
        return FALSE;
    }

    prgnattr = prgn->prgnattr;
    if (prgnattr != &prgn->rgnattr)
    {
        GDIOBJ_vSetObjectAttr(&prgn->BaseObject, NULL);
        prgn->prgnattr = &prgn->rgnattr;
        ppi = PsGetCurrentProcessWin32Process();
        GdiPoolFree(ppi->pPoolRgnAttr, prgnattr);
    }

    REGION_UnlockRgn(prgn);

    return GreSetObjectOwner(hRgn, OwnerMask);
}

Referenced by co_UserFreeWindow(), ForceNCPaintErase(), IntBeginPaint(), IntGetNCUpdateRgn(), IntInvalidateWindows(), SelectWindowRgn(), and UserUpdateMonitorSize().

IntRectInRegion()

BOOL FASTCALL IntRectInRegion	(	HRGN	hRgn,
		LPRECTL	rc
	)

Definition at line 3509 of file region.c.

{
    PREGION Rgn;
    BOOL Ret;

    Rgn = REGION_LockRgn(hRgn);
    if (Rgn == NULL)
    {
        return ERROR;
    }

    Ret = REGION_RectInRegion(Rgn, rc);
    REGION_UnlockRgn(Rgn);
    return Ret;
}

Referenced by NtGdiRectInRegion().

IntSysCreateRectpRgn()

PREGION FASTCALL IntSysCreateRectpRgn	(	INT	LeftRect,
		INT	TopRect,
		INT	RightRect,
		INT	BottomRect
	)

Definition at line 2426 of file region.c.

{
    PREGION prgn;

    /* Allocate a region, without a handle */
    prgn = (PREGION)GDIOBJ_AllocateObject(GDIObjType_RGN_TYPE, sizeof(REGION), BASEFLAG_LOOKASIDE);
    if (prgn == NULL)
    {
        return NULL;
    }

    /* Initialize it */
    prgn->Buffer = &prgn->rdh.rcBound;
    prgn->prgnattr = &prgn->rgnattr;
    prgn->prgnattr->AttrFlags = ATTR_RGN_VALID;
    REGION_SetRectRgn(prgn, LeftRect, TopRect, RightRect, BottomRect);

    return prgn;
}

Referenced by _Success_(), CLIPPING_UpdateGCRegion(), co_UserRedrawWindow(), co_VIS_WindowLayoutChanged(), co_WinPosSetWindowPos(), DC_InitHack(), DC_vCopyState(), DC_vInitDc(), DC_vUpdateDC(), DceGetVisRgn(), DceUpdateVisRgn(), IntGdiBitBltRgn(), IntGdiFillRgn(), IntGdiSetMetaRgn(), IntInvalidateWindows(), IntScrollWindowEx(), IntSetDefaultRegion(), NtGdiSelectClipPath(), and PATH_FillPathEx().

NtGdiCombineRgn()

INT APIENTRY NtGdiCombineRgn	(	IN HRGN	hrgnDst,
		IN HRGN	hrgnSrc1,
		IN HRGN	hrgnSrc2,
		IN INT	iMode
	)

Definition at line 3533 of file region.c.

{
    HRGN ahrgn[3];
    PREGION aprgn[3];
    INT iResult;

    /* Validate the combine mode */
    if ((iMode < RGN_AND) || (iMode > RGN_COPY))
    {
        return ERROR;
    }

    /* Validate that we have the required regions */
    if ((hrgnDst == NULL) ||
        (hrgnSrc1 == NULL) ||
        ((iMode != RGN_COPY) && (hrgnSrc2 == NULL)))
    {
        DPRINT1("NtGdiCombineRgn invalid parameters: %p, %p, %p, %d\n",
                hrgnDst, hrgnSrc1, hrgnSrc2, iMode);
        EngSetLastError(ERROR_INVALID_HANDLE);
        return ERROR;
    }

    /* Lock all regions */
    ahrgn[0] = hrgnDst;
    ahrgn[1] = hrgnSrc1;
    ahrgn[2] = iMode != RGN_COPY ? hrgnSrc2 : NULL;
    if (!GDIOBJ_bLockMultipleObjects(3, (HGDIOBJ*)ahrgn, (PVOID*)aprgn, GDIObjType_RGN_TYPE))
    {
        DPRINT1("NtGdiCombineRgn failed to lock regions: %p, %p, %p, %d\n",
                hrgnDst, hrgnSrc1, hrgnSrc2, iMode);
        return ERROR;
    }

    /* HACK: Sync usermode attributes */
    REGION_vSyncRegion(aprgn[0]);
    if (aprgn[1] != aprgn[0])
        REGION_vSyncRegion(aprgn[1]);
    if ((aprgn[2] != NULL) && (aprgn[2] != aprgn[0]) && (aprgn[2] != aprgn[1]))
        REGION_vSyncRegion(aprgn[2]);

    /* Call the internal function */
    iResult = IntGdiCombineRgn(aprgn[0], aprgn[1], aprgn[2], iMode);

    /* Unlock and return */
    REGION_UnlockRgn(aprgn[0]);
    REGION_UnlockRgn(aprgn[1]);
    if (aprgn[2] != NULL)
        REGION_UnlockRgn(aprgn[2]);

    return iResult;
}

Referenced by CombineRgn().

NtGdiCreateEllipticRgn()

HRGN APIENTRY NtGdiCreateEllipticRgn	(	INT	Left,
		INT	Top,
		INT	Right,
		INT	Bottom
	)

Definition at line 3592 of file region.c.

{
    return NtGdiCreateRoundRectRgn(Left,
                                   Top,
                                   Right, Bottom,
                                   Right - Left,
                                   Bottom - Top);
}

Referenced by CreateEllipticRgnIndirect().

NtGdiCreateRectRgn()

HRGN APIENTRY NtGdiCreateRectRgn	(	INT	LeftRect,
		INT	TopRect,
		INT	RightRect,
		INT	BottomRect
	)

Definition at line 3607 of file region.c.

{
    PREGION pRgn;
    HRGN hRgn;

    /* Allocate region data structure with space for 1 RECTL */
    pRgn = REGION_AllocUserRgnWithHandle(1);
    if (pRgn == NULL)
    {
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return NULL;
    }

    hRgn = pRgn->BaseObject.hHmgr;

    REGION_SetRectRgn(pRgn, LeftRect, TopRect, RightRect, BottomRect);
    REGION_UnlockRgn(pRgn);

    DPRINT("Returning %p.\n", hRgn);

    return hRgn;
}

Referenced by CreateRectRgn(), and NtGdiCreateRoundRectRgn().

NtGdiCreateRoundRectRgn()

HRGN APIENTRY NtGdiCreateRoundRectRgn	(	INT	left,
		INT	top,
		INT	right,
		INT	bottom,
		INT	ellipse_width,
		INT	ellipse_height
	)

Definition at line 3636 of file region.c.

{
    PREGION obj;
    HRGN hrgn;
    int a, b, i, x, y;
    INT64 asq, bsq, dx, dy, err;
    RECT *rects;

    /* Make the dimensions sensible */
    if (left > right)
    {
        INT tmp = left;
        left = right;
        right = tmp;
    }

    if (top > bottom)
    {
        INT tmp = top;
        top = bottom;
        bottom = tmp;
    }

    /* the region is for the rectangle interior, but only at right and bottom for some reason */
    right--;
    bottom--;

    ellipse_width = min( right - left, abs( ellipse_width ));
    ellipse_height = min( bottom - top, abs( ellipse_height ));

    /* Check if we can do a normal rectangle instead */

    if ((ellipse_width < 2) || (ellipse_height < 2))
        return NtGdiCreateRectRgn(left, top, right, bottom);

    obj = REGION_AllocUserRgnWithHandle( ellipse_height );
    if (obj == NULL)
        return 0;

    hrgn = obj->BaseObject.hHmgr;

    obj->rdh.rcBound.left   = left;
    obj->rdh.rcBound.top    = top;
    obj->rdh.rcBound.right  = right;
    obj->rdh.rcBound.bottom = bottom;
    rects = obj->Buffer;

    /* based on an algorithm by Alois Zingl */

    a = ellipse_width - 1;
    b = ellipse_height - 1;
    asq = (INT64)8 * a * a;
    bsq = (INT64)8 * b * b;
    dx  = (INT64)4 * b * b * (1 - a);
    dy  = (INT64)4 * a * a * (1 + (b % 2));
    err = dx + dy + a * a * (b % 2);

    x = 0;
    y = ellipse_height / 2;

    rects[y].left = left;
    rects[y].right = right;

    while (x <= ellipse_width / 2)
    {
        INT64 e2 = 2 * err;
        if (e2 >= dx)
        {
            x++;
            err += dx += bsq;
        }
        if (e2 <= dy)
        {
            y++;
            err += dy += asq;
            rects[y].left = left + x;
            rects[y].right = right - x;
        }
    }
    for (i = 0; i < ellipse_height / 2; i++)
    {
        rects[i].left = rects[b - i].left;
        rects[i].right = rects[b - i].right;
        rects[i].top = top + i;
        rects[i].bottom = rects[i].top + 1;
    }
    for (; i < ellipse_height; i++)
    {
        rects[i].top = bottom - ellipse_height + i;
        rects[i].bottom = rects[i].top + 1;
    }
    rects[ellipse_height / 2].top = top + ellipse_height / 2;  /* extend to top of rectangle */

    REGION_UnlockRgn(obj);
    return hrgn;
}

Referenced by NtGdiCreateEllipticRgn().

NtGdiEqualRgn()

BOOL APIENTRY NtGdiEqualRgn	(	HRGN	hSrcRgn1,
		HRGN	hSrcRgn2
	)

Definition at line 3741 of file region.c.

{
    HRGN ahrgn[2];
    PREGION aprgn[2];
    PREGION rgn1, rgn2;
    PRECTL tRect1, tRect2;
    ULONG i;
    BOOL bRet = FALSE;

    /* Check if we got 2 regions */
    if ((hSrcRgn1 == NULL) || (hSrcRgn2 == NULL))
    {
        return FALSE;
    }

    /* Check if these are the same regions */
    if (hSrcRgn1 == hSrcRgn2)
    {
        /* Make sure this region is valid */
        if ((GDI_HANDLE_GET_TYPE(hSrcRgn1) == GDILoObjType_LO_REGION_TYPE) &&
            GreIsHandleValid(hSrcRgn1))
        {
            return TRUE;
        }
        return FALSE;
    }

    /* Lock both regions */
    ahrgn[0] = hSrcRgn1;
    ahrgn[1] = hSrcRgn2;
    if (!GDIOBJ_bLockMultipleObjects(2, (HGDIOBJ*)ahrgn, (PVOID*)aprgn, GDIObjType_RGN_TYPE))
    {
        DPRINT1("NtGdiEqualRgn failed to lock regions: %p, %p\n",
                hSrcRgn1, hSrcRgn2);
        return FALSE;
    }

    REGION_vSyncRegion(aprgn[0]);
    REGION_vSyncRegion(aprgn[1]);

    rgn1 = aprgn[0];
    rgn2 = aprgn[1];

    if (rgn1->rdh.nCount != rgn2->rdh.nCount)
        goto exit;

    if (rgn1->rdh.nCount == 0)
    {
        bRet = TRUE;
        goto exit;
    }

    if ((rgn1->rdh.rcBound.left   != rgn2->rdh.rcBound.left)  ||
        (rgn1->rdh.rcBound.right  != rgn2->rdh.rcBound.right) ||
        (rgn1->rdh.rcBound.top    != rgn2->rdh.rcBound.top)   ||
        (rgn1->rdh.rcBound.bottom != rgn2->rdh.rcBound.bottom))
        goto exit;

    tRect1 = rgn1->Buffer;
    tRect2 = rgn2->Buffer;

    if ((tRect1 == NULL) || (tRect2 == NULL))
        goto exit;

    for (i=0; i < rgn1->rdh.nCount; i++)
    {
        if ((tRect1[i].left   != tRect2[i].left)  ||
            (tRect1[i].right  != tRect2[i].right) ||
            (tRect1[i].top    != tRect2[i].top)   ||
            (tRect1[i].bottom != tRect2[i].bottom))
            goto exit;
    }

    bRet = TRUE;

exit:
    REGION_UnlockRgn(rgn1);
    REGION_UnlockRgn(rgn2);
    return bRet;
}

NtGdiExtCreateRegion()

HRGN APIENTRY NtGdiExtCreateRegion	(	OPTIONAL LPXFORM	Xform,
		DWORD	Count,
		LPRGNDATA	RgnData
	)

Definition at line 3826 of file region.c.

{
    HRGN hRgn;
    PREGION Region;
    DWORD nCount = 0;
    DWORD iType = 0;
    DWORD dwSize = 0;
    UINT i;
    RECT* rects;
    NTSTATUS Status = STATUS_SUCCESS;
    MATRIX matrix;
    XFORMOBJ xo;

    DPRINT("NtGdiExtCreateRegion\n");
    _SEH2_TRY
    {
        ProbeForRead(RgnData, Count, 1);
        nCount = RgnData->rdh.nCount;
        iType = RgnData->rdh.iType;
        dwSize = RgnData->rdh.dwSize;
        rects = (RECT*)RgnData->Buffer;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = _SEH2_GetExceptionCode();
    }
    _SEH2_END;

    if (!NT_SUCCESS(Status))
    {
        SetLastNtError(Status);
        return NULL;
    }

    /* Check parameters, but don't set last error here */
    if ((Count < sizeof(RGNDATAHEADER) + nCount * sizeof(RECT)) ||
        (iType != RDH_RECTANGLES) ||
        (dwSize != sizeof(RGNDATAHEADER)))
    {
        return NULL;
    }

    Region = REGION_AllocUserRgnWithHandle(nCount);

    if (Region == NULL)
    {
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
    hRgn = Region->BaseObject.hHmgr;

    _SEH2_TRY
    {
        /* Insert the rectangles one by one */
        for(i=0; i<nCount; i++)
        {
            if ( rects[i].left < rects[i].right && rects[i].top < rects[i].bottom )
            {
                if (!REGION_UnionRectWithRgn(Region, &rects[i]))
                {
                   REGION_UnlockRgn(Region);
                   GreDeleteObject(hRgn);
                   hRgn = NULL;
                   _SEH2_LEAVE;
                }
            }
        }

        if (Xform != NULL)
        {
            ULONG ret;

            /* Init the XFORMOBJ from the Xform struct */
            Status = STATUS_INVALID_PARAMETER;
            XFORMOBJ_vInit(&xo, &matrix);
            ret = XFORMOBJ_iSetXform(&xo, (XFORML*)Xform);

            /* Check for error */
            if (ret != DDI_ERROR)
            {
                /* Apply the coordinate transformation on the rects */
                if (XFORMOBJ_bApplyXform(&xo,
                                         XF_LTOL,
                                         Region->rdh.nCount * 2,
                                         Region->Buffer,
                                         Region->Buffer))
                {
                    Status = STATUS_SUCCESS;
                }
            }
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = _SEH2_GetExceptionCode();
    }
    _SEH2_END;
    if (!NT_SUCCESS(Status))
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        REGION_UnlockRgn(Region);
        GreDeleteObject(hRgn);
        return NULL;
    }

    if (hRgn) REGION_UnlockRgn(Region);

    return hRgn;
}

Referenced by ExtCreateRegion().

NtGdiGetRgnBox()

INT APIENTRY NtGdiGetRgnBox	(	HRGN	hRgn,
		PRECTL	pRect
	)

Definition at line 3941 of file region.c.

{
    PREGION Rgn;
    RECTL SafeRect;
    DWORD ret;
    NTSTATUS Status = STATUS_SUCCESS;

    Rgn = REGION_LockRgn(hRgn);
    if (Rgn == NULL)
    {
        return ERROR;
    }

    ret = REGION_GetRgnBox(Rgn, &SafeRect);
    REGION_UnlockRgn(Rgn);
    if (ret == ERROR)
    {
        return ret;
    }

    _SEH2_TRY
    {
        ProbeForWrite(pRect, sizeof(RECT), 1);
        *pRect = SafeRect;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = _SEH2_GetExceptionCode();
    }
    _SEH2_END;
    if (!NT_SUCCESS(Status))
    {
        return ERROR;
    }

    return ret;
}

Referenced by emfdrv_stroke_and_fill_path(), and GetRgnBox().

NtGdiOffsetRgn()

INT APIENTRY NtGdiOffsetRgn	(	_In_ HRGN	hrgn,
		_In_ INT	cx,
		_In_ INT	cy
	)

Definition at line 3983 of file region.c.

{
    PREGION prgn;
    INT iResult;

    DPRINT("NtGdiOffsetRgn: hrgn %p cx %d cy %d\n", hrgn, cx, cy);

    /* Lock the region */
    prgn = REGION_LockRgn(hrgn);
    if (prgn == NULL)
    {
        DPRINT1("NtGdiOffsetRgn: failed to lock region %p\n", hrgn);
        return ERROR;
    }

    /* Call the internal function */
    if (!REGION_bOffsetRgn(prgn, cx, cy))
    {
        iResult = ERROR;
    }
    else
    {
        iResult = REGION_Complexity(prgn);
    }

    /* Unlock and return the result */
    REGION_UnlockRgn(prgn);
    return iResult;
}

Referenced by co_UserExcludeUpdateRgn(), co_UserGetUpdateRgn(), co_WinPosSetWindowPos(), DceResetActiveDCEs(), IntCalcWindowRgn(), and OffsetRgn().

NtGdiPtInRegion()

BOOL APIENTRY NtGdiPtInRegion	(	_In_ HRGN	hrgn,
		_In_ INT	x,
		_In_ INT	y
	)

Definition at line 4018 of file region.c.

{
    PREGION prgn;
    BOOL bResult;

    /* Lock the region */
    prgn = REGION_LockRgn(hrgn);
    if (prgn == NULL)
    {
        DPRINT1("NtGdiPtInRegion: hrgn error\n");
        return FALSE;
    }

    /* Call the internal function */
    bResult = REGION_PtInRegion(prgn, x, y);

    /* Unlock and return the result */
    REGION_UnlockRgn(prgn);
    return bResult;
}

Referenced by IntPtInWindow(), and PtInRegion().

NtGdiRectInRegion()

__kernel_entry BOOL APIENTRY NtGdiRectInRegion	(	_In_ HRGN	hrgn,
		_Inout_ LPRECT	prclUnsafe
	)

Definition at line 4045 of file region.c.

{
    RECTL rcTemp;

    /* Probe and copy the rect */
    _SEH2_TRY
    {
        ProbeForRead(prclUnsafe, sizeof(RECT), 1);
        rcTemp = *prclUnsafe;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        DPRINT1("NtGdiRectInRegion: Exception accessing the rect\n");
        return FALSE;
    }
    _SEH2_END;

    /* Call the internal function */
    return IntRectInRegion(hrgn, &rcTemp);
}

Referenced by RectInRegion().

NtGdiSetRectRgn()

BOOL APIENTRY NtGdiSetRectRgn	(	_In_ HRGN	hrgn,
		_In_ INT	xLeft,
		_In_ INT	yTop,
		_In_ INT	xRight,
		_In_ INT	yBottom
	)

Definition at line 4070 of file region.c.

{
    PREGION prgn;

    /* Lock the region */
    prgn = REGION_LockRgn(hrgn);
    if (prgn == NULL)
    {
        return FALSE;
    }

    /* Call the internal API */
    REGION_SetRectRgn(prgn, xLeft, yTop, xRight, yBottom);

    /* Unlock the region and return success */
    REGION_UnlockRgn(prgn);
    return TRUE;
}

Referenced by co_UserGetUpdateRgn(), and SetRectRgn().

REGION_AllocRgnWithHandle()

PREGION FASTCALL REGION_AllocRgnWithHandle

(

INT

nReg

)

Definition at line 2219 of file region.c.

{
    //HRGN hReg;
    PREGION pReg;

    pReg = (PREGION)GDIOBJ_AllocateObject(GDIObjType_RGN_TYPE,
                                          sizeof(REGION),
                                          BASEFLAG_LOOKASIDE);
    if (pReg == NULL)
    {
        DPRINT1("Could not allocate a palette.\n");
        return NULL;
    }

    //hReg = pReg->BaseObject.hHmgr;

    if ((nReg == 0) || (nReg == 1))
    {
        /* Testing shows that > 95% of all regions have only 1 rect.
           Including that here saves us from having to do another allocation */
        pReg->Buffer = &pReg->rdh.rcBound;
    }
    else
    {
        pReg->Buffer = ExAllocatePoolWithTag(PagedPool,
                                             nReg * sizeof(RECT),
                                             TAG_REGION);
        if (pReg->Buffer == NULL)
        {
            DPRINT1("Could not allocate region buffer\n");
            GDIOBJ_vDeleteObject(&pReg->BaseObject);
            return NULL;
        }
    }

    EMPTY_REGION(pReg);
    pReg->rdh.dwSize = sizeof(RGNDATAHEADER);
    pReg->rdh.nCount = nReg;
    pReg->rdh.nRgnSize = nReg * sizeof(RECT);
    pReg->prgnattr = &pReg->rgnattr;

    /* Initialize the region attribute */
    pReg->rgnattr.AttrFlags = 0;
    pReg->rgnattr.iComplexity = SIMPLEREGION;
    pReg->rgnattr.Rect = pReg->rdh.rcBound;

    /* Finally insert the region into the handle table */
    if (!GDIOBJ_hInsertObject(&pReg->BaseObject, GDI_OBJ_HMGR_POWNED))
    {
        DPRINT1("Could not insert palette into handle table.\n");
        GDIOBJ_vFreeObject(&pReg->BaseObject);
        return NULL;
    }

    return pReg;
}

Referenced by REGION_AllocUserRgnWithHandle(), and REGION_XorRegion().

REGION_AllocUserRgnWithHandle()

PREGION FASTCALL REGION_AllocUserRgnWithHandle

(

INT

nRgn

)

Definition at line 2313 of file region.c.

{
    PREGION prgn;

    prgn = REGION_AllocRgnWithHandle(nRgn);
    if (prgn == NULL)
    {
        return NULL;
    }

    if (!REGION_bAllocRgnAttr(prgn))
    {
        ASSERT(FALSE);
    }

    return prgn;
}

Referenced by GreCreateFrameRgn(), GreCreatePolyPolygonRgn(), NtGdiCreateRectRgn(), NtGdiCreateRoundRectRgn(), NtGdiExtCreateRegion(), and NtGdiPathToRegion().

REGION_bAddRect()

static __inline BOOL REGION_bAddRect ( _Inout_ PREGION  prgn, _In_ LONG  left, _In_ LONG  top, _In_ LONG  right, _In_ LONG  bottom  )

static

Definition at line 504 of file region.c.

{
    if (!REGION_bEnsureBufferSize(prgn, prgn->rdh.nCount + 1))
    {
        return FALSE;
    }

    REGION_vAddRect(prgn, left, top, right, bottom);
    return TRUE;
}

Referenced by REGION_bMergeRect(), REGION_IntersectO(), and REGION_SubtractO().

REGION_bAllocRgnAttr()

BOOL NTAPI REGION_bAllocRgnAttr

(

PREGION

prgn

)

Definition at line 2279 of file region.c.

{
    PPROCESSINFO ppi;
    PRGN_ATTR prgnattr;

    NT_ASSERT(prgn->prgnattr == &prgn->rgnattr);

    ppi = PsGetCurrentProcessWin32Process();
    ASSERT(ppi);

    prgnattr = GdiPoolAllocate(ppi->pPoolRgnAttr);
    if (prgnattr == NULL)
    {
        DPRINT1("Could not allocate RGN attr\n");
        return FALSE;
    }

    /* Copy the current region attribute */
    *prgnattr = prgn->rgnattr;

    /* Set the object attribute in the handle table */
    prgn->prgnattr = prgnattr;
    GDIOBJ_vSetObjectAttr(&prgn->BaseObject, prgnattr);

    return TRUE;
}

Referenced by REGION_AllocUserRgnWithHandle().

REGION_bCopy()

BOOL FASTCALL REGION_bCopy	(	PREGION	dst,
		PREGION	src
	)

Definition at line 1844 of file region.c.

{
    if ( !dst || !src ) return FALSE;
    return REGION_CopyRegion( dst, src);
}

Referenced by _Success_(), CLIPPING_UpdateGCRegion(), and GdiSelectVisRgn().

REGION_bEnsureBufferSize()

static __inline BOOL REGION_bEnsureBufferSize ( _Inout_ PREGION  prgn, _In_ UINT  cRects  )

static

Definition at line 468 of file region.c.

{
    /* Check if the current region size is too small */
    if (cRects > prgn->rdh.nRgnSize / sizeof(RECTL))
    {
        /* Allocate a new buffer */
        return REGION_bGrowBufferSize(prgn, cRects);
    }

    return TRUE;
}

Referenced by REGION_bAddRect(), REGION_SubtractNonO1(), REGION_SubtractO(), and REGION_UnionNonO().

REGION_bGrowBufferSize()

static BOOL REGION_bGrowBufferSize ( _Inout_ PREGION  prgn, _In_ UINT  cRects  )

static

Definition at line 418 of file region.c.

{
    ULONG cjNewSize;
    PVOID pvBuffer;
    NT_ASSERT(cRects > 0);

    /* Make sure we don't overflow */
    if (cRects > MAXULONG / sizeof(RECTL))
    {
        return FALSE;
    }

    /* Calculate new buffer size */
    cjNewSize = cRects * sizeof(RECTL);

    /* Avoid allocating too often, by duplicating the old buffer size
       Note: we don't do an overflow check, since the old size will never
       get that large before running out of memory. */
    if (2 * prgn->rdh.nRgnSize > cjNewSize)
    {
        cjNewSize = 2 * prgn->rdh.nRgnSize;
    }

    /* Allocate the new buffer */
    pvBuffer = ExAllocatePoolWithTag(PagedPool, cjNewSize, TAG_REGION);
    if (pvBuffer == NULL)
    {
        return FALSE;
    }

    /* Copy the rects into the new buffer */
    COPY_RECTS(pvBuffer, prgn->Buffer, prgn->rdh.nCount);

    /* Free the old buffer */
    if (prgn->Buffer != &prgn->rdh.rcBound)
    {
        ExFreePoolWithTag(prgn->Buffer, TAG_REGION);
    }

    /* Set the new buffer */
    prgn->Buffer = pvBuffer;
    prgn->rdh.nRgnSize = cjNewSize;

    return TRUE;
}

Referenced by REGION_bEnsureBufferSize().

REGION_bIntersectRegion()

BOOL FASTCALL REGION_bIntersectRegion	(	PREGION	newReg,
		PREGION	reg1,
		PREGION	reg2
	)

Definition at line 1854 of file region.c.

{
    if ( !newReg || !reg1 || !reg2 ) return FALSE;
    return REGION_IntersectRegion( newReg, reg1, reg2);
}

Referenced by CLIPPING_UpdateGCRegion(), and IntGdiSetMetaRgn().

REGION_bMakeFrameRegion()

static BOOL REGION_bMakeFrameRegion ( _Inout_ PREGION  prgnDest, _Inout_ PREGION  prgnSrc, _In_ INT  cx, _In_ INT  cy  )

static

Definition at line 1956 of file region.c.

{
    /* Handle negative cx / cy */
    cx = abs(cx);
    cy = abs(cy);

    /* Check border size (the cast is necessary to catch cx/cy == INT_MIN!) */
    if (((UINT)cx > MAX_COORD) || ((UINT)cy > MAX_COORD))
    {
        return FALSE;
    }

    /* Fail on empty source region */
    if (!REGION_NOT_EMPTY(prgnSrc))
    {
        return FALSE;
    }

    /* Handle trivial case */
    if ((cx == 0) && (cy == 0))
    {
        EMPTY_REGION(prgnDest);
        return TRUE;
    }

    /* Handle simple source region */
    if (REGION_Complexity(prgnSrc) == SIMPLEREGION)
    {
        return REGION_bMakeSimpleFrameRgn(prgnDest, &prgnSrc->rdh.rcBound, cx, cy);
    }

    /* Check if we can move the region to create the frame region */
    if ((prgnSrc->rdh.rcBound.left < (MIN_COORD + cx)) ||
        (prgnSrc->rdh.rcBound.top < (MIN_COORD + cy)) ||
        (prgnSrc->rdh.rcBound.right > (MAX_COORD - cx)) ||
        (prgnSrc->rdh.rcBound.bottom > (MAX_COORD - cy)))
    {
        return FALSE;
    }

    /* Copy the source region */
    if (!REGION_CopyRegion(prgnDest, prgnSrc))
    {
        return FALSE;
    }

    /* Move the source region to the bottom-right */
    NT_VERIFY(REGION_bOffsetRgn(prgnSrc, cx, cy));

    /* Intersect with the source region (this crops the top-left frame) */
    REGION_IntersectRegion(prgnDest, prgnDest, prgnSrc);

    /* Move the source region to the bottom-left */
    NT_VERIFY(REGION_bOffsetRgn(prgnSrc, -2 * cx, 0));

    /* Intersect with the source region (this crops the top-right frame) */
    REGION_IntersectRegion(prgnDest, prgnDest, prgnSrc);

    /* Move the source region to the top-left */
    NT_VERIFY(REGION_bOffsetRgn(prgnSrc, 0, -2 * cy));

    /* Intersect with the source region (this crops the bottom-right frame) */
    REGION_IntersectRegion(prgnDest, prgnDest, prgnSrc);

    /* Move the source region to the top-right  */
    NT_VERIFY(REGION_bOffsetRgn(prgnSrc, 2 * cx, 0));

    /* Intersect with the source region (this crops the bottom-left frame) */
    REGION_IntersectRegion(prgnDest, prgnDest, prgnSrc);

    /* Move the source region back to the original position */
    NT_VERIFY(REGION_bOffsetRgn(prgnSrc, -cx, cy));

    /* Finally subtract the cropped region from the source */
    REGION_SubtractRegion(prgnDest, prgnSrc, prgnDest);

    return TRUE;
}

Referenced by GreCreateFrameRgn().

REGION_bMakeSimpleFrameRgn()

static BOOL REGION_bMakeSimpleFrameRgn ( _Inout_ PREGION  prgn, _In_ PRECTL  prclSrc, _In_ INT  cx, _In_ INT  cy  )

static

Definition at line 1865 of file region.c.

{
    RECTL arcl[4];
    UINT i;

    NT_ASSERT((cx >= 0) && (cy >= 0));
    NT_ASSERT((prclSrc->bottom > prclSrc->top) &&
              (prclSrc->right > prclSrc->left));

    /* Start with an empty region */
    EMPTY_REGION(prgn);

    /* Check for the case where the frame covers the whole rect */
    if (((prclSrc->bottom - prclSrc->top) <= cy * 2) ||
        ((prclSrc->right - prclSrc->left) <= cx * 2))
    {
        prgn->rdh.rcBound = *prclSrc;
        prgn->Buffer[0] = *prclSrc;
        prgn->rdh.nCount = 1;
        return TRUE;
    }

    i = 0;

    if (cy != 0)
    {
        /* Top rectangle */
        arcl[i].left = prclSrc->left;
        arcl[i].top = prclSrc->top;
        arcl[i].right = prclSrc->right;
        arcl[i].bottom = prclSrc->top + cy;
        i++;
    }

    if (cx != 0)
    {
        /* Left rectangle */
        arcl[i].left = prclSrc->left;
        arcl[i].top = prclSrc->top + cy;
        arcl[i].right = prclSrc->left + cx;
        arcl[i].bottom = prclSrc->bottom - cy;
        i++;

        /* Right rectangle */
        arcl[i].left = prclSrc->right - cx;
        arcl[i].top = prclSrc->top + cy;
        arcl[i].right = prclSrc->right;
        arcl[i].bottom = prclSrc->bottom - cy;
        i++;
    }

    if (cy != 0)
    {
        /* Bottom rectangle */
        arcl[i].left = prclSrc->left;
        arcl[i].top = prclSrc->bottom - cy;
        arcl[i].right = prclSrc->right;
        arcl[i].bottom = prclSrc->bottom;
        i++;
    }

    if (i != 0)
    {
        /* The frame results in a complex region. rcBounds remains
           the same, though. */
        prgn->rdh.nCount = i;
        NT_ASSERT(prgn->rdh.nCount > 1);
        prgn->rdh.nRgnSize = prgn->rdh.nCount * sizeof(RECT);
        NT_ASSERT(prgn->Buffer == &prgn->rdh.rcBound);
        prgn->Buffer = ExAllocatePoolWithTag(PagedPool,
                                            prgn->rdh.nRgnSize,
                                            TAG_REGION);
        if (prgn->Buffer == NULL)
        {
            prgn->rdh.nRgnSize = 0;
            return FALSE;
        }

        _PRAGMA_WARNING_SUPPRESS(__WARNING_MAYBE_UNINIT_VAR) // arcl is initialized
        COPY_RECTS(prgn->Buffer, arcl, prgn->rdh.nCount);
    }

    return TRUE;
}

Referenced by REGION_bMakeFrameRegion().

REGION_bMergeRect()

static __inline BOOL REGION_bMergeRect ( _Inout_ PREGION  prgn, _In_ LONG  left, _In_ LONG  top, _In_ LONG  right, _In_ LONG  bottom  )

static

Definition at line 1385 of file region.c.

{
    if ((prgn->rdh.nCount != 0) &&
        (prgn->Buffer[prgn->rdh.nCount - 1].top == top) &&
        (prgn->Buffer[prgn->rdh.nCount - 1].bottom == bottom) &&
        (prgn->Buffer[prgn->rdh.nCount - 1].right >= left))
    {
        if (prgn->Buffer[prgn->rdh.nCount - 1].right < right)
        {
            prgn->Buffer[prgn->rdh.nCount - 1].right = right;
        }
    }
    else
    {
        if (!REGION_bAddRect(prgn, left, top, right, bottom))
        {
            return FALSE;
        }
    }

    return TRUE;
}

Referenced by REGION_UnionO().

REGION_bOffsetRgn()

BOOL FASTCALL REGION_bOffsetRgn	(	_Inout_ PREGION	prgn,
		_In_ INT	cx,
		_In_ INT	cy
	)

Definition at line 2727 of file region.c.

{
    PRECTL prcl;
    UINT i;

    NT_ASSERT(prgn != NULL);

    /* Check for trivial case */
    if ((cx == 0) && (cy == 0))
    {
        return TRUE;
    }

    /* Check for empty regions, we ignore the offset values here */
    if (prgn->rdh.nCount == 0)
    {
        return TRUE;
    }

    /* Make sure the offset is within the legal range */
    if ((cx > MAX_COORD) || (cx < MIN_COORD) ||
        (cy > MAX_COORD) || (cy < MIN_COORD))
    {
        return FALSE;
    }

    /* Are we moving right? */
    if (cx > 0)
    {
        /* Check if we stay inside the bounds on the right side */
        if (prgn->rdh.rcBound.right > (MAX_COORD - cx))
        {
            return FALSE;
        }
    }
    else
    {
        /* Check if we stay inside the bounds on the left side */
        if (prgn->rdh.rcBound.left < (MIN_COORD - cx))
        {
            return FALSE;
        }
    }

    /* Are we moving down? */
    if (cy > 0)
    {
        /* Check if we stay inside the bounds on the right side */
        if (prgn->rdh.rcBound.bottom > (MAX_COORD - cy))
        {
            return FALSE;
        }
    }
    else
    {
        /* Check if we stay inside the bounds on the left side */
        if (prgn->rdh.rcBound.top < (MIN_COORD - cy))
        {
            return FALSE;
        }
    }

    /* Loop to move the rects */
    prcl = prgn->Buffer;
    for (i = 0; i < prgn->rdh.nCount; i++)
    {
        prcl[i].left += cx;
        prcl[i].right += cx;
        prcl[i].top += cy;
        prcl[i].bottom += cy;
    }

    /* Finally update the bounds rect */
    if (prgn->Buffer != &prgn->rdh.rcBound)
    {
        prgn->rdh.rcBound.left += cx;
        prgn->rdh.rcBound.right += cx;
        prgn->rdh.rcBound.top += cy;
        prgn->rdh.rcBound.bottom += cy;
    }

    return TRUE;
}

Referenced by CLIPPING_UpdateGCRegion(), co_IntGetUpdateRgn(), co_UserRedrawWindow(), co_VIS_WindowLayoutChanged(), co_WinPosSetWindowPos(), DceResetActiveDCEs(), GdiSelectVisRgn(), IntGdiBitBltRgn(), IntGdiFillRgn(), IntInvalidateWindows(), IntScrollWindowEx(), NtGdiGetRandomRgn(), NtGdiOffsetClipRgn(), NtGdiOffsetRgn(), REGION_bMakeFrameRegion(), REGION_bXformRgn(), UserScrollDC(), and VIS_ComputeVisibleRegion().

REGION_bXformRgn()

BOOL FASTCALL REGION_bXformRgn	(	_Inout_ PREGION	prgn,
		_In_ PMATRIX	pmx
	)

Definition at line 2082 of file region.c.

{
    XFORMOBJ xo;
    ULONG i, cjSize;
    PPOINT ppt;
    PULONG pcPoints;
    RECT rect;
    BOOL bResult;

    /* Check for zero rectangles and return TRUE for translation only matrices */
    if (prgn->rdh.nCount < 1)
        return (pmx->flAccel & XFORM_UNITY) != 0;

    /* Check if this is a scaling only matrix (off-diagonal elements are 0 */
    if (pmx->flAccel & XFORM_SCALE)
    {
        /* Check if this is a translation only matrix */
        if (pmx->flAccel & XFORM_UNITY)
        {
            /* Just offset the region */
            return REGION_bOffsetRgn(prgn, (pmx->fxDx + 8) / 16, (pmx->fxDy + 8) / 16);
        }
        else
        {
            /* Initialize the xform object */
            XFORMOBJ_vInit(&xo, pmx);

            /* Scaling can move the rects out of the coordinate space, so
             * we first need to check whether we can apply the transformation
             * on the bounds rect without modifying the region */
            if (!XFORMOBJ_bApplyXform(&xo, XF_LTOL, 2, &prgn->rdh.rcBound, &rect))
            {
                return FALSE;
            }

            /* Apply the xform to the rects in the region */
            if (!XFORMOBJ_bApplyXform(&xo,
                                      XF_LTOL,
                                      prgn->rdh.nCount * 2,
                                      prgn->Buffer,
                                      prgn->Buffer))
            {
                /* This can not happen, since we already checked the bounds! */
                NT_ASSERT(FALSE);
            }

            /* Reset bounds */
            RECTL_vSetEmptyRect(&prgn->rdh.rcBound);

            /* Loop all rects in the region */
            for (i = 0; i < prgn->rdh.nCount; i++)
            {
                /* Make sure the rect is well-ordered after the xform */
                RECTL_vMakeWellOrdered(&prgn->Buffer[i]);

                /* Update bounds */
                if (!RECTL_bUnionRect(&prgn->rdh.rcBound,
                                 &prgn->rdh.rcBound,
                                 &prgn->Buffer[i]))
                {
                    DPRINT1("NULL Set in Union Rects\n");
                    return FALSE;
                }
            }

            /* Loop all rects in the region */
            for (i = 0; i < prgn->rdh.nCount - 1; i++)
            {
                NT_ASSERT(prgn->Buffer[i].top <= prgn->Buffer[i].bottom);
                NT_ASSERT(prgn->Buffer[i + 1].top >= prgn->Buffer[i].top);
            }

            return TRUE;
        }
    }
    else
    {
        /* Allocate a buffer for the polygons */
        cjSize = prgn->rdh.nCount * (4 * sizeof(POINT) + sizeof(ULONG));
        ppt = ExAllocatePoolWithTag(PagedPool, cjSize, GDITAG_REGION);
        if (ppt == NULL)
        {
            return FALSE;
        }

        /* Fill the buffer with the rects */
        pcPoints = (PULONG)&ppt[4 * prgn->rdh.nCount];
        for (i = 0; i < prgn->rdh.nCount; i++)
        {
            /* Make sure the rect is within the legal range */
            pcPoints[i] = 4;
            ppt[4 * i + 0].x = prgn->Buffer[i].left;
            ppt[4 * i + 0].y = prgn->Buffer[i].top;
            ppt[4 * i + 1].x = prgn->Buffer[i].right;
            ppt[4 * i + 1].y = prgn->Buffer[i].top;
            ppt[4 * i + 2].x = prgn->Buffer[i].right;
            ppt[4 * i + 2].y = prgn->Buffer[i].bottom;
            ppt[4 * i + 3].x = prgn->Buffer[i].left;
            ppt[4 * i + 3].y = prgn->Buffer[i].bottom;
        }

        /* Initialize the xform object */
        XFORMOBJ_vInit(&xo, pmx);

        /* Apply the xform to the rects in the buffer */
        if (!XFORMOBJ_bApplyXform(&xo,
                                  XF_LTOL,
                                  prgn->rdh.nCount * 2,
                                  ppt,
                                  ppt))
        {
            /* This means, there were coordinates that would go outside of
               the coordinate space after the transformation */
            ExFreePoolWithTag(ppt, GDITAG_REGION);
            return FALSE;
        }

        /* Now use the polygons to create a polygon region */
        bResult = REGION_SetPolyPolygonRgn(prgn,
                                           ppt,
                                           pcPoints,
                                           prgn->rdh.nCount,
                                           WINDING);

        /* Free the polygon buffer */
        ExFreePoolWithTag(ppt, GDITAG_REGION);

        return bResult;
    }

}

Referenced by REGION_LPTODP().

REGION_Coalesce()

static INT FASTCALL REGION_Coalesce ( PREGION  pReg, INT  prevStart, INT  curStart  )

static

 Attempt to merge the rects in the current band with those in the
 previous one. Used only by REGION_RegionOp.

Results: The new index for the previous band.

Note

Side Effects: If coalescing takes place:

• rectangles in the previous band will have their bottom fields altered.
• pReg->numRects will be decreased.

Definition at line 822 of file region.c.

{
    RECTL *pPrevRect;  /* Current rect in previous band */
    RECTL *pCurRect;   /* Current rect in current band */
    RECTL *pRegEnd;    /* End of region */
    INT curNumRects;   /* Number of rectangles in current band */
    INT prevNumRects;  /* Number of rectangles in previous band */
    INT bandtop;       /* Top coordinate for current band */

    pRegEnd = pReg->Buffer + pReg->rdh.nCount;
    pPrevRect = pReg->Buffer + prevStart;
    prevNumRects = curStart - prevStart;

    /* Figure out how many rectangles are in the current band. Have to do
     * this because multiple bands could have been added in REGION_RegionOp
     * at the end when one region has been exhausted. */
    pCurRect = pReg->Buffer + curStart;
    bandtop = pCurRect->top;
    for (curNumRects = 0;
         (pCurRect != pRegEnd) && (pCurRect->top == bandtop);
         curNumRects++)
    {
        pCurRect++;
    }

    if (pCurRect != pRegEnd)
    {
        /* If more than one band was added, we have to find the start
         * of the last band added so the next coalescing job can start
         * at the right place... (given when multiple bands are added,
         * this may be pointless -- see above). */
        pRegEnd--;
        while ((pRegEnd-1)->top == pRegEnd->top)
        {
            pRegEnd--;
        }

        curStart = pRegEnd - pReg->Buffer;
        pRegEnd = pReg->Buffer + pReg->rdh.nCount;
    }

    if ((curNumRects == prevNumRects) && (curNumRects != 0))
    {
        pCurRect -= curNumRects;

        /* The bands may only be coalesced if the bottom of the previous
         * matches the top scanline of the current. */
        if (pPrevRect->bottom == pCurRect->top)
        {
            /* Make sure the bands have rects in the same places. This
             * assumes that rects have been added in such a way that they
             * cover the most area possible. I.e. two rects in a band must
             * have some horizontal space between them. */
            do
            {
                if ((pPrevRect->left != pCurRect->left) ||
                    (pPrevRect->right != pCurRect->right))
                {
                    /* The bands don't line up so they can't be coalesced. */
                    return (curStart);
                }

                pPrevRect++;
                pCurRect++;
                prevNumRects -= 1;
            }
            while (prevNumRects != 0);

            pReg->rdh.nCount -= curNumRects;
            pCurRect -= curNumRects;
            pPrevRect -= curNumRects;

            /* The bands may be merged, so set the bottom of each rect
             * in the previous band to that of the corresponding rect in
             * the current band. */
            do
            {
                pPrevRect->bottom = pCurRect->bottom;
                pPrevRect++;
                pCurRect++;
                curNumRects -= 1;
            }
            while (curNumRects != 0);

            /* If only one band was added to the region, we have to backup
             * curStart to the start of the previous band.
             *
             * If more than one band was added to the region, copy the
             * other bands down. The assumption here is that the other bands
             * came from the same region as the current one and no further
             * coalescing can be done on them since it's all been done
             * already... curStart is already in the right place. */
            if (pCurRect == pRegEnd)
            {
                curStart = prevStart;
            }
            else
            {
                do
                {
                    *pPrevRect++ = *pCurRect++;
                }
                while (pCurRect != pRegEnd);
            }
        }
    }

    return (curStart);
}

Referenced by REGION_RegionOp().

REGION_Complexity()

INT FASTCALL REGION_Complexity

(

PREGION

prgn

)

Definition at line 567 of file region.c.

{
    if (prgn == NULL)
        return NULLREGION;

    DPRINT("Region Complexity -> %lu", prgn->rdh.nCount);
    switch (prgn->rdh.nCount)
    {
        case 0:
            return NULLREGION;
        case 1:
            return SIMPLEREGION;
        default:
            return COMPLEXREGION;
    }
}

Referenced by _Success_(), co_WinPosSetWindowPos(), DxEngGetDCState(), IntGdiCombineRgn(), IntGdiSetMetaRgn(), NtGdiOffsetClipRgn(), NtGdiOffsetRgn(), REGION_bMakeFrameRegion(), REGION_CropRegion(), REGION_GetRgnBox(), REGION_SubtractRectFromRgn(), and REGION_UnlockRgn().

REGION_computeWAET()

static VOID FASTCALL REGION_computeWAET ( EDGE_TABLE_ENTRY *  AET )

static

Definition at line 2957 of file region.c.

{
    register EDGE_TABLE_ENTRY *pWETE;
    register INT inside = 1;
    register INT isInside = 0;

    AET->nextWETE = (EDGE_TABLE_ENTRY *)NULL;
    pWETE = AET;
    AET = AET->next;
    while (AET)
    {
        if (AET->ClockWise)
            isInside++;
        else
            isInside--;

        if ((!inside && !isInside) ||
            ( inside &&  isInside))
        {
            pWETE->nextWETE = AET;
            pWETE = AET;
            inside = !inside;
        }
        AET = AET->next;
    }

    pWETE->nextWETE = (EDGE_TABLE_ENTRY *)NULL;
}

Referenced by REGION_SetPolyPolygonRgn().

REGION_CopyRegion()

static BOOL FASTCALL REGION_CopyRegion ( PREGION  dst, PREGION  src  )

static

Definition at line 587 of file region.c.

{
    /* Only copy if source and dest are not equal */
    if (dst != src)
    {
        /* Check if we need to increase our buffer */
        if (dst->rdh.nRgnSize < src->rdh.nCount * sizeof(RECT))
        {
            PRECTL temp;

            /* Allocate a new buffer */
            temp = ExAllocatePoolWithTag(PagedPool,
                                         src->rdh.nCount * sizeof(RECT),
                                         TAG_REGION);
            if (temp == NULL)
                return FALSE;

            /* Free the old buffer */
            if ((dst->Buffer != NULL) && (dst->Buffer != &dst->rdh.rcBound))
                ExFreePoolWithTag(dst->Buffer, TAG_REGION);

            /* Set the new buffer and the size */
            dst->Buffer = temp;
            dst->rdh.nRgnSize = src->rdh.nCount * sizeof(RECT);
        }

        dst->rdh.nCount = src->rdh.nCount;
        dst->rdh.rcBound.left = src->rdh.rcBound.left;
        dst->rdh.rcBound.top = src->rdh.rcBound.top;
        dst->rdh.rcBound.right = src->rdh.rcBound.right;
        dst->rdh.rcBound.bottom = src->rdh.rcBound.bottom;
        dst->rdh.iType = src->rdh.iType;
        COPY_RECTS(dst->Buffer, src->Buffer, src->rdh.nCount);
    }

    return TRUE;
}

Referenced by IntGdiCombineRgn(), REGION_bCopy(), REGION_bMakeFrameRegion(), REGION_SubtractRegion(), and REGION_UnionRegion().

REGION_CreateETandAET()

static VOID FASTCALL REGION_CreateETandAET ( const ULONG *  Count, INT  nbpolygons, const POINT *  pts, EDGE_TABLE *  ET, EDGE_TABLE_ENTRY *  AET, EDGE_TABLE_ENTRY *  pETEs, SCANLINE_LISTBLOCK *  pSLLBlock  )

static

Definition at line 3189 of file region.c.

{
    const POINT *top, *bottom;
    const POINT *PrevPt, *CurrPt, *EndPt;
    INT poly, count;
    INT iSLLBlock = 0;
    INT dy;

    /* Initialize the Active Edge Table */
    AET->next = (EDGE_TABLE_ENTRY *)NULL;
    AET->back = (EDGE_TABLE_ENTRY *)NULL;
    AET->nextWETE = (EDGE_TABLE_ENTRY *)NULL;
    AET->bres.minor_axis = SMALL_COORDINATE;

    /* Initialize the Edge Table. */
    ET->scanlines.next = (SCANLINE_LIST *)NULL;
    ET->ymax = SMALL_COORDINATE;
    ET->ymin = LARGE_COORDINATE;
    pSLLBlock->next = (SCANLINE_LISTBLOCK *)NULL;

    EndPt = pts - 1;
    for (poly = 0; poly < nbpolygons; poly++)
    {
        count = Count[poly];
        EndPt += count;
        if (count < 2)
            continue;

        PrevPt = EndPt;

        /*  For each vertex in the array of points.
         *  In this loop we are dealing with two vertices at
         *  a time -- these make up one edge of the polygon. */
        while (count--)
        {
            CurrPt = pts++;

            /*  Find out which point is above and which is below. */
            if (PrevPt->y > CurrPt->y)
            {
                bottom = PrevPt, top = CurrPt;
                pETEs->ClockWise = 0;
            }
            else
            {
                bottom = CurrPt, top = PrevPt;
                pETEs->ClockWise = 1;
            }

            /* Don't add horizontal edges to the Edge table. */
            if (bottom->y != top->y)
            {
                /* -1 so we don't get last scanline */
                pETEs->ymax = bottom->y - 1;

                /*  Initialize integer edge algorithm */
                dy = bottom->y - top->y;
                BRESINITPGONSTRUCT(dy, top->x, bottom->x, pETEs->bres);

                REGION_InsertEdgeInET(ET,
                                      pETEs,
                                      top->y,
                                      &pSLLBlock,
                                      &iSLLBlock);

                if (PrevPt->y > ET->ymax)
                    ET->ymax = PrevPt->y;
                if (PrevPt->y < ET->ymin)
                    ET->ymin = PrevPt->y;
                pETEs++;
            }

            PrevPt = CurrPt;
        }
    }
}

Referenced by REGION_SetPolyPolygonRgn().

REGION_CropRegion()

INT FASTCALL REGION_CropRegion	(	PREGION	rgnDst,
		PREGION	rgnSrc,
		const RECTL *	rect
	)

Definition at line 678 of file region.c.

{
    PRECTL lpr, rpr;
    ULONG i, j, clipa, clipb, nRgnSize;
    INT left = MAXLONG;
    INT right = MINLONG;
    INT top = MAXLONG;
    INT bottom = MINLONG;

    if ((rect->left >= rect->right) ||
        (rect->top >= rect->bottom) ||
        (EXTENTCHECK(rect, &rgnSrc->rdh.rcBound) == 0))
    {
        goto empty;
    }

    /* Skip all rects that are completely above our intersect rect */
    for (clipa = 0; clipa < rgnSrc->rdh.nCount; clipa++)
    {
        /* bottom is exclusive, so break when we go above it */
        if (rgnSrc->Buffer[clipa].bottom > rect->top) break;
    }

    /* Bail out, if there is nothing left */
    if (clipa == rgnSrc->rdh.nCount) goto empty;

    /* Find the last rect that is still within the intersect rect (exclusive) */
    for (clipb = clipa; clipb < rgnSrc->rdh.nCount; clipb++)
    {
        /* bottom is exclusive, so stop, when we start at that y pos */
        if (rgnSrc->Buffer[clipb].top >= rect->bottom) break;
    }

    /* Bail out, if there is nothing left */
    if (clipb == clipa) goto empty;

    // clipa - index of the first rect in the first intersecting band
    // clipb - index of the last rect in the last intersecting band plus 1

    /* Check if the buffer in the dest region is large enough,
       otherwise allocate a new one */
    nRgnSize = (clipb - clipa) * sizeof(RECT);
    if ((rgnDst != rgnSrc) && (rgnDst->rdh.nRgnSize < nRgnSize))
    {
        PRECTL temp;
        temp = ExAllocatePoolWithTag(PagedPool, nRgnSize, TAG_REGION);
        if (temp == NULL)
            return ERROR;

        /* Free the old buffer */
        if (rgnDst->Buffer && (rgnDst->Buffer != &rgnDst->rdh.rcBound))
            ExFreePoolWithTag(rgnDst->Buffer, TAG_REGION);

        rgnDst->Buffer = temp;
        rgnDst->rdh.nCount = 0;
        rgnDst->rdh.nRgnSize = nRgnSize;
        rgnDst->rdh.iType = RDH_RECTANGLES;
    }

    /* Loop all rects within the intersect rect from the y perspective */
    for (i = clipa, j = 0; i < clipb ; i++)
    {
        /* i - src index, j - dst index, j is always <= i for obvious reasons */

        lpr = &rgnSrc->Buffer[i];

        /* Make sure the source rect is not retarded */
        ASSERT(lpr->bottom > lpr->top);
        ASSERT(lpr->right > lpr->left);

        /* We already checked above, this should hold true */
        ASSERT(lpr->bottom > rect->top);
        ASSERT(lpr->top < rect->bottom);

        /* Check if this rect is really inside the intersect rect */
        if ((lpr->left < rect->right) && (lpr->right > rect->left))
        {
            rpr = &rgnDst->Buffer[j];

            /* Crop the rect with the intersect rect */
            rpr->top = max(lpr->top, rect->top);
            rpr->bottom = min(lpr->bottom, rect->bottom);
            rpr->left = max(lpr->left, rect->left);
            rpr->right = min(lpr->right, rect->right);

            /* Make sure the resulting rect is not retarded */
            ASSERT(rpr->bottom > rpr->top);
            ASSERT(rpr->right > rpr->left);

            /* Track new bounds */
            if (rpr->left < left) left = rpr->left;
            if (rpr->right > right) right = rpr->right;
            if (rpr->top < top) top = rpr->top;
            if (rpr->bottom > bottom) bottom = rpr->bottom;

            /* Next target rect */
            j++;
        }
    }

    if (j == 0) goto empty;

    /* Update the bounds rect */
    rgnDst->rdh.rcBound.left = left;
    rgnDst->rdh.rcBound.right = right;
    rgnDst->rdh.rcBound.top = top;
    rgnDst->rdh.rcBound.bottom = bottom;

    /* Set new rect count */
    rgnDst->rdh.nCount = j;

    return REGION_Complexity(rgnDst);

empty:
    if (rgnDst->Buffer == NULL)
    {
        rgnDst->Buffer = &rgnDst->rdh.rcBound;
    }

    EMPTY_REGION(rgnDst);
    return NULLREGION;
}

REGION_Delete()

VOID FASTCALL REGION_Delete

(

PREGION

pRgn

)

Definition at line 2468 of file region.c.

{
    if (pRgn == prgnDefault)
        return;

    GDIOBJ_vDeleteObject(&pRgn->BaseObject);
}

Referenced by _Success_(), CLIPPING_UpdateGCRegion(), co_UserRedrawWindow(), co_VIS_WindowLayoutChanged(), co_WinPosSetWindowPos(), DC_vCleanup(), DC_vCopyState(), DC_vUpdateDC(), DceUpdateVisRgn(), GreCreateFrameRgn(), GreCreatePolyPolygonRgn(), IntEngWndUpdateClipObj(), IntGdiBitBltRgn(), IntGdiCleanDC(), IntGdiFillRgn(), IntGdiReleaseVisRgn(), IntGdiSetMetaRgn(), IntInvalidateWindows(), IntScrollWindowEx(), IntValidateParents(), NtGdiExcludeClipRect(), NtGdiIntersectClipRect(), NtGdiPathToRegion(), NtGdiSelectClipPath(), PATH_FillPathEx(), UserRedrawDesktop(), UserScrollDC(), and VIS_ComputeVisibleRegion().

REGION_FreeStorage()

static VOID FASTCALL REGION_FreeStorage ( SCANLINE_LISTBLOCK *  pSLLBlock )

static

Definition at line 3041 of file region.c.

{
    SCANLINE_LISTBLOCK   *tmpSLLBlock;

    while (pSLLBlock)
    {
        tmpSLLBlock = pSLLBlock->next;
        ExFreePoolWithTag(pSLLBlock, TAG_REGION);
        pSLLBlock = tmpSLLBlock;
    }
}

Referenced by REGION_SetPolyPolygonRgn().

REGION_GetRgnBox()

INT FASTCALL REGION_GetRgnBox	(	PREGION	Rgn,
		PRECTL	pRect
	)

Definition at line 2562 of file region.c.

{
    DWORD ret;

    if (Rgn != NULL)
    {
        *pRect = Rgn->rdh.rcBound;
        ret = REGION_Complexity(Rgn);

        return ret;
    }
    return 0; // If invalid region return zero
}

Referenced by _Success_(), co_WinPosSetWindowPos(), IntGdiBitBltRgn(), IntGdiFillRgn(), IntGdiGetRgnBox(), NtGdiExtFloodFill(), NtGdiExtSelectClipRgn(), NtGdiGetBoundsRect(), NtGdiGetRgnBox(), NtUserEnumDisplayMonitors(), UpdateVisRgn(), and UserScrollDC().

REGION_InsertEdgeInET()

static VOID FASTCALL REGION_InsertEdgeInET ( EDGE_TABLE *  ET, EDGE_TABLE_ENTRY *  ETE, INT  scanline, SCANLINE_LISTBLOCK **  SLLBlock, INT *  iSLLBlock  )

static

Definition at line 2826 of file region.c.

{
    EDGE_TABLE_ENTRY *start, *prev;
    SCANLINE_LIST *pSLL, *pPrevSLL;
    SCANLINE_LISTBLOCK *tmpSLLBlock;

    /* Find the right bucket to put the edge into */
    pPrevSLL = &ET->scanlines;
    pSLL = pPrevSLL->next;
    while (pSLL && (pSLL->scanline < scanline))
    {
        pPrevSLL = pSLL;
        pSLL = pSLL->next;
    }

    /* Reassign pSLL (pointer to SCANLINE_LIST) if necessary */
    if ((!pSLL) || (pSLL->scanline > scanline))
    {
        if (*iSLLBlock > SLLSPERBLOCK-1)
        {
            tmpSLLBlock = ExAllocatePoolWithTag(PagedPool,
                                                sizeof(SCANLINE_LISTBLOCK),
                                                TAG_REGION);
            if (tmpSLLBlock == NULL)
            {
                DPRINT1("REGION_InsertEdgeInETL(): Can't alloc SLLB\n");
                /* FIXME: Free resources? */
                return;
            }

            (*SLLBlock)->next = tmpSLLBlock;
            tmpSLLBlock->next = (SCANLINE_LISTBLOCK *)NULL;
            *SLLBlock = tmpSLLBlock;
            *iSLLBlock = 0;
        }

        pSLL = &((*SLLBlock)->SLLs[(*iSLLBlock)++]);

        pSLL->next = pPrevSLL->next;
        pSLL->edgelist = (EDGE_TABLE_ENTRY *)NULL;
        pPrevSLL->next = pSLL;
    }

    pSLL->scanline = scanline;

    /* Now insert the edge in the right bucket */
    prev = (EDGE_TABLE_ENTRY *)NULL;
    start = pSLL->edgelist;
    while (start && (start->bres.minor_axis < ETE->bres.minor_axis))
    {
        prev = start;
        start = start->next;
    }

    ETE->next = start;

    if (prev)
        prev->next = ETE;
    else
        pSLL->edgelist = ETE;
}

Referenced by REGION_CreateETandAET().

REGION_InsertionSort()

static BOOL FASTCALL REGION_InsertionSort ( EDGE_TABLE_ENTRY *  AET )

static

Definition at line 2998 of file region.c.

{
    EDGE_TABLE_ENTRY *pETEchase;
    EDGE_TABLE_ENTRY *pETEinsert;
    EDGE_TABLE_ENTRY *pETEchaseBackTMP;
    BOOL changed = FALSE;

    AET = AET->next;
    while (AET)
    {
        pETEinsert = AET;
        pETEchase = AET;
        while (pETEchase->back->bres.minor_axis > AET->bres.minor_axis)
            pETEchase = pETEchase->back;

        AET = AET->next;
        if (pETEchase != pETEinsert)
        {
            pETEchaseBackTMP = pETEchase->back;
            pETEinsert->back->next = AET;
            if (AET)
                AET->back = pETEinsert->back;

            pETEinsert->next = pETEchase;
            pETEchase->back->next = pETEinsert;
            pETEchase->back = pETEinsert;
            pETEinsert->back = pETEchaseBackTMP;
            changed = TRUE;
        }
    }

    return changed;
}

Referenced by REGION_SetPolyPolygonRgn().

REGION_IntersectO()

static BOOL FASTCALL REGION_IntersectO ( PREGION  pReg, PRECTL  r1, PRECTL  r1End, PRECTL  r2, PRECTL  r2End, INT  top, INT  bottom  )

static

Handle an overlapping band for REGION_Intersect.

Results: None.

Note

Side Effects: Rectangles may be added to the region.

Definition at line 1250 of file region.c.

{
    INT left, right;

    while ((r1 != r1End) && (r2 != r2End))
    {
        left = max(r1->left, r2->left);
        right = min(r1->right, r2->right);

        /* If there's any overlap between the two rectangles, add that
         * overlap to the new region.
         * There's no need to check for subsumption because the only way
         * such a need could arise is if some region has two rectangles
         * right next to each other. Since that should never happen... */
        if (left < right)
        {
            if (!REGION_bAddRect(pReg, left, top, right, bottom))
            {
                return FALSE;
            }
        }

        /* Need to advance the pointers. Shift the one that extends
         * to the right the least, since the other still has a chance to
         * overlap with that region's next rectangle, if you see what I mean. */
        if (r1->right < r2->right)
        {
            r1++;
        }
        else if (r2->right < r1->right)
        {
            r2++;
        }
        else
        {
            r1++;
            r2++;
        }
    }

    return TRUE;
}

Referenced by REGION_IntersectRegion().

REGION_IntersectRegion()

static BOOL FASTCALL REGION_IntersectRegion ( PREGION  newReg, PREGION  reg1, PREGION  reg2  )

static

Definition at line 1306 of file region.c.

{
    /* Check for trivial reject */
    if ((reg1->rdh.nCount == 0) ||
        (reg2->rdh.nCount == 0) ||
        (EXTENTCHECK(&reg1->rdh.rcBound, &reg2->rdh.rcBound) == 0))
    {
        newReg->rdh.nCount = 0;
    }
    else
    {
        if (!REGION_RegionOp(newReg,
                        reg1,
                        reg2,
                        REGION_IntersectO,
                        NULL,
                        NULL))
            return FALSE;
    }

    /* Can't alter newReg's extents before we call miRegionOp because
     * it might be one of the source regions and miRegionOp depends
     * on the extents of those regions being the same. Besides, this
     * way there's no checking against rectangles that will be nuked
     * due to coalescing, so we have to examine fewer rectangles. */
    REGION_SetExtents(newReg);
    return TRUE;
}

Referenced by IntGdiCombineRgn(), REGION_bIntersectRegion(), and REGION_bMakeFrameRegion().

REGION_loadAET()

static VOID FASTCALL REGION_loadAET ( EDGE_TABLE_ENTRY *  AET, EDGE_TABLE_ENTRY *  ETEs  )

static

Definition at line 2904 of file region.c.

{
    EDGE_TABLE_ENTRY *pPrevAET;
    EDGE_TABLE_ENTRY *tmp;

    pPrevAET = AET;
    AET = AET->next;
    while (ETEs)
    {
        while (AET && (AET->bres.minor_axis < ETEs->bres.minor_axis))
        {
            pPrevAET = AET;
            AET = AET->next;
        }

        tmp = ETEs->next;
        ETEs->next = AET;
        if (AET)
            AET->back = ETEs;

        ETEs->back = pPrevAET;
        pPrevAET->next = ETEs;
        pPrevAET = ETEs;

        ETEs = tmp;
    }
}

Referenced by REGION_SetPolyPolygonRgn().

REGION_LockRgn()

PREGION FASTCALL REGION_LockRgn

(

_In_ HRGN

hrgn

)

Definition at line 2377 of file region.c.

{
    PREGION prgn;

    prgn = GDIOBJ_LockObject(hrgn, GDIObjType_RGN_TYPE);
    if (prgn == NULL)
        return NULL;

    REGION_vSyncRegion(prgn);
    return prgn;
}

Referenced by _Success_(), co_IntGetUpdateRgn(), co_WinPosSetWindowPos(), DceUpdateVisRgn(), ForceNCPaintErase(), GreCreateFrameRgn(), IntDefWindowProc(), IntGdiGetRgnBox(), IntGdiSetRegionOwner(), IntInvalidateWindows(), IntRectInRegion(), IntScrollWindowEx(), IntValidateParents(), NtGdiExtSelectClipRgn(), NtGdiFillRgn(), NtGdiGetRandomRgn(), NtGdiGetRgnBox(), NtGdiInvertRgn(), NtGdiOffsetRgn(), NtGdiPtInRegion(), NtGdiSetRectRgn(), NtUserCallHwndParamLock(), NtUserRedrawWindow(), PaintSuspendedWindow(), UserScrollDC(), and VIS_ComputeVisibleRegion().

REGION_PtInRegion()

BOOL FASTCALL REGION_PtInRegion	(	PREGION	prgn,
		INT	X,
		INT	Y
	)

Definition at line 2602 of file region.c.

{
    ULONG i;
    PRECT r;

    if (prgn->rdh.nCount > 0 && INRECT(prgn->rdh.rcBound, X, Y))
    {
        r =  prgn->Buffer;
        for (i = 0; i < prgn->rdh.nCount; i++)
        {
            if (INRECT(r[i], X, Y))
                return TRUE;
        }
    }

    return FALSE;
}

Referenced by NtGdiExtFloodFill(), NtGdiPtInRegion(), and NtGdiPtVisible().

REGION_PtsToRegion()

static INT FASTCALL REGION_PtsToRegion ( INT  numFullPtBlocks, INT  iCurPtBlock, POINTBLOCK *  FirstPtBlock, PREGION  reg  )

static

Definition at line 3063 of file region.c.

{
    RECTL *rects;
    POINT *pts;
    POINTBLOCK *CurPtBlock;
    INT i;
    RECTL *extents, *temp;
    INT numRects;

    extents = &reg->rdh.rcBound;

    numRects = ((numFullPtBlocks * NUMPTSTOBUFFER) + iCurPtBlock) >> 1;

    /* Make sure, we have at least one rect */
    if (numRects == 0)
    {
        numRects = 1;
    }

    temp = ExAllocatePoolWithTag(PagedPool, numRects * sizeof(RECT), TAG_REGION);
    if (temp == NULL)
    {
        return 0;
    }

    if (reg->Buffer != NULL)
    {
        COPY_RECTS(temp, reg->Buffer, reg->rdh.nCount);
        if (reg->Buffer != &reg->rdh.rcBound)
            ExFreePoolWithTag(reg->Buffer, TAG_REGION);
    }
    reg->Buffer = temp;

    reg->rdh.nCount = numRects;
    CurPtBlock = FirstPtBlock;
    rects = reg->Buffer - 1;
    numRects = 0;
    extents->left = LARGE_COORDINATE,  extents->right = SMALL_COORDINATE;

    for ( ; numFullPtBlocks >= 0; numFullPtBlocks--)
    {
        /* The loop uses 2 points per iteration */
        i = NUMPTSTOBUFFER >> 1;
        if (numFullPtBlocks == 0)
            i = iCurPtBlock >> 1;

        for (pts = CurPtBlock->pts; i--; pts += 2)
        {
            if (pts->x == pts[1].x)
                continue;

            if ((numRects && pts->x == rects->left) &&
                (pts->y == rects->bottom) &&
                (pts[1].x == rects->right) &&
                ((numRects == 1) || (rects[-1].top != rects->top)) &&
                (i && pts[2].y > pts[1].y))
            {
                rects->bottom = pts[1].y + 1;
                continue;
            }

            numRects++;
            rects++;
            rects->left = pts->x;
            rects->top = pts->y;
            rects->right = pts[1].x;
            rects->bottom = pts[1].y + 1;

            if (rects->left < extents->left)
                extents->left = rects->left;
            if (rects->right > extents->right)
                extents->right = rects->right;
        }

        CurPtBlock = CurPtBlock->next;
    }

    if (numRects)
    {
        extents->top = reg->Buffer->top;
        extents->bottom = rects->bottom;
    }
    else
    {
        extents->left = 0;
        extents->top = 0;
        extents->right = 0;
        extents->bottom = 0;
    }

    reg->rdh.nCount = numRects;

    return(TRUE);
}

Referenced by REGION_SetPolyPolygonRgn().

REGION_RectInRegion()

BOOL FASTCALL REGION_RectInRegion	(	PREGION	Rgn,
		const RECTL *	rect
	)

Definition at line 2625 of file region.c.

{
    PRECTL pCurRect, pRectEnd;
    RECT rc;

    /* Swap the coordinates to make right >= left and bottom >= top */
    /* (region building rectangles are normalized the same way) */
    if (rect->top > rect->bottom)
    {
        rc.top = rect->bottom;
        rc.bottom = rect->top;
    }
    else
    {
        rc.top = rect->top;
        rc.bottom = rect->bottom;
    }

    if (rect->right < rect->left)
    {
        rc.right = rect->left;
        rc.left = rect->right;
    }
    else
    {
        rc.right = rect->right;
        rc.left = rect->left;
    }

    /* This is (just) a useful optimization */
    if ((Rgn->rdh.nCount > 0) && EXTENTCHECK(&Rgn->rdh.rcBound, &rc))
    {
        for (pCurRect = Rgn->Buffer, pRectEnd = pCurRect +
                                                Rgn->rdh.nCount; pCurRect < pRectEnd; pCurRect++)
        {
            if (pCurRect->bottom <= rc.top)
                continue;             /* Not far enough down yet */

            if (pCurRect->top >= rc.bottom)
                break;                /* Too far down */

            if (pCurRect->right <= rc.left)
                continue;              /* Not far enough over yet */

            if (pCurRect->left >= rc.right)
            {
                continue;
            }

            return TRUE;
        }
    }

    return FALSE;
}

Referenced by IntRectInRegion(), and NtGdiRectVisible().

REGION_RegionOp()

static BOOL FASTCALL REGION_RegionOp ( PREGION  newReg, PREGION  reg1, PREGION  reg2, overlapProcp  overlapFunc, nonOverlapProcp  nonOverlap1Func, nonOverlapProcp  nonOverlap2Func  )

static

  Apply an operation to two regions. Called by REGION_Union,
  REGION_Inverse, REGION_Subtract, REGION_Intersect...

Results: None.

Side Effects: The new region is overwritten.

Note

The idea behind this function is to view the two regions as sets. Together they cover a rectangle of area that this function divides into horizontal bands where points are covered only by one region or by both. For the first case, the nonOverlapFunc is called with each the band and the band's upper and lower extents. For the second, the overlapFunc is called to process the entire band. It is responsible for clipping the rectangles in the band, though this function provides the boundaries. At the end of each band, the new region is coalesced, if possible, to reduce the number of rectangles in the region.

Definition at line 960 of file region.c.

{
    RECTL *r1;                         /* Pointer into first region */
    RECTL *r2;                         /* Pointer into 2d region */
    RECTL *r1End;                      /* End of 1st region */
    RECTL *r2End;                      /* End of 2d region */
    INT ybot;                          /* Bottom of intersection */
    INT ytop;                          /* Top of intersection */
    RECTL *oldRects;                   /* Old rects for newReg */
    ULONG prevBand;                    /* Index of start of
                                        * Previous band in newReg */
    ULONG curBand;                     /* Index of start of current band in newReg */
    RECTL *r1BandEnd;                  /* End of current band in r1 */
    RECTL *r2BandEnd;                  /* End of current band in r2 */
    ULONG top;                         /* Top of non-overlapping band */
    ULONG bot;                         /* Bottom of non-overlapping band */

    /* Initialization:
     *  set r1, r2, r1End and r2End appropriately, preserve the important
     * parts of the destination region until the end in case it's one of
     * the two source regions, then mark the "new" region empty, allocating
     * another array of rectangles for it to use. */
    r1 = reg1->Buffer;
    r2 = reg2->Buffer;
    r1End = r1 + reg1->rdh.nCount;
    r2End = r2 + reg2->rdh.nCount;

    /* newReg may be one of the src regions so we can't empty it. We keep a
     * note of its rects pointer (so that we can free them later), preserve its
     * extents and simply set numRects to zero. */
    oldRects = newReg->Buffer;
    newReg->rdh.nCount = 0;

    /* Allocate a reasonable number of rectangles for the new region. The idea
     * is to allocate enough so the individual functions don't need to
     * reallocate and copy the array, which is time consuming, yet we don't
     * have to worry about using too much memory. I hope to be able to
     * nuke the Xrealloc() at the end of this function eventually. */
    newReg->rdh.nRgnSize = max(reg1->rdh.nCount + 1, reg2->rdh.nCount) * 2 * sizeof(RECT);

    newReg->Buffer = ExAllocatePoolWithTag(PagedPool,
                                           newReg->rdh.nRgnSize,
                                           TAG_REGION);
    if (newReg->Buffer == NULL)
    {
        newReg->rdh.nRgnSize = 0;
        return FALSE;
    }

    /* Initialize ybot and ytop.
     * In the upcoming loop, ybot and ytop serve different functions depending
     * on whether the band being handled is an overlapping or non-overlapping
     * band.
     *  In the case of a non-overlapping band (only one of the regions
     * has points in the band), ybot is the bottom of the most recent
     * intersection and thus clips the top of the rectangles in that band.
     * ytop is the top of the next intersection between the two regions and
     * serves to clip the bottom of the rectangles in the current band.
     *  For an overlapping band (where the two regions intersect), ytop clips
     * the top of the rectangles of both regions and ybot clips the bottoms. */
    if (reg1->rdh.rcBound.top < reg2->rdh.rcBound.top)
        ybot = reg1->rdh.rcBound.top;
    else
        ybot = reg2->rdh.rcBound.top;

    /* prevBand serves to mark the start of the previous band so rectangles
     * can be coalesced into larger rectangles. qv. miCoalesce, above.
     * In the beginning, there is no previous band, so prevBand == curBand
     * (curBand is set later on, of course, but the first band will always
     * start at index 0). prevBand and curBand must be indices because of
     * the possible expansion, and resultant moving, of the new region's
     * array of rectangles. */
    prevBand = 0;
    do
    {
        curBand = newReg->rdh.nCount;

        /* This algorithm proceeds one source-band (as opposed to a
         * destination band, which is determined by where the two regions
         * intersect) at a time. r1BandEnd and r2BandEnd serve to mark the
         * rectangle after the last one in the current band for their
         * respective regions. */
        r1BandEnd = r1;
        while ((r1BandEnd != r1End) && (r1BandEnd->top == r1->top))
        {
            r1BandEnd++;
        }

        r2BandEnd = r2;
        while ((r2BandEnd != r2End) && (r2BandEnd->top == r2->top))
        {
            r2BandEnd++;
        }

        /* First handle the band that doesn't intersect, if any.
         *
         * Note that attention is restricted to one band in the
         * non-intersecting region at once, so if a region has n
         * bands between the current position and the next place it overlaps
         * the other, this entire loop will be passed through n times. */
        if (r1->top < r2->top)
        {
            top = max(r1->top,ybot);
            bot = min(r1->bottom,r2->top);

            if ((top != bot) && (nonOverlap1Func != NULL))
            {
                if (!(*nonOverlap1Func)(newReg, r1, r1BandEnd, top, bot)) return FALSE;
            }

            ytop = r2->top;
        }
        else if (r2->top < r1->top)
        {
            top = max(r2->top,ybot);
            bot = min(r2->bottom,r1->top);

            if ((top != bot) && (nonOverlap2Func != NULL))
            {
                if (!(*nonOverlap2Func)(newReg, r2, r2BandEnd, top, bot) ) return FALSE;
            }

            ytop = r1->top;
        }
        else
        {
            ytop = r1->top;
        }

        /* If any rectangles got added to the region, try and coalesce them
         * with rectangles from the previous band. Note we could just do
         * this test in miCoalesce, but some machines incur a not
         * inconsiderable cost for function calls, so... */
        if (newReg->rdh.nCount != curBand)
        {
            prevBand = REGION_Coalesce(newReg, prevBand, curBand);
        }

        /* Now see if we've hit an intersecting band. The two bands only
         * intersect if ybot > ytop */
        ybot = min(r1->bottom, r2->bottom);
        curBand = newReg->rdh.nCount;
        if (ybot > ytop)
        {
            if (!(*overlapFunc)(newReg, r1, r1BandEnd, r2, r2BandEnd, ytop, ybot)) return FALSE;
        }

        if (newReg->rdh.nCount != curBand)
        {
            prevBand = REGION_Coalesce(newReg, prevBand, curBand);
        }

        /* If we've finished with a band (bottom == ybot) we skip forward
         * in the region to the next band. */
        if (r1->bottom == ybot)
        {
            r1 = r1BandEnd;
        }
        if (r2->bottom == ybot)
        {
            r2 = r2BandEnd;
        }
    }
    while ((r1 != r1End) && (r2 != r2End));

    /* Deal with whichever region still has rectangles left. */
    curBand = newReg->rdh.nCount;
    if (r1 != r1End)
    {
        if (nonOverlap1Func != NULL)
        {
            do
            {
                r1BandEnd = r1;
                while ((r1BandEnd < r1End) && (r1BandEnd->top == r1->top))
                {
                    r1BandEnd++;
                }

                if (!(*nonOverlap1Func)(newReg,
                                   r1,
                                   r1BandEnd,
                                   max(r1->top,ybot),
                                   r1->bottom))
                    return FALSE;
                r1 = r1BandEnd;
            }
            while (r1 != r1End);
        }
    }
    else if ((r2 != r2End) && (nonOverlap2Func != NULL))
    {
        do
        {
            r2BandEnd = r2;
            while ((r2BandEnd < r2End) && (r2BandEnd->top == r2->top))
            {
                r2BandEnd++;
            }

            if (!(*nonOverlap2Func)(newReg,
                               r2,
                               r2BandEnd,
                               max(r2->top,ybot),
                               r2->bottom))
                return FALSE;
            r2 = r2BandEnd;
        }
        while (r2 != r2End);
    }

    if (newReg->rdh.nCount != curBand)
    {
        (VOID)REGION_Coalesce(newReg, prevBand, curBand);
    }

    /* A bit of cleanup. To keep regions from growing without bound,
     * we shrink the array of rectangles to match the new number of
     * rectangles in the region. This never goes to 0, however...
     *
     * Only do this stuff if the number of rectangles allocated is more than
     * twice the number of rectangles in the region (a simple optimization...). */
    if ((newReg->rdh.nRgnSize > (2 * newReg->rdh.nCount * sizeof(RECT))) &&
        (newReg->rdh.nCount > 2))
    {
        if (REGION_NOT_EMPTY(newReg))
        {
            RECTL *prev_rects = newReg->Buffer;
            newReg->Buffer = ExAllocatePoolWithTag(PagedPool,
                                                   newReg->rdh.nCount * sizeof(RECT),
                                                   TAG_REGION);

            if (newReg->Buffer == NULL)
            {
                newReg->Buffer = prev_rects;
            }
            else
            {
                newReg->rdh.nRgnSize = newReg->rdh.nCount*sizeof(RECT);
                COPY_RECTS(newReg->Buffer, prev_rects, newReg->rdh.nCount);
                if (prev_rects != &newReg->rdh.rcBound)
                    ExFreePoolWithTag(prev_rects, TAG_REGION);
            }
        }
        else
        {
            /* No point in doing the extra work involved in an Xrealloc if
             * the region is empty */
            newReg->rdh.nRgnSize = sizeof(RECT);
            if (newReg->Buffer != &newReg->rdh.rcBound)
                ExFreePoolWithTag(newReg->Buffer, TAG_REGION);

            newReg->Buffer = ExAllocatePoolWithTag(PagedPool,
                                                   sizeof(RECT),
                                                   TAG_REGION);
            ASSERT(newReg->Buffer);
        }
    }

    newReg->rdh.iType = RDH_RECTANGLES;

    if (oldRects != &newReg->rdh.rcBound)
        ExFreePoolWithTag(oldRects, TAG_REGION);
    return TRUE;
}