engbrush.c File Reference

#include <win32k.h>

Include dependency graph for engbrush.c:

Go to the source code of this file.

Functions
	DBG_DEFAULT_CHANNEL (EngBrush)
NTSTATUS NTAPI	InitBrushImpl (VOID)
VOID NTAPI	EBRUSHOBJ_vInit (EBRUSHOBJ *pebo, PBRUSH pbrush, PSURFACE psurf, COLORREF crBackgroundClr, COLORREF crForegroundClr, PPALETTE ppalDC)
VOID NTAPI	EBRUSHOBJ_vInitFromDC (EBRUSHOBJ *pebo, PBRUSH pbrush, PDC pdc)
VOID FASTCALL	EBRUSHOBJ_vSetSolidRGBColor (EBRUSHOBJ *pebo, COLORREF crColor)
VOID NTAPI	EBRUSHOBJ_vCleanup (EBRUSHOBJ *pebo)
VOID NTAPI	EBRUSHOBJ_vUpdateFromDC (EBRUSHOBJ *pebo, PBRUSH pbrush, PDC pdc)
BOOL APIENTRY	EngRealizeBrush (BRUSHOBJ *pbo, SURFOBJ *psoDst, SURFOBJ *psoPattern, SURFOBJ *psoMask, XLATEOBJ *pxlo, ULONG iHatch)
static PPALETTE	FixupDIBBrushPalette (_In_ PPALETTE ppalDIB, _In_ PPALETTE ppalDC)
BOOL NTAPI	EBRUSHOBJ_bRealizeBrush (EBRUSHOBJ *pebo, BOOL bCallDriver)
PVOID NTAPI	EBRUSHOBJ_pvGetEngBrush (EBRUSHOBJ *pebo)
SURFOBJ *NTAPI	EBRUSHOBJ_psoPattern (EBRUSHOBJ *pebo)
SURFOBJ *NTAPI	EBRUSHOBJ_psoMask (EBRUSHOBJ *pebo)
PVOID APIENTRY	BRUSHOBJ_pvAllocRbrush (IN BRUSHOBJ *pbo, IN ULONG cj)
PVOID APIENTRY	BRUSHOBJ_pvGetRbrush (IN BRUSHOBJ *pbo)
ULONG APIENTRY	BRUSHOBJ_ulGetBrushColor (IN BRUSHOBJ *pbo)

Variables
static const ULONG	gaulHatchBrushes [HS_DDI_MAX][8]
HSURF	gahsurfHatch [HS_DDI_MAX]

Function Documentation

BRUSHOBJ_pvAllocRbrush()

PVOID APIENTRY BRUSHOBJ_pvAllocRbrush	(	IN BRUSHOBJ *	pbo,
		IN ULONG	cj
	)

Exported DDI functions

Definition at line 509 of file engbrush.c.

{
    pbo->pvRbrush = EngAllocMem(0, cj, GDITAG_RBRUSH);
    return pbo->pvRbrush;
}

BRUSHOBJ_pvGetRbrush()

PVOID APIENTRY BRUSHOBJ_pvGetRbrush

(

IN BRUSHOBJ *

pbo

)

Definition at line 521 of file engbrush.c.

{
    EBRUSHOBJ *pebo = CONTAINING_RECORD(pbo, EBRUSHOBJ, BrushObject);
    BOOL bResult;
 
    if (!pbo->pvRbrush)
    {
        bResult = EBRUSHOBJ_bRealizeBrush(pebo, TRUE);
        if (!bResult)
        {
            if (pbo->pvRbrush)
            {
                EngFreeMem(pbo->pvRbrush);
                pbo->pvRbrush = NULL;
            }
        }
    }
 
    return pbo->pvRbrush;
}

BRUSHOBJ_ulGetBrushColor()

ULONG APIENTRY BRUSHOBJ_ulGetBrushColor

(

IN BRUSHOBJ *

pbo

)

Definition at line 547 of file engbrush.c.

