cliprgn.c File Reference

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

Include dependency graph for cliprgn.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
VOID FASTCALL	IntGdiReleaseRaoRgn (PDC pDC)
VOID FASTCALL	IntGdiReleaseVisRgn (PDC pDC)
VOID FASTCALL	UpdateVisRgn (PDC pdc)
VOID FASTCALL	GdiSelectVisRgn (HDC hdc, PREGION prgn)
	_Success_ (return!=ERROR)
int APIENTRY	NtGdiExtSelectClipRgn (HDC hDC, HRGN hrgn, int fnMode)
INT APIENTRY	NtGdiExcludeClipRect (_In_ HDC hdc, _In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom)
INT APIENTRY	NtGdiIntersectClipRect (_In_ HDC hdc, _In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom)
INT APIENTRY	NtGdiOffsetClipRgn (_In_ HDC hdc, _In_ INT xOffset, _In_ INT yOffset)
BOOL APIENTRY	NtGdiPtVisible (HDC hDC, int X, int Y)
BOOL APIENTRY	NtGdiRectVisible (HDC hDC, LPRECT UnsafeRect)
int FASTCALL	IntGdiSetMetaRgn (PDC pDC)
int APIENTRY	NtGdiSetMetaRgn (HDC hDC)
VOID FASTCALL	CLIPPING_UpdateGCRegion (PDC pDC)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 11 of file cliprgn.c.

Function Documentation

_Success_()

_Success_

(

return!

= ERROR

)

Definition at line 89 of file cliprgn.c.

{
    int Ret = ERROR;
    PREGION prgnNClip, prgnOrigClip = dc->dclevel.prgnClip;
 
    //
    // No Coping Regions and no intersecting Regions or an User calling w NULL Region or have the Original Clip Region.
    //
    if (fnMode != RGN_COPY && (fnMode != RGN_AND || !prgn || prgnOrigClip))
    {
        prgnNClip = IntSysCreateRectpRgn(0, 0, 0, 0);
 
        // Have Original Clip Region.
        if (prgnOrigClip)
        {
           // This will fail on NULL prgn.
           Ret = IntGdiCombineRgn(prgnNClip, prgnOrigClip, prgn, fnMode);
 
           if (Ret)
           {
              REGION_Delete(prgnOrigClip);
              dc->dclevel.prgnClip = prgnNClip;
              IntGdiReleaseRaoRgn(dc);
           }
           else
              REGION_Delete(prgnNClip);
        }
        else // NULL Original Clip Region, setup a new one and process mode.
        {
            PREGION prgnClip;
            RECTL rcl;
#if 0
            PSURFACE pSurface;
 
            // See IntSetDefaultRegion.
 
            rcl.left   = 0;
            rcl.top    = 0;
            rcl.right  = dc->dclevel.sizl.cx;
            rcl.bottom = dc->dclevel.sizl.cy;
 
            //EngAcquireSemaphoreShared(pdc->ppdev->hsemDevLock);
            if (dc->ppdev->flFlags & PDEV_META_DEVICE)
            {
                pSurface = dc->dclevel.pSurface;
                if (pSurface && pSurface->flags & PDEV_SURFACE)
                {
                   rcl.left   += dc->ppdev->ptlOrigion.x;
                   rcl.top    += dc->ppdev->ptlOrigion.y;
                   rcl.right  += dc->ppdev->ptlOrigion.x;
                   rcl.bottom += dc->ppdev->ptlOrigion.y;
                }
            }
            //EngReleaseSemaphore(pdc->ppdev->hsemDevLock);
//#if 0
            rcl.left   += dc->ptlDCOrig.x;
            rcl.top    += dc->ptlDCOrig.y;
            rcl.right  += dc->ptlDCOrig.x;
            rcl.bottom += dc->ptlDCOrig.y;
#endif
            REGION_GetRgnBox(dc->prgnVis, &rcl);
 
            prgnClip = IntSysCreateRectpRgnIndirect(&rcl);
 
            Ret = IntGdiCombineRgn(prgnNClip, prgnClip, prgn, fnMode);
 
            if (Ret)
            {
                dc->dclevel.prgnClip = prgnNClip;
                IntGdiReleaseRaoRgn(dc);
            }
            else
                REGION_Delete(prgnNClip);
 
            REGION_Delete(prgnClip);
        }
        return Ret;
    }
 
    // Fall through to normal RectOS mode.
 
    //
    // Handle NULL Region and Original Clip Region.
    //
    if (!prgn)
    {
        if (prgnOrigClip)
        {
            REGION_Delete(dc->dclevel.prgnClip);
            dc->dclevel.prgnClip = NULL;
            IntGdiReleaseRaoRgn(dc);
        }
        return SIMPLEREGION;
    }
 
    //
    // Combine the new Clip region with original Clip and caller Region.
    //
    if ( prgnOrigClip &&
        (Ret = IntGdiCombineRgn(prgnOrigClip, prgn, NULL, RGN_COPY)) ) // Clip could fail.
    {
        IntGdiReleaseRaoRgn(dc);
    }
    else // NULL original Clip, just copy caller region to new.
    {
       prgnNClip = IntSysCreateRectpRgn(0, 0, 0, 0);
       REGION_bCopy(prgnNClip, prgn);
       Ret = REGION_Complexity(prgnNClip);
       dc->dclevel.prgnClip = prgnNClip;
       IntGdiReleaseRaoRgn(dc);
    }
    return Ret;
}

