brush.c File Reference

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

Include dependency graph for brush.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
HPEN APIENTRY	ExtCreatePen (DWORD dwPenStyle, DWORD dwWidth, CONST LOGBRUSH *lplb, DWORD dwStyleCount, CONST DWORD *lpStyle)
HBRUSH WINAPI	CreateDIBPatternBrush (HGLOBAL hglbDIBPacked, UINT fuColorSpec)
HBRUSH WINAPI	CreateDIBPatternBrushPt (CONST VOID *lpPackedDIB, UINT fuColorSpec)
HBRUSH WINAPI	CreateHatchBrush (INT fnStyle, COLORREF clrref)
HBRUSH WINAPI	CreatePatternBrush (HBITMAP hbmp)
HBRUSH WINAPI	CreateSolidBrush (IN COLORREF crColor)
HBRUSH WINAPI	CreateBrushIndirect (CONST LOGBRUSH *LogBrush)
BOOL WINAPI	GetBrushOrgEx (HDC hdc, LPPOINT pt)
BOOL WINAPI	SetBrushOrgEx (HDC hdc, int nXOrg, int nYOrg, LPPOINT lppt)
DWORD WINAPI	GetBrushAttributes (HBRUSH hbr)
HBRUSH WINAPI	SetBrushAttributes (HBRUSH hbm, DWORD dwFlags)
HBRUSH WINAPI	ClearBrushAttributes (HBRUSH hbm, DWORD dwFlags)
BOOL WINAPI	UnrealizeObject (HGDIOBJ hgdiobj)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 3 of file brush.c.

Function Documentation

ClearBrushAttributes()

HBRUSH WINAPI ClearBrushAttributes	(	HBRUSH	hbm,
		DWORD	dwFlags
	)

Definition at line 375 of file brush.c.

{
    if ( dwFlags & ~SC_BB_STOCKOBJ )
    {
        return NULL;
    }
    return NtGdiClearBrushAttributes(hbm, dwFlags);
}

CreateBrushIndirect()

HBRUSH WINAPI CreateBrushIndirect

(

CONST LOGBRUSH *

LogBrush

)

Definition at line 206 of file brush.c.

{
    HBRUSH hBrush;

    switch (LogBrush->lbStyle)
    {
    case BS_DIBPATTERN:
        hBrush = CreateDIBPatternBrush((HGLOBAL)LogBrush->lbHatch,
                                       LogBrush->lbColor);
        break;

    case BS_DIBPATTERNPT:
        hBrush = CreateDIBPatternBrushPt((PVOID)LogBrush->lbHatch,
                                         LogBrush->lbColor);
        break;

    case BS_PATTERN:
        hBrush = NtGdiCreatePatternBrushInternal((HBITMAP)LogBrush->lbHatch,
                 FALSE,
                 FALSE);
        break;

    case BS_PATTERN8X8:
        hBrush = NtGdiCreatePatternBrushInternal((HBITMAP)LogBrush->lbHatch,
                 FALSE,
                 TRUE);
        break;

    case BS_SOLID:
/*        hBrush = hGetPEBHandle(hctBrushHandle, LogBrush->lbColor);
        if (!hBrush)*/
        hBrush = NtGdiCreateSolidBrush(LogBrush->lbColor, 0);
        break;

    case BS_HATCHED:
        hBrush = NtGdiCreateHatchBrushInternal(LogBrush->lbHatch,
                                               LogBrush->lbColor,
                                               FALSE);
        break;

    case BS_NULL:
        hBrush = NtGdiGetStockObject(NULL_BRUSH);
        break;

    default:
        SetLastError(ERROR_INVALID_PARAMETER);
        hBrush = NULL;
        break;
    }

    return hBrush;
}

Referenced by test_pattern_brush().

CreateDIBPatternBrush()

HBRUSH WINAPI CreateDIBPatternBrush	(	HGLOBAL	hglbDIBPacked,
		UINT	fuColorSpec
	)

Definition at line 114 of file brush.c.

{
    PVOID lpPackedDIB;
    HBRUSH hBrush = NULL;
    PBITMAPINFO pConvertedInfo;
    UINT ConvertedInfoSize;

    lpPackedDIB = GlobalLock(hglbDIBPacked);
    if (lpPackedDIB == NULL)
        return 0;

    pConvertedInfo = ConvertBitmapInfo((PBITMAPINFO)lpPackedDIB, fuColorSpec,
                                       &ConvertedInfoSize, TRUE);
    if (pConvertedInfo)
    {
        hBrush = NtGdiCreateDIBBrush(pConvertedInfo, fuColorSpec,
                                     ConvertedInfoSize, FALSE, FALSE, lpPackedDIB);
        if ((PBITMAPINFO)lpPackedDIB != pConvertedInfo)
            RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo);
    }

    GlobalUnlock(hglbDIBPacked);

    return hBrush;
}