{
    EBRUSHOBJ *pebo = CONTAINING_RECORD(pbo, EBRUSHOBJ, BrushObject);
    return pebo->ulRGBColor;
}

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

EngBrush

)

EBRUSHOBJ_bRealizeBrush()

BOOL NTAPI EBRUSHOBJ_bRealizeBrush	(	EBRUSHOBJ *	pebo,
		BOOL	bCallDriver
	)

Definition at line 331 of file engbrush.c.

{
    BOOL bResult;
    PFN_DrvRealizeBrush pfnRealizeBrush = NULL;
    PSURFACE psurfPattern;
    SURFOBJ *psoMask;
    PPDEVOBJ ppdev;
    EXLATEOBJ exlo;
    PPALETTE ppalPattern;
    PBRUSH pbr = pebo->pbrush;
    HBITMAP hbmPattern;
    ULONG iHatch;
 
    /* All EBRUSHOBJs have a surface, see EBRUSHOBJ_vInit */
    ASSERT(pebo->psurfTrg);
 
    ppdev = (PPDEVOBJ)pebo->psurfTrg->SurfObj.hdev;
    if (!ppdev)
        ppdev = gpmdev->ppdevGlobal;
 
    if (bCallDriver)
    {
        /* Get the Drv function */
        pfnRealizeBrush = ppdev->DriverFunctions.RealizeBrush;
        if (pfnRealizeBrush == NULL)
        {
            ERR("No DrvRealizeBrush. Cannot realize brush\n");
            return FALSE;
        }
 
        /* Get the mask */
        psoMask = EBRUSHOBJ_psoMask(pebo);
    }
    else
    {
        /* Use the Eng function */
        pfnRealizeBrush = EngRealizeBrush;
 
        /* We don't handle the mask bitmap here. We do this only on demand */
        psoMask = NULL;
    }
 
    /* Check if this is a hatch brush */
    if (pbr->flAttrs & BR_IS_HATCH)
    {
        /* Get the hatch brush pattern from the PDEV */
        hbmPattern = (HBITMAP)ppdev->ahsurf[pbr->iHatch];
        iHatch = pbr->iHatch;
    }
    else
    {
        /* Use the brushes pattern */
        hbmPattern = pbr->hbmPattern;
        iHatch = -1;
    }
 
    psurfPattern = SURFACE_ShareLockSurface(hbmPattern);
    ASSERT(psurfPattern);
    ASSERT(psurfPattern->ppal);
 
    /* DIB brushes with DIB_PAL_COLORS usage need a new palette */
    if (pbr->flAttrs & BR_IS_DIBPALCOLORS)
    {
        /* Create a palette with the colors from the DC */
        ppalPattern = FixupDIBBrushPalette(psurfPattern->ppal, pebo->ppalDC);
        if (ppalPattern == NULL)
        {
            ERR("FixupDIBBrushPalette() failed.\n");
            return FALSE;
        }
 
        pebo->ppalDIB = ppalPattern;
    }
    else
    {
        /* The palette is already as it should be */
        ppalPattern = psurfPattern->ppal;
    }
 
    /* Initialize XLATEOBJ for the brush */
    EXLATEOBJ_vInitialize(&exlo,
                          ppalPattern,
                          pebo->psurfTrg->ppal,
                          0,
                          pebo->crCurrentBack,
                          pebo->crCurrentText);
 
    /* Create the realization */
    bResult = pfnRealizeBrush(&pebo->BrushObject,
                              &pebo->psurfTrg->SurfObj,
                              &psurfPattern->SurfObj,
                              psoMask,
                              &exlo.xlo,
                              iHatch);
 
    /* Cleanup the XLATEOBJ */
    EXLATEOBJ_vCleanup(&exlo);
 
    /* Unlock surface */
    SURFACE_ShareUnlockSurface(psurfPattern);
 
    return bResult;
}

Referenced by BRUSHOBJ_pvGetRbrush(), and EBRUSHOBJ_pvGetEngBrush().