CLIPPING_UpdateGCRegion()

VOID FASTCALL CLIPPING_UpdateGCRegion

(

PDC

pDC

)

Definition at line 739 of file cliprgn.c.

{
    // Moved from Release Rao. Though it still gets over written.
    RECTL_vSetEmptyRect(&pDC->erclClip);
 
    /* Must have VisRgn set to a valid state! */
    ASSERT (pDC->prgnVis);
#if 0 // (w2k3) This works with limitations. (w7u) ReactOS relies on Rao.
    if ( !pDC->dclevel.prgnClip &&
         !pDC->dclevel.prgnMeta &&
         !pDC->prgnAPI)
    {
        if (pDC->prgnRao)
            REGION_Delete(pDC->prgnRao);
        pDC->prgnRao = NULL;
 
        REGION_bOffsetRgn(pDC->prgnVis, pDC->ptlDCOrig.x, pDC->ptlDCOrig.y);
 
        RtlCopyMemory(&pDC->erclClip,
                      &pDC->prgnVis->rdh.rcBound,
                       sizeof(RECTL));
 
        IntEngUpdateClipRegion(&pDC->co,
                                pDC->prgnVis->rdh.nCount,
                                pDC->prgnVis->Buffer,
                               &pDC->erclClip);
 
        REGION_bOffsetRgn(pDC->prgnVis, -pDC->ptlDCOrig.x, -pDC->ptlDCOrig.y);
 
        pDC->fs &= ~DC_DIRTY_RAO;
        UpdateVisRgn(pDC);
        return;
    }
#endif
    if (pDC->prgnAPI)
    {
        REGION_Delete(pDC->prgnAPI);
        pDC->prgnAPI = NULL;
    }
 
    if (pDC->prgnRao)
        REGION_Delete(pDC->prgnRao);
 
    pDC->prgnRao = IntSysCreateRectpRgn(0,0,0,0);
 
    ASSERT(pDC->prgnRao);
 
    if (pDC->dclevel.prgnMeta || pDC->dclevel.prgnClip)
    {
        pDC->prgnAPI = IntSysCreateRectpRgn(0,0,0,0);
        if (!pDC->dclevel.prgnMeta)
        {
            REGION_bCopy(pDC->prgnAPI,
                         pDC->dclevel.prgnClip);
        }
        else if (!pDC->dclevel.prgnClip)
        {
            REGION_bCopy(pDC->prgnAPI,
                         pDC->dclevel.prgnMeta);
        }
        else
        {
            REGION_bIntersectRegion(pDC->prgnAPI,
                                    pDC->dclevel.prgnClip,
                                    pDC->dclevel.prgnMeta);
        }
    }
 
    if (pDC->prgnAPI)
    {
        REGION_bIntersectRegion(pDC->prgnRao,
                                pDC->prgnVis,
                                pDC->prgnAPI);
    }
    else
    {
        REGION_bCopy(pDC->prgnRao,
                     pDC->prgnVis);
    }
 
 
    REGION_bOffsetRgn(pDC->prgnRao, pDC->ptlDCOrig.x, pDC->ptlDCOrig.y);
 
    RtlCopyMemory(&pDC->erclClip,
                  &pDC->prgnRao->rdh.rcBound,
                  sizeof(RECTL));
 
    pDC->fs &= ~DC_DIRTY_RAO;
    UpdateVisRgn(pDC);
 
    // pDC->co should be used. Example, CLIPOBJ_cEnumStart uses XCLIPOBJ to build
    // the rects from region objects rects in pClipRgn->Buffer.
    // With pDC->co.pClipRgn->Buffer,
    // pDC->co.pClipRgn = pDC->prgnRao ? pDC->prgnRao : pDC->prgnVis;
 
    IntEngUpdateClipRegion(&pDC->co,
                           pDC->prgnRao->rdh.nCount,
                           pDC->prgnRao->Buffer,
                           &pDC->erclClip);
 
    REGION_bOffsetRgn(pDC->prgnRao, -pDC->ptlDCOrig.x, -pDC->ptlDCOrig.y);
}

