region.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_REGION

Macros
#define	IntSysCreateRectpRgnIndirect(prc)    IntSysCreateRectpRgn((prc)->left, (prc)->top, (prc)->right, (prc)->bottom)
#define	GreCreateRectRgnIndirect(prc)    NtGdiCreateRectRgn((prc)->left, (prc)->top, (prc)->right, (prc)->bottom)
#define	GreSetRectRgnIndirect(hRgn, prc)    NtGdiSetRectRgn(hRgn, (prc)->left, (prc)->top, (prc)->right, (prc)->bottom);

Typedefs
typedef struct _REGION	REGION
typedef struct _REGION *	PREGION

Functions
PREGION FASTCALL	REGION_AllocRgnWithHandle (INT n)
PREGION FASTCALL	REGION_AllocUserRgnWithHandle (INT n)
BOOL FASTCALL	REGION_UnionRectWithRgn (PREGION rgn, const RECTL *rect)
INT FASTCALL	REGION_SubtractRectFromRgn (PREGION prgnDest, PREGION prgnSrc, const RECTL *prcl)
INT FASTCALL	REGION_GetRgnBox (PREGION Rgn, RECTL *pRect)
BOOL FASTCALL	REGION_RectInRegion (PREGION Rgn, const RECTL *rc)
BOOL FASTCALL	REGION_PtInRegion (PREGION, INT, INT)
INT FASTCALL	REGION_CropRegion (PREGION rgnDst, PREGION rgnSrc, const RECTL *rect)
VOID FASTCALL	REGION_SetRectRgn (PREGION pRgn, INT LeftRect, INT TopRect, INT RightRect, INT BottomRect)
VOID NTAPI	REGION_vCleanup (PVOID ObjectBody)
VOID FASTCALL	REGION_Delete (PREGION)
INT APIENTRY	IntGdiGetRgnBox (HRGN, RECTL *)
PREGION FASTCALL	REGION_LockRgn (_In_ HRGN hrgn)
VOID FASTCALL	REGION_UnlockRgn (_In_ PREGION prgn)
BOOL FASTCALL	REGION_bXformRgn (_Inout_ PREGION prgn, _In_ PMATRIX pmx)
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	REGION_bOffsetRgn (_Inout_ PREGION prgn, _In_ INT cx, _In_ INT cy)
BOOL FASTCALL	IntRectInRegion (HRGN, LPRECTL)
INT FASTCALL	IntGdiCombineRgn (PREGION, PREGION, PREGION, INT)
INT FASTCALL	REGION_Complexity (PREGION)
PREGION FASTCALL	IntSysCreateRectpRgn (INT, INT, INT, INT)
BOOL FASTCALL	IntGdiSetRegionOwner (HRGN, DWORD)
HRGN FASTCALL	GreCreateFrameRgn (HRGN hrgn, INT x, INT y)

Variables
PREGION	prgnDefault
HRGN	hrgnDefault

Macro Definition Documentation

GreCreateRectRgnIndirect

#define GreCreateRectRgnIndirect

(

prc

)

NtGdiCreateRectRgn((prc)->left, (prc)->top, (prc)->right, (prc)->bottom)

Definition at line 96 of file region.h.

GreSetRectRgnIndirect

#define GreSetRectRgnIndirect	(		hRgn,
			prc
	)		NtGdiSetRectRgn(hRgn, (prc)->left, (prc)->top, (prc)->right, (prc)->bottom);

Definition at line 99 of file region.h.

IntSysCreateRectpRgnIndirect

#define IntSysCreateRectpRgnIndirect

(

prc

)

IntSysCreateRectpRgn((prc)->left, (prc)->top, (prc)->right, (prc)->bottom)

Definition at line 93 of file region.h.

Typedef Documentation

PREGION

typedef struct _REGION * PREGION

REGION

typedef struct _REGION REGION

Function Documentation

GreCreateFrameRgn()

HRGN FASTCALL GreCreateFrameRgn	(	HRGN	hrgn,
		INT	x,
		INT	y
	)

Definition at line 2038 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 3470 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 2503 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	,
		RECTL *
	)

IntGdiSetRegionOwner()

BOOL FASTCALL IntGdiSetRegionOwner	(	HRGN	hRgn,
		DWORD	OwnerMask
	)

Definition at line 2475 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 3506 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 2423 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().

REGION_AllocRgnWithHandle()

PREGION FASTCALL REGION_AllocRgnWithHandle

(

INT

n

)

Definition at line 2216 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

n

)

Definition at line 2310 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_bOffsetRgn()

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

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