Referenced by CreateBrushIndirect().

CreateDIBPatternBrushPt()

HBRUSH WINAPI CreateDIBPatternBrushPt	(	CONST VOID *	lpPackedDIB,
		UINT	fuColorSpec
	)

Definition at line 146 of file brush.c.

{
    HBRUSH hBrush = NULL;
    PBITMAPINFO pConvertedInfo;
    UINT ConvertedInfoSize;

    if (lpPackedDIB == NULL)
        return 0;

    pConvertedInfo = ConvertBitmapInfo((PBITMAPINFO)lpPackedDIB, fuColorSpec,
                                       &ConvertedInfoSize, TRUE);
    if (pConvertedInfo)
    {
        hBrush = NtGdiCreateDIBBrush(pConvertedInfo, fuColorSpec,
                                     ConvertedInfoSize, FALSE, FALSE, (PVOID)lpPackedDIB);
        if ((PBITMAPINFO)lpPackedDIB != pConvertedInfo)
            RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo);
    }

    return hBrush;
}

Referenced by CreateBrushIndirect(), test_palette_brush(), and test_pattern_brush().

CreateHatchBrush()

HBRUSH WINAPI CreateHatchBrush	(	INT	fnStyle,
		COLORREF	clrref
	)

Definition at line 175 of file brush.c.

{
    return NtGdiCreateHatchBrushInternal(fnStyle, clrref, FALSE);
}

Referenced by test_hatch_brush().

CreatePatternBrush()

HBRUSH WINAPI CreatePatternBrush

(

HBITMAP

hbmp

)

Definition at line 186 of file brush.c.

{
    return NtGdiCreatePatternBrushInternal(hbmp, FALSE, FALSE);
}

Referenced by test_pattern_brush().

CreateSolidBrush()

HBRUSH WINAPI CreateSolidBrush

(

IN COLORREF

crColor

)

Definition at line 196 of file brush.c.

{
    /* Call Server-Side API */
    return NtGdiCreateSolidBrush(crColor, NULL);
}

Referenced by test_solidbrush().

ExtCreatePen()

HPEN APIENTRY ExtCreatePen	(	DWORD	dwPenStyle,
		DWORD	dwWidth,
		CONST LOGBRUSH *	lplb,
		DWORD	dwStyleCount,
		CONST DWORD *	lpStyle
	)

Definition at line 13 of file brush.c.

{
    PVOID lpPackedDIB = NULL;
    HPEN hPen = NULL;
    PBITMAPINFO pConvertedInfo = NULL;
    UINT ConvertedInfoSize = 0, lbStyle;
    BOOL Hit = FALSE;

    if ((dwPenStyle & PS_STYLE_MASK) == PS_USERSTYLE)
    {
        if(!lpStyle)
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            return 0;
        }
    } // This is an enhancement and prevents a call to kernel space.
    else if ((dwPenStyle & PS_STYLE_MASK) == PS_INSIDEFRAME &&
             (dwPenStyle & PS_TYPE_MASK) != PS_GEOMETRIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
    else if ((dwPenStyle & PS_STYLE_MASK) == PS_ALTERNATE &&
             (dwPenStyle & PS_TYPE_MASK) != PS_COSMETIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
    else
    {
        if (dwStyleCount || lpStyle)
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            return 0;
        }
    }

    lbStyle = lplb->lbStyle;

    if (lplb->lbStyle > BS_HATCHED)
    {
        if (lplb->lbStyle == BS_PATTERN)
        {
            pConvertedInfo = (PBITMAPINFO)lplb->lbHatch;
            if (!pConvertedInfo) return 0;
        }
        else
        {
            if ((lplb->lbStyle == BS_DIBPATTERN) || (lplb->lbStyle == BS_DIBPATTERNPT))
            {
                if (lplb->lbStyle == BS_DIBPATTERN)
                {
                    lbStyle = BS_DIBPATTERNPT;
                    lpPackedDIB = GlobalLock((HGLOBAL)lplb->lbHatch);
                    if (lpPackedDIB == NULL) return 0;
                }
                pConvertedInfo = ConvertBitmapInfo((PBITMAPINFO)lpPackedDIB,
                                                   lplb->lbColor,
                                                   &ConvertedInfoSize,
                                                   TRUE);
                Hit = TRUE; // We converted DIB.
            }
            else
                pConvertedInfo = (PBITMAPINFO)lpStyle;
        }
    }
    else
        pConvertedInfo = (PBITMAPINFO)lplb->lbHatch;


    hPen = NtGdiExtCreatePen(dwPenStyle,
                             dwWidth,
                             lbStyle,
                             lplb->lbColor,
                             lplb->lbHatch,
                             (ULONG_PTR)pConvertedInfo,
                             dwStyleCount,
                             (PULONG)lpStyle,
                             ConvertedInfoSize,
                             FALSE,
                             NULL);


    if (lplb->lbStyle == BS_DIBPATTERN) GlobalUnlock((HGLOBAL)lplb->lbHatch);

    if (Hit)
    {
        if ((PBITMAPINFO)lpPackedDIB != pConvertedInfo)
            RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo);
    }
    return hPen;
}