Referenced by DC_vPrepareDCsForBlit(), NtGdiGetBoundsRect(), NtGdiGetRandomRgn(), and NtGdiRectVisible().

GdiSelectVisRgn()

VOID FASTCALL GdiSelectVisRgn	(	HDC	hdc,
		PREGION	prgn
	)

Definition at line 57 of file cliprgn.c.

{
    DC *dc;
 
    if (!(dc = DC_LockDc(hdc)))
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return;
    }
 
    if (!prgn)
    {
       DPRINT1("SVR: Setting NULL Region\n");
       IntGdiReleaseVisRgn(dc);
       IntSetDefaultRegion(dc);
       DC_UnlockDc(dc);
       return;
    }
 
    dc->fs |= DC_DIRTY_RAO;
 
    ASSERT(dc->prgnVis != NULL);
    ASSERT(prgn != NULL);
 
    REGION_bCopy(dc->prgnVis, prgn);
    REGION_bOffsetRgn(dc->prgnVis, -dc->ptlDCOrig.x, -dc->ptlDCOrig.y);
 
    DC_UnlockDc(dc);
}

Referenced by DC_vUpdateDC(), and DceUpdateVisRgn().

IntGdiReleaseRaoRgn()

VOID FASTCALL IntGdiReleaseRaoRgn

(

PDC

pDC

)

Definition at line 16 of file cliprgn.c.

{
    INT Index = GDI_HANDLE_GET_INDEX(pDC->BaseObject.hHmgr);
    PGDI_TABLE_ENTRY Entry = &GdiHandleTable->Entries[Index];
    pDC->fs |= DC_DIRTY_RAO;
    Entry->Flags |= GDI_ENTRY_VALIDATE_VIS; // Need to validate Vis.
}

Referenced by _Success_(), IntGdiReleaseVisRgn(), IntGdiSetMetaRgn(), IntSetDefaultRegion(), and NtGdiOffsetClipRgn().

IntGdiReleaseVisRgn()

VOID FASTCALL IntGdiReleaseVisRgn

(

PDC

pDC

)

Definition at line 26 of file cliprgn.c.

{
    IntGdiReleaseRaoRgn(pDC);
    REGION_Delete(pDC->prgnVis);
    pDC->prgnVis = prgnDefault; // Vis can not be NULL!!!
}

Referenced by GdiSelectVisRgn().

IntGdiSetMetaRgn()

int FASTCALL IntGdiSetMetaRgn

(

PDC

pDC

)

Definition at line 675 of file cliprgn.c.

{
    INT Ret = ERROR;
 
    if ( pDC->dclevel.prgnMeta )
    {
        if ( pDC->dclevel.prgnClip )
        {
            PREGION prgn = IntSysCreateRectpRgn(0,0,0,0);
            if ( prgn )
            {
                if (REGION_bIntersectRegion(prgn, pDC->dclevel.prgnMeta, pDC->dclevel.prgnClip))
                {
                    // See Restore/SaveDC
                    REGION_Delete(pDC->dclevel.prgnMeta);
                    pDC->dclevel.prgnMeta = prgn;
 
                    REGION_Delete(pDC->dclevel.prgnClip);
                    pDC->dclevel.prgnClip = NULL;
                    IntGdiReleaseRaoRgn(pDC);
 
                    Ret = REGION_Complexity(pDC->dclevel.prgnMeta);
                }
                else
                    REGION_Delete(prgn);
            }
        }
        else
            Ret = REGION_Complexity(pDC->dclevel.prgnMeta);
    }
    else
    {
        if ( pDC->dclevel.prgnClip )
        {
            Ret = REGION_Complexity(pDC->dclevel.prgnClip);
            pDC->dclevel.prgnMeta = pDC->dclevel.prgnClip;
            pDC->dclevel.prgnClip = NULL;
        }
        else
            Ret = SIMPLEREGION;
    }
 
    return Ret;
}

Referenced by NtGdiSetMetaRgn().

NtGdiExcludeClipRect()

INT APIENTRY NtGdiExcludeClipRect	(	_In_ HDC	hdc,
		_In_ INT	xLeft,
		_In_ INT	yTop,
		_In_ INT	xRight,
		_In_ INT	yBottom
	)

Definition at line 438 of file cliprgn.c.