EBRUSHOBJ_psoMask()

SURFOBJ *NTAPI EBRUSHOBJ_psoMask

(

EBRUSHOBJ *

pebo

)

Definition at line 468 of file engbrush.c.

{
    HBITMAP hbmMask;
    PSURFACE psurfMask;
    PPDEVOBJ ppdev;
 
    /* Check if we don't have a mask yet */
    if (pebo->psoMask == NULL)
    {
        /* Check if this is a hatch brush */
        if (pebo->flattrs & BR_IS_HATCH)
        {
            /* Get the PDEV */
            ppdev = (PPDEVOBJ)pebo->psurfTrg->SurfObj.hdev;
            if (!ppdev)
                ppdev = gpmdev->ppdevGlobal;
 
            /* Use the hatch bitmap as the mask */
            hbmMask = (HBITMAP)ppdev->ahsurf[pebo->pbrush->iHatch];
            psurfMask = SURFACE_ShareLockSurface(hbmMask);
            if (psurfMask == NULL)
            {
                ERR("Failed to lock hatch brush for PDEV %p, iHatch %lu\n",
                    ppdev, pebo->pbrush->iHatch);
                return NULL;
            }
 
            NT_ASSERT(psurfMask->SurfObj.iBitmapFormat == BMF_1BPP);
            pebo->psoMask = &psurfMask->SurfObj;
        }
    }
 
    return pebo->psoMask;
}

Referenced by EBRUSHOBJ_bRealizeBrush().

EBRUSHOBJ_psoPattern()

SURFOBJ *NTAPI EBRUSHOBJ_psoPattern

(

EBRUSHOBJ *

pebo

)

Definition at line 457 of file engbrush.c.

{
    PSURFACE psurfPattern;
 
    psurfPattern = EBRUSHOBJ_pvGetEngBrush(pebo);
 
    return psurfPattern ? &psurfPattern->SurfObj : NULL;
}

EBRUSHOBJ_pvGetEngBrush()

PVOID NTAPI EBRUSHOBJ_pvGetEngBrush

(

EBRUSHOBJ *

pebo

)

Definition at line 437 of file engbrush.c.

{
    BOOL bResult;
 
    if (!pebo->pengbrush)
    {
        bResult = EBRUSHOBJ_bRealizeBrush(pebo, FALSE);
        if (!bResult)
        {
            if (pebo->pengbrush)
                EngDeleteSurface(pebo->pengbrush);
            pebo->pengbrush = NULL;
        }
    }
 
    return pebo->pengbrush;
}

Referenced by EBRUSHOBJ_psoPattern().

EBRUSHOBJ_vCleanup()

VOID NTAPI EBRUSHOBJ_vCleanup

(

EBRUSHOBJ *

pebo

)

Definition at line 175 of file engbrush.c.

{
    /* Check if there's a GDI realisation */
    if (pebo->pengbrush)
    {
        /* Unlock the bitmap again */
        SURFACE_ShareUnlockSurface(pebo->pengbrush);
        pebo->pengbrush = NULL;
    }
 
    /* Check if there's a driver's realisation */
    if (pebo->BrushObject.pvRbrush)
    {
        /* Free allocated driver memory */
        EngFreeMem(pebo->BrushObject.pvRbrush);
        pebo->BrushObject.pvRbrush = NULL;
    }
 
    if (pebo->psoMask != NULL)
    {
        SURFACE_ShareUnlockSurface(pebo->psoMask);
        pebo->psoMask = NULL;
    }
 
    /* Dereference the palettes */
    if (pebo->ppalSurf)
    {
        PALETTE_ShareUnlockPalette(pebo->ppalSurf);
    }
    if (pebo->ppalDC)
    {
        PALETTE_ShareUnlockPalette(pebo->ppalDC);
    }
    if (pebo->ppalDIB)
    {
        PALETTE_ShareUnlockPalette(pebo->ppalDIB);
    }
}

