painting.c File Reference

#include <precomp.h>

Include dependency graph for painting.c:

Go to the source code of this file.

Functions
BOOL WINAPI	LineTo (_In_ HDC hdc, _In_ INT x, _In_ INT y)
BOOL WINAPI	MoveToEx (_In_ HDC hdc, _In_ INT x, _In_ INT y, _Out_opt_ LPPOINT ppt)
BOOL WINAPI	Ellipse (_In_ HDC hdc, _In_ INT left, _In_ INT top, _In_ INT right, _In_ INT bottom)
BOOL WINAPI	Rectangle (_In_ HDC hdc, _In_ INT left, _In_ INT top, _In_ INT right, _In_ INT bottom)
BOOL WINAPI	RoundRect (_In_ HDC hdc, _In_ INT left, _In_ INT top, _In_ INT right, _In_ INT bottom, _In_ INT width, _In_ INT height)
COLORREF WINAPI	GetPixel (_In_ HDC hdc, _In_ INT x, _In_ INT y)
COLORREF WINAPI	SetPixel (_In_ HDC hdc, _In_ INT x, _In_ INT y, _In_ COLORREF crColor)
BOOL WINAPI	SetPixelV (_In_ HDC hdc, _In_ INT x, _In_ INT y, _In_ COLORREF crColor)
BOOL WINAPI	FillRgn (_In_ HDC hdc, _In_ HRGN hrgn, _In_ HBRUSH hbr)
BOOL WINAPI	FrameRgn (_In_ HDC hdc, _In_ HRGN hrgn, _In_ HBRUSH hbr, _In_ INT nWidth, _In_ INT nHeight)
BOOL WINAPI	InvertRgn (_In_ HDC hdc, _In_ HRGN hrgn)
BOOL WINAPI	PaintRgn (_In_ HDC hdc, _In_ HRGN hrgn)
BOOL WINAPI	PolyBezier (_In_ HDC hdc, _In_reads_(cpt) const POINT *apt, _In_ DWORD cpt)
BOOL WINAPI	PolyBezierTo (_In_ HDC hdc, _In_reads_(cpt) const POINT *apt, _In_ DWORD cpt)
BOOL WINAPI	PolyDraw (_In_ HDC hdc, _In_reads_(cpt) const POINT *apt, _In_reads_(cpt) const BYTE *aj, _In_ INT cpt)
BOOL WINAPI	Polygon (_In_ HDC hdc, _In_reads_(cpt) const POINT *apt, _In_ INT cpt)
BOOL WINAPI	Polyline (_In_ HDC hdc, _In_reads_(cpt) const POINT *apt, _In_ INT cpt)
BOOL WINAPI	PolylineTo (_In_ HDC hdc, _In_reads_(cpt) const POINT *apt, _In_ DWORD cpt)
BOOL WINAPI	PolyPolygon (_In_ HDC hdc, _In_ const POINT *apt, _In_reads_(csz) const INT *asz, _In_ INT csz)
BOOL WINAPI	PolyPolyline (_In_ HDC hdc, _In_ CONST POINT *apt, _In_reads_(csz) CONST DWORD *asz, _In_ DWORD csz)
BOOL WINAPI	ExtFloodFill (_In_ HDC hdc, _In_ INT xStart, _In_ INT yStart, _In_ COLORREF crFill, _In_ UINT fuFillType)
BOOL WINAPI	FloodFill (_In_ HDC hdc, _In_ INT xStart, _In_ INT yStart, _In_ COLORREF crFill)
BOOL WINAPI	BitBlt (_In_ HDC hdcDest, _In_ INT xDest, _In_ INT yDest, _In_ INT cx, _In_ INT cy, _In_opt_ HDC hdcSrc, _In_ INT xSrc, _In_ INT ySrc, _In_ DWORD dwRop)
BOOL WINAPI	PatBlt (_In_ HDC hdc, _In_ INT nXLeft, _In_ INT nYLeft, _In_ INT nWidth, _In_ INT nHeight, _In_ DWORD dwRop)
BOOL WINAPI	PolyPatBlt (_In_ HDC hdc, _In_ DWORD dwRop, _In_ PPOLYPATBLT pPoly, _In_ DWORD nCount, _In_ DWORD dwMode)
BOOL WINAPI	StretchBlt (_In_ HDC hdcDest, _In_ INT xDest, _In_ INT yDest, _In_ INT cxDest, _In_ INT cyDest, _In_opt_ HDC hdcSrc, _In_ INT xSrc, _In_ INT ySrc, _In_ INT cxSrc, _In_ INT cySrc, _In_ DWORD dwRop)
BOOL WINAPI	MaskBlt (_In_ HDC hdcDest, _In_ INT xDest, _In_ INT yDest, _In_ INT cx, _In_ INT cy, _In_ HDC hdcSrc, _In_ INT xSrc, _In_ INT ySrc, _In_ HBITMAP hbmMask, _In_ INT xMask, _In_ INT yMask, _In_ DWORD dwRop)
BOOL WINAPI	PlgBlt (_In_ HDC hdcDest, _In_reads_(3) const POINT *ppt, _In_ HDC hdcSrc, _In_ INT xSrc, _In_ INT ySrc, _In_ INT cx, _In_ INT cy, _In_opt_ HBITMAP hbmMask, _In_ INT xMask, _In_ INT yMask)
BOOL WINAPI	GdiAlphaBlend (_In_ HDC hdcDst, _In_ INT xDst, _In_ INT yDst, _In_ INT cxDst, _In_ INT cyDst, _In_ HDC hdcSrc, _In_ INT xSrc, _In_ INT ySrc, _In_ INT cxSrc, _In_ INT cySrc, _In_ BLENDFUNCTION blendfn)
BOOL WINAPI	GdiTransparentBlt (_In_ HDC hdcDst, _In_ INT xDst, _In_ INT yDst, _In_ INT cxDst, _In_ INT cyDst, _In_ HDC hdcSrc, _In_ INT xSrc, _In_ INT ySrc, _In_ INT cxSrc, _In_ INT cySrc, _In_ UINT crTransparent)
BOOL WINAPI	GdiGradientFill (_In_ HDC hdc, _In_reads_(nVertex) PTRIVERTEX pVertex, _In_ ULONG nVertex, _In_ PVOID pMesh, _In_ ULONG nCount, _In_ ULONG ulMode)