{
    INT iComplexity = ERROR;
    RECTL rect;
    PDC pdc;
    PREGION prgn;
 
    /* Lock the DC */
    pdc = DC_LockDc(hdc);
    if (pdc == NULL)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return ERROR;
    }
 
    /* Convert coordinates to device space */
    rect.left   = xLeft;
    rect.top    = yTop;
    rect.right  = xRight;
    rect.bottom = yBottom;
    RECTL_vMakeWellOrdered(&rect);
    IntLPtoDP(pdc, (LPPOINT)&rect, 2);
 
    prgn = IntSysCreateRectpRgnIndirect(&rect);
    if ( prgn )
    {
        iComplexity = IntSelectClipRgn( pdc, prgn, RGN_DIFF );
 
        REGION_Delete(prgn);
    }
 
    /* Emulate Windows behavior */
    if (iComplexity == SIMPLEREGION)
        iComplexity = COMPLEXREGION;
 
    /* Unlock the DC */
    DC_UnlockDc(pdc);
 
    return iComplexity;
}

Referenced by ExcludeClipRect(), and START_TEST().

NtGdiExtSelectClipRgn()

int APIENTRY NtGdiExtSelectClipRgn	(	HDC	hDC,
		HRGN	hrgn,
		int	fnMode
	)

Definition at line 310 of file cliprgn.c.

{
    int retval;
    DC *dc;
    PREGION prgn;
 
    if ( fnMode < RGN_AND || fnMode > RGN_COPY )
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return ERROR;
    }
 
    if (!(dc = DC_LockDc(hDC)))
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return ERROR;
    }
 
    prgn = REGION_LockRgn(hrgn);
 
    if ((prgn == NULL) && (fnMode != RGN_COPY))
    {
        //EngSetLastError(ERROR_INVALID_HANDLE); doesn't set this.
        retval = ERROR;
    }
    else
    {
#if 0   // Testing GDI Batch.
        {
            RECTL rcl;
            if (prgn)
                REGION_GetRgnBox(prgn, &rcl);
            else
                fnMode |= GDIBS_NORECT;
            retval = IntGdiExtSelectClipRect(dc, &rcl, fnMode);
        }
#else
        retval = IntGdiExtSelectClipRgn(dc, prgn, fnMode);
#endif
    }
 
    if (prgn)
        REGION_UnlockRgn(prgn);
 
    DC_UnlockDc(dc);
    return retval;
}

NtGdiIntersectClipRect()

INT APIENTRY NtGdiIntersectClipRect	(	_In_ HDC	hdc,
		_In_ INT	xLeft,
		_In_ INT	yTop,
		_In_ INT	xRight,
		_In_ INT	yBottom
	)

Definition at line 486 of file cliprgn.c.

{
    INT iComplexity = ERROR;
    RECTL rect;
    PDC pdc;
    PREGION prgn;
 
    DPRINT("NtGdiIntersectClipRect(%p, %d,%d-%d,%d)\n",
            hdc, xLeft, yTop, xRight, yBottom);
 
    /* Lock the DC */
    pdc = DC_LockDc(hdc);
    if (!pdc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return ERROR;
    }
 
    /* Convert coordinates to device space */
    rect.left   = xLeft;
    rect.top    = yTop;
    rect.right  = xRight;
    rect.bottom = yBottom;
    RECTL_vMakeWellOrdered(&rect);
    IntLPtoDP(pdc, (LPPOINT)&rect, 2);
 
    prgn = IntSysCreateRectpRgnIndirect(&rect);
    if ( prgn )
    {
        iComplexity = IntSelectClipRgn( pdc, prgn, RGN_AND );
 
        REGION_Delete(prgn);
    }
 
    /* Emulate Windows behavior */
    if ( iComplexity == SIMPLEREGION )
        iComplexity = COMPLEXREGION;
 
    /* Unlock the DC */
    DC_UnlockDc(pdc);
 
    return iComplexity;
}

Referenced by co_IntDrawCaret(), co_UserExcludeUpdateRgn(), DrawTextExWorker(), IntersectClipRect(), and START_TEST().

NtGdiOffsetClipRgn()

INT APIENTRY NtGdiOffsetClipRgn	(	_In_ HDC	hdc,
		_In_ INT	xOffset,
		_In_ INT	yOffset
	)

Definition at line 537 of file cliprgn.c.

