region.c File Reference

#include <precomp.h>
#include <debug.h>

Include dependency graph for region.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	MIN_COORD   (INT_MIN/16)
#define	MAX_COORD   (INT_MAX/16)
#define	INRECT(r, x, y)

Functions
static VOID FASTCALL	SortRects (PRECT pRect, INT nCount)
BOOL FASTCALL	DeleteRegion (_In_ HRGN hrgn)
INT FASTCALL	MirrorRgnByWidth (_In_ HRGN hrgn, _In_ INT Width, _Out_opt_ HRGN *phrgn)
INT WINAPI	MirrorRgnDC (_In_ HDC hdc, _In_ HRGN hrgn, _Out_opt_ HRGN *phrn)
FORCEINLINE ULONG	IntSetNullRgn (_Inout_ PRGN_ATTR prgnattr)
FORCEINLINE ULONG	IntSetRectRgn (_Inout_ PRGN_ATTR prgnattr, _In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom)
INT WINAPI	CombineRgn (_In_ HRGN hrgnDest, _In_ HRGN hrgnSrc1, _In_ HRGN hrgnSrc2, _In_ INT iCombineMode)
HRGN WINAPI	CreateEllipticRgnIndirect (const RECT *prc)
HRGN WINAPI	CreatePolygonRgn (const POINT *lppt, int cPoints, int fnPolyFillMode)
HRGN WINAPI	CreatePolyPolygonRgn (const POINT *lppt, const INT *lpPolyCounts, int nCount, int fnPolyFillMode)
HRGN WINAPI	CreateRectRgn (int x1, int y1, int x2, int y2)
HRGN WINAPI	CreateRectRgnIndirect (const RECT *prc)
INT WINAPI	ExcludeClipRect (_In_ HDC hdc, _In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom)
HRGN WINAPI	ExtCreateRegion (CONST XFORM *lpXform, DWORD nCount, CONST RGNDATA *lpRgnData)
INT WINAPI	ExtSelectClipRgn (_In_ HDC hdc, _In_ HRGN hrgn, _In_ INT iMode)
int WINAPI	GetClipRgn (HDC hdc, HRGN hrgn)
int WINAPI	GetMetaRgn (HDC hdc, HRGN hrgn)
DWORD WINAPI	GetRegionData (HRGN hrgn, DWORD nCount, LPRGNDATA lpRgnData)
INT WINAPI	GetRgnBox (HRGN hrgn, LPRECT prcOut)
INT WINAPI	IntersectClipRect (_In_ HDC hdc, _In_ INT nLeft, _In_ INT nTop, _In_ INT nRight, _In_ INT nBottom)
BOOL WINAPI	MirrorRgn (HWND hwnd, HRGN hrgn)
INT WINAPI	OffsetClipRgn (HDC hdc, INT nXOffset, INT nYOffset)
INT WINAPI	OffsetRgn (HRGN hrgn, int nXOffset, int nYOffset)
BOOL WINAPI	PtInRegion (IN HRGN hrgn, int x, int y)
BOOL WINAPI	RectInRegion (HRGN hrgn, LPCRECT prcl)
int WINAPI	SelectClipRgn (_In_ HDC hdc, _In_ HRGN hrgn)
BOOL WINAPI	SetRectRgn (_In_ HRGN hrgn, _In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom)
int WINAPI	SetMetaRgn (HDC hDC)

Macro Definition Documentation

INRECT

#define INRECT	(		r,
			x,
			y
	)

Value:

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

Definition at line 14 of file region.c.

MAX_COORD

#define MAX_COORD   (INT_MAX/16)

Definition at line 12 of file region.c.

MIN_COORD

#define MIN_COORD   (INT_MIN/16)

Definition at line 11 of file region.c.

NDEBUG

#define NDEBUG

Definition at line 3 of file region.c.

Function Documentation

CombineRgn()

INT WINAPI CombineRgn	(	_In_ HRGN	hrgnDest,
		_In_ HRGN	hrgnSrc1,
		_In_ HRGN	hrgnSrc2,
		_In_ INT	iCombineMode
	)

Definition at line 195 of file region.c.