Function Documentation

BitBlt()

BOOL WINAPI BitBlt	(	_In_ HDC	hdcDest,
		_In_ INT	xDest,
		_In_ INT	yDest,
		_In_ INT	cx,
		_In_ INT	cy,
		_In_opt_ HDC	hdcSrc,
		_In_ INT	xSrc,
		_In_ INT	ySrc,
		_In_ DWORD	dwRop
	)

Definition at line 511 of file painting.c.

{
    /* Use PatBlt for no source blt, like windows does */
    if (!ROP_USES_SOURCE(dwRop))
    {
        return PatBlt(hdcDest, xDest, yDest, cx, cy, dwRop);
    }
 
    /* For meta DCs we use StretchBlt via emfdc.c */
    HANDLE_METADC(BOOL,
                  BitBlt,
                  FALSE,
                  hdcDest,
                  xDest,
                  yDest,
                  cx,
                  cy,
                  hdcSrc,
                  xSrc,
                  ySrc,
                  dwRop);
 
    if ( GdiConvertAndCheckDC(hdcDest) == NULL ) return FALSE;
 
    return NtGdiBitBlt(hdcDest, xDest, yDest, cx, cy, hdcSrc, xSrc, ySrc, dwRop, CLR_INVALID, 0);
}

Referenced by BitBlt().

Ellipse()

BOOL WINAPI Ellipse	(	_In_ HDC	hdc,
		_In_ INT	left,
		_In_ INT	top,
		_In_ INT	right,
		_In_ INT	bottom
	)

Definition at line 71 of file painting.c.

{
    HANDLE_METADC(BOOL, Ellipse, FALSE, hdc, left, top, right, bottom);
 
    if ( GdiConvertAndCheckDC(hdc) == NULL ) return FALSE;
 
    return NtGdiEllipse(hdc, left, top, right, bottom);
}

Referenced by Ellipse().

ExtFloodFill()

BOOL WINAPI ExtFloodFill	(	_In_ HDC	hdc,
		_In_ INT	xStart,
		_In_ INT	yStart,
		_In_ COLORREF	crFill,
		_In_ UINT	fuFillType
	)

Definition at line 477 of file painting.c.

{
    HANDLE_METADC(BOOL, ExtFloodFill, FALSE, hdc, xStart, yStart, crFill, fuFillType);
 
    if ( GdiConvertAndCheckDC(hdc) == NULL ) return FALSE;
 
    return NtGdiExtFloodFill(hdc, xStart, yStart, crFill, fuFillType);
}

Referenced by ExtFloodFill(), and FloodFill().

FillRgn()

BOOL WINAPI FillRgn	(	_In_ HDC	hdc,
		_In_ HRGN	hrgn,
		_In_ HBRUSH	hbr
	)

Definition at line 183 of file painting.c.

