dcobjs.c File Reference

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

Include dependency graph for dcobjs.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
VOID FASTCALL	DC_vUpdateFillBrush (PDC pdc)
VOID FASTCALL	DC_vUpdateLineBrush (PDC pdc)
VOID FASTCALL	DC_vUpdateTextBrush (PDC pdc)
VOID FASTCALL	DC_vUpdateBackgroundBrush (PDC pdc)
VOID NTAPI	DC_vSetBrushOrigin (PDC pdc, LONG x, LONG y)
NtGdiSetBrushOrg
Sets the brush origin that GDI uses when drawing with pattern brushes. The brush origin is relative to the DC origin. @implemented
	_Success_ (return!=FALSE)
HPALETTE NTAPI	GdiSelectPalette (HDC hDC, HPALETTE hpal, BOOL ForceBackground)
HBRUSH APIENTRY	NtGdiSelectBrush (IN HDC hDC, IN HBRUSH hBrush)
HPEN APIENTRY	NtGdiSelectPen (IN HDC hDC, IN HPEN hPen)
BOOL NTAPI	DC_bIsBitmapCompatible (PDC pdc, PSURFACE psurf)
HBITMAP APIENTRY	NtGdiSelectBitmap (IN HDC hdc, IN HBITMAP hbmp)
BOOL APIENTRY	NtGdiSelectClipPath (HDC hDC, int Mode)
HFONT NTAPI	DC_hSelectFont (_In_ PDC pdc, _In_ HFONT hlfntNew)
HFONT APIENTRY	NtGdiSelectFont (_In_ HDC hdc, _In_ HFONT hfont)
HANDLE APIENTRY	NtGdiGetDCObject (HDC hDC, INT ObjectType)
INT APIENTRY	NtGdiGetRandomRgn (HDC hdc, HRGN hrgnDest, INT iCode)
ULONG APIENTRY	NtGdiEnumObjects (IN HDC hdc, IN INT iObjectType, IN ULONG cjBuf, OUT OPTIONAL PVOID pvBuf)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 11 of file dcobjs.c.

Function Documentation

_Success_()

_Success_

(

return!

= FALSE

)

Definition at line 161 of file dcobjs.c.

{
 
    POINT ptOut;
                /* Call the internal function */
    BOOL  Ret = GreSetBrushOrg( hdc, x, y, &ptOut);
    if (Ret)
    {
       /* Check if the old origin was requested */
       if (pptOut != NULL)
       {
           /* Enter SEH for buffer transfer */
           _SEH2_TRY
           {
               /* Probe and copy the old origin */
               ProbeForWrite(pptOut, sizeof(POINT), 1);
               *pptOut = ptOut;
           }
           _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
           {
               _SEH2_YIELD(return FALSE);
           }
           _SEH2_END;
       }
    }
    return Ret;
}

DC_bIsBitmapCompatible()

BOOL NTAPI DC_bIsBitmapCompatible	(	PDC	pdc,
		PSURFACE	psurf
	)

Definition at line 314 of file dcobjs.c.

{
    ULONG cBitsPixel;
 
    /* Must be an API bitmap */
    if (!(psurf->flags & API_BITMAP)) return FALSE;
 
    /* DIB sections are always compatible */
    if (psurf->hSecure != NULL) return TRUE;
 
    /* See if this is the same PDEV */
    if (psurf->SurfObj.hdev == (HDEV)pdc->ppdev)
        return TRUE;
 
    /* Get the bit depth of the bitmap */
    cBitsPixel = gajBitsPerFormat[psurf->SurfObj.iBitmapFormat];
 
    /* 1 BPP is compatible */
    if ((cBitsPixel == 1) || (cBitsPixel == pdc->ppdev->gdiinfo.cBitsPixel))
        return TRUE;
 
    return FALSE;
}

Referenced by NtGdiSelectBitmap().

DC_hSelectFont()

HFONT NTAPI DC_hSelectFont	(	_In_ PDC	pdc,
		_In_ HFONT	hlfntNew
	)

Definition at line 550 of file dcobjs.c.

