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 214 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 255 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 191 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 251 of file region.c.

CLOCKWISE

#define CLOCKWISE   1

Definition at line 307 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 135 of file region.c.

COUNTERCLOCKWISE

#define COUNTERCLOCKWISE   -1

Definition at line 308 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 148 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 381 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 359 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 166 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 157 of file region.c.

LARGE_COORDINATE

#define LARGE_COORDINATE   INT_MAX

Definition at line 401 of file region.c.

NDEBUG

#define NDEBUG

Definition at line 126 of file region.c.

NUMPTSTOBUFFER

#define NUMPTSTOBUFFER   200

Definition at line 512 of file region.c.

REGION_NOT_EMPTY

#define REGION_NOT_EMPTY

(

pReg

)

pReg->rdh.nCount

Definition at line 155 of file region.c.

RGN_DEFAULT_RECTS

#define RGN_DEFAULT_RECTS   2

Definition at line 514 of file region.c.

SLLSPERBLOCK

#define SLLSPERBLOCK   25

Definition at line 339 of file region.c.

SMALL_COORDINATE

#define SMALL_COORDINATE   INT_MIN

Definition at line 402 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 509 of file region.c.

overlapProcp

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

Definition at line 508 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 4082 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 */

GreCreateFrameRgn()

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

Definition at line 2025 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;
    }
 

Referenced by NtGdiFrameRgn().

GreCreatePolyPolygonRgn()

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

Definition at line 3452 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;
    }

Referenced by NtGdiPolyPolyDraw().

IntGdiCombineRgn()

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

Definition at line 2487 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;
    }

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 2561 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);

Referenced by co_UserGetUpdateRect(), and IntGetNCUpdateRgn().

IntGdiSetRegionOwner()

BOOL FASTCALL IntGdiSetRegionOwner	(	HRGN	hRgn,
		DWORD	OwnerMask
	)

Definition at line 2459 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);

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

IntRectInRegion()

BOOL FASTCALL IntRectInRegion	(	HRGN	hRgn,
		LPRECTL	rc
	)

Definition at line 3488 of file region.c.

{
    PREGION Rgn;
    BOOL Ret;
 
    Rgn = REGION_LockRgn(hRgn);
    if (Rgn == NULL)
    {
        return ERROR;
    }
 
    Ret = REGION_RectInRegion(Rgn, rc);

Referenced by NtGdiRectInRegion().

IntSysCreateRectpRgn()

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

Definition at line 2407 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);

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 3511 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]);

NtGdiCreateEllipticRgn()

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

Definition at line 3570 of file region.c.

{
    return NtGdiCreateRoundRectRgn(Left,
                                   Top,
                                   Right, Bottom,

NtGdiCreateRectRgn()

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

Definition at line 3585 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);

NtGdiCreateRoundRectRgn()

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

Definition at line 3614 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 */
 

Referenced by NtGdiCreateEllipticRgn().

NtGdiEqualRgn()

BOOL APIENTRY NtGdiEqualRgn	(	HRGN	hSrcRgn1,
		HRGN	hSrcRgn2
	)

Definition at line 3719 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);

NtGdiExtCreateRegion()

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

Definition at line 3804 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);

NtGdiGetRgnBox()

INT APIENTRY NtGdiGetRgnBox	(	HRGN	hRgn,
		PRECTL	pRect
	)

Definition at line 3919 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;
    }

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 3961 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 */

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 3996 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 */

Referenced by IntPtInWindow(), and PtInRegion().

NtGdiRectInRegion()

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

Definition at line 4023 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;
 

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 4048 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 */

Referenced by co_UserGetUpdateRgn(), and SetRectRgn().

REGION_AllocRgnWithHandle()

PREGION FASTCALL REGION_AllocRgnWithHandle

(

INT

nReg

)

Definition at line 2201 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;
    }

Referenced by REGION_AllocUserRgnWithHandle(), and REGION_XorRegion().

REGION_AllocUserRgnWithHandle()

PREGION FASTCALL REGION_AllocUserRgnWithHandle

(

INT

nRgn

)

Definition at line 2294 of file region.c.

{
    PREGION prgn;
 
    prgn = REGION_AllocRgnWithHandle(nRgn);
    if (prgn == NULL)
    {
        return NULL;
    }
 
    if (!REGION_bAllocRgnAttr(prgn))
    {
        ASSERT(FALSE);
    }

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 492 of file region.c.

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

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

REGION_bAllocRgnAttr()

BOOL NTAPI REGION_bAllocRgnAttr

(

PREGION

prgn

)

Definition at line 2261 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);