{
    PRGN_ATTR prngattrDest = NULL;
    PRGN_ATTR prngattrSrc1 = NULL;
    PRGN_ATTR prngattrSrc2 = NULL;
    RECT rcTemp;
 
    /* Get the region attribute for dest and source 1 */
    prngattrDest = GdiGetRgnAttr(hrgnDest);
    prngattrSrc1 = GdiGetRgnAttr(hrgnSrc1);
 
    /* If that failed or if the source 1 region is complex, go to win32k */
    if ((prngattrDest == NULL) || (prngattrSrc1 == NULL) ||
        (prngattrSrc1->iComplexity > SIMPLEREGION))
    {
        return NtGdiCombineRgn(hrgnDest, hrgnSrc1, hrgnSrc2, iCombineMode);
    }
 
    /* Handle RGN_COPY first, it needs only hrgnSrc1 */
    if (iCombineMode == RGN_COPY)
    {
        /* Check if the source region is a NULLREGION */
        if (prngattrSrc1->iComplexity == NULLREGION)
        {
            /* The dest region is a NULLREGION, too */
            return IntSetNullRgn(prngattrDest);
        }
 
        /* We already know that the source region cannot be complex, so
           create a rect region from the bounds of the source rect */
        return IntSetRectRgn(prngattrDest,
                             prngattrSrc1->Rect.left,
                             prngattrSrc1->Rect.top,
                             prngattrSrc1->Rect.right,
                             prngattrSrc1->Rect.bottom);
    }
 
    /* For all other operations we need hrgnSrc2 */
    prngattrSrc2 = GdiGetRgnAttr(hrgnSrc2);
 
    /* If we got no attribute or the region is complex, go to win32k */
    if ((prngattrSrc2 == NULL) || (prngattrSrc2->iComplexity > SIMPLEREGION))
    {
        return NtGdiCombineRgn(hrgnDest, hrgnSrc1, hrgnSrc2, iCombineMode);
    }
 
    /* Handle RGN_AND */
    if (iCombineMode == RGN_AND)
    {
        /* Check if either of the regions is a NULLREGION */
        if ((prngattrSrc1->iComplexity == NULLREGION) ||
            (prngattrSrc2->iComplexity == NULLREGION))
        {
            /* Result is also a NULLREGION */
            return IntSetNullRgn(prngattrDest);
        }
 
        /* Get the intersection of the 2 rects */
        if (!IntersectRect(&rcTemp, &prngattrSrc1->Rect, &prngattrSrc2->Rect))
        {
            /* The rects do not intersect, result is a NULLREGION */
            return IntSetNullRgn(prngattrDest);
        }
 
        /* Use the intersection of the rects */
        return IntSetRectRgn(prngattrDest,
                             rcTemp.left,
                             rcTemp.top,
                             rcTemp.right,
                             rcTemp.bottom);
    }
 
    /* Handle RGN_DIFF */
    if (iCombineMode == RGN_DIFF)
    {
        /* Check if source 1 is a NULLREGION */
        if (prngattrSrc1->iComplexity == NULLREGION)
        {
            /* The result is a NULLREGION as well */
            return IntSetNullRgn(prngattrDest);
        }
 
        /* Get the intersection of the 2 rects */
        if ((prngattrSrc2->iComplexity == NULLREGION) ||
            !IntersectRect(&rcTemp, &prngattrSrc1->Rect, &prngattrSrc2->Rect))
        {
            /* The rects do not intersect, dest equals source 1 */
            return IntSetRectRgn(prngattrDest,
                                 prngattrSrc1->Rect.left,
                                 prngattrSrc1->Rect.top,
                                 prngattrSrc1->Rect.right,
                                 prngattrSrc1->Rect.bottom);
        }
 
        /* We need to check is whether we can subtract the rects. For that
           we call SubtractRect, which will give us the bounding box of the
           subtraction. The function returns FALSE if the resulting rect is
           empty */
        if (!SubtractRect(&rcTemp, &prngattrSrc1->Rect, &rcTemp))
        {
            /* The result is a NULLREGION */
            return IntSetNullRgn(prngattrDest);
        }
 
        /* Now check if the result of SubtractRect matches the source 1 rect.
           Since we already know that the rects intersect, the result can
           only match the source 1 rect, if it could not be "cut" on either
           side, but the overlapping was on a corner, so the new bounding box
           equals the previous rect */
        if (!EqualRect(&rcTemp, &prngattrSrc1->Rect))
        {
            /* We got a properly subtracted rect, so use it. */
            return IntSetRectRgn(prngattrDest,
                                 rcTemp.left,
                                 rcTemp.top,
                                 rcTemp.right,
                                 rcTemp.bottom);
        }
 
        /* The result would be a complex region, go to win32k */
        return NtGdiCombineRgn(hrgnDest, hrgnSrc1, hrgnSrc2, iCombineMode);
    }
 
    /* Handle OR and XOR */
    if ((iCombineMode == RGN_OR) || (iCombineMode == RGN_XOR))
    {
        /* Check if source 1 is a NULLREGION */
        if (prngattrSrc1->iComplexity == NULLREGION)
        {
            /* Check if source 2 is also a NULLREGION */
            if (prngattrSrc2->iComplexity == NULLREGION)
            {
                /* Both are NULLREGIONs, result is also a NULLREGION */
                return IntSetNullRgn(prngattrDest);
            }
 
            /* The result is equal to source 2 */
            return IntSetRectRgn(prngattrDest,
                                 prngattrSrc2->Rect.left,
                                 prngattrSrc2->Rect.top,
                                 prngattrSrc2->Rect.right,
                                 prngattrSrc2->Rect.bottom );
        }
 
        /* Check if only source 2 is a NULLREGION */
        if (prngattrSrc2->iComplexity == NULLREGION)
        {
            /* The result is equal to source 1 */
            return IntSetRectRgn(prngattrDest,
                                 prngattrSrc1->Rect.left,
                                 prngattrSrc1->Rect.top,
                                 prngattrSrc1->Rect.right,
                                 prngattrSrc1->Rect.bottom);
        }
 
        /* Do the rects have the same x extent */
        if ((prngattrSrc1->Rect.left == prngattrSrc2->Rect.left) &&
            (prngattrSrc1->Rect.right == prngattrSrc2->Rect.right))
        {
            /* Do the rects also have the same y extent */
            if ((prngattrSrc1->Rect.top == prngattrSrc2->Rect.top) &&
                (prngattrSrc1->Rect.bottom == prngattrSrc2->Rect.bottom))
            {
                /* Rects are equal, if this is RGN_OR, the result is source 1 */
                if (iCombineMode == RGN_OR)
                {
                    /* The result is equal to source 1 */
                    return IntSetRectRgn(prngattrDest,
                                         prngattrSrc1->Rect.left,
                                         prngattrSrc1->Rect.top,
                                         prngattrSrc1->Rect.right,
                                         prngattrSrc1->Rect.bottom );
                }
                else
                {
                    /* XORing with itself yields an empty region */
                    return IntSetNullRgn(prngattrDest);
                }
            }
 
            /* Check if the rects are disjoint */
            if ((prngattrSrc2->Rect.bottom < prngattrSrc1->Rect.top) ||
                (prngattrSrc2->Rect.top > prngattrSrc1->Rect.bottom))
            {
                /* The result would be a complex region, go to win32k */
                return NtGdiCombineRgn(hrgnDest, hrgnSrc1, hrgnSrc2, iCombineMode);
            }
 
            /* Check if this is OR */
            if (iCombineMode == RGN_OR)
            {
                /* Use the maximum extent of both rects combined */
                return IntSetRectRgn(prngattrDest,
                                     prngattrSrc1->Rect.left,
                                     min(prngattrSrc1->Rect.top, prngattrSrc2->Rect.top),
                                     prngattrSrc1->Rect.right,
                                     max(prngattrSrc1->Rect.bottom, prngattrSrc2->Rect.bottom));
            }
 
            /* Check if the rects are adjacent */
            if (prngattrSrc2->Rect.bottom == prngattrSrc1->Rect.top)
            {
                /* The result is the combined rects */
                return IntSetRectRgn(prngattrDest,
                                     prngattrSrc1->Rect.left,
                                     prngattrSrc2->Rect.top,
                                     prngattrSrc1->Rect.right,
                                     prngattrSrc1->Rect.bottom );
            }
            else if (prngattrSrc2->Rect.top == prngattrSrc1->Rect.bottom)
            {
                /* The result is the combined rects */
                return IntSetRectRgn(prngattrDest,
                                     prngattrSrc1->Rect.left,
                                     prngattrSrc1->Rect.top,
                                     prngattrSrc1->Rect.right,
                                     prngattrSrc2->Rect.bottom );
            }
 
            /* When we are here, this is RGN_XOR and the rects overlap */
            return NtGdiCombineRgn(hrgnDest, hrgnSrc1, hrgnSrc2, iCombineMode);
        }
 
        /* Do the rects have the same y extent */
        if ((prngattrSrc1->Rect.top == prngattrSrc2->Rect.top) &&
            (prngattrSrc1->Rect.bottom == prngattrSrc2->Rect.bottom))
        {
            /* Check if the rects are disjoint */
            if ((prngattrSrc2->Rect.right < prngattrSrc1->Rect.left) ||
                (prngattrSrc2->Rect.left > prngattrSrc1->Rect.right))
            {
                /* The result would be a complex region, go to win32k */
                return NtGdiCombineRgn(hrgnDest, hrgnSrc1, hrgnSrc2, iCombineMode);
            }
 
            /* Check if this is OR */
            if (iCombineMode == RGN_OR)
            {
                /* Use the maximum extent of both rects combined */
                return IntSetRectRgn(prngattrDest,
                                     min(prngattrSrc1->Rect.left, prngattrSrc2->Rect.left),
                                     prngattrSrc1->Rect.top,
                                     max(prngattrSrc1->Rect.right, prngattrSrc2->Rect.right),
                                     prngattrSrc1->Rect.bottom);
            }
 
            /* Check if the rects are adjacent */
            if (prngattrSrc2->Rect.right == prngattrSrc1->Rect.left)
            {
                /* The result is the combined rects */
                return IntSetRectRgn(prngattrDest,
                                     prngattrSrc2->Rect.left,
                                     prngattrSrc1->Rect.top,
                                     prngattrSrc1->Rect.right,
                                     prngattrSrc1->Rect.bottom );
            }
            else if (prngattrSrc2->Rect.left == prngattrSrc1->Rect.right)
            {
                /* The result is the combined rects */
                return IntSetRectRgn(prngattrDest,
                                     prngattrSrc1->Rect.left,
                                     prngattrSrc1->Rect.top,
                                     prngattrSrc2->Rect.right,
                                     prngattrSrc1->Rect.bottom );
            }
 
            /* When we are here, this is RGN_XOR and the rects overlap */
            return NtGdiCombineRgn(hrgnDest, hrgnSrc1, hrgnSrc2, iCombineMode);
        }
 
        /* Last case: RGN_OR and one rect is completely within the other */
        if (iCombineMode == RGN_OR)
        {
            /* Check if rect 1 can contain rect 2 */
            if (prngattrSrc1->Rect.left <= prngattrSrc2->Rect.left)
            {
                /* rect 1 might be the outer one, check of that is true */
                if ((prngattrSrc1->Rect.right >= prngattrSrc2->Rect.right) &&
                    (prngattrSrc1->Rect.top <= prngattrSrc2->Rect.top) &&
                    (prngattrSrc1->Rect.bottom >= prngattrSrc2->Rect.bottom))
                {
                    /* Rect 1 contains rect 2, use it */
                    return IntSetRectRgn(prngattrDest,
                                         prngattrSrc1->Rect.left,
                                         prngattrSrc1->Rect.top,
                                         prngattrSrc1->Rect.right,
                                         prngattrSrc1->Rect.bottom );
                }
            }
            else
            {
                /* rect 2 might be the outer one, check of that is true */
                if ((prngattrSrc2->Rect.right >= prngattrSrc1->Rect.right) &&
                    (prngattrSrc2->Rect.top <= prngattrSrc1->Rect.top) &&
                    (prngattrSrc2->Rect.bottom >= prngattrSrc1->Rect.bottom))
                {
                    /* Rect 2 contains rect 1, use it */
                    return IntSetRectRgn(prngattrDest,
                                         prngattrSrc2->Rect.left,
                                         prngattrSrc2->Rect.top,
                                         prngattrSrc2->Rect.right,
                                         prngattrSrc2->Rect.bottom );
                }
            }
        }
 
        /* We couldn't handle the operation, go to win32k */
        return NtGdiCombineRgn(hrgnDest, hrgnSrc1, hrgnSrc2, iCombineMode);
    }
 
    DPRINT1("Invalid iCombineMode %d\n", iCombineMode);
    SetLastError(ERROR_INVALID_PARAMETER);
    return ERROR;
}