Referenced by DC_vCleanup(), EBRUSHOBJ_vUpdateFromDC(), GdiFlushUserBatch(), IntGdiPolyPatBlt(), and UserDrawIconEx().

EBRUSHOBJ_vInit()

VOID NTAPI EBRUSHOBJ_vInit	(	EBRUSHOBJ *	pebo,
		PBRUSH	pbrush,
		PSURFACE	psurf,
		COLORREF	crBackgroundClr,
		COLORREF	crForegroundClr,
		PPALETTE	ppalDC
	)

Definition at line 52 of file engbrush.c.

{
    ASSERT(pebo);
    ASSERT(pbrush);
 
    pebo->BrushObject.flColorType = 0;
    pebo->BrushObject.pvRbrush = NULL;
    pebo->pbrush = pbrush;
    pebo->pengbrush = NULL;
    pebo->flattrs = pbrush->flAttrs;
    pebo->psoMask = NULL;
 
    /* Initialize 1 bpp fore and back colors */
    pebo->crCurrentBack = crBackgroundClr;
    pebo->crCurrentText = crForegroundClr;
 
    pebo->psurfTrg = psurf;
    /* We are initializing for a new memory DC */
    if(!pebo->psurfTrg)
        pebo->psurfTrg = psurfDefaultBitmap;
    ASSERT(pebo->psurfTrg);
    ASSERT(pebo->psurfTrg->ppal);
 
    /* Initialize palettes */
    pebo->ppalSurf = pebo->psurfTrg->ppal;
    GDIOBJ_vReferenceObjectByPointer(&pebo->ppalSurf->BaseObject);
    pebo->ppalDC = ppalDC;
    if(!pebo->ppalDC)
        pebo->ppalDC = gppalDefault;
    GDIOBJ_vReferenceObjectByPointer(&pebo->ppalDC->BaseObject);
    pebo->ppalDIB = NULL;
 
    if (pbrush->flAttrs & BR_IS_NULL)
    {
        /* NULL brushes don't need a color */
        pebo->BrushObject.iSolidColor = 0;
    }
    else if (pbrush->flAttrs & BR_IS_SOLID)
    {
        /* Set the RGB color */
        EBRUSHOBJ_vSetSolidRGBColor(pebo, pbrush->BrushAttr.lbColor);
    }
    else
    {
        /* This is a pattern brush that needs realization */
        pebo->BrushObject.iSolidColor = 0xFFFFFFFF;
 
        /* Use foreground color of hatch brushes */
        if (pbrush->flAttrs & BR_IS_HATCH)
            pebo->crCurrentText = pbrush->BrushAttr.lbColor;
    }
}

Referenced by EBRUSHOBJ_vInitFromDC(), IntGdiFillRgn(), and UserDrawIconEx().

EBRUSHOBJ_vInitFromDC()

VOID NTAPI EBRUSHOBJ_vInitFromDC	(	EBRUSHOBJ *	pebo,
		PBRUSH	pbrush,
		PDC	pdc
	)

Definition at line 112 of file engbrush.c.

{
    EBRUSHOBJ_vInit(pebo, pbrush, pdc->dclevel.pSurface,
        pdc->pdcattr->crBackgroundClr, pdc->pdcattr->crForegroundClr,
        pdc->dclevel.ppal);
}

Referenced by DC_vInitDc(), EBRUSHOBJ_vUpdateFromDC(), GdiFlushUserBatch(), and IntGdiPolyPatBlt().

EBRUSHOBJ_vSetSolidRGBColor()

VOID FASTCALL EBRUSHOBJ_vSetSolidRGBColor	(	EBRUSHOBJ *	pebo,
		COLORREF	crColor
	)

Definition at line 122 of file engbrush.c.