Referenced by REGION_AllocUserRgnWithHandle().

REGION_bCopy()

BOOL FASTCALL REGION_bCopy	(	PREGION	dst,
		PREGION	src
	)

Definition at line 1828 of file region.c.

{

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

REGION_bEnsureBufferSize()

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

static

Definition at line 456 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);
    }

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 406 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;

Referenced by REGION_bEnsureBufferSize().

REGION_bIntersectRegion()

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

Definition at line 1838 of file region.c.

{

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 1940 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);

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 1849 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);
    }

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 1371 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;
        }
    }

Referenced by REGION_UnionO().

REGION_bOffsetRgn()

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

Definition at line 2707 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;
    }

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 2066 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);
 

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 808 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);
            }
        }
    }

Referenced by REGION_RegionOp().

REGION_Complexity()

INT FASTCALL REGION_Complexity

(

PREGION

prgn

)

Definition at line 554 of file region.c.

{
    if (prgn == NULL)
        return NULLREGION;
 
    DPRINT("Region Complexity: %lu\n", prgn->rdh.nCount);
    switch (prgn->rdh.nCount)
    {
        case 0:
            return NULLREGION;
        case 1:
            return SIMPLEREGION;
        default:

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 2937 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;
    }

Referenced by REGION_SetPolyPolygonRgn().

REGION_CopyRegion()

static BOOL FASTCALL REGION_CopyRegion ( PREGION  dst, PREGION  src  )

static

Definition at line 574 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);
    }

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 3168 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 665 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;
    }
 

REGION_Delete()

VOID FASTCALL REGION_Delete

(

PREGION

pRgn

)

Definition at line 2449 of file region.c.

{
    if (pRgn == prgnDefault)
        return;

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 3021 of file region.c.

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

Referenced by REGION_SetPolyPolygonRgn().

REGION_GetRgnBox()

INT FASTCALL REGION_GetRgnBox	(	PREGION	Rgn,
		PRECTL	pRect
	)

Definition at line 2543 of file region.c.

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

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 2806 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;

Referenced by REGION_CreateETandAET().

REGION_InsertionSort()

static BOOL FASTCALL REGION_InsertionSort ( EDGE_TABLE_ENTRY *  AET )

static

Definition at line 2978 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;
        }
    }

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 1236 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++;
        }
    }

Referenced by REGION_IntersectRegion().

REGION_IntersectRegion()

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

static

Definition at line 1292 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. */

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 2884 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;
 

Referenced by REGION_SetPolyPolygonRgn().

REGION_LockRgn()

PREGION FASTCALL REGION_LockRgn

(

_In_ HRGN

hrgn

)

Definition at line 2358 of file region.c.

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

Referenced by 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 2582 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;
        }
    }

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 3042 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;

Referenced by REGION_SetPolyPolygonRgn().

REGION_RectInRegion()

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

Definition at line 2605 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;
        }
    }

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 946 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)

Referenced by REGION_IntersectRegion(), REGION_SubtractRegion(), and REGION_UnionRegion().

REGION_SetExtents()

static VOID FASTCALL REGION_SetExtents ( PREGION  pReg )

static

Definition at line 617 of file region.c.