{
    XFORMOBJ xo;
    ULONG i, cjSize;
    PPOINT ppt;
    PULONG pcPoints;
    RECT rect;
    BOOL bResult;
 
    /* Check for zero rectangles and return TRUE for translation only matrices */
    if (prgn->rdh.nCount < 1)
        return (pmx->flAccel & XFORM_UNITY) != 0;
 
    /* Check if this is a scaling only matrix (off-diagonal elements are 0 */
    if (pmx->flAccel & XFORM_SCALE)
    {
        /* Check if this is a translation only matrix */
        if (pmx->flAccel & XFORM_UNITY)
        {
            /* Just offset the region */
            return REGION_bOffsetRgn(prgn, (pmx->fxDx + 8) / 16, (pmx->fxDy + 8) / 16);
        }
        else
        {
            /* Initialize the xform object */
            XFORMOBJ_vInit(&xo, pmx);
 
            /* Scaling can move the rects out of the coordinate space, so
             * we first need to check whether we can apply the transformation
             * on the bounds rect without modifying the region */
            if (!XFORMOBJ_bApplyXform(&xo, XF_LTOL, 2, &prgn->rdh.rcBound, &rect))
            {
                return FALSE;
            }
 
            /* Apply the xform to the rects in the region */
            if (!XFORMOBJ_bApplyXform(&xo,
                                      XF_LTOL,
                                      prgn->rdh.nCount * 2,
                                      prgn->Buffer,
                                      prgn->Buffer))
            {
                /* This can not happen, since we already checked the bounds! */
                NT_ASSERT(FALSE);
            }
 
            /* Reset bounds */
            RECTL_vSetEmptyRect(&prgn->rdh.rcBound);
 
            /* Loop all rects in the region */
            for (i = 0; i < prgn->rdh.nCount; i++)
            {
                /* Make sure the rect is well-ordered after the xform */
                RECTL_vMakeWellOrdered(&prgn->Buffer[i]);
 
                /* Update bounds */
                if (!RECTL_bUnionRect(&prgn->rdh.rcBound,
                                 &prgn->rdh.rcBound,
                                 &prgn->Buffer[i]))
                {
                    DPRINT1("NULL Set in Union Rects\n");
                    return FALSE;
                }
            }
 
            /* Loop all rects in the region */
            for (i = 0; i < prgn->rdh.nCount - 1; i++)
            {
                NT_ASSERT(prgn->Buffer[i].top <= prgn->Buffer[i].bottom);
                NT_ASSERT(prgn->Buffer[i + 1].top >= prgn->Buffer[i].top);
            }
 
            return TRUE;
        }
    }
    else
    {
        /* Allocate a buffer for the polygons */
        cjSize = prgn->rdh.nCount * (4 * sizeof(POINT) + sizeof(ULONG));
        ppt = ExAllocatePoolWithTag(PagedPool, cjSize, GDITAG_REGION);
        if (ppt == NULL)
        {
            return FALSE;
        }
 
        /* Fill the buffer with the rects */
        pcPoints = (PULONG)&ppt[4 * prgn->rdh.nCount];
        for (i = 0; i < prgn->rdh.nCount; i++)
        {
            /* Make sure the rect is within the legal range */
            pcPoints[i] = 4;
            ppt[4 * i + 0].x = prgn->Buffer[i].left;
            ppt[4 * i + 0].y = prgn->Buffer[i].top;
            ppt[4 * i + 1].x = prgn->Buffer[i].right;
            ppt[4 * i + 1].y = prgn->Buffer[i].top;
            ppt[4 * i + 2].x = prgn->Buffer[i].right;
            ppt[4 * i + 2].y = prgn->Buffer[i].bottom;
            ppt[4 * i + 3].x = prgn->Buffer[i].left;
            ppt[4 * i + 3].y = prgn->Buffer[i].bottom;
        }
 
        /* Initialize the xform object */
        XFORMOBJ_vInit(&xo, pmx);
 
        /* Apply the xform to the rects in the buffer */
        if (!XFORMOBJ_bApplyXform(&xo,
                                  XF_LTOL,
                                  prgn->rdh.nCount * 2,
                                  ppt,
                                  ppt))
        {
            /* This means, there were coordinates that would go outside of
               the coordinate space after the transformation */
            ExFreePoolWithTag(ppt, GDITAG_REGION);
            return FALSE;
        }
 
        /* Now use the polygons to create a polygon region */
        bResult = REGION_SetPolyPolygonRgn(prgn,
                                           ppt,
                                           pcPoints,
                                           prgn->rdh.nCount,
                                           WINDING);
 
        /* Free the polygon buffer */
        ExFreePoolWithTag(ppt, GDITAG_REGION);
 
        return bResult;

Referenced by REGION_LPTODP().

REGION_Complexity()

INT FASTCALL REGION_Complexity

(

PREGION

prgn

)

Definition at line 564 of file region.c.

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

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

REGION_CropRegion()

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

Definition at line 675 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 2465 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_GetRgnBox()

INT FASTCALL REGION_GetRgnBox	(	PREGION	Rgn,
		RECTL *	pRect
	)

REGION_LockRgn()

PREGION FASTCALL REGION_LockRgn

(

_In_ HRGN

hrgn

)

Definition at line 2374 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 2599 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_RectInRegion()

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

Definition at line 2622 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_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 3272 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	pRgn,
		INT	LeftRect,
		INT	TopRect,
		INT	RightRect,
		INT	BottomRect
	)

Definition at line 2682 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_SubtractRectFromRgn()

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

Definition at line 1824 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_UnionRectWithRgn()

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

Adds a rectangle to a REGION

Definition at line 1809 of file region.c.

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

Referenced by NtGdiExtCreateRegion().

REGION_UnlockRgn()

VOID FASTCALL REGION_UnlockRgn

(

_In_ PREGION

prgn

)

Definition at line 2389 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_vCleanup()

VOID NTAPI REGION_vCleanup

(

PVOID

ObjectBody

)

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

Variable Documentation

hrgnDefault

HRGN hrgnDefault

extern

Definition at line 131 of file region.c.

prgnDefault

PREGION prgnDefault

extern

Definition at line 130 of file region.c.

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