BRUSH Class Reference

#include <brush.hpp>

Inheritance diagram for BRUSH:

Collaboration diagram for BRUSH:

Public Member Functions
	_Analysis_mode_ (_Analysis_operator_new_null_) inline void *__cdecl operator new(_In_ size_t cjSize) throw ()
void	operator delete (void *pvObject)
	BRUSH (_In_ FLONG flAttrs, _In_ COLORREF crColor, _In_ ULONG iHatch, _In_opt_ HBITMAP hbmPattern, _In_opt_ PVOID pvClient, _In_ GDILOOBJTYPE objtype)
	~BRUSH (VOID)
BOOL	bAllocateBrushAttr (VOID)
_Check_return_	_Ret_opt_bytecount_ (sizeof(BRUSH)) static inline PBRUSH LockForRead(_In_ HBRUSH hbr)
_Check_return_	_Ret_opt_bytecount_ (sizeof(BRUSH)) static inline PBRUSH LockForWrite(_In_ HBRUSH hbr)
_Check_return_	_Ret_opt_bytecap_ (sizeof(BRUSH)) static inline PBRUSH LockAny(_In_ HBRUSH hbr)
UINT	cjGetObject (_In_ UINT cjBuffer, _Out_bytecap_(cjBuffer) PLOGBRUSH plbBuffer) const
HBITMAP	hbmGetBitmapHandle (_Out_ PUINT puUsage) const
VOID	vSetSolidColor (_In_ COLORREF crColor)
Public Member Functions inherited from BASEOBJECT
VOID	vUnlock (VOID)
HGDIOBJ	hHmgr (VOID)
HGDIOBJ	hInsertObject (OWNER owner)

Static Public Member Functions
static VOID	vDeleteObject (_In_ PVOID pvObject)
Static Public Member Functions inherited from BASEOBJECT
static PVOID	pvAllocate (_In_ GDIOBJTYPE objtype, _In_ SIZE_T cjSize)

Additional Inherited Members
Public Types inherited from BASEOBJECT
enum	OWNER { POWNED = GDI_OBJ_HMGR_POWNED, PUBLIC = GDI_OBJ_HMGR_PUBLIC, NONE = GDI_OBJ_HMGR_NONE }
Protected Member Functions inherited from BASEOBJECT
	BASEOBJECT (_In_ GDILOOBJTYPE loobjtype)
VOID	vSetObjectAttr (_In_opt_ PVOID pvUserAttr)
Static Protected Member Functions inherited from BASEOBJECT
static BASEOBJECT *	LockExclusive (HGDIOBJ hobj, GDIOBJTYPE objtype)
static BASEOBJECT *	LockExclusive (HGDIOBJ hobj, GDILOOBJTYPE loobjtype)
static BASEOBJECT *	LockShared (HGDIOBJ hobj, GDILOOBJTYPE loobjtype, OWNER owner)
Protected Attributes inherited from _BRUSHBODY
ULONG	iHatch
HBITMAP	hbmPattern
HBITMAP	hbmClient
ULONG	flAttrs
ULONG	ulBrushUnique
BRUSH_ATTR *	pBrushAttr
BRUSH_ATTR	BrushAttr
POINT	ptOrigin
ULONG	bCacheGrabbed
COLORREF	crBack
COLORREF	crFore
ULONG	ulPalTime
ULONG	ulSurfTime
PVOID	pvRBrush
HDEV	hdev
LONG	lWidth
FLOATOBJ	eWidth
ULONG	ulPenStyle
DWORD *	pStyle
ULONG	dwStyleCount
BYTE	jJoin
BYTE	jEndCap
INT	iBrushStyle
ULONG	ulStyleSize
LIST_ENTRY	ListHead

Detailed Description

Definition at line 15 of file brush.hpp.

Constructor & Destructor Documentation

BRUSH()

BRUSH::BRUSH	(	_In_ FLONG	flAttrs,
		_In_ COLORREF	crColor,
		_In_ ULONG	iHatch,
		_In_opt_ HBITMAP	hbmPattern,
		_In_opt_ PVOID	pvClient,
		_In_ GDILOOBJTYPE	objtype = GDILoObjType_LO_BRUSH_TYPE
	)