{
 
    if ((hrgn == NULL) || (hbr == NULL))
        return FALSE;
 
    HANDLE_METADC(BOOL, FillRgn, FALSE, hdc, hrgn, hbr);
 
    if ( GdiConvertAndCheckDC(hdc) == NULL ) return FALSE;
 
    return NtGdiFillRgn(hdc, hrgn, hbr);
}

Referenced by FillRgn(), HEADER_DrawItem(), OnPaint(), CardWindow::PaintCardRgn(), CUIFBalloonWindow::PaintFrameProc(), PaintRgn(), PlayEnhMetaFileRecord(), PlayMetaFileRecord(), print_preview(), Test_FrameRgn(), TOOLTIPS_Refresh(), and visualize_region_differences().

FloodFill()

BOOL WINAPI FloodFill	(	_In_ HDC	hdc,
		_In_ INT	xStart,
		_In_ INT	yStart,
		_In_ COLORREF	crFill
	)

Definition at line 497 of file painting.c.

{
    return ExtFloodFill(hdc, xStart, yStart, crFill, FLOODFILLBORDER);
}

FrameRgn()

BOOL WINAPI FrameRgn	(	_In_ HDC	hdc,
		_In_ HRGN	hrgn,
		_In_ HBRUSH	hbr,
		_In_ INT	nWidth,
		_In_ INT	nHeight
	)

Definition at line 205 of file painting.c.

{
 
    if ((hrgn == NULL) || (hbr == NULL))
        return FALSE;
 
    HANDLE_METADC(BOOL, FrameRgn, FALSE, hdc, hrgn, hbr, nWidth, nHeight);
 
    if ( GdiConvertAndCheckDC(hdc) == NULL ) return FALSE;
 
    return NtGdiFrameRgn(hdc, hrgn, hbr, nWidth, nHeight);
}

Referenced by FrameRgn().

GdiAlphaBlend()

BOOL WINAPI GdiAlphaBlend	(	_In_ HDC	hdcDst,
		_In_ INT	xDst,
		_In_ INT	yDst,
		_In_ INT	cxDst,
		_In_ INT	cyDst,
		_In_ HDC	hdcSrc,
		_In_ INT	xSrc,
		_In_ INT	ySrc,
		_In_ INT	cxSrc,
		_In_ INT	cySrc,
		_In_ BLENDFUNCTION	blendfn
	)

Definition at line 833 of file painting.c.

{
    if (hdcSrc == NULL ) return FALSE;
 
    if (GDI_HANDLE_GET_TYPE(hdcSrc) == GDI_OBJECT_TYPE_METADC) return FALSE;
 
    HANDLE_EMETAFDC(BOOL,
                  AlphaBlend,
                  FALSE,
                  hdcDst,
                  xDst,
                  yDst,
                  cxDst,
                  cyDst,
                  hdcSrc,
                  xSrc,
                  ySrc,
                  cxSrc,
                  cySrc,
                  blendfn);
 
    if ( GdiConvertAndCheckDC(hdcDst) == NULL ) return FALSE;
 
    return NtGdiAlphaBlend(hdcDst,
                           xDst,
                           yDst,
                           cxDst,
                           cyDst,
                           hdcSrc,
                           xSrc,
                           ySrc,
                           cxSrc,
                           cySrc,
                           blendfn,
                           0);
}

GdiGradientFill()

BOOL WINAPI GdiGradientFill	(	_In_ HDC	hdc,
		_In_reads_(nVertex) PTRIVERTEX	pVertex,
		_In_ ULONG	nVertex,
		_In_ PVOID	pMesh,
		_In_ ULONG	nCount,
		_In_ ULONG	ulMode
	)

Definition at line 925 of file painting.c.

{
    if (GDI_HANDLE_GET_TYPE(hdc) == GDILoObjType_LO_METADC16_TYPE) return TRUE;
 
    HANDLE_EMETAFDC(BOOL, GradientFill, FALSE, hdc, pVertex, nVertex, pMesh, nCount, ulMode);
 
    if ( GdiConvertAndCheckDC(hdc) == NULL ) return FALSE;
 
    return NtGdiGradientFill(hdc, pVertex, nVertex, pMesh, nCount, ulMode);
}

GdiTransparentBlt()

BOOL WINAPI GdiTransparentBlt	(	_In_ HDC	hdcDst,
		_In_ INT	xDst,
		_In_ INT	yDst,
		_In_ INT	cxDst,
		_In_ INT	cyDst,
		_In_ HDC	hdcSrc,
		_In_ INT	xSrc,
		_In_ INT	ySrc,
		_In_ INT	cxSrc,
		_In_ INT	cySrc,
		_In_ UINT	crTransparent
	)

Definition at line 887 of file painting.c.