CreateEllipticRgnIndirect()

HRGN WINAPI CreateEllipticRgnIndirect

(

const RECT *

prc

)

Definition at line 520 of file region.c.

{
    /* Notes if prc is NULL it will crash on All Windows NT I checked 2000/XP/VISTA */
    return NtGdiCreateEllipticRgn(prc->left, prc->top, prc->right, prc->bottom);
 
}

CreatePolygonRgn()

HRGN WINAPI CreatePolygonRgn	(	const POINT *	lppt,
		int	cPoints,
		int	fnPolyFillMode
	)

Definition at line 534 of file region.c.

{
    return (HRGN) NtGdiPolyPolyDraw( (HDC)UlongToHandle(fnPolyFillMode), (PPOINT) lppt, (PULONG) &cPoints, 1, GdiPolyPolyRgn);
}

CreatePolyPolygonRgn()

HRGN WINAPI CreatePolyPolygonRgn	(	const POINT *	lppt,
		const INT *	lpPolyCounts,
		int	nCount,
		int	fnPolyFillMode
	)

Definition at line 544 of file region.c.

{
    return (HRGN) NtGdiPolyPolyDraw(  (HDC)UlongToHandle(fnPolyFillMode), (PPOINT) lppt, (PULONG) lpPolyCounts, (ULONG) nCount, GdiPolyPolyRgn );
}