Definition at line 14 of file brush.cpp.

    : BASEOBJECT(loobjtype)
{
    static ULONG ulGlobalBrushUnique = 0;

    /* Get a unique value */
    this->ulBrushUnique = InterlockedIncrementUL(&ulGlobalBrushUnique);

    /* Start with kmode brush attribute */
    this->pBrushAttr = &this->BrushAttr;

    /* Set parameters */
    this->flAttrs = flAttrs;
    this->iHatch = iHatch;
    this->hbmPattern = hbmPattern;
    this->hbmClient = (HBITMAP)pvClient;
    this->pBrushAttr->lbColor = crColor;

    /* Initialize the other fields */
    this->ptOrigin.x = 0;
    this->ptOrigin.y = 0;
    this->bCacheGrabbed = FALSE;
    this->crBack = 0;
    this->crFore = 0;
    this->ulPalTime = 0;
    this->ulSurfTime = 0;
    this->pvRBrush = NULL;
    this->hdev = NULL;

    /* FIXME: should be done only in PEN constructor,
       but our destructor needs it! */
    this->dwStyleCount = 0;
    this->pStyle = NULL;
}

~BRUSH()

BRUSH::~BRUSH

(

VOID

)

Definition at line 55 of file brush.cpp.

{
    /* Check if we have a user mode brush attribute */
    if (this->pBrushAttr != &this->BrushAttr)
    {
        /* Free memory to the process GDI pool */
        GdiPoolFree(GetBrushAttrPool(), this->pBrushAttr);
    }

    /* Delete the pattern bitmap (may have already been deleted during gdi cleanup) */
    if (this->hbmPattern != NULL && GreIsHandleValid(this->hbmPattern))
    {
        GreSetBitmapOwner(this->hbmPattern, BASEOBJECT::OWNER::POWNED);
        GreDeleteObject(this->hbmPattern);
    }

    /* Delete styles */
    if ((this->pStyle != NULL) && !(this->flAttrs & BR_IS_DEFAULTSTYLE))
    {
        ExFreePoolWithTag(this->pStyle, GDITAG_PENSTYLE);
    }
}

Member Function Documentation

_Analysis_mode_()

BRUSH::_Analysis_mode_ ( _Analysis_operator_new_null_  ) throw ( )

inlinenew

Definition at line 19 of file brush.hpp.

    {
        return ExAllocatePoolWithTag(PagedPool, cjSize, GDITAG_HMGR_BRUSH_TYPE);
        //return BASEOBJECT::pvAllocate(GDIObjType_BRUSH_TYPE, cjSize);
    }

_Ret_opt_bytecap_()

_Check_return_ BRUSH::_Ret_opt_bytecap_ ( sizeof(BRUSH)  )

inline

Definition at line 91 of file brush.hpp.

    {
        return static_cast<PBRUSH>(
            BASEOBJECT::LockShared(hbr,
                                   GDILoObjType_LO_BRUSH_TYPE,
                                   BASEOBJECT::OWNER::NONE));
    }

_Ret_opt_bytecount_() [1/2]

_Check_return_ BRUSH::_Ret_opt_bytecount_ ( sizeof(BRUSH)  )

inline

Definition at line 63 of file brush.hpp.

    {
        return static_cast<PBRUSH>(
            BASEOBJECT::LockShared(hbr,
                                   GDILoObjType_LO_BRUSH_TYPE,
                                   BASEOBJECT::OWNER::PUBLIC));
    }

_Ret_opt_bytecount_() [2/2]

_Check_return_ BRUSH::_Ret_opt_bytecount_ ( sizeof(BRUSH)  )

inline

Definition at line 77 of file brush.hpp.

    {
        return static_cast<PBRUSH>(
            BASEOBJECT::LockShared(hbr,
                                   GDILoObjType_LO_BRUSH_TYPE,
                                   BASEOBJECT::OWNER::POWNED));
    }

bAllocateBrushAttr()

BOOL BRUSH::bAllocateBrushAttr

(

VOID

)

Definition at line 91 of file brush.cpp.