{
    RECTL *pRect, *pRectEnd, *pExtents;
 
    /* Quick check for NULLREGION */
    if (pReg->rdh.nCount == 0)
    {
        pReg->rdh.rcBound.left = 0;
        pReg->rdh.rcBound.top = 0;
        pReg->rdh.rcBound.right = 0;
        pReg->rdh.rcBound.bottom = 0;
        pReg->rdh.iType = RDH_RECTANGLES;
        return;
    }
 
    pExtents = &pReg->rdh.rcBound;
    pRect = pReg->Buffer;
    pRectEnd = pReg->Buffer + pReg->rdh.nCount - 1;
 
    /* Since pRect is the first rectangle in the region, it must have the
     * smallest top and since pRectEnd is the last rectangle in the region,
     * it must have the largest bottom, because of banding. Initialize left and
     * right from pRect and pRectEnd, resp., as good things to initialize them
     * to... */
    pExtents->left = pRect->left;
    pExtents->top = pRect->top;
    pExtents->right = pRectEnd->right;
    pExtents->bottom = pRectEnd->bottom;
 
    while (pRect <= pRectEnd)
    {
        if (pRect->left < pExtents->left)
            pExtents->left = pRect->left;
        if (pRect->right > pExtents->right)
            pExtents->right = pRect->right;
        pRect++;
    }

Referenced by REGION_IntersectRegion(), and REGION_SubtractRegion().

REGION_SetPolyPolygonRgn()

BOOL FASTCALL REGION_SetPolyPolygonRgn	(	_Inout_ PREGION	prgn,
		_In_ const POINT *	ppt,
		_In_ const ULONG *	pcPoints,
		_In_ ULONG	cPolygons,
		_In_ INT	iMode
	)

Definition at line 3254 of file region.c.

{
    EDGE_TABLE_ENTRY *pAET;               /* Active Edge Table        */
    INT y;                                /* Current scanline         */
    INT iPts = 0;                         /* Number of pts in buffer  */
    EDGE_TABLE_ENTRY *pWETE;              /* Winding Edge Table Entry */
    SCANLINE_LIST *pSLL;                  /* Current SCANLINE_LIST    */
    POINT *pts;                           /* Output buffer            */
    EDGE_TABLE_ENTRY *pPrevAET;           /* Pointer to previous AET  */
    EDGE_TABLE ET;                        /* Header node for ET       */
    EDGE_TABLE_ENTRY AET;                 /* Header node for AET      */
    EDGE_TABLE_ENTRY *pETEs;              /* EDGE_TABLEEntries pool   */
    SCANLINE_LISTBLOCK SLLBlock;          /* Header for SCANLINE_LIST */
    INT fixWAET = FALSE;
    POINTBLOCK FirstPtBlock, *curPtBlock; /* PtBlock buffers          */
    POINTBLOCK *tmpPtBlock;
    UINT numFullPtBlocks = 0;
    UINT poly, total;
    BOOL bResult = FALSE;
 
    /* Check if iMode is valid */
    if ((iMode != ALTERNATE) && (iMode != WINDING))
    {
        DPRINT1("Invalid iMode: %lu\n", iMode);
        return FALSE;
    }
 
    /* Special case a rectangle */
    if (((cPolygons == 1) && ((pcPoints[0] == 4) ||
         ((pcPoints[0] == 5) && (ppt[4].x == ppt[0].x) && (ppt[4].y == ppt[0].y)))) &&
        (((ppt[0].y == ppt[1].y) &&
          (ppt[1].x == ppt[2].x) &&
          (ppt[2].y == ppt[3].y) &&
          (ppt[3].x == ppt[0].x)) ||
         ((ppt[0].x == ppt[1].x) &&
          (ppt[1].y == ppt[2].y) &&
          (ppt[2].x == ppt[3].x) &&
          (ppt[3].y == ppt[0].y))))
    {
        REGION_SetRectRgn(prgn,
                          min(ppt[0].x, ppt[2].x),
                          min(ppt[0].y, ppt[2].y),
                          max(ppt[0].x, ppt[2].x),
                          max(ppt[0].y, ppt[2].y));
        return TRUE;
    }
 
    for (poly = total = 0; poly < cPolygons; poly++)
        total += pcPoints[poly];
 
    pETEs = ExAllocatePoolWithTag(PagedPool,
                                  sizeof(EDGE_TABLE_ENTRY) * total,
                                  TAG_REGION);
    if (pETEs == NULL)
    {
        DPRINT1("Failed to allocate %lu edge entries\n", total);
        return FALSE;
    }
 
    pts = FirstPtBlock.pts;
    REGION_CreateETandAET(pcPoints, cPolygons, ppt, &ET, &AET, pETEs, &SLLBlock);
    pSLL = ET.scanlines.next;
    curPtBlock = &FirstPtBlock;
 
    if (iMode != WINDING)
    {
        /*  For each scanline */
        for (y = ET.ymin; y < ET.ymax; y++)
        {
            /*  Add a new edge to the active edge table when we
             *  get to the next edge. */
            if (pSLL != NULL && y == pSLL->scanline)
            {
                REGION_loadAET(&AET, pSLL->edgelist);
                pSLL = pSLL->next;
            }
            pPrevAET = &AET;
            pAET = AET.next;
 
            /*  For each active edge */
            while (pAET)
            {
                pts->x = pAET->bres.minor_axis,  pts->y = y;
                pts++, iPts++;
 
                /* Send out the buffer */
                if (iPts == NUMPTSTOBUFFER)
                {
                    tmpPtBlock = ExAllocatePoolWithTag(PagedPool,
                                                       sizeof(POINTBLOCK),
                                                       TAG_REGION);
                    if (tmpPtBlock == NULL)
                    {
                        DPRINT1("Can't alloc tmpPtBlock\n");
                        goto Cleanup;
                    }
 
                    curPtBlock->next = tmpPtBlock;
                    curPtBlock = tmpPtBlock;
                    pts = curPtBlock->pts;
                    numFullPtBlocks++;
                    iPts = 0;
                }
 
                EVALUATEEDGEEVENODD(pAET, pPrevAET, y);
            }
 
            REGION_InsertionSort(&AET);
        }
    }
    else
    {
        /* For each scanline */
        for (y = ET.ymin; y < ET.ymax; y++)
        {
            /*  Add a new edge to the active edge table when we
             *  get to the next edge. */
            if (pSLL != NULL && y == pSLL->scanline)
            {
                REGION_loadAET(&AET, pSLL->edgelist);
                REGION_computeWAET(&AET);
                pSLL = pSLL->next;
            }
 
            pPrevAET = &AET;
            pAET = AET.next;
            pWETE = pAET;
 
            /* For each active edge */
            while (pAET)
            {
                /* Add to the buffer only those edges that
                 * are in the Winding active edge table. */
                if (pWETE == pAET)
                {
                    pts->x = pAET->bres.minor_axis;
                    pts->y = y;
                    pts++;
                    iPts++;
 
                    /* Send out the buffer */
                    if (iPts == NUMPTSTOBUFFER)
                    {
                        tmpPtBlock = ExAllocatePoolWithTag(PagedPool,
                                                           sizeof(POINTBLOCK),
                                                           TAG_REGION);
                        if (tmpPtBlock == NULL)
                        {
                            DPRINT1("Can't alloc tPB\n");
                            goto Cleanup;
                        }
                        curPtBlock->next = tmpPtBlock;
                        curPtBlock = tmpPtBlock;
                        pts = curPtBlock->pts;
                        numFullPtBlocks++;
                        iPts = 0;
                    }
 
                    pWETE = pWETE->nextWETE;
                }
 
                EVALUATEEDGEWINDING(pAET, pPrevAET, y, fixWAET);
            }
 
            /* Recompute the winding active edge table if
             * we just resorted or have exited an edge. */
            if (REGION_InsertionSort(&AET) || fixWAET)
            {
                REGION_computeWAET(&AET);
                fixWAET = FALSE;
            }
        }
    }
 
    REGION_PtsToRegion(numFullPtBlocks, iPts, &FirstPtBlock, prgn);
    bResult = TRUE;
 
Cleanup:
    REGION_FreeStorage(SLLBlock.next);
 
    for (curPtBlock = FirstPtBlock.next; numFullPtBlocks-- > 0;)
    {
        tmpPtBlock = curPtBlock->next;
        ExFreePoolWithTag(curPtBlock, TAG_REGION);
        curPtBlock = tmpPtBlock;
    }
 

Referenced by GreCreatePolyPolygonRgn(), PATH_PathToRegion(), and REGION_bXformRgn().

REGION_SetRectRgn()

VOID FASTCALL REGION_SetRectRgn	(	PREGION	rgn,
		INT	LeftRect,
		INT	TopRect,
		INT	RightRect,
		INT	BottomRect
	)

Definition at line 2665 of file region.c.

{
    PRECTL firstRect;
 
    if (LeftRect > RightRect)
    {
        INT tmp = LeftRect;
        LeftRect = RightRect;
        RightRect = tmp;
    }
 
    if (TopRect > BottomRect)
    {
        INT tmp = TopRect;
        TopRect = BottomRect;
        BottomRect = tmp;
    }
 
    if ((LeftRect != RightRect) && (TopRect != BottomRect))
    {
        firstRect = rgn->Buffer;
        ASSERT(firstRect);
        firstRect->left = rgn->rdh.rcBound.left = LeftRect;
        firstRect->top = rgn->rdh.rcBound.top = TopRect;
        firstRect->right = rgn->rdh.rcBound.right = RightRect;
        firstRect->bottom = rgn->rdh.rcBound.bottom = BottomRect;
        rgn->rdh.nCount = 1;
        rgn->rdh.iType = RDH_RECTANGLES;
    }
    else
    {

Referenced by co_IntGetUpdateRgn(), IntSetDefaultRegion(), IntSysCreateRectpRgn(), NtGdiCreateRectRgn(), NtGdiSelectBitmap(), NtGdiSetRectRgn(), REGION_SetPolyPolygonRgn(), REGION_vSyncRegion(), and UserScrollDC().

REGION_SubtractNonO1()

static BOOL FASTCALL REGION_SubtractNonO1 ( PREGION  pReg, PRECTL  r, PRECTL  rEnd, INT  top, INT  bottom  )

static

 Deal with non-overlapping band for subtraction. Any parts from
 region 2 we discard. Anything from region 1 we add to the region.

Results: None.

Note

Side Effects: pReg may be affected.

Definition at line 1561 of file region.c.

{
    if (r != rEnd)
    {
        if (!REGION_bEnsureBufferSize(pReg, pReg->rdh.nCount + (rEnd - r)))
        {
            return FALSE;
        }
 
        do
        {
            REGION_vAddRect(pReg, r->left, top, r->right, bottom);
            r++;
        }
        while (r != rEnd);
    }

Referenced by REGION_SubtractRegion().

REGION_SubtractO()

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

static

 Overlapping band subtraction. x1 is the left-most point not yet
 checked.

Results: None.

Note

Side Effects: pReg may have rectangles added to it.

Definition at line 1600 of file region.c.

{
    INT left;
 
    left = r1->left;
 
    while ((r1 != r1End) && (r2 != r2End))
    {
        if (r2->right <= left)
        {
            /* Subtrahend missed the boat: go to next subtrahend. */
            r2++;
        }
        else if (r2->left <= left)
        {
            /* Subtrahend preceeds minuend: nuke left edge of minuend. */
            left = r2->right;
            if (left >= r1->right)
            {
                /* Minuend completely covered: advance to next minuend and
                 * reset left fence to edge of new minuend. */
                r1++;
                if (r1 != r1End)
                    left = r1->left;
            }
            else
            {
                /* Subtrahend now used up since it doesn't extend beyond
                 * minuend */
                r2++;
            }
        }
        else if (r2->left < r1->right)
        {
            /* Left part of subtrahend covers part of minuend: add uncovered
             * part of minuend to region and skip to next subtrahend. */
            if (!REGION_bAddRect(pReg, left, top, r2->left, bottom))
            {
                return FALSE;
            }
 
            left = r2->right;
            if (left >= r1->right)
            {
                /* Minuend used up: advance to new... */
                r1++;
                if (r1 != r1End)
                    left = r1->left;
            }
            else
            {
                /* Subtrahend used up */
                r2++;
            }
        }
        else
        {
            /* Minuend used up: add any remaining piece before advancing. */
            if (r1->right > left)
            {
                if (!REGION_bAddRect(pReg, left, top, r1->right, bottom))
                {
                    return FALSE;
                }
            }
 
            r1++;
            if (r1 != r1End)
                left = r1->left;
        }
    }
 
    /* Make sure the buffer is large enough for all remaining operations */
    if (r1 != r1End)
    {
        if (!REGION_bEnsureBufferSize(pReg, pReg->rdh.nCount + (r1End - r1)))
        {
            return FALSE;
        }
 
        /* Add remaining minuend rectangles to region. */
        do
        {
            REGION_vAddRect(pReg, left, top, r1->right, bottom);
            r1++;
            if (r1 != r1End)
            {
                left = r1->left;
            }
        }
        while (r1 != r1End);
    }

Referenced by REGION_SubtractRegion().

REGION_SubtractRectFromRgn()

INT FASTCALL REGION_SubtractRectFromRgn	(	PREGION	prgnDest,
		PREGION	prgnSrc,
		const RECTL *	prcl
	)

Definition at line 1811 of file region.c.

{
    REGION rgnLocal;
 
    rgnLocal.Buffer = &rgnLocal.rdh.rcBound;
    rgnLocal.rdh.nCount = 1;
    rgnLocal.rdh.nRgnSize = sizeof(RECT);
    rgnLocal.rdh.rcBound = *prcl;

REGION_SubtractRegion()

static BOOL FASTCALL REGION_SubtractRegion ( PREGION  regD, PREGION  regM, PREGION  regS  )

static

 Subtract regS from regM and leave the result in regD.
 S stands for subtrahend, M for minuend and D for difference.

Results: TRUE.

Note

Side Effects: regD is overwritten.

Definition at line 1717 of file region.c.

{
    /* Check for trivial reject */
    if ((regM->rdh.nCount == 0) ||
        (regS->rdh.nCount == 0) ||
        (EXTENTCHECK(&regM->rdh.rcBound, &regS->rdh.rcBound) == 0))
    {
        return REGION_CopyRegion(regD, regM);
    }
 
    if (!REGION_RegionOp(regD,
                    regM,
                    regS,
                    REGION_SubtractO,
                    REGION_SubtractNonO1,
                    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 unaltered. Besides, this
     * way there's no checking against rectangles that will be nuked
     * due to coalescing, so we have to examine fewer rectangles. */

Referenced by IntGdiCombineRgn(), REGION_bMakeFrameRegion(), REGION_SubtractRectFromRgn(), and REGION_XorRegion().

REGION_UnionNonO()

static BOOL FASTCALL REGION_UnionNonO ( PREGION  pReg, PRECTL  r, PRECTL  rEnd, INT  top, INT  bottom  )

static

 Handle a non-overlapping band for the union operation. Just
 Adds the rectangles into the region. Doesn't have to check for
 subsumption or anything.

Results: None.

Note

Side Effects: pReg->numRects is incremented and the final rectangles overwritten with the rectangles we're passed.

Definition at line 1344 of file region.c.

{
    if (r != rEnd)
    {
        if (!REGION_bEnsureBufferSize(pReg, pReg->rdh.nCount + (rEnd - r)))
        {
            return FALSE;
        }
 
        do
        {
            REGION_vAddRect(pReg, r->left, top, r->right, bottom);
            r++;
        }
        while (r != rEnd);
    }

Referenced by REGION_UnionRegion().

REGION_UnionO()

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

static

 Handle an overlapping band for the union operation. Picks the
 left-most rectangle each time and merges it into the region.

Results: None.

Note

Side Effects: Rectangles are overwritten in pReg->rects and pReg->numRects will be changed.

Definition at line 1414 of file region.c.

{
    while ((r1 != r1End) && (r2 != r2End))
    {
        if (r1->left < r2->left)
        {
            if (!REGION_bMergeRect(pReg, r1->left, top, r1->right, bottom)) return FALSE;
            r1++;
        }
        else
        {
            if (!REGION_bMergeRect(pReg, r2->left, top, r2->right, bottom)) return FALSE;
            r2++;
        }
    }
 
    if (r1 != r1End)
    {
        do
        {
            if (!REGION_bMergeRect(pReg, r1->left, top, r1->right, bottom)) return FALSE;
            r1++;
        }
        while (r1 != r1End);
    }
    else
    {
        while (r2 != r2End)
        {
            if (!REGION_bMergeRect(pReg, r2->left, top, r2->right, bottom)) return FALSE;
            r2++;
        }
    }

Referenced by REGION_UnionRegion().

REGION_UnionRectWithRgn()

BOOL FASTCALL REGION_UnionRectWithRgn	(	PREGION	rgn,
		const RECTL *	rect
	)

Adds a rectangle to a REGION

Definition at line 1796 of file region.c.

{
    REGION region;
 
    region.Buffer = &region.rdh.rcBound;
    region.rdh.nCount = 1;
    region.rdh.nRgnSize = sizeof(RECT);

Referenced by NtGdiExtCreateRegion().

REGION_UnionRegion()

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

static

Definition at line 1464 of file region.c.

{
    BOOL ret = TRUE;
 
    /* Checks all the simple cases
     * Region 1 and 2 are the same or region 1 is empty */
    if ((reg1 == reg2) || (reg1->rdh.nCount == 0) ||
        (reg1->rdh.rcBound.right <= reg1->rdh.rcBound.left) ||
        (reg1->rdh.rcBound.bottom <= reg1->rdh.rcBound.top))
    {
        if (newReg != reg2)
        {
            ret = REGION_CopyRegion(newReg, reg2);
        }
 
        return ret;
    }
 
    /* If nothing to union (region 2 empty) */
    if ((reg2->rdh.nCount == 0) ||
        (reg2->rdh.rcBound.right <= reg2->rdh.rcBound.left) ||
        (reg2->rdh.rcBound.bottom <= reg2->rdh.rcBound.top))
    {
        if (newReg != reg1)
        {
            ret = REGION_CopyRegion(newReg, reg1);
        }
 
        return ret;
    }
 
    /* Region 1 completely subsumes region 2 */
    if ((reg1->rdh.nCount == 1) &&
        (reg1->rdh.rcBound.left <= reg2->rdh.rcBound.left) &&
        (reg1->rdh.rcBound.top <= reg2->rdh.rcBound.top) &&
        (reg2->rdh.rcBound.right <= reg1->rdh.rcBound.right) &&
        (reg2->rdh.rcBound.bottom <= reg1->rdh.rcBound.bottom))
    {
        if (newReg != reg1)
        {
            ret = REGION_CopyRegion(newReg, reg1);
        }
 
        return ret;
    }
 
    /* Region 2 completely subsumes region 1 */
    if ((reg2->rdh.nCount == 1) &&
        (reg2->rdh.rcBound.left <= reg1->rdh.rcBound.left) &&
        (reg2->rdh.rcBound.top <= reg1->rdh.rcBound.top) &&
        (reg1->rdh.rcBound.right <= reg2->rdh.rcBound.right) &&
        (reg1->rdh.rcBound.bottom <= reg2->rdh.rcBound.bottom))
    {
        if (newReg != reg2)
        {
            ret = REGION_CopyRegion(newReg, reg2);
        }
 
        return ret;
    }
 
    if ((ret = REGION_RegionOp(newReg,
                    reg1,
                    reg2,
                    REGION_UnionO,
                    REGION_UnionNonO,
                    REGION_UnionNonO)))
    {
    newReg->rdh.rcBound.left = min(reg1->rdh.rcBound.left, reg2->rdh.rcBound.left);
    newReg->rdh.rcBound.top = min(reg1->rdh.rcBound.top, reg2->rdh.rcBound.top);
    newReg->rdh.rcBound.right = max(reg1->rdh.rcBound.right, reg2->rdh.rcBound.right);
    newReg->rdh.rcBound.bottom = max(reg1->rdh.rcBound.bottom, reg2->rdh.rcBound.bottom);

Referenced by IntGdiCombineRgn(), and REGION_XorRegion().

REGION_UnlockRgn()

VOID FASTCALL REGION_UnlockRgn

(

_In_ PREGION

prgn

)

Definition at line 2373 of file region.c.

{
    PRGN_ATTR prgnattr;
 
    NT_ASSERT(prgn != NULL);
    NT_ASSERT(prgn->prgnattr != NULL);
 
    /* Get the region attribute and check if it's user mode */
    prgnattr = prgn->prgnattr;
    if (prgnattr != &prgn->rgnattr)
    {
        NT_ASSERT(GreGetObjectOwner(prgn->BaseObject.hHmgr) == GDI_OBJ_HMGR_POWNED);
        prgnattr->iComplexity = REGION_Complexity(prgn);
        prgnattr->Rect.left   = prgn->rdh.rcBound.left;
        prgnattr->Rect.top    = prgn->rdh.rcBound.top;
        prgnattr->Rect.right  = prgn->rdh.rcBound.right;
        prgnattr->Rect.bottom = prgn->rdh.rcBound.bottom;
        prgnattr->AttrFlags |= ATTR_RGN_VALID;
    }

Referenced by co_IntGetUpdateRgn(), co_WinPosSetWindowPos(), DceUpdateVisRgn(), ForceNCPaintErase(), GreCreateFrameRgn(), GreCreatePolyPolygonRgn(), IntDefWindowProc(), IntGdiGetRgnBox(), IntGdiSetRegionOwner(), IntInvalidateWindows(), IntRectInRegion(), IntScrollWindowEx(), IntValidateParents(), NtGdiCombineRgn(), NtGdiCreateRectRgn(), NtGdiCreateRoundRectRgn(), NtGdiEqualRgn(), NtGdiExtCreateRegion(), NtGdiExtSelectClipRgn(), NtGdiFillRgn(), NtGdiGetRandomRgn(), NtGdiGetRgnBox(), NtGdiInvertRgn(), NtGdiOffsetRgn(), NtGdiPathToRegion(), NtGdiPtInRegion(), NtGdiSetRectRgn(), NtUserCallHwndParamLock(), NtUserRedrawWindow(), PaintSuspendedWindow(), REGION_XorRegion(), UserScrollDC(), and VIS_ComputeVisibleRegion().

REGION_vAddRect()

FORCEINLINE VOID REGION_vAddRect	(	_Inout_ PREGION	prgn,
		_In_ LONG	left,
		_In_ LONG	top,
		_In_ LONG	right,
		_In_ LONG	bottom
	)

Definition at line 472 of file region.c.

{
    PRECTL prcl;
    NT_ASSERT((prgn->rdh.nCount + 1) * sizeof(RECT) <= prgn->rdh.nRgnSize);
 
    prcl = &prgn->Buffer[prgn->rdh.nCount];
    prcl->left = left;
    prcl->top = top;
    prcl->right = right;

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

REGION_vCleanup()

VOID NTAPI REGION_vCleanup

(

PVOID

ObjectBody

)

Definition at line 2433 of file region.c.

{
    PREGION pRgn = (PREGION)ObjectBody;
    PPROCESSINFO ppi = PsGetCurrentProcessWin32Process();
    ASSERT(ppi);
 
    ASSERT(pRgn->prgnattr);
    if (pRgn->prgnattr != &pRgn->rgnattr)
        GdiPoolFree(ppi->pPoolRgnAttr, pRgn->prgnattr);
 

REGION_vSyncRegion()

static VOID REGION_vSyncRegion ( _In_ PREGION  prgn )

static

Definition at line 2315 of file region.c.

{
    PRGN_ATTR prgnattr;
 
    NT_ASSERT(prgn != NULL);
    NT_ASSERT(prgn->prgnattr != NULL);
    NT_ASSERT((prgn->prgnattr == &prgn->rgnattr) ||
              (prgn->prgnattr->AttrFlags & ATTR_RGN_VALID));
 
    /* Get the region attribute and check if it's dirty (modified) */
    prgnattr = prgn->prgnattr;
    if (prgnattr->AttrFlags & ATTR_RGN_DIRTY)
    {
        NT_ASSERT(GreGetObjectOwner(prgn->BaseObject.hHmgr) == GDI_OBJ_HMGR_POWNED);
        NT_ASSERT(prgnattr != &prgn->rgnattr);
 
        if (prgnattr->iComplexity == NULLREGION)
        {
            EMPTY_REGION(prgn);
        }
        else if (prgnattr->iComplexity == SIMPLEREGION)
        {
            REGION_SetRectRgn(prgn,
                              prgnattr->Rect.left,
                              prgnattr->Rect.top,
                              prgnattr->Rect.right,
                              prgnattr->Rect.bottom);
        }
        else
        {
            /* Should not happen, region attribute is corrupted! */
            DPRINT1("Region attribute is corrupted, ignoring\n");
            NT_ASSERT(FALSE);
        }
    }
 

Referenced by NtGdiCombineRgn(), NtGdiEqualRgn(), and REGION_LockRgn().

REGION_XorRegion()

static BOOL FASTCALL REGION_XorRegion ( PREGION  dr, PREGION  sra, PREGION  srb  )

static

Definition at line 1753 of file region.c.

{
    HRGN htra, htrb;
    PREGION tra, trb;
    BOOL ret;
 
    // FIXME: Don't use a handle
    tra = REGION_AllocRgnWithHandle(sra->rdh.nCount + 1);
    if (tra == NULL)
    {
        return FALSE;
    }
    htra = tra->BaseObject.hHmgr;
 
    // FIXME: Don't use a handle
    trb = REGION_AllocRgnWithHandle(srb->rdh.nCount + 1);
    if (trb == NULL)
    {
        REGION_UnlockRgn(tra);
        GreDeleteObject(htra);
        return FALSE;
    }
    htrb = trb->BaseObject.hHmgr;
 
    ret = REGION_SubtractRegion(tra, sra, srb) &&
          REGION_SubtractRegion(trb, srb, sra) &&
          REGION_UnionRegion(dr, tra, trb);
    REGION_UnlockRgn(tra);
    REGION_UnlockRgn(trb);
 
    GreDeleteObject(htra);

Referenced by IntGdiCombineRgn().

Variable Documentation

hrgnDefault

HRGN hrgnDefault = NULL

Definition at line 130 of file region.c.

prgnDefault

PREGION prgnDefault = NULL

Definition at line 129 of file region.c.

Referenced by DC_InitHack(), IntGdiReleaseVisRgn(), IntSetDefaultRegion(), and REGION_Delete().