GetBrushAttributes()

DWORD WINAPI GetBrushAttributes

(

HBRUSH

hbr

)

Definition at line 347 of file brush.c.

{
    if ( GDI_HANDLE_IS_STOCKOBJ(hbr) )
    {
        return SC_BB_STOCKOBJ;
    }
    return 0;
}

GetBrushOrgEx()

BOOL WINAPI GetBrushOrgEx	(	HDC	hdc,
		LPPOINT	pt
	)

Definition at line 266 of file brush.c.

{
    PDC_ATTR Dc_Attr;

    if (!GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr)) return FALSE;
    if (pt)
    {
        pt->x = Dc_Attr->ptlBrushOrigin.x;
        pt->y = Dc_Attr->ptlBrushOrigin.y;
    }
    return TRUE;
}

SetBrushAttributes()

HBRUSH WINAPI SetBrushAttributes	(	HBRUSH	hbm,
		DWORD	dwFlags
	)

Definition at line 361 of file brush.c.

{
    if ( dwFlags & ~SC_BB_STOCKOBJ )
    {
        return NULL;
    }
    return NtGdiSetBrushAttributes(hbm, dwFlags);
}

SetBrushOrgEx()

BOOL WINAPI SetBrushOrgEx	(	HDC	hdc,
		int	nXOrg,
		int	nYOrg,
		LPPOINT	lppt
	)

Definition at line 284 of file brush.c.

{
    PDC_ATTR Dc_Attr;
#if 0
// Handle something other than a normal dc object.
    if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
    {
        PLDC pLDC = GdiGetLDC(hdc);
        if ( (pLDC == NULL) || (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC))
        {
            SetLastError(ERROR_INVALID_HANDLE);
            return FALSE;
        }
        if (pLDC->iType == LDC_EMFLDC)
        {
            return EMFDRV_SetBrushOrg(hdc, nXOrg, nYOrg); // ReactOS only.
        }
        return FALSE;
    }
#endif
    if (GdiGetHandleUserData((HGDIOBJ) hdc, GDI_OBJECT_TYPE_DC, (PVOID)&Dc_Attr))
    {
        PGDIBSSETBRHORG pgSBO;

        /* Does the caller want the current brush origin to be returned? */
        if (lppt)
        {
            lppt->x = Dc_Attr->ptlBrushOrigin.x;
            lppt->y = Dc_Attr->ptlBrushOrigin.y;
        }

        /* Check if we have nothing to do */
        if ((nXOrg == Dc_Attr->ptlBrushOrigin.x) &&
            (nYOrg == Dc_Attr->ptlBrushOrigin.y))
            return TRUE;

        /* Allocate a batch command buffer */
        pgSBO = GdiAllocBatchCommand(hdc, GdiBCSetBrushOrg);
        if (pgSBO != NULL)
        {
            /* Set current brush origin in the DC attribute */
            Dc_Attr->ptlBrushOrigin.x = nXOrg;
            Dc_Attr->ptlBrushOrigin.y = nYOrg;

            /* Setup the GDI batch command */
            pgSBO->ptlBrushOrigin = Dc_Attr->ptlBrushOrigin;

            return TRUE;
        }
    }

    /* Fall back to the slower kernel path */
    return NtGdiSetBrushOrg(hdc, nXOrg, nYOrg, lppt);
}

Referenced by test_brush_org().

UnrealizeObject()

BOOL WINAPI UnrealizeObject

(

HGDIOBJ

hgdiobj

)

Definition at line 389 of file brush.c.

{
    BOOL retValue = TRUE;
    /*
       Win 2k Graphics API, Black Book. by coriolis.com
       Page 62, Note that Steps 3, 5, and 6 are not required for Windows NT(tm)
       and Windows 2000(tm).

       Step 5. UnrealizeObject(hTrackBrush);
     */
    /*
        msdn.microsoft.com,
        "Windows 2000/XP: If hgdiobj is a brush, UnrealizeObject does nothing,
        and the function returns TRUE. Use SetBrushOrgEx to set the origin of
        a brush."
     */
    if (GDI_HANDLE_GET_TYPE(hgdiobj) != GDI_OBJECT_TYPE_BRUSH)
    {
        retValue = NtGdiUnrealizeObject(hgdiobj);
    }

    return retValue;
}