CreateRectRgn()

HRGN WINAPI CreateRectRgn	(	int	x1,
		int	y1,
		int	x2,
		int	y2
	)

Definition at line 557 of file region.c.

{
    PRGN_ATTR pRgn_Attr;
    HRGN hrgn = NULL;
    int tmp;
 
    /* Normalize points, REGION_SetRectRgn does this too. */
    if ( x1 > x2 )
    {
        tmp = x1;
        x1 = x2;
        x2 = tmp;
    }
 
    if ( y1 > y2 )
    {
        tmp = y1;
        y1 = y2;
        y2 = tmp;
    }
    /* Check outside 28 bit limit for universal set bound box. REGION_SetRectRgn doesn't do this! */
    if ( x1 < MIN_COORD ||
         y1 < MIN_COORD ||
         x2 > MAX_COORD ||
         y2 > MAX_COORD  )
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
 
    hrgn = hGetPEBHandle(hctRegionHandle, 0);
    if (hrgn)
    {
       DPRINT1("PEB Handle Cache Test return hrgn %p, should be NULL!\n",hrgn);
       hrgn = NULL;
    }
 
    if (!hrgn)
        hrgn = NtGdiCreateRectRgn(0, 0, 1, 1);
 
    if (!hrgn)
        return hrgn;
 
    if (!(pRgn_Attr = GdiGetRgnAttr(hrgn)) )
    {
        DPRINT1("No Attr for Region handle!!!\n");
        DeleteRegion(hrgn);
        return NULL;
    }
 
    pRgn_Attr->AttrFlags = ATTR_RGN_VALID;
 
    IntSetRectRgn( pRgn_Attr, x1, y1, x2, y2 );
 
    return hrgn;
}

CreateRectRgnIndirect()

HRGN WINAPI CreateRectRgnIndirect

(

const RECT *

prc

)

Definition at line 619 of file region.c.

{
    /* Notes if prc is NULL it will crash on All Windows NT I checked 2000/XP/VISTA */
    return CreateRectRgn(prc->left, prc->top, prc->right, prc->bottom);
 
}

DeleteRegion()