{
    ULONG iSolidColor;
    EXLATEOBJ exlo;
 
    /* Never use with non-solid brushes */
    ASSERT(pebo->flattrs & BR_IS_SOLID);
 
    /* Set the RGB color */
    crColor &= 0xFFFFFF;
    pebo->crRealize = crColor;
    pebo->ulRGBColor = crColor;
 
    /* Special handling for mono-surfaces */
    if (pebo->ppalSurf->flFlags & PAL_MONOCHROME)
    {
        /* Determine the indices for back and fore color */
        ULONG iBackIndex =
            PALETTE_ulGetNearestPaletteIndex(pebo->ppalSurf, pebo->crCurrentBack);
        ULONG iForeIndex = iBackIndex ^ 1;
 
        /* Get the translated back color */
        ULONG rgbBack = PALETTE_ulGetRGBColorFromIndex(pebo->ppalSurf, iBackIndex);
 
        /* Match the pen color against RGB and translated background color */
        if ((crColor == rgbBack) || (crColor == pebo->crCurrentBack))
                pebo->BrushObject.iSolidColor = iBackIndex;
        else
            pebo->BrushObject.iSolidColor = iForeIndex;
 
        pebo->flattrs |= BR_NEED_BK_CLR;
    }
    else
    {
        /* Initialize an XLATEOBJ RGB -> surface */
        EXLATEOBJ_vInitialize(&exlo,
                              &gpalRGB,
                              pebo->ppalSurf,
                              pebo->crCurrentBack,
                              0,
                              0);
 
        /* Translate the brush color to the target format */
        iSolidColor = XLATEOBJ_iXlate(&exlo.xlo, crColor);
        pebo->BrushObject.iSolidColor = iSolidColor;
 
        /* Clean up the XLATEOBJ */
        EXLATEOBJ_vCleanup(&exlo);
    }
}

Referenced by DC_vUpdateBackgroundBrush(), DC_vUpdateFillBrush(), DC_vUpdateLineBrush(), DC_vUpdateTextBrush(), and EBRUSHOBJ_vInit().

EBRUSHOBJ_vUpdateFromDC()

VOID NTAPI EBRUSHOBJ_vUpdateFromDC	(	EBRUSHOBJ *	pebo,
		PBRUSH	pbrush,
		PDC	pdc
	)

Definition at line 216 of file engbrush.c.

{
    /* Cleanup the brush */
    EBRUSHOBJ_vCleanup(pebo);
 
    /* Reinitialize */
    EBRUSHOBJ_vInitFromDC(pebo, pbrush, pdc);
}

Referenced by DC_vUpdateBackgroundBrush(), DC_vUpdateFillBrush(), DC_vUpdateLineBrush(), and DC_vUpdateTextBrush().

EngRealizeBrush()

BOOL APIENTRY EngRealizeBrush	(	BRUSHOBJ *	pbo,
		SURFOBJ *	psoDst,
		SURFOBJ *	psoPattern,
		SURFOBJ *	psoMask,
		XLATEOBJ *	pxlo,
		ULONG	iHatch
	)

This function is not exported, because it makes no sense for The driver to punt back to this function

Definition at line 233 of file engbrush.c.

{
    EBRUSHOBJ *pebo;
    HBITMAP hbmpRealize;
    SURFOBJ *psoRealize;
    PSURFACE psurfRealize;
    POINTL ptlSrc = {0, 0};
    RECTL rclDest;
    ULONG lWidth;
 
    /* Calculate width in bytes of the realized brush */
    lWidth = WIDTH_BYTES_ALIGN32(psoPattern->sizlBitmap.cx,
                                  BitsPerFormat(psoDst->iBitmapFormat));
 
    /* Allocate a bitmap */
    hbmpRealize = EngCreateBitmap(psoPattern->sizlBitmap,
                                  lWidth,
                                  psoDst->iBitmapFormat,
                                  BMF_NOZEROINIT,
                                  NULL);
    if (!hbmpRealize)
    {
        return FALSE;
    }
 
    /* Lock the bitmap */
    psurfRealize = SURFACE_ShareLockSurface(hbmpRealize);
 
    /* Already delete the pattern bitmap (will be kept until dereferenced) */
    EngDeleteSurface((HSURF)hbmpRealize);
 
    if (!psurfRealize)
    {
        return FALSE;
    }
 
    /* Copy the bits to the new format bitmap */
    rclDest.left = rclDest.top = 0;
    rclDest.right = psoPattern->sizlBitmap.cx;
    rclDest.bottom = psoPattern->sizlBitmap.cy;
    psoRealize = &psurfRealize->SurfObj;
    EngCopyBits(psoRealize, psoPattern, NULL, pxlo, &rclDest, &ptlSrc);
 
 
    pebo = CONTAINING_RECORD(pbo, EBRUSHOBJ, BrushObject);
    pebo->pengbrush = (PVOID)psurfRealize;
 
    return TRUE;
}