{
    HANDLE_EMETAFDC(BOOL,
                  TransparentBlt,
                  FALSE,
                  hdcDst,
                  xDst,
                  yDst,
                  cxDst,
                  cyDst,
                  hdcSrc,
                  xSrc,
                  ySrc,
                  cxSrc,
                  cySrc,
                  crTransparent);
 
    if ( GdiConvertAndCheckDC(hdcDst) == NULL ) return FALSE;
 
    return NtGdiTransparentBlt(hdcDst, xDst, yDst, cxDst, cyDst, hdcSrc, xSrc, ySrc, cxSrc, cySrc, crTransparent);
}

GetPixel()

COLORREF WINAPI GetPixel	(	_In_ HDC	hdc,
		_In_ INT	x,
		_In_ INT	y
	)

Definition at line 133 of file painting.c.

{
    if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC) return CLR_INVALID;
    if (!GdiValidateHandle((HGDIOBJ) hdc)) return CLR_INVALID;
    return NtGdiGetPixel(hdc, x, y);
}

InvertRgn()

BOOL WINAPI InvertRgn	(	_In_ HDC	hdc,
		_In_ HRGN	hrgn
	)

Definition at line 229 of file painting.c.

{
 
    if (hrgn == NULL)
        return FALSE;
 
    HANDLE_METADC(BOOL, InvertRgn, FALSE, hdc, hrgn);
 
    if ( GdiConvertAndCheckDC(hdc) == NULL ) return FALSE;
 
    return NtGdiInvertRgn(hdc, hrgn);
}

Referenced by InvertRgn(), PaintSelectionRect(), PlayEnhMetaFileRecord(), and PlayMetaFileRecord().

LineTo()

BOOL WINAPI LineTo	(	_In_ HDC	hdc,
		_In_ INT	x,
		_In_ INT	y
	)

Definition at line 9 of file painting.c.

{
    HANDLE_METADC(BOOL, LineTo, FALSE, hdc, x, y);
 
    if ( GdiConvertAndCheckDC(hdc) == NULL ) return FALSE;
 
    return NtGdiLineTo(hdc, x, y);
}

Referenced by LineTo(), and PolyBezierTo().

MaskBlt()

BOOL WINAPI MaskBlt	(	_In_ HDC	hdcDest,
		_In_ INT	xDest,
		_In_ INT	yDest,
		_In_ INT	cx,
		_In_ INT	cy,
		_In_ HDC	hdcSrc,
		_In_ INT	xSrc,
		_In_ INT	ySrc,
		_In_ HBITMAP	hbmMask,
		_In_ INT	xMask,
		_In_ INT	yMask,
		_In_ DWORD	dwRop
	)

Definition at line 737 of file painting.c.

{
    HANDLE_EMETAFDC(BOOL,
                  MaskBlt,
                  FALSE,
                  hdcDest,
                  xDest,
                  yDest,
                  cx,
                  cy,
                  hdcSrc,
                  xSrc,
                  ySrc,
                  hbmMask,
                  xMask,
                  yMask,
                  dwRop);
 
    if ( GdiConvertAndCheckDC(hdcDest) == NULL ) return FALSE;
 
    return NtGdiMaskBlt(hdcDest,
                        xDest,
                        yDest,
                        cx,
                        cy,
                        hdcSrc,
                        xSrc,
                        ySrc,
                        hbmMask,
                        xMask,
                        yMask,
                        dwRop,
                        CLR_INVALID);
}

Referenced by MaskBlt().

MoveToEx()

BOOL WINAPI MoveToEx	(	_In_ HDC	hdc,
		_In_ INT	x,
		_In_ INT	y,
		_Out_opt_ LPPOINT	ppt
	)

Definition at line 24 of file painting.c.