BOOL FASTCALL DeleteRegion

(

_In_ HRGN

hrgn

)

Definition at line 64 of file region.c.

{
    PRGN_ATTR Rgn_Attr = GdiGetRgnAttr(hrgn);
 
    if ( Rgn_Attr )
    {
        PGDIBSOBJECT pgO;
 
        pgO = GdiAllocBatchCommand(NULL, GdiBCDelRgn);
        if (pgO)
        {
            pgO->hgdiobj = hrgn;
            return TRUE;
        }
    }
    return NtGdiDeleteObjectApp(hrgn);
}

Referenced by CreateRectRgn().

ExcludeClipRect()

INT WINAPI ExcludeClipRect	(	_In_ HDC	hdc,
		_In_ INT	xLeft,
		_In_ INT	yTop,
		_In_ INT	xRight,
		_In_ INT	yBottom
	)

Definition at line 633 of file region.c.

{
    HANDLE_METADC(INT, ExcludeClipRect, ERROR, hdc, xLeft, yTop, xRight, yBottom);
 
    return NtGdiExcludeClipRect(hdc, xLeft, yTop, xRight, yBottom);
}

Referenced by ExcludeClipRect().

ExtCreateRegion()

HRGN WINAPI ExtCreateRegion	(	CONST XFORM *	lpXform,
		DWORD	nCount,
		CONST RGNDATA *	lpRgnData
	)

Definition at line 650 of file region.c.

{
    if (lpRgnData)
    {
        if ((!lpXform) && (lpRgnData->rdh.nCount == 1))
        {
            PRECT pRect = (PRECT)&lpRgnData->Buffer[0];
            return CreateRectRgn(pRect->left, pRect->top, pRect->right, pRect->bottom);
        }
        return NtGdiExtCreateRegion((LPXFORM) lpXform, nCount,(LPRGNDATA) lpRgnData);
    }
    SetLastError(ERROR_INVALID_PARAMETER);
    return NULL;
}

Referenced by MirrorRgnByWidth().

ExtSelectClipRgn()

INT WINAPI ExtSelectClipRgn	(	_In_ HDC	hdc,
		_In_ HRGN	hrgn,
		_In_ INT	iMode
	)

Definition at line 674 of file region.c.

{
    INT Ret;
    HRGN NewRgn = NULL;
 
    HANDLE_METADC(INT, ExtSelectClipRgn, 0, hdc, hrgn, iMode);
 
#if 0
    if ( hrgn )
    {
        if ( GetLayout(hdc) & LAYOUT_RTL )
        {
            if ( MirrorRgnDC(hdc, hrgn, &NewRgn) )
            {
                if ( NewRgn ) hrgn = NewRgn;
            }
        }
    }
#endif
    /* Batch handles RGN_COPY only! */
    if (iMode == RGN_COPY)
    {
        PDC_ATTR pdcattr;
        PRGN_ATTR pRgn_Attr = NULL;
 
        /* Get the DC attribute */
        pdcattr = GdiGetDcAttr(hdc);
        if ( pdcattr )
        {
            PGDI_TABLE_ENTRY pEntry = GdiHandleTable + GDI_HANDLE_GET_INDEX(hdc);
 
            /* hrgn can be NULL unless the RGN_COPY mode is specified. */
            if (hrgn) pRgn_Attr = GdiGetRgnAttr(hrgn);
 
            if ( !(pdcattr->ulDirty_ & DC_DIBSECTION) &&
                 !(pEntry->Flags & GDI_ENTRY_VALIDATE_VIS) )
            {
                if (!hrgn || (hrgn && pRgn_Attr && pRgn_Attr->iComplexity <= SIMPLEREGION) )
                {
                    PGDIBSEXTSELCLPRGN pgO = GdiAllocBatchCommand(hdc, GdiBCExtSelClipRgn);
                    if (pgO)
                    {
                        pgO->fnMode = iMode;
 
                        if ( hrgn && pRgn_Attr )
                        {
                            Ret = pRgn_Attr->iComplexity;
                            // Note from ntgdi/dcstate.c : "The VisRectRegion field needs to be set to a valid state."
                            if ( pdcattr->VisRectRegion.Rect.left   >= pRgn_Attr->Rect.right  ||
                                 pdcattr->VisRectRegion.Rect.top    >= pRgn_Attr->Rect.bottom ||
                                 pdcattr->VisRectRegion.Rect.right  <= pRgn_Attr->Rect.left   ||
                                 pdcattr->VisRectRegion.Rect.bottom <= pRgn_Attr->Rect.top )
                                Ret = NULLREGION;
 
                            // Pass the rect since this region will go away.
                            pgO->rcl = pRgn_Attr->Rect;
                        }
                        else
                        {
                            Ret = pdcattr->VisRectRegion.iComplexity;
                            pgO->fnMode |= GDIBS_NORECT; // Set no hrgn mode.
                        }
                        if ( NewRgn ) DeleteObject(NewRgn);
                        return Ret;
                    }
                }
            }
        }
    }
    Ret = NtGdiExtSelectClipRgn(hdc, hrgn, iMode);
 
    if ( NewRgn ) DeleteObject(NewRgn);
 
    return Ret;
}