{
    PLFONT plfntNew;
    HFONT hlfntOld;
 
    // Legacy crap that will die with font engine rewrite
    if (!NT_SUCCESS(TextIntRealizeFont(hlfntNew, NULL)))
    {
        return NULL;
    }
 
    /* Get the current selected font */
    hlfntOld = pdc->dclevel.plfnt->BaseObject.hHmgr;
 
    /* Check if a new font should be selected */
    if (hlfntNew != hlfntOld)
    {
        /* Lock the new font */
        plfntNew = LFONT_ShareLockFont(hlfntNew);
        if (plfntNew)
        {
            /* Success, dereference the old font */
            LFONT_ShareUnlockFont(pdc->dclevel.plfnt);
 
            /* Select the new font */
            pdc->dclevel.plfnt = plfntNew;
            pdc->pdcattr->hlfntNew = hlfntNew;
 
            /* Update dirty flags */
            pdc->pdcattr->ulDirty_ |= DIRTY_CHARSET;
            pdc->pdcattr->ulDirty_ &= ~SLOW_WIDTHS;
        }
        else
        {
            /* Failed, restore old, return NULL */
            pdc->pdcattr->hlfntNew = hlfntOld;
            hlfntOld = NULL;
        }
    }
 
    return hlfntOld;
}

Referenced by GdiFlushUserBatch(), and NtGdiSelectFont().

DC_vSetBrushOrigin()

VOID NTAPI DC_vSetBrushOrigin	(	PDC	pdc,
		LONG	x,
		LONG	y
	)

Definition at line 142 of file dcobjs.c.

{
    /* Set the brush origin */
    pdc->dclevel.ptlBrushOrigin.x = x;
    pdc->dclevel.ptlBrushOrigin.y = y;
 
    /* Set the fill origin */
    pdc->ptlFillOrigin.x = x + pdc->ptlDCOrig.x;
    pdc->ptlFillOrigin.y = y + pdc->ptlDCOrig.y;
}

Referenced by GdiFlushUserBatch(), and GreSetBrushOrg().

DC_vUpdateBackgroundBrush()

VOID FASTCALL DC_vUpdateBackgroundBrush

(

PDC

pdc

)

Definition at line 126 of file dcobjs.c.

{
    PDC_ATTR pdcattr = pdc->pdcattr;
 
    if(pdcattr->ulDirty_ & DIRTY_BACKGROUND)
        EBRUSHOBJ_vUpdateFromDC(&pdc->eboBackground, pbrDefaultBrush, pdc);
 
    /* Update the eboBackground's solid color */
    EBRUSHOBJ_vSetSolidRGBColor(&pdc->eboBackground, pdcattr->crBackgroundClr);
 
    /* Clear flag */
    pdcattr->ulDirty_ &= ~DIRTY_BACKGROUND;
}

Referenced by GdiFlushUserBatch(), IntExtTextOutW(), and IntGdiCleanDC().

DC_vUpdateFillBrush()

VOID FASTCALL DC_vUpdateFillBrush

(

PDC

pdc

)

Definition at line 16 of file dcobjs.c.

{
    PDC_ATTR pdcattr = pdc->pdcattr;
    PBRUSH pbrFill;
 
    /* Check if the brush handle has changed */
    if (pdcattr->hbrush != pdc->dclevel.pbrFill->BaseObject.hHmgr)
    {
        /* Try to lock the new brush */
        pbrFill = BRUSH_ShareLockBrush(pdcattr->hbrush);
        if (pbrFill)
        {
            /* Unlock old brush, set new brush */
            BRUSH_ShareUnlockBrush(pdc->dclevel.pbrFill);
            pdc->dclevel.pbrFill = pbrFill;
 
            /* Mark eboFill as dirty */
            pdcattr->ulDirty_ |= DIRTY_FILL;
        }
        else
        {
            /* Invalid brush handle, restore old one */
            pdcattr->hbrush = pdc->dclevel.pbrFill->BaseObject.hHmgr;
        }
    }
 
    /* Check if the EBRUSHOBJ needs update */
    if (pdcattr->ulDirty_ & DIRTY_FILL)
    {
        /* Update eboFill */
        EBRUSHOBJ_vUpdateFromDC(&pdc->eboFill, pdc->dclevel.pbrFill, pdc);
    }
 
    /* Check for DC brush */
    if (pdcattr->hbrush == StockObjects[DC_BRUSH])
    {
        /* Update the eboFill's solid color */
        EBRUSHOBJ_vSetSolidRGBColor(&pdc->eboFill, pdcattr->crBrushClr);
    }
 
    /* Clear flags */
    pdcattr->ulDirty_ &= ~(DIRTY_FILL | DC_BRUSH_DIRTY);
}