{
    INT iComplexity;
    PDC pdc;
    POINTL apt[2];
 
    /* Lock the DC */
    pdc = DC_LockDc(hdc);
    if (pdc == NULL)
    {
        if (!hdc) EngSetLastError(ERROR_INVALID_HANDLE);
        return ERROR;
    }
 
    /* Check if we have a clip region */
    if (pdc->dclevel.prgnClip != NULL)
    {
        /* Convert coordinates into device space. Note that we need to convert
           2 coordinates to account for rotation / shear / offset */
        apt[0].x = 0;
        apt[0].y = 0;
        apt[1].x = xOffset;
        apt[1].y = yOffset;
        IntLPtoDP(pdc, apt, 2);
 
        /* Offset the clip region */
        if (!REGION_bOffsetRgn(pdc->dclevel.prgnClip,
                               apt[1].x - apt[0].x,
                               apt[1].y - apt[0].y))
        {
            iComplexity = ERROR;
        }
        else
        {
            IntGdiReleaseRaoRgn(pdc);
            UpdateVisRgn(pdc);
            iComplexity = REGION_Complexity(pdc->dclevel.prgnClip);
        }
 
        /* Mark the RAO region as dirty */
        pdc->fs |= DC_DIRTY_RAO;
    }
    else
    {
        /* NULL means no clipping, i.e. the "whole" region */
        iComplexity = SIMPLEREGION;
    }
 
    /* Unlock the DC and return the complexity */
    DC_UnlockDc(pdc);
    return iComplexity;
}

Referenced by OffsetClipRgn(), and START_TEST().

NtGdiPtVisible()

BOOL APIENTRY NtGdiPtVisible	(	HDC	hDC,
		int	X,
		int	Y
	)

Definition at line 593 of file cliprgn.c.

{
    BOOL ret = FALSE;
    PDC dc;
    PREGION prgn;
 
    if(!(dc = DC_LockDc(hDC)))
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    prgn = dc->prgnRao ? dc->prgnRao : dc->prgnVis;
 
    if (prgn)
    {
        POINT pt = {X, Y};
        IntLPtoDP(dc, &pt, 1);
        ret = REGION_PtInRegion(prgn, pt.x, pt.y);
    }
 
    DC_UnlockDc(dc);
 
    return ret;
}

NtGdiRectVisible()

BOOL APIENTRY NtGdiRectVisible	(	HDC	hDC,
		LPRECT	UnsafeRect
	)

Definition at line 623 of file cliprgn.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PDC dc = DC_LockDc(hDC);
    BOOL Result = FALSE;
    RECTL Rect;
    PREGION prgn;
 
    if (!dc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    _SEH2_TRY
    {
        ProbeForRead(UnsafeRect,
                   sizeof(RECT),
                   1);
        Rect = *UnsafeRect;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = _SEH2_GetExceptionCode();
    }
    _SEH2_END;
 
    if(!NT_SUCCESS(Status))
    {
        DC_UnlockDc(dc);
        SetLastNtError(Status);
        return FALSE;
    }
 
    if (dc->fs & DC_DIRTY_RAO)
        CLIPPING_UpdateGCRegion(dc);
 
    prgn = dc->prgnRao ? dc->prgnRao : dc->prgnVis;
    if (prgn)
    {
         IntLPtoDP(dc, (LPPOINT)&Rect, 2);
         Result = REGION_RectInRegion(prgn, &Rect);
    }
    DC_UnlockDc(dc);
 
    return Result;
}

NtGdiSetMetaRgn()

int APIENTRY NtGdiSetMetaRgn

(

HDC

hDC

)

Definition at line 721 of file cliprgn.c.

{
  INT Ret;
  PDC pDC = DC_LockDc(hDC);
 
  if (!pDC)
  {
     EngSetLastError(ERROR_INVALID_PARAMETER);
     return ERROR;
  }
  Ret = IntGdiSetMetaRgn(pDC);
 
  DC_UnlockDc(pDC);
  return Ret;
}

UpdateVisRgn()

VOID FASTCALL UpdateVisRgn

(

PDC

pdc

)

Definition at line 39 of file cliprgn.c.

{
    INT Index = GDI_HANDLE_GET_INDEX(pdc->BaseObject.hHmgr);
    PGDI_TABLE_ENTRY pEntry = &GdiHandleTable->Entries[Index];
 
    /* Setup Vis Region Attribute information to User side */
    pEntry->Flags |= GDI_ENTRY_VALIDATE_VIS;
    pdc->pdcattr->VisRectRegion.iComplexity = REGION_GetRgnBox(pdc->prgnVis, &pdc->pdcattr->VisRectRegion.Rect);
    pdc->pdcattr->VisRectRegion.AttrFlags = ATTR_RGN_VALID;
    pEntry->Flags &= ~GDI_ENTRY_VALIDATE_VIS;
}

Referenced by CLIPPING_UpdateGCRegion(), DC_vInitDc(), and NtGdiOffsetClipRgn().