Referenced by ExtSelectClipRgn(), and SelectClipRgn().

GetClipRgn()

int WINAPI GetClipRgn	(	HDC	hdc,
		HRGN	hrgn
	)

Definition at line 758 of file region.c.

{
    INT Ret;
 
    /* Check if DC handle is valid */
    if (!GdiGetDcAttr(hdc))
    {
        /* Last error code differs from what NtGdiGetRandomRgn returns */
        SetLastError(ERROR_INVALID_PARAMETER);
        return -1;
    }
 
    Ret = NtGdiGetRandomRgn(hdc, hrgn, CLIPRGN);
 
//  if (Ret)
//  {
//     if(GetLayout(hdc) & LAYOUT_RTL) MirrorRgnDC(hdc,(HRGN)Ret, NULL);
//  }
    return Ret;
}

GetMetaRgn()

int WINAPI GetMetaRgn	(	HDC	hdc,
		HRGN	hrgn
	)

Definition at line 787 of file region.c.

{
    return NtGdiGetRandomRgn(hdc, hrgn, METARGN);
}

GetRegionData()

DWORD WINAPI GetRegionData	(	HRGN	hrgn,
		DWORD	nCount,
		LPRGNDATA	lpRgnData
	)

Definition at line 799 of file region.c.

{
    if (!lpRgnData)
    {
        nCount = 0;
    }
 
    return NtGdiGetRegionData(hrgn,nCount,lpRgnData);
}

GetRgnBox()

INT WINAPI GetRgnBox	(	HRGN	hrgn,
		LPRECT	prcOut
	)

Definition at line 817 of file region.c.

{
    PRGN_ATTR Rgn_Attr;
 
    if (!(Rgn_Attr = GdiGetRgnAttr(hrgn)))
        return NtGdiGetRgnBox(hrgn, prcOut);
 
    if (Rgn_Attr->iComplexity == NULLREGION)
    {
        prcOut->left   = 0;
        prcOut->top    = 0;
        prcOut->right  = 0;
        prcOut->bottom = 0;
    }
    else
    {
        if (Rgn_Attr->iComplexity != SIMPLEREGION)
            return NtGdiGetRgnBox(hrgn, prcOut);
        /* WARNING! prcOut is never checked newbies! */
        RtlCopyMemory( prcOut, &Rgn_Attr->Rect, sizeof(RECT));
    }
    return Rgn_Attr->iComplexity;
}

IntersectClipRect()

INT WINAPI IntersectClipRect	(	_In_ HDC	hdc,
		_In_ INT	nLeft,
		_In_ INT	nTop,
		_In_ INT	nRight,
		_In_ INT	nBottom
	)

Definition at line 847 of file region.c.

{
    HANDLE_METADC(INT, IntersectClipRect, ERROR, hdc, nLeft, nTop, nRight, nBottom);
    return NtGdiIntersectClipRect(hdc, nLeft, nTop, nRight, nBottom);
}

Referenced by IntersectClipRect().

IntSetNullRgn()

FORCEINLINE ULONG IntSetNullRgn

(

_Inout_ PRGN_ATTR

prgnattr

)

Definition at line 157 of file region.c.

{
    prgnattr->iComplexity = NULLREGION;
    prgnattr->AttrFlags |= ATTR_RGN_DIRTY;
    prgnattr->Rect.left = prgnattr->Rect.top = prgnattr->Rect.right = prgnattr->Rect.bottom = 0;
    return NULLREGION;
}

Referenced by CombineRgn(), IntSetRectRgn(), and SetRectRgn().

IntSetRectRgn()

FORCEINLINE ULONG IntSetRectRgn	(	_Inout_ PRGN_ATTR	prgnattr,
		_In_ INT	xLeft,
		_In_ INT	yTop,
		_In_ INT	xRight,
		_In_ INT	yBottom
	)

Definition at line 168 of file region.c.

{
    ASSERT(xLeft <= xRight);
    ASSERT(yTop <= yBottom);
 
    if ((xLeft == xRight) || (yTop == yBottom))
        return IntSetNullRgn(prgnattr);
 
    prgnattr->iComplexity = SIMPLEREGION;
    prgnattr->Rect.left = xLeft;
    prgnattr->Rect.top = yTop;
    prgnattr->Rect.right = xRight;
    prgnattr->Rect.bottom = yBottom;
    prgnattr->AttrFlags |= ATTR_RGN_DIRTY;
    return SIMPLEREGION;
}

Referenced by CombineRgn(), and CreateRectRgn().

MirrorRgn()

BOOL WINAPI MirrorRgn	(	HWND	hwnd,
		HRGN	hrgn
	)

Definition at line 863 of file region.c.

{
    INT l;
    RECT Rect;
    GetWindowRect(hwnd, &Rect);
    l = Rect.right - Rect.left;
    Rect.right -= Rect.left;
    return MirrorRgnByWidth(hrgn, l, NULL);
}

Referenced by GetWindowRgn().

MirrorRgnByWidth()

INT FASTCALL MirrorRgnByWidth	(	_In_ HRGN	hrgn,
		_In_ INT	Width,
		_Out_opt_ HRGN *	phrgn
	)