Referenced by EBRUSHOBJ_bRealizeBrush().

FixupDIBBrushPalette()

static PPALETTE FixupDIBBrushPalette ( _In_ PPALETTE  ppalDIB, _In_ PPALETTE  ppalDC  )

static

Definition at line 291 of file engbrush.c.

{
    PPALETTE ppalNew;
    ULONG i, iPalIndex, crColor;
 
    /* Allocate a new palette */
    ppalNew = PALETTE_AllocPalette(PAL_INDEXED,
                                   ppalDIB->NumColors,
                                   NULL,
                                   0,
                                   0,
                                   0);
    if (ppalNew == NULL)
    {
        ERR("Failed to allcate palette for brush\n");
        return NULL;
    }
 
    /* Loop all colors */
    for (i = 0; i < ppalDIB->NumColors; i++)
    {
        /* Get the RGB color, which is the index into the DC palette */
        iPalIndex = PALETTE_ulGetRGBColorFromIndex(ppalDIB, i);
 
        /* Roll over when index is too big */
        iPalIndex %= ppalDC->NumColors;
 
        /* Set the indexed DC color as the new color */
        crColor = PALETTE_ulGetRGBColorFromIndex(ppalDC, iPalIndex);
        PALETTE_vSetRGBColorForIndex(ppalNew, i, crColor);
    }
 
    /* Return the new palette */
    return ppalNew;
}

Referenced by EBRUSHOBJ_bRealizeBrush().

InitBrushImpl()

NTSTATUS NTAPI InitBrushImpl

(

VOID

)

Internal functions

Definition at line 31 of file engbrush.c.

{
    ULONG i;
    SIZEL sizl = {8, 8};
 
    /* Loop all hatch styles */
    for (i = 0; i < HS_DDI_MAX; i++)
    {
        /* Create a default hatch bitmap */
        gahsurfHatch[i] = (HSURF)EngCreateBitmap(sizl,
                                                 0,
                                                 BMF_1BPP,
                                                 0,
                                                 (PVOID)gaulHatchBrushes[i]);
    }
 
    return STATUS_SUCCESS;
}

Referenced by DriverEntry().

Variable Documentation

gahsurfHatch

HSURF gahsurfHatch[HS_DDI_MAX]

Definition at line 24 of file engbrush.c.

Referenced by InitBrushImpl(), and PDEVOBJ_bEnablePDEV().

gaulHatchBrushes

const ULONG gaulHatchBrushes[HS_DDI_MAX][8]

static

Initial value:

=
{
    {0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF}, 
    {0xF7, 0xF7, 0xF7, 0xF7, 0xF7, 0xF7, 0xF7, 0xF7}, 
    {0xFE, 0xFD, 0xFB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F}, 
    {0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 0xFE}, 
    {0xF7, 0xF7, 0xF7, 0xF7, 0x00, 0xF7, 0xF7, 0xF7}, 
    {0x7E, 0xBD, 0xDB, 0xE7, 0xE7, 0xDB, 0xBD, 0x7E}  
}

Definition at line 14 of file engbrush.c.

Referenced by InitBrushImpl().