{
    PDC_ATTR pdcattr;
 
    HANDLE_METADC(BOOL, MoveTo, FALSE, hdc, x, y);
 
    /* Get the DC attribute */
    pdcattr = GdiGetDcAttr(hdc);
    if (pdcattr == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (ppt)
    {
        if ( pdcattr->ulDirty_ & DIRTY_PTLCURRENT ) // Double hit!
        {
            ppt->x = pdcattr->ptfxCurrent.x; // ret prev before change.
            ppt->y = pdcattr->ptfxCurrent.y;
            DPtoLP (hdc, ppt, 1);          // reconvert back.
        }
        else
        {
            ppt->x = pdcattr->ptlCurrent.x;
            ppt->y = pdcattr->ptlCurrent.y;
        }
    }
 
    pdcattr->ptlCurrent.x = x;
    pdcattr->ptlCurrent.y = y;
 
    pdcattr->ulDirty_ &= ~DIRTY_PTLCURRENT;
    pdcattr->ulDirty_ |= ( DIRTY_PTFXCURRENT|DIRTY_STYLESTATE); // Set dirty
    return TRUE;
}

PaintRgn()

BOOL WINAPI PaintRgn	(	_In_ HDC	hdc,
		_In_ HRGN	hrgn
	)

Definition at line 250 of file painting.c.

{
    return FillRgn(hdc, hrgn, GetCurrentObject(hdc, OBJ_BRUSH));
}

Referenced by draw_graphics(), PlayEnhMetaFileRecord(), PlayMetaFileRecord(), and Test_PaintRgn().

PatBlt()

BOOL WINAPI PatBlt	(	_In_ HDC	hdc,
		_In_ INT	nXLeft,
		_In_ INT	nYLeft,
		_In_ INT	nWidth,
		_In_ INT	nHeight,
		_In_ DWORD	dwRop
	)

Definition at line 549 of file painting.c.

{
    PDC_ATTR pdcattr;
 
    HANDLE_EMETAFDC(BOOL, PatBlt, FALSE, hdc, nXLeft, nYLeft, nWidth, nHeight, dwRop);
 
    if ( GdiConvertAndCheckDC(hdc) == NULL ) return FALSE;
 
    /* Get the DC attribute */
    pdcattr = GdiGetDcAttr(hdc);
    if (pdcattr && !(pdcattr->ulDirty_ & DC_DIBSECTION))
    {
        PGDIBSPATBLT pgO;
 
        pgO = GdiAllocBatchCommand(hdc, GdiBCPatBlt);
        if (pgO)
        {
            pdcattr->ulDirty_ |= DC_MODE_DIRTY;
            pgO->nXLeft  = nXLeft;
            pgO->nYLeft  = nYLeft;
            pgO->nWidth  = nWidth;
            pgO->nHeight = nHeight;
            pgO->dwRop   = dwRop;
            /* Snapshot attributes */
            pgO->hbrush          = pdcattr->hbrush;
            pgO->crForegroundClr = pdcattr->crForegroundClr;
            pgO->crBackgroundClr = pdcattr->crBackgroundClr;
            pgO->crBrushClr      = pdcattr->crBrushClr;
            pgO->ulForegroundClr = pdcattr->ulForegroundClr;
            pgO->ulBackgroundClr = pdcattr->ulBackgroundClr;
            pgO->ulBrushClr      = pdcattr->ulBrushClr;
            return TRUE;
        }
    }
    return NtGdiPatBlt( hdc,  nXLeft,  nYLeft,  nWidth,  nHeight,  dwRop);
}

Referenced by BitBlt(), PatBlt(), and PolyPatBlt().

PlgBlt()

BOOL WINAPI PlgBlt	(	_In_ HDC	hdcDest,
		_In_reads_(3) const POINT *	ppt,
		_In_ HDC	hdcSrc,
		_In_ INT	xSrc,
		_In_ INT	ySrc,
		_In_ INT	cx,
		_In_ INT	cy,
		_In_opt_ HBITMAP	hbmMask,
		_In_ INT	xMask,
		_In_ INT	yMask
	)

Definition at line 790 of file painting.c.

{
    HANDLE_EMETAFDC(BOOL,
                  PlgBlt,
                  FALSE,
                  hdcDest,
                  ppt,
                  hdcSrc,
                  xSrc,
                  ySrc,
                  cx,
                  cy,
                  hbmMask,
                  xMask,
                  yMask);
 
    if ( GdiConvertAndCheckDC(hdcDest) == NULL ) return FALSE;
 
    return NtGdiPlgBlt(hdcDest,
                       (LPPOINT)ppt,
                       hdcSrc,
                       xSrc,
                       ySrc,
                       cx,
                       cy,
                       hbmMask,
                       xMask,
                       yMask,
                       CLR_INVALID);
}

Referenced by PlgBlt().

PolyBezier()

BOOL WINAPI PolyBezier	(	_In_ HDC	hdc,
		_In_reads_(cpt) const POINT *	apt,
		_In_ DWORD	cpt
	)

Definition at line 263 of file painting.c.

{
    HANDLE_EMETAFDC(BOOL, PolyBezier, FALSE, hdc, apt, cpt);
 
    if ( GdiConvertAndCheckDC(hdc) == NULL ) return FALSE;
 
    return NtGdiPolyPolyDraw(hdc ,(PPOINT)apt, &cpt, 1, GdiPolyBezier);
}

Referenced by Bezier(), DrawPrimitive(), PlayEnhMetaFileRecord(), PolyBezier(), test_all_functions(), test_emf_polybezier(), and test_enhmetafile_file().

PolyBezierTo()

BOOL WINAPI PolyBezierTo	(	_In_ HDC	hdc,
		_In_reads_(cpt) const POINT *	apt,
		_In_ DWORD	cpt
	)

Definition at line 281 of file painting.c.

{
    POINT pt1 = { 0, 0 };
    BOOL ret = FALSE;
 
    HANDLE_EMETAFDC(BOOL, PolyBezierTo, FALSE, hdc, apt, cpt);
 
    if ( GdiConvertAndCheckDC(hdc) == NULL ) return FALSE;
 
    /* This section of code is just an optimization so we can do an early return.
     * Everything would work the same even if this code were removed. */
    if (cpt == 3)
    {
        /* If there are exactly 3 points, see if all three points of
         * the PolyBezierTo are equal. */
        if (apt[0].x == apt[1].x && apt[1].x == apt[2].x &&
            apt[0].y == apt[1].y && apt[1].y == apt[2].y)
        {
            /* If all points are equal and they equal the start point,
             * then we can just return TRUE as an optimization. */
            if (GetCurrentPositionEx(hdc, &pt1) &&
                pt1.x == apt[0].x && pt1.y == apt[0].y)
            {
                return TRUE;
            }
            /* If they are all equal, but not equal to the start point,
             * then we can just do a LineTo and return as an optimization. */
            return LineTo(hdc, apt[0].x, apt[0].y);
        }
    }
 
    /* Following based on Wine 10.0 nulldrv_PolyBezierTo function */
    POINT *pts = HeapAlloc(GetProcessHeap(), 0, (cpt + 1) * sizeof(*apt));
    if (!pts)
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
 
    if (GetCurrentPositionEx(hdc, &pt1))
    {
        pts[0] = pt1;
        memcpy(&pts[1], apt, sizeof(*apt) * cpt);
        cpt++;
        ret = NtGdiPolyPolyDraw(hdc, (PPOINT)pts, &cpt, 1, GdiPolyBezierTo);
    }
 
    HeapFree(GetProcessHeap(), 0, pts);
 
    return ret;
}

Referenced by MainWndProc(), PlayEnhMetaFileRecord(), PolyBezierTo(), test_all_functions(), test_emf_polybezier(), and test_enhmetafile_file().

PolyDraw()

BOOL WINAPI PolyDraw	(	_In_ HDC	hdc,
		_In_reads_(cpt) const POINT *	apt,
		_In_reads_(cpt) const BYTE *	aj,
		_In_ INT	cpt
	)

Definition at line 342 of file painting.c.

{
    HANDLE_EMETAFDC(BOOL, PolyDraw, FALSE, hdc, apt, aj, cpt);
 
    if ( GdiConvertAndCheckDC(hdc) == NULL ) return FALSE;
 
    return NtGdiPolyDraw(hdc, (PPOINT)apt, (PBYTE)aj, cpt);
}

Referenced by PolyDraw().

Polygon()

BOOL WINAPI Polygon	(	_In_ HDC	hdc,
		_In_reads_(cpt) const POINT *	apt,
		_In_ INT	cpt
	)

Definition at line 361 of file painting.c.

{
    HANDLE_METADC(BOOL, Polygon, FALSE, hdc, apt, cpt);
 
    if ( GdiConvertAndCheckDC(hdc) == NULL ) return FALSE;
 
    return NtGdiPolyPolyDraw(hdc , (PPOINT)apt, (PULONG)&cpt, 1, GdiPolyPolygon);
}

Referenced by Polygon().

Polyline()

BOOL WINAPI Polyline	(	_In_ HDC	hdc,
		_In_reads_(cpt) const POINT *	apt,
		_In_ INT	cpt
	)

Definition at line 379 of file painting.c.

{
    HANDLE_METADC(BOOL, Polyline, FALSE, hdc, apt, cpt);
 
    if ( GdiConvertAndCheckDC(hdc) == NULL ) return FALSE;
 
    return NtGdiPolyPolyDraw(hdc, (PPOINT)apt, (PULONG)&cpt, 1, GdiPolyPolyLine);
}

Referenced by Polyline().

PolylineTo()

BOOL WINAPI PolylineTo	(	_In_ HDC	hdc,
		_In_reads_(cpt) const POINT *	apt,
		_In_ DWORD	cpt
	)

Definition at line 397 of file painting.c.

{
    POINT pt1 = { 0, 0 };
    BOOL ret = FALSE;
 
    HANDLE_EMETAFDC(BOOL, PolylineTo, FALSE, hdc, apt, cpt);
 
    if ( GdiConvertAndCheckDC(hdc) == NULL ) return FALSE;
 
    /* Following based on Wine 10.0 nulldrv_PolylineTo function */
    POINT *pts = HeapAlloc(GetProcessHeap(), 0, (cpt + 1) * sizeof(*apt));
    if (!pts)
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
 
    if (GetCurrentPositionEx(hdc, &pt1))
    {
        pts[0] = pt1;
        memcpy(&pts[1], apt, sizeof(*apt) * cpt);
        cpt++;
        ret = NtGdiPolyPolyDraw(hdc, (PPOINT)pts, &cpt, 1, GdiPolyLineTo);
    }
 
    HeapFree(GetProcessHeap(), 0, pts);
 
    return ret;
}

Referenced by PlayEnhMetaFileRecord(), PolylineTo(), test_all_functions(), and test_emf_paths().

PolyPatBlt()

BOOL WINAPI PolyPatBlt	(	_In_ HDC	hdc,
		_In_ DWORD	dwRop,
		_In_ PPOLYPATBLT	pPoly,
		_In_ DWORD	nCount,
		_In_ DWORD	dwMode
	)

Definition at line 594 of file painting.c.

{
    UINT i;
    BOOL bResult;
    HBRUSH hbrOld;
    PDC_ATTR pdcattr;
 
    /* Handle meta DCs */
    if ((GDI_HANDLE_GET_TYPE(hdc) == GDILoObjType_LO_METADC16_TYPE) ||
        (GDI_HANDLE_GET_TYPE(hdc) == GDILoObjType_LO_ALTDC_TYPE))
    {
        if (!GdiValidateHandle(hdc))
        {
            return FALSE;
        }
 
        /* Save the current DC brush */
        hbrOld = SelectObject(hdc, GetStockObject(DC_BRUSH));
 
        /* Assume success */
        bResult = TRUE;
 
        /* Loop all rect */
        for (i = 0; i < nCount; i++)
        {
            /* Select the brush for this rect */
            SelectObject(hdc, pPoly[i].hBrush);
 
            /* Do the PatBlt operation for this rect */
            bResult &= PatBlt(hdc,
                               pPoly[i].nXLeft,
                               pPoly[i].nYLeft,
                               pPoly[i].nWidth,
                               pPoly[i].nHeight,
                               dwRop);
        }
 
        /* Restore the old brush */
        SelectObject(hdc, hbrOld);
 
        return bResult;
    }
 
    /* Get the DC attribute */
    pdcattr = GdiGetDcAttr(hdc);
    if (nCount && pdcattr && !(pdcattr->ulDirty_ & DC_DIBSECTION))
    {
        PGDIBSPPATBLT pgO;
        PTEB pTeb = NtCurrentTeb();
 
        pgO = GdiAllocBatchCommand(hdc, GdiBCPolyPatBlt);
        if (pgO)
        {
            USHORT cjSize = 0;
            if (nCount > 1) cjSize = (nCount-1) * sizeof(PATRECT);
 
            if ((pTeb->GdiTebBatch.Offset + cjSize) <= GDIBATCHBUFSIZE)
            {
                pdcattr->ulDirty_ |= DC_MODE_DIRTY;
                pgO->Count = nCount;
                pgO->Mode  = dwMode;
                pgO->rop4  = dwRop;
                /* Snapshot attributes */
                pgO->crForegroundClr = pdcattr->crForegroundClr;
                pgO->crBackgroundClr = pdcattr->crBackgroundClr;
                pgO->crBrushClr      = pdcattr->crBrushClr;
                pgO->ulForegroundClr = pdcattr->ulForegroundClr;
                pgO->ulBackgroundClr = pdcattr->ulBackgroundClr;
                pgO->ulBrushClr      = pdcattr->ulBrushClr;
                RtlCopyMemory(pgO->pRect, pPoly, nCount * sizeof(PATRECT));
                // Recompute offset and return size, remember one is already accounted for in the structure.
                pTeb->GdiTebBatch.Offset += cjSize;
                ((PGDIBATCHHDR)pgO)->Size += cjSize;
                return TRUE;
            }
            // Reset offset and count then fall through
            pTeb->GdiTebBatch.Offset -= sizeof(GDIBSPPATBLT);
            pTeb->GdiBatchCount--;
        }
    }
    return NtGdiPolyPatBlt(hdc, dwRop, pPoly, nCount, dwMode);
}

PolyPolygon()

BOOL WINAPI PolyPolygon	(	_In_ HDC	hdc,
		_In_ const POINT *	apt,
		_In_reads_(csz) const INT *	asz,
		_In_ INT	csz
	)

Definition at line 436 of file painting.c.

{
    HANDLE_METADC(BOOL, PolyPolygon, FALSE, hdc, apt, asz, csz);
 
    if ( GdiConvertAndCheckDC(hdc) == NULL ) return FALSE;
 
    return NtGdiPolyPolyDraw(hdc, (PPOINT)apt, (PULONG)asz, csz, GdiPolyPolygon);
}

Referenced by PolyPolygon().

PolyPolyline()

BOOL WINAPI PolyPolyline	(	_In_ HDC	hdc,
		_In_ CONST POINT *	apt,
		_In_reads_(csz) CONST DWORD *	asz,
		_In_ DWORD	csz
	)

Definition at line 455 of file painting.c.

{
    if (GDI_HANDLE_GET_TYPE(hdc) == GDILoObjType_LO_METADC16_TYPE)
        return FALSE;
 
    HANDLE_EMETAFDC(BOOL, PolyPolyline, FALSE, hdc, apt, asz, csz);
 
    if ( GdiConvertAndCheckDC(hdc) == NULL ) return FALSE;
 
    return NtGdiPolyPolyDraw(hdc , (PPOINT)apt, (PULONG)asz, csz, GdiPolyPolyLine);
}

Referenced by PolyPolyline().

Rectangle()

BOOL WINAPI Rectangle	(	_In_ HDC	hdc,
		_In_ INT	left,
		_In_ INT	top,
		_In_ INT	right,
		_In_ INT	bottom
	)

Definition at line 91 of file painting.c.

{
    HANDLE_METADC(BOOL, Rectangle, FALSE, hdc, left, top, right, bottom);
 
    if ( GdiConvertAndCheckDC(hdc) == NULL ) return FALSE;
 
    return NtGdiRectangle(hdc, left, top, right, bottom);
}

Referenced by Rectangle().

RoundRect()

BOOL WINAPI RoundRect	(	_In_ HDC	hdc,
		_In_ INT	left,
		_In_ INT	top,
		_In_ INT	right,
		_In_ INT	bottom,
		_In_ INT	width,
		_In_ INT	height
	)

Definition at line 111 of file painting.c.

{
    HANDLE_METADC(BOOL, RoundRect, FALSE, hdc, left, top, right, bottom, width, height);
 
    if ( GdiConvertAndCheckDC(hdc) == NULL ) return FALSE;
 
    return NtGdiRoundRect(hdc, left, top, right, bottom, width, height);
}

Referenced by RoundRect().

SetPixel()

COLORREF WINAPI SetPixel	(	_In_ HDC	hdc,
		_In_ INT	x,
		_In_ INT	y,
		_In_ COLORREF	crColor
	)

Definition at line 149 of file painting.c.

{
    HANDLE_METADC(COLORREF, SetPixel, CLR_INVALID, hdc, x, y, crColor);
 
    if ( GdiConvertAndCheckDC(hdc) == NULL ) return FALSE;
 
    return NtGdiSetPixel(hdc, x, y, crColor);
}

Referenced by SetPixel(), and SetPixelV().

SetPixelV()

BOOL WINAPI SetPixelV	(	_In_ HDC	hdc,
		_In_ INT	x,
		_In_ INT	y,
		_In_ COLORREF	crColor
	)

Definition at line 168 of file painting.c.

{
    return SetPixel(hdc, x, y, crColor) != CLR_INVALID;
}

StretchBlt()

BOOL WINAPI StretchBlt	(	_In_ HDC	hdcDest,
		_In_ INT	xDest,
		_In_ INT	yDest,
		_In_ INT	cxDest,
		_In_ INT	cyDest,
		_In_opt_ HDC	hdcSrc,
		_In_ INT	xSrc,
		_In_ INT	ySrc,
		_In_ INT	cxSrc,
		_In_ INT	cySrc,
		_In_ DWORD	dwRop
	)

Definition at line 687 of file painting.c.

{
    HANDLE_METADC(BOOL,
                  StretchBlt,
                  FALSE,
                  hdcDest,
                  xDest,
                  yDest,
                  cxDest,
                  cyDest,
                  hdcSrc,
                  xSrc,
                  ySrc,
                  cxSrc,
                  cySrc,
                  dwRop);
 
    if ( GdiConvertAndCheckDC(hdcDest) == NULL ) return FALSE;
 
    return NtGdiStretchBlt(hdcDest,
                           xDest,
                           yDest,
                           cxDest,
                           cyDest,
                           hdcSrc,
                           xSrc,
                           ySrc,
                           cxSrc,
                           cySrc,
                           dwRop,
                           CLR_INVALID);
}

Referenced by StretchBlt().