Definition at line 85 of file region.c.

{
    INT cRgnDSize, Ret = 0;
    PRGNDATA pRgnData;
 
    cRgnDSize = NtGdiGetRegionData(hrgn, 0, NULL);
 
    if (cRgnDSize)
    {
        pRgnData = HeapAlloc(GetProcessHeap(), 0, cRgnDSize * sizeof(LONG));
        if (pRgnData)
        {
            if ( GetRegionData(hrgn, cRgnDSize, pRgnData) )
            {
                HRGN hRgnex;
                UINT i;
                INT SaveL = pRgnData->rdh.rcBound.left;
                pRgnData->rdh.rcBound.left = Width - pRgnData->rdh.rcBound.right;
                pRgnData->rdh.rcBound.right = Width - SaveL;
                if (pRgnData->rdh.nCount > 0)
                {
                    PRECT pRect = (PRECT)&pRgnData->Buffer;
                    for (i = 0; i < pRgnData->rdh.nCount; i++)
                    {
                        SaveL = pRect[i].left;
                        pRect[i].left = Width - pRect[i].right;
                        pRect[i].right = Width - SaveL;
                    }
                }
                SortRects((PRECT)&pRgnData->Buffer, pRgnData->rdh.nCount);
                hRgnex = ExtCreateRegion(NULL, cRgnDSize , pRgnData);
                if (hRgnex)
                {
                    if (phrgn)
                    {
                        *phrgn = hRgnex;
                    }
                    else
                    {
                        CombineRgn(hrgn, hRgnex, 0, RGN_COPY);
                        DeleteObject(hRgnex);
                    }
                    Ret = 1;
                }
            }
            HeapFree( GetProcessHeap(), 0, pRgnData);
        }
    }
    return Ret;
}

Referenced by MirrorRgn(), and MirrorRgnDC().

MirrorRgnDC()

INT WINAPI MirrorRgnDC	(	_In_ HDC	hdc,
		_In_ HRGN	hrgn,
		_Out_opt_ HRGN *	phrn
	)

Definition at line 141 of file region.c.

{
    if (!GdiValidateHandle((HGDIOBJ) hdc) ||
        (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC))
        return 0;
 
    return MirrorRgnByWidth(hrgn, NtGdiGetDeviceWidth(hdc), phrn);
}

Referenced by ExtSelectClipRgn().

OffsetClipRgn()

INT WINAPI OffsetClipRgn	(	HDC	hdc,
		INT	nXOffset,
		INT	nYOffset
	)

Definition at line 878 of file region.c.

{
    HANDLE_METADC(INT, OffsetClipRgn, ERROR, hdc, nXOffset, nYOffset);
    return NtGdiOffsetClipRgn(hdc, nXOffset, nYOffset);
}

Referenced by OffsetClipRgn().

OffsetRgn()

INT WINAPI OffsetRgn	(	HRGN	hrgn,
		int	nXOffset,
		int	nYOffset
	)

Definition at line 893 of file region.c.

{
    PRGN_ATTR pRgn_Attr;
    RECTL rc;
 
    if (!(pRgn_Attr = GdiGetRgnAttr(hrgn)))
        return NtGdiOffsetRgn(hrgn,nXOffset,nYOffset);
 
    if ( pRgn_Attr->iComplexity == NULLREGION)
        return pRgn_Attr->iComplexity;
 
    if ( pRgn_Attr->iComplexity != SIMPLEREGION)
        return NtGdiOffsetRgn(hrgn,nXOffset,nYOffset);
 
    rc = pRgn_Attr->Rect;
 
    if (rc.left < rc.right)
    {
        if (rc.top < rc.bottom)
        {
            rc.left   += nXOffset;
            rc.top    += nYOffset;
            rc.right  += nXOffset;
            rc.bottom += nYOffset;
 
            /* Make sure the offset is within the legal range */
            if ( (rc.left   & MIN_COORD && ((rc.left   & MIN_COORD) != MIN_COORD)) ||
                 (rc.top    & MIN_COORD && ((rc.top    & MIN_COORD) != MIN_COORD)) ||
                 (rc.right  & MIN_COORD && ((rc.right  & MIN_COORD) != MIN_COORD)) ||
                 (rc.bottom & MIN_COORD && ((rc.bottom & MIN_COORD) != MIN_COORD))  )
            {
                DPRINT("OffsetRgn ERROR\n");
                return ERROR;
            }
 
            pRgn_Attr->Rect = rc;
            pRgn_Attr->AttrFlags |= ATTR_RGN_DIRTY;
        }
    }
    return pRgn_Attr->iComplexity;
}

PtInRegion()

BOOL WINAPI PtInRegion	(	IN HRGN	hrgn,
		int	x,
		int	y
	)

Definition at line 942 of file region.c.

{
    PRGN_ATTR pRgn_Attr;
 
    if (!(pRgn_Attr = GdiGetRgnAttr(hrgn)))
        return NtGdiPtInRegion(hrgn,x,y);
 
    if ( pRgn_Attr->iComplexity == NULLREGION)
        return FALSE;
 
    if ( pRgn_Attr->iComplexity != SIMPLEREGION)
        return NtGdiPtInRegion(hrgn,x,y);
 
    return INRECT( pRgn_Attr->Rect, x, y);
}