{
    PBRUSH_ATTR pBrushAttr;
    NT_ASSERT(this->pBrushAttr == &this->BrushAttr);

    /* Allocate a brush attribute from the pool */
    pBrushAttr = static_cast<PBRUSH_ATTR>(GdiPoolAllocate(GetBrushAttrPool()));
    if (pBrushAttr == NULL)
    {
        ERR("Could not allocate brush attr\n");
        return FALSE;
    }

    /* Copy the content from the kernel mode brush attribute */
    this->pBrushAttr = pBrushAttr;
    *this->pBrushAttr = this->BrushAttr;

    /* Set the object attribute in the handle table */
    vSetObjectAttr(pBrushAttr);

    return TRUE;
}

cjGetObject()

UINT BRUSH::cjGetObject	(	_In_ UINT	cjBuffer,
		_Out_bytecap_(cjBuffer) PLOGBRUSH	plbBuffer
	)		const

Definition at line 140 of file brush.cpp.

{
    /* Check if only size is requested */
    if (plb == NULL)
        return sizeof(LOGBRUSH);

    /* Check if size is ok */
    if (cjSize == 0)
        return 0;

    /* Set color */
    plb->lbColor = this->BrushAttr.lbColor;

    /* Set style and hatch based on the attribute flags */
    if (this->flAttrs & BR_IS_SOLID)
    {
        plb->lbStyle = BS_SOLID;
        plb->lbHatch = 0;
    }
    else if (this->flAttrs & BR_IS_HATCH)
    {
        plb->lbStyle = BS_HATCHED;
        plb->lbHatch = this->iHatch;
    }
    else if (this->flAttrs & BR_IS_DIB)
    {
        plb->lbStyle = BS_DIBPATTERN;
        plb->lbHatch = (ULONG_PTR)this->hbmClient;
    }
    else if (this->flAttrs & BR_IS_BITMAP)
    {
        plb->lbStyle = BS_PATTERN;
        plb->lbHatch = (ULONG_PTR)this->hbmClient;
    }
    else if (this->flAttrs & BR_IS_NULL)
    {
        plb->lbStyle = BS_NULL;
        plb->lbHatch = 0;
    }
    else
    {
        NT_ASSERT(FALSE);
    }

    return sizeof(LOGBRUSH);
}

hbmGetBitmapHandle()

HBITMAP BRUSH::hbmGetBitmapHandle

(

_Out_ PUINT

puUsage

)

const

Definition at line 128 of file brush.cpp.

{
    /* Return the color usage based on flags */
    *puUsage = (this->flAttrs & BR_IS_DIBPALCOLORS) ? DIB_PAL_COLORS :
               (this->flAttrs & BR_IS_DIBPALINDICES) ? DIB_PAL_INDICES :
               DIB_RGB_COLORS;

    return this->hbmPattern;
}

operator delete()

void BRUSH::operator delete ( void *  pvObject )

inline

HACK! better would be to extract the exact object type's tag

Definition at line 33 of file brush.hpp.

    {
        ExFreePool(pvObject);
        //ExFreePoolWithTag(pvObject, GDITAG_HMGR_BRUSH_TYPE);
        //BASEOBJECT::pvFree(GDIObjType_BRUSH_TYPE, cjSize);
    }

vDeleteObject()

VOID BRUSH::vDeleteObject ( _In_ PVOID  pvObject )

static

Definition at line 80 of file brush.cpp.

{
    PBRUSH pbr = static_cast<PBRUSH>(pvObject);
    NT_ASSERT((GDI_HANDLE_GET_TYPE(pbr->hHmgr()) == GDILoObjType_LO_BRUSH_TYPE) ||
              (GDI_HANDLE_GET_TYPE(pbr->hHmgr()) == GDILoObjType_LO_PEN_TYPE) ||
              (GDI_HANDLE_GET_TYPE(pbr->hHmgr()) == GDILoObjType_LO_EXTPEN_TYPE));
    delete pbr;
}

Referenced by BRUSH_vDeleteObject().

vSetSolidColor()

VOID BRUSH::vSetSolidColor

(

_In_ COLORREF

crColor

)

Definition at line 116 of file brush.cpp.

{
    NT_ASSERT(this->flAttrs & BR_IS_SOLID);

    /* Set new color and reset the pal times */
    this->pBrushAttr->lbColor = crColor & 0xFFFFFF;
    this->ulPalTime = -1;
    this->ulSurfTime = -1;
}

---

The documentation for this class was generated from the following files:

• win32ss/gdi/ntgdi/brush.hpp
• win32ss/gdi/ntgdi/brush.cpp