Referenced by DC_vPrepareDCsForBlit(), GdiFlushUserBatch(), GreStretchBltMask(), IntGdiCleanDC(), IntGdiFillRgn(), IntGdiPolygon(), IntGdiSetTextColor(), IntRectangle(), IntRoundRect(), NtGdiAngleArc(), NtGdiArcInternal(), NtGdiEllipse(), NtGdiFillPath(), NtGdiGetDCObject(), NtGdiMaskBlt(), NtGdiPatBlt(), NtGdiPolyDraw(), NtGdiPolyPolyDraw(), NtGdiSelectBrush(), and NtGdiStrokeAndFillPath().

DC_vUpdateLineBrush()

VOID FASTCALL DC_vUpdateLineBrush

(

PDC

pdc

)

Definition at line 62 of file dcobjs.c.

{
    PDC_ATTR pdcattr = pdc->pdcattr;
    PBRUSH pbrLine;
 
    /* Check if the pen handle has changed */
    if (pdcattr->hpen != pdc->dclevel.pbrLine->BaseObject.hHmgr)
    {
        /* Try to lock the new pen */
        pbrLine = PEN_ShareLockPen(pdcattr->hpen);
        if (pbrLine)
        {
            /* Unlock old brush, set new brush */
            BRUSH_ShareUnlockBrush(pdc->dclevel.pbrLine);
            pdc->dclevel.pbrLine = pbrLine;
 
            /* Mark eboLine as dirty */
            pdcattr->ulDirty_ |= DIRTY_LINE;
        }
        else
        {
            /* Invalid pen handle, restore old one */
            pdcattr->hpen = pdc->dclevel.pbrLine->BaseObject.hHmgr;
        }
    }
 
    /* Check if the EBRUSHOBJ needs update */
    if (pdcattr->ulDirty_ & DIRTY_LINE)
    {
        /* Update eboLine */
        EBRUSHOBJ_vUpdateFromDC(&pdc->eboLine, pdc->dclevel.pbrLine, pdc);
    }
 
    /* Check for DC pen */
    if (pdcattr->hpen == StockObjects[DC_PEN])
    {
        /* Update the eboLine's solid color */
        EBRUSHOBJ_vSetSolidRGBColor(&pdc->eboLine, pdcattr->crPenClr);
    }
 
    /* Clear flags */
    pdcattr->ulDirty_ &= ~(DIRTY_LINE | DC_PEN_DIRTY);
}

Referenced by DC_vPrepareDCsForBlit(), IntGdiCleanDC(), IntGdiPolygon(), IntGdiSetTextColor(), IntRectangle(), IntRoundRect(), NtGdiAngleArc(), NtGdiArcInternal(), NtGdiEllipse(), NtGdiFillPath(), NtGdiGetDCObject(), NtGdiPolyDraw(), NtGdiPolyPolyDraw(), NtGdiSelectPen(), NtGdiStrokeAndFillPath(), and NtGdiStrokePath().

DC_vUpdateTextBrush()

VOID FASTCALL DC_vUpdateTextBrush

(

PDC

pdc

)

Definition at line 108 of file dcobjs.c.

{
    PDC_ATTR pdcattr = pdc->pdcattr;
 
    /* Timo : The text brush should never be changed.
     * Jérôme : Yeah, but its palette must be updated anyway! */
    if(pdcattr->ulDirty_ & DIRTY_TEXT)
        EBRUSHOBJ_vUpdateFromDC(&pdc->eboText, pbrDefaultBrush, pdc);
 
    /* Update the eboText's solid color */
    EBRUSHOBJ_vSetSolidRGBColor(&pdc->eboText, pdcattr->crForegroundClr);
 
    /* Clear flag */
    pdcattr->ulDirty_ &= ~DIRTY_TEXT;
}

Referenced by DC_vPrepareDCsForBlit(), GdiFlushUserBatch(), IntExtTextOutW(), IntGdiCleanDC(), and IntGdiSetTextColor().

GdiSelectPalette()

HPALETTE NTAPI GdiSelectPalette	(	HDC	hDC,
		HPALETTE	hpal,
		BOOL	ForceBackground
	)

FIXME: we shouldn't dereference pSurface when the PDEV is not locked

Definition at line 199 of file dcobjs.c.

{
    PDC pdc;
    HPALETTE oldPal = NULL;
    PPALETTE ppal;
 
    // FIXME: Mark the palette as a [fore\back]ground pal
    pdc = DC_LockDc(hDC);
    if (!pdc)
    {
        return NULL;
    }
 
    /* Check if this is a valid palette handle */
    ppal = PALETTE_ShareLockPalette(hpal);
    if (!ppal)
    {
        DC_UnlockDc(pdc);
        return NULL;
    }
 
    /* Is this a valid palette for this depth? */
    if ((!pdc->dclevel.pSurface) ||
        (BitsPerFormat(pdc->dclevel.pSurface->SurfObj.iBitmapFormat) <= 8
            && (ppal->flFlags & PAL_INDEXED)) ||
        (BitsPerFormat(pdc->dclevel.pSurface->SurfObj.iBitmapFormat) > 8))
    {
        /* Get old palette, set new one */
        oldPal = pdc->dclevel.hpal;
        pdc->dclevel.hpal = hpal;
        DC_vSelectPalette(pdc, ppal);
 
        /* Mark the brushes invalid */
        pdc->pdcattr->ulDirty_ |= DIRTY_FILL | DIRTY_LINE |
                                  DIRTY_BACKGROUND | DIRTY_TEXT;
    }
 
    if(pdc->dctype == DCTYPE_MEMORY)
    {
        // This didn't work anyway
        //IntGdiRealizePalette(hDC);
    }
 
    PALETTE_ShareUnlockPalette(ppal);
    DC_UnlockDc(pdc);
 
    return oldPal;
}

NtGdiEnumObjects()

ULONG APIENTRY NtGdiEnumObjects	(	IN HDC	hdc,
		IN INT	iObjectType,
		IN ULONG	cjBuf,
		OUT OPTIONAL PVOID	pvBuf
	)

Definition at line 784 of file dcobjs.c.

{
    UNIMPLEMENTED;
    return 0;
}

NtGdiGetDCObject()

HANDLE APIENTRY NtGdiGetDCObject	(	HDC	hDC,
		INT	ObjectType
	)

Definition at line 629 of file dcobjs.c.

{
    HGDIOBJ SelObject;
    DC *pdc;
    PDC_ATTR pdcattr;
 
    /* From Wine: GetCurrentObject does not SetLastError() on a null object */
    if(!hDC) return NULL;
 
    if(!(pdc = DC_LockDc(hDC)))
    {
        return NULL;
    }
    pdcattr = pdc->pdcattr;
 
    if (pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
        DC_vUpdateFillBrush(pdc);
 
    if (pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
        DC_vUpdateLineBrush(pdc);
 
    switch(ObjectType)
    {
        case GDI_OBJECT_TYPE_EXTPEN:
        case GDI_OBJECT_TYPE_PEN:
            SelObject = pdcattr->hpen;
            break;
 
        case GDI_OBJECT_TYPE_BRUSH:
            SelObject = pdcattr->hbrush;
            break;
 
        case GDI_OBJECT_TYPE_PALETTE:
            SelObject = pdc->dclevel.hpal;
            break;
 
        case GDI_OBJECT_TYPE_FONT:
            SelObject = pdcattr->hlfntNew;
            break;
 
        case GDI_OBJECT_TYPE_BITMAP:
        {
            SURFACE *psurf = pdc->dclevel.pSurface;
            SelObject = psurf ? psurf->BaseObject.hHmgr : StockObjects[DEFAULT_BITMAP];
            break;
        }
 
        case GDI_OBJECT_TYPE_COLORSPACE:
            DPRINT1("FIXME: NtGdiGetCurrentObject() ObjectType OBJ_COLORSPACE not supported yet!\n");
            // SelObject = dc->dclevel.pColorSpace.BaseObject.hHmgr; ?
            SelObject = NULL;
            break;
 
        default:
            SelObject = NULL;
            EngSetLastError(ERROR_INVALID_PARAMETER);
            break;
    }
 
    DC_UnlockDc(pdc);
    return SelObject;
}

NtGdiGetRandomRgn()

INT APIENTRY NtGdiGetRandomRgn	(	HDC	hdc,
		HRGN	hrgnDest,
		INT	iCode
	)

Todo:

FIXME This is not really correct, since we already modified the region

Definition at line 709 of file dcobjs.c.

{
    INT ret = 0;
    PDC pdc;
    PREGION prgnSrc = NULL;
 
    pdc = DC_LockDc(hdc);
    if (!pdc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return -1;
    }
 
    switch (iCode)
    {
        case CLIPRGN:
            prgnSrc = pdc->dclevel.prgnClip;
            break;
 
        case METARGN:
            prgnSrc = pdc->dclevel.prgnMeta;
            break;
 
        case APIRGN:
            if (pdc->fs & DC_DIRTY_RAO)
                CLIPPING_UpdateGCRegion(pdc);
            if (pdc->prgnAPI)
            {
                prgnSrc = pdc->prgnAPI;
            }
            else if (pdc->dclevel.prgnClip)
            {
                prgnSrc = pdc->dclevel.prgnClip;
            }
            else if (pdc->dclevel.prgnMeta)
            {
                prgnSrc = pdc->dclevel.prgnMeta;
            }
            break;
 
        case SYSRGN:
            prgnSrc = pdc->prgnVis;
            break;
 
        default:
            break;
    }
 
    if (prgnSrc)
    {
        PREGION prgnDest = REGION_LockRgn(hrgnDest);
        if (prgnDest)
        {
            ret = IntGdiCombineRgn(prgnDest, prgnSrc, 0, RGN_COPY) == ERROR ? -1 : 1;
            if ((ret == 1) && (iCode == SYSRGN))
            {
                ret = REGION_bOffsetRgn(prgnDest, pdc->ptlDCOrig.x, pdc->ptlDCOrig.y);
            }
            REGION_UnlockRgn(prgnDest);
        }
        else
            ret = -1;
    }
 
    DC_UnlockDc(pdc);
 
    return ret;
}

NtGdiSelectBitmap()

HBITMAP APIENTRY NtGdiSelectBitmap	(	IN HDC	hdc,
		IN HBITMAP	hbmp
	)

Definition at line 343 of file dcobjs.c.

{
    PDC pdc;
    HBITMAP hbmpOld;
    PSURFACE psurfNew, psurfOld;
    HDC hdcOld;
    ASSERT_NOGDILOCKS();
 
    /* Verify parameters */
    if (hdc == NULL || hbmp == NULL) return NULL;
 
    /* First lock the DC */
    pdc = DC_LockDc(hdc);
    if (!pdc)
    {
        return NULL;
    }
 
    /* Must be a memory dc to select a bitmap */
    if (pdc->dctype != DCTYPE_MEMORY)
    {
        DC_UnlockDc(pdc);
        return NULL;
    }
 
    /* Save the old bitmap */
    psurfOld = pdc->dclevel.pSurface;
 
    /* Check if there is a bitmap selected */
    if (psurfOld)
    {
        /* Get the old bitmap's handle */
        hbmpOld = psurfOld->BaseObject.hHmgr;
    }
    else
    {
        /* Use the default bitmap */
        hbmpOld = StockObjects[DEFAULT_BITMAP];
    }
 
    /* Check if the new bitmap is already selected */
    if (hbmp == hbmpOld)
    {
        /* Unlock the DC and return the old bitmap */
        DC_UnlockDc(pdc);
        return hbmpOld;
    }
 
    /* Check if the default bitmap was passed */
    if (hbmp == StockObjects[DEFAULT_BITMAP])
    {
        psurfNew = NULL;
 
        /* Default bitmap is 1x1 pixel */
        pdc->dclevel.sizl.cx = 1;
        pdc->dclevel.sizl.cy = 1;
    }
    else
    {
        /* Reference the new bitmap and check if it's valid */
        psurfNew = SURFACE_ShareLockSurface(hbmp);
        if (!psurfNew)
        {
            DC_UnlockDc(pdc);
            return NULL;
        }
 
        /* Check if the bitmap is compatible with the dc */
        if (!DC_bIsBitmapCompatible(pdc, psurfNew))
        {
            /* Dereference the bitmap, unlock the DC and fail. */
            SURFACE_ShareUnlockSurface(psurfNew);
            DC_UnlockDc(pdc);
            return NULL;
        }
 
        /* Set the bitmap's hdc and check if it was set before */
        hdcOld = InterlockedCompareExchangePointer((PVOID*)&psurfNew->hdc, hdc, 0);
        if (hdcOld != NULL)
        {
            /* The bitmap is already selected into a different DC */
            ASSERT(hdcOld != hdc);
 
            /* Dereference the bitmap, unlock the DC and fail. */
            SURFACE_ShareUnlockSurface(psurfNew);
            DC_UnlockDc(pdc);
            return NULL;
        }
 
        /* Copy the bitmap size */
        pdc->dclevel.sizl = psurfNew->SurfObj.sizlBitmap;
 
        /* Check if the bitmap is a dibsection */
        if (psurfNew->hSecure)
        {
            /* Set DIBSECTION attribute */
            pdc->pdcattr->ulDirty_ |= DC_DIBSECTION;
        }
        else
        {
            /* Remove DIBSECTION attribute */
            pdc->pdcattr->ulDirty_ &= ~DC_DIBSECTION;
        }
    }
 
    /* Select the new bitmap */
    pdc->dclevel.pSurface = psurfNew;
 
    /* Check if there was a bitmap selected before */
    if (psurfOld)
    {
        /* Reset hdc of the old bitmap, it isn't selected anymore */
        psurfOld->hdc = NULL;
 
        /* Dereference the old bitmap */
        SURFACE_ShareUnlockSurface(psurfOld);
    }
 
    /* Mark the DC brushes and the RAO region invalid */
    pdc->pdcattr->ulDirty_ |= DIRTY_FILL | DIRTY_LINE;
    pdc->fs |= DC_DIRTY_RAO;
 
    /* Update the system region */
    REGION_SetRectRgn(pdc->prgnVis,
                      0,
                      0,
                      pdc->dclevel.sizl.cx,
                      pdc->dclevel.sizl.cy);
 
    /* Unlock the DC */
    DC_UnlockDc(pdc);
 
    /* Return the old bitmap handle */
    return hbmpOld;
}

NtGdiSelectBrush()

HBRUSH APIENTRY NtGdiSelectBrush	(	IN HDC	hDC,
		IN HBRUSH	hBrush
	)

Definition at line 257 of file dcobjs.c.

{
    PDC pDC;
    HBRUSH hOrgBrush;
 
    if (hDC == NULL || hBrush == NULL) return NULL;
 
    pDC = DC_LockDc(hDC);
    if (!pDC)
    {
        return NULL;
    }
 
    /* Simply return the user mode value, without checking */
    hOrgBrush = pDC->pdcattr->hbrush;
    pDC->pdcattr->hbrush = hBrush;
    DC_vUpdateFillBrush(pDC);
 
    DC_UnlockDc(pDC);
 
    return hOrgBrush;
}

NtGdiSelectClipPath()

BOOL APIENTRY NtGdiSelectClipPath	(	HDC	hDC,
		int	Mode
	)

Definition at line 484 of file dcobjs.c.

{
    PREGION  RgnPath;
    PPATH pPath, pNewPath;
    BOOL  success = FALSE;
    PDC_ATTR pdcattr;
    PDC pdc;
 
    pdc = DC_LockDc(hDC);
    if (!pdc)
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    pdcattr = pdc->pdcattr;
 
    pPath = PATH_LockPath(pdc->dclevel.hPath);
    if (!pPath)
    {
        DC_UnlockDc(pdc);
        return FALSE;
    }
 
    /* Check that path is closed */
    if (pPath->state != PATH_Closed)
    {
        EngSetLastError(ERROR_CAN_NOT_COMPLETE);
        success = FALSE;
        goto Exit;
    }
 
    /* Construct a region from the path */
    RgnPath = IntSysCreateRectpRgn(0, 0, 0, 0);
    if (!RgnPath)
    {
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
        DC_UnlockDc(pdc);
        return FALSE;
    }
 
    pNewPath = PATH_FlattenPath(pPath);
 
    success = PATH_PathToRegion(pNewPath, pdcattr->jFillMode, RgnPath);
 
    PATH_UnlockPath(pNewPath);
    PATH_Delete(pNewPath->BaseObject.hHmgr);
 
    if (success) success = IntGdiExtSelectClipRgn(pdc, RgnPath, Mode) != ERROR;
 
    REGION_Delete(RgnPath);
 
Exit:
    PATH_UnlockPath(pPath);
    PATH_Delete(pdc->dclevel.hPath);
    pdc->dclevel.flPath &= ~DCPATH_ACTIVE;
    pdc->dclevel.hPath = NULL;
 
    DC_UnlockDc(pdc);
 
    return success;
}

NtGdiSelectFont()

HFONT APIENTRY NtGdiSelectFont	(	_In_ HDC	hdc,
		_In_ HFONT	hfont
	)

Definition at line 597 of file dcobjs.c.

{
    HFONT hfontOld;
    PDC pdc;
 
    /* Check parameters */
    if ((hdc == NULL) || (hfont == NULL))
    {
        return NULL;
    }
 
    /* Lock the DC */
    pdc = DC_LockDc(hdc);
    if (!pdc)
    {
        return NULL;
    }
 
    /* Call the internal function */
    hfontOld = DC_hSelectFont(pdc, hfont);
 
    /* Unlock the DC */
    DC_UnlockDc(pdc);
 
    /* Return the previously selected font */
    return hfontOld;
}

Referenced by co_IntInitializeDesktopGraphics(), GdiSelectFont(), IntDrawMenuBarTemp(), IntPaintDesktop(), MENU_CalcItemSize(), MENU_DrawMenuBar(), MENU_DrawMenuItem(), MENU_DrawPopupGlyph(), MENU_DrawPopupMenu(), MENU_PopupMenuCalcSize(), MENU_SelectItem(), MENU_ShowSubPopup(), START_TEST(), UITOOLS95_DFC_ButtonCheckRadio(), UITOOLS95_DrawFrameCaption(), UITOOLS95_DrawFrameMenu(), UITOOLS95_DrawFrameScroll(), and UserDrawCaptionText().

NtGdiSelectPen()

HPEN APIENTRY NtGdiSelectPen	(	IN HDC	hDC,
		IN HPEN	hPen
	)

Definition at line 287 of file dcobjs.c.

{
    PDC pDC;
    HPEN hOrgPen;
 
    if (hDC == NULL || hPen == NULL) return NULL;
 
    pDC = DC_LockDc(hDC);
    if (!pDC)
    {
        return NULL;
    }
 
    /* Simply return the user mode value, without checking */
    hOrgPen = pDC->pdcattr->hpen;
    pDC->pdcattr->hpen = hPen;
    DC_vUpdateLineBrush(pDC);
 
    DC_UnlockDc(pDC);
 
    return hOrgPen;
}