RectInRegion()

BOOL WINAPI RectInRegion	(	HRGN	hrgn,
		LPCRECT	prcl
	)

Definition at line 965 of file region.c.

{
    PRGN_ATTR pRgn_Attr;
    RECTL rc;
 
    if (!(pRgn_Attr = GdiGetRgnAttr(hrgn)))
        return NtGdiRectInRegion(hrgn, (LPRECT) prcl);
 
    if ( pRgn_Attr->iComplexity == NULLREGION)
        return FALSE;
 
    if ( pRgn_Attr->iComplexity != SIMPLEREGION)
        return NtGdiRectInRegion(hrgn, (LPRECT) prcl);
 
    /* swap the coordinates to make right >= left and bottom >= top */
    /* (region building rectangles are normalized the same way) */
    if ( prcl->top > prcl->bottom)
    {
        rc.top = prcl->bottom;
        rc.bottom = prcl->top;
    }
    else
    {
        rc.top = prcl->top;
        rc.bottom = prcl->bottom;
    }
    if ( prcl->right < prcl->left)
    {
        rc.right = prcl->left;
        rc.left = prcl->right;
    }
    else
    {
        rc.right = prcl->right;
        rc.left = prcl->left;
    }
 
    if ( ( pRgn_Attr->Rect.left   >= rc.right )  ||
         ( pRgn_Attr->Rect.right  <= rc.left )   ||
         ( pRgn_Attr->Rect.top    >= rc.bottom ) ||
         ( pRgn_Attr->Rect.bottom <= rc.top ) )
    {
        return FALSE;
    }
 
    return TRUE;
}

SelectClipRgn()

int WINAPI SelectClipRgn	(	_In_ HDC	hdc,
		_In_ HRGN	hrgn
	)

Definition at line 1019 of file region.c.

{
    return ExtSelectClipRgn(hdc, hrgn, RGN_COPY);
}

SetMetaRgn()

int WINAPI SetMetaRgn

(

HDC

hDC

)

Definition at line 1087 of file region.c.

{
    if (GDI_HANDLE_GET_TYPE(hDC) != GDILoObjType_LO_DC_TYPE)
    {
        PLDC pLDC = GdiGetLDC(hDC);
        if ( pLDC && GDI_HANDLE_GET_TYPE(hDC) != GDILoObjType_LO_METADC16_TYPE )
        {
            if (pLDC->iType == LDC_EMFLDC && !EMFDC_SetMetaRgn( pLDC ))
            {
                return ERROR;
            }
        }
        else
        {
            SetLastError(ERROR_INVALID_HANDLE);
            return ERROR;
        }
    }
    return NtGdiSetMetaRgn(hDC);
}

SetRectRgn()

BOOL WINAPI SetRectRgn	(	_In_ HRGN	hrgn,
		_In_ INT	xLeft,
		_In_ INT	yTop,
		_In_ INT	xRight,
		_In_ INT	yBottom
	)

Definition at line 1031 of file region.c.

{
    PRGN_ATTR prngattr;
 
    /* Try to get the region attribute */
    prngattr = GdiGetRgnAttr(hrgn);
    if (prngattr == NULL)
    {
        return NtGdiSetRectRgn(hrgn, xLeft, yTop, xRight, yBottom);
    }
 
    /* check for NULL region */
    if ((xLeft == xRight) || (yTop == yBottom))
    {
        IntSetNullRgn(prngattr);
        return TRUE;
    }
 
    if (xLeft > xRight)
    {
        prngattr->Rect.left   = xRight;
        prngattr->Rect.right  = xLeft;
    }
    else
    {
        prngattr->Rect.left   = xLeft;
        prngattr->Rect.right  = xRight;
    }
 
    if (yTop > yBottom)
    {
        prngattr->Rect.top    = yBottom;
        prngattr->Rect.bottom = yTop;
    }
    else
    {
        prngattr->Rect.top    = yTop;
        prngattr->Rect.bottom = yBottom;
    }
 
    prngattr->AttrFlags |= ATTR_RGN_DIRTY ;
    prngattr->iComplexity = SIMPLEREGION;
 
    return TRUE;
}

SortRects()

static VOID FASTCALL SortRects ( PRECT  pRect, INT  nCount  )

static

Definition at line 23 of file region.c.

{
    INT i, a, b, c, s;
    RECT sRect;
 
    if (nCount > 0)
    {
        i = 1; // set index point
        c = nCount; // set inverse count
        do
        {
            s = i; // set sort count
            if ( i < nCount )
            {
                a = i - 1; // [0]
                b = i;     // [1]
                do
                {
                    if ( pRect[a].top != pRect[b].top ) break;
                    if ( pRect[a].left > pRect[b].left )
                    {
                        sRect = pRect[a];
                        pRect[a] = pRect[b];
                        pRect[b] = sRect;
                    }
                    ++s;
                    b++;
                }
                while ( s < nCount );
            }
            ++i;
        }
        while ( c-- != 1 );
    }
}

Referenced by MirrorRgnByWidth().