From e2a450fc3f17125722660d9e9de78cedbb9ef381 Mon Sep 17 00:00:00 2001 From: Timo Kreuzer Date: Mon, 23 Mar 2009 00:38:59 +0000 Subject: [PATCH] Brush rewrite part 1/x - Make the EBRUSHOBJ structure somewhat like XPs. - Make the eboXxx members of the DC real EBRUSHOBJs and initialize them on DC creation. Except for IntArc they are not yet used and there still with the old way of doing it. - Implement DC_vUpdateXxxBrush functions that update the DCs EBRUSHOBJs after changes to the dcattr. - Implement EBRUSHOBJ_bRealizeBrush that realizes the brush by either calling the DrvRealizeBrush or EngRealizeBrush, which is currently only stubbed and this functionality is not plugged in due to other broken features. - EBRUSHOBJ_vInit: Store the RGB color and return it in BRUSHOBJ_ulGetBrushColor. - Implement EBRUSHOBJ_vSetSolidBrushColor, EBRUSHOBJ_vUpdate and EBRUSHOBJ_vUnrealizeBrush - Rename PENOBJ_bla to PEN_bla. - Make GDIOBJ_ShareUnlockObjByPtr an inline function - Implement GDIOBJ_IncrementShareCount as inline function. - NtGdiSelectBitmap: keep a shared reference on the selected bitmap. - EngAssociateSurface: don't ASSERT, but fail if locking the surface handle failed. - EngModifySurface: use an exclusive lock and handle everything inside this function. svn path=/trunk/; revision=40179 --- reactos/subsystems/win32/win32k/eng/bitblt.c | 12 +- .../subsystems/win32/win32k/eng/engbrush.c | 140 +++++++++++++-- reactos/subsystems/win32/win32k/eng/lineto.c | 4 +- reactos/subsystems/win32/win32k/eng/surface.c | 48 +++-- .../subsystems/win32/win32k/include/brush.h | 47 ++++- reactos/subsystems/win32/win32k/include/dc.h | 8 +- .../subsystems/win32/win32k/include/gdiobj.h | 20 ++- reactos/subsystems/win32/win32k/include/pen.h | 28 +-- reactos/subsystems/win32/win32k/objects/arc.c | 15 +- .../subsystems/win32/win32k/objects/bitmaps.c | 13 +- reactos/subsystems/win32/win32k/objects/dc.c | 168 +++++++++++++++++- .../win32/win32k/objects/fillshap.c | 16 +- .../subsystems/win32/win32k/objects/gdiobj.c | 10 -- .../subsystems/win32/win32k/objects/line.c | 10 +- reactos/subsystems/win32/win32k/objects/pen.c | 32 ++-- .../win32/win32k/objects/stockobj.c | 4 +- 16 files changed, 461 insertions(+), 114 deletions(-) diff --git a/reactos/subsystems/win32/win32k/eng/bitblt.c b/reactos/subsystems/win32/win32k/eng/bitblt.c index 9dcabd7dcde..e1979cb7036 100644 --- a/reactos/subsystems/win32/win32k/eng/bitblt.c +++ b/reactos/subsystems/win32/win32k/eng/bitblt.c @@ -92,7 +92,7 @@ BltMask(SURFOBJ* Dest, BYTE *tMask, *lMask; static BYTE maskbit[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 }; /* Pattern brushes */ - PEBRUSHOBJ GdiBrush = NULL; + PEBRUSHOBJ pebo = NULL; SURFOBJ *psoPattern = NULL; PSURFACE psurfPattern; ULONG PatternWidth = 0, PatternHeight = 0, PatternY = 0; @@ -107,12 +107,12 @@ BltMask(SURFOBJ* Dest, if (pbo && pbo->iSolidColor == 0xFFFFFFFF) { - GdiBrush = CONTAINING_RECORD( + pebo = CONTAINING_RECORD( pbo, EBRUSHOBJ, BrushObject); - psurfPattern = SURFACE_LockSurface(GdiBrush->GdiBrushObject->hbmPattern); + psurfPattern = SURFACE_LockSurface(pebo->pbrush->hbmPattern); if (psurfPattern != NULL) { psoPattern = &psurfPattern->SurfObj; @@ -145,7 +145,7 @@ BltMask(SURFOBJ* Dest, { DibFunctionsForBitmapFormat[Dest->iBitmapFormat].DIB_PutPixel( Dest, DestRect->left + i, DestRect->top + j, - DIB_GetSource(psoPattern, (DestRect->left + i) % PatternWidth, PatternY, GdiBrush ? GdiBrush->XlateObject : NULL)); + DIB_GetSource(psoPattern, (DestRect->left + i) % PatternWidth, PatternY, pebo ? pebo->XlateObject : NULL)); } } c8++; @@ -220,7 +220,7 @@ CallDibBitBlt(SURFOBJ* OutputObj, if (ROP4_USES_PATTERN(Rop4) && pbo && pbo->iSolidColor == 0xFFFFFFFF) { GdiBrush = CONTAINING_RECORD(pbo, EBRUSHOBJ, BrushObject); - if ((psurfPattern = SURFACE_LockSurface(GdiBrush->GdiBrushObject->hbmPattern))) + if ((psurfPattern = SURFACE_LockSurface(GdiBrush->pbrush->hbmPattern))) { BltInfo.PatternSurface = &psurfPattern->SurfObj; } @@ -763,7 +763,7 @@ CallDibStretchBlt(SURFOBJ* psoDest, if (ROP4_USES_PATTERN(Rop4) && pbo && pbo->iSolidColor == 0xFFFFFFFF) { GdiBrush = CONTAINING_RECORD(pbo, EBRUSHOBJ, BrushObject); - psurfPattern = SURFACE_LockSurface(GdiBrush->GdiBrushObject->hbmPattern); + psurfPattern = SURFACE_LockSurface(GdiBrush->pbrush->hbmPattern); if (psurfPattern) { PatternSurface = &psurfPattern->SurfObj; diff --git a/reactos/subsystems/win32/win32k/eng/engbrush.c b/reactos/subsystems/win32/win32k/eng/engbrush.c index 259703fa771..3a04627f6c2 100644 --- a/reactos/subsystems/win32/win32k/eng/engbrush.c +++ b/reactos/subsystems/win32/win32k/eng/engbrush.c @@ -4,8 +4,7 @@ * PURPOSE: GDI Driver Brush Functions * FILE: subsystem/win32/win32k/eng/engbrush.c * PROGRAMER: Jason Filby - * REVISION HISTORY: - * 3/7/1999: Created + * Timo Kreuzer */ #include @@ -15,9 +14,29 @@ /** Internal functions ********************************************************/ -VOID FASTCALL +/** + * This function is not exported, because it makes no sense for + * The driver to punt back to this function */ +BOOL +APIENTRY +EngRealizeBrush( + BRUSHOBJ *pbo, + SURFOBJ *psoDst, + SURFOBJ *psoPattern, + SURFOBJ *psoMask, + XLATEOBJ *pxlo, + ULONG iHatch) +{ + UNIMPLEMENTED; + return FALSE; +} + +VOID +FASTCALL EBRUSHOBJ_vInit(EBRUSHOBJ *pebo, PBRUSH pbrush, XLATEOBJ *pxlo) { + ULONG iSolidColor; + ASSERT(pebo); ASSERT(pbrush); @@ -27,20 +46,109 @@ EBRUSHOBJ_vInit(EBRUSHOBJ *pebo, PBRUSH pbrush, XLATEOBJ *pxlo) } else if (pbrush->flAttrs & GDIBRUSH_IS_SOLID) { - pebo->BrushObject.iSolidColor = XLATEOBJ_iXlate(pxlo, pbrush->BrushAttr.lbColor); + /* Set the RGB color */ + pebo->crRealize = pbrush->BrushAttr.lbColor; + pebo->ulRGBColor = pbrush->BrushAttr.lbColor; + + /* Translate the brush color to the target format */ + iSolidColor = XLATEOBJ_iXlate(pxlo, pbrush->BrushAttr.lbColor); + pebo->BrushObject.iSolidColor = iSolidColor; } else { + /* This is a pattern brush that needs realization */ pebo->BrushObject.iSolidColor = 0xFFFFFFFF; - // FIXME: What about calling DrvRealizeBrush? +// EBRUSHOBJ_bRealizeBrush(pebo); } pebo->BrushObject.pvRbrush = pbrush->ulRealization; pebo->BrushObject.flColorType = 0; - pebo->GdiBrushObject = pbrush; + pebo->pbrush = pbrush; pebo->XlateObject = pxlo; } +VOID +FASTCALL +EBRUSHOBJ_vSetSolidBrushColor(EBRUSHOBJ *pebo, ULONG iSolidColor) +{ + /* Never use with non-solid brushes */ + ASSERT(pebo->flattrs & GDIBRUSH_IS_SOLID); + + pebo->BrushObject.iSolidColor = iSolidColor; +} + +BOOL +FASTCALL +EBRUSHOBJ_bRealizeBrush(EBRUSHOBJ *pebo) +{ + BOOL bResult; + PFN_DrvRealizeBrush pfnRealzizeBrush; + PSURFACE psurfTrg, psurfPattern, psurfMask; + PPDEVOBJ ppdev; + XLATEOBJ *pxlo; + + psurfTrg = pebo->psurfTrg; // FIXME: all EBRUSHOBJs need a surface + ppdev = (PPDEVOBJ)psurfTrg->SurfObj.hdev; // FIXME: all SURFACEs need a PDEV + + pfnRealzizeBrush = ppdev->DriverFunctions.RealizeBrush; + if (!pfnRealzizeBrush) + { + pfnRealzizeBrush = EngRealizeBrush; + } + + psurfPattern = SURFACE_LockSurface(pebo->pbrush->hbmPattern); + + /* FIXME: implement mask */ + psurfMask = NULL; + + // FIXME + pxlo = NULL; + + bResult = pfnRealzizeBrush(&pebo->BrushObject, + &pebo->psurfTrg->SurfObj, + psurfPattern ? &psurfPattern->SurfObj : NULL, + psurfMask ? &psurfMask->SurfObj : NULL, + pxlo, + -1); // FIXME: what about hatch brushes? + + if (psurfPattern) + SURFACE_UnlockSurface(psurfPattern); + + if (psurfMask) + SURFACE_UnlockSurface(psurfMask); + + return bResult; +} + +VOID +FASTCALL +EBRUSHOBJ_vUnrealizeBrush(EBRUSHOBJ *pebo) +{ + /* Check if it's a GDI realisation */ + if (pebo->pengbrush) + { + + } + else if (pebo->BrushObject.pvRbrush) + { + /* Free allocated driver memory */ + EngFreeMem(pebo->BrushObject.pvRbrush); + } +} + + + +VOID +FASTCALL +EBRUSHOBJ_vUpdate(EBRUSHOBJ *pebo, PBRUSH pbrush, XLATEOBJ *pxlo) +{ + /* Unrealize the brush */ + EBRUSHOBJ_vUnrealizeBrush(pebo); + + EBRUSHOBJ_vInit(pebo, pbrush, pxlo); +} + + /** Exported DDI functions ****************************************************/ @@ -48,30 +156,34 @@ EBRUSHOBJ_vInit(EBRUSHOBJ *pebo, PBRUSH pbrush, XLATEOBJ *pxlo) * @implemented */ PVOID APIENTRY -BRUSHOBJ_pvAllocRbrush(IN BRUSHOBJ *BrushObj, - IN ULONG ObjSize) +BRUSHOBJ_pvAllocRbrush( + IN BRUSHOBJ *pbo, + IN ULONG cj) { - BrushObj->pvRbrush=EngAllocMem(0, ObjSize, 0); - return(BrushObj->pvRbrush); + pbo->pvRbrush = EngAllocMem(0, cj, 'rbdG'); + return pbo->pvRbrush; } /* * @implemented */ PVOID APIENTRY -BRUSHOBJ_pvGetRbrush(IN BRUSHOBJ *BrushObj) +BRUSHOBJ_pvGetRbrush( + IN BRUSHOBJ *pbo) { // FIXME: this is wrong! Read msdn. - return(BrushObj->pvRbrush); + return pbo->pvRbrush; } /* * @implemented */ ULONG APIENTRY -BRUSHOBJ_ulGetBrushColor(IN BRUSHOBJ *BrushObj) +BRUSHOBJ_ulGetBrushColor( + IN BRUSHOBJ *pbo) { - return BrushObj->iSolidColor; + EBRUSHOBJ *pebo = CONTAINING_RECORD(pbo, EBRUSHOBJ, BrushObject); + return pebo->ulRGBColor; } /* EOF */ diff --git a/reactos/subsystems/win32/win32k/eng/lineto.c b/reactos/subsystems/win32/win32k/eng/lineto.c index a0412d89423..57f32260d39 100644 --- a/reactos/subsystems/win32/win32k/eng/lineto.c +++ b/reactos/subsystems/win32/win32k/eng/lineto.c @@ -530,9 +530,9 @@ IntEngLineTo(SURFOBJ *psoDest, EBRUSHOBJ, BrushObject); ASSERT(GdiBrush); - ASSERT(GdiBrush->GdiBrushObject); + ASSERT(GdiBrush->pbrush); - if (GdiBrush->GdiBrushObject->flAttrs & GDIBRUSH_IS_NULL) + if (GdiBrush->pbrush->flAttrs & GDIBRUSH_IS_NULL) return TRUE; /* No success yet */ diff --git a/reactos/subsystems/win32/win32k/eng/surface.c b/reactos/subsystems/win32/win32k/eng/surface.c index 6603fd02397..738a229732f 100644 --- a/reactos/subsystems/win32/win32k/eng/surface.c +++ b/reactos/subsystems/win32/win32k/eng/surface.c @@ -506,27 +506,33 @@ EngCreateDeviceSurface(IN DHSURF dhsurf, /* * @implemented */ -BOOL APIENTRY -EngAssociateSurface(IN HSURF hsurf, - IN HDEV hdev, - IN ULONG Hooks) +BOOL +APIENTRY +EngAssociateSurface( + IN HSURF hsurf, + IN HDEV hdev, + IN FLONG flHooks) { SURFOBJ *pso; PSURFACE psurf; - PDEVOBJ* Device; + PDEVOBJ* ppdev; - Device = (PDEVOBJ*)hdev; + ppdev = (PDEVOBJ*)hdev; + /* Lock the surface */ psurf = SURFACE_LockSurface(hsurf); - ASSERT(psurf); + if (!psurf) + { + return FALSE; + } pso = &psurf->SurfObj; /* Associate the hdev */ pso->hdev = hdev; - pso->dhpdev = Device->hPDev; + pso->dhpdev = ppdev->hPDev; /* Hook up specified functions */ - psurf->flHooks = Hooks; + psurf->flHooks = flHooks; SURFACE_UnlockSurface(psurf); @@ -548,25 +554,29 @@ EngModifySurface( IN VOID *pvReserved) { SURFOBJ *pso; + PSURFACE psurf; + PDEVOBJ* ppdev; - pso = EngLockSurface(hsurf); - if (pso == NULL) + psurf = SURFACE_LockSurface(hsurf); + if (psurf == NULL) { return FALSE; } - if (!EngAssociateSurface(hsurf, hdev, flHooks)) - { - EngUnlockSurface(pso); - - return FALSE; - } - + ppdev = (PDEVOBJ*)hdev; + pso = &psurf->SurfObj; pso->dhsurf = dhsurf; pso->lDelta = lDelta; pso->pvScan0 = pvScan0; - EngUnlockSurface(pso); + /* Associate the hdev */ + pso->hdev = hdev; + pso->dhpdev = ppdev->hPDev; + + /* Hook up specified functions */ + psurf->flHooks = flHooks; + + SURFACE_UnlockSurface(psurf); return TRUE; } diff --git a/reactos/subsystems/win32/win32k/include/brush.h b/reactos/subsystems/win32/win32k/include/brush.h index 6173fe5e75e..e6c35457b55 100644 --- a/reactos/subsystems/win32/win32k/include/brush.h +++ b/reactos/subsystems/win32/win32k/include/brush.h @@ -15,7 +15,7 @@ * A MAILING LIST FIRST. */ -typedef struct +typedef struct _BRUSH { /* Header for all gdi objects in the handle table. Do not (re)move this. */ @@ -44,11 +44,33 @@ typedef struct ULONG Unknown6C; } BRUSH, *PBRUSH; -typedef struct +typedef struct _EBRUSHOBJ { - BRUSHOBJ BrushObject; - PBRUSH GdiBrushObject; - XLATEOBJ *XlateObject; + BRUSHOBJ BrushObject; + + COLORREF crRealize; + ULONG ulRGBColor; + DWORD pengbrush; + ULONG ulSurfPalTime; + ULONG ulDCPalTime; + COLORREF crCurrentText; + COLORREF crCurrentBack; + COLORADJUSTMENT *pca; +// DWORD dwUnknown2c; +// DWORD dwUnknown30; + SURFACE * psurfTrg; +// PALETTE * ppalSurf; +// PALETTE * ppalDC; +// PALETTE * ppal3; +// DWORD dwUnknown44; + BRUSH * pbrush; + FLONG flattrs; + DWORD ulUnique; +// DWORD dwUnknown54; +// DWORD dwUnknown58; + + /* Ros specific */ + XLATEOBJ *XlateObject; } EBRUSHOBJ, *PEBRUSHOBJ; /* GDI Brush Attributes */ @@ -78,10 +100,25 @@ typedef struct #define BRUSH_LockBrush(hBrush) ((PBRUSH)GDIOBJ_LockObj((HGDIOBJ)hBrush, GDI_OBJECT_TYPE_BRUSH)) #define BRUSH_UnlockBrush(pBrush) GDIOBJ_UnlockObjByPtr((POBJ)pBrush) +#define BRUSH_ShareLockBrush(hBrush) ((PBRUSH)GDIOBJ_ShareLockObj((HGDIOBJ)hBrush, GDI_OBJECT_TYPE_BRUSH)) +#define BRUSH_ShareUnlockBrush(pBrush) GDIOBJ_ShareUnlockObjByPtr((POBJ)pBrush) + INT FASTCALL BRUSH_GetObject (PBRUSH GdiObject, INT Count, LPLOGBRUSH Buffer); BOOL INTERNAL_CALL BRUSH_Cleanup(PVOID ObjectBody); VOID FASTCALL EBRUSHOBJ_vInit(EBRUSHOBJ *BrushInst, PBRUSH BrushObj, XLATEOBJ *XlateObj); +VOID +FASTCALL +EBRUSHOBJ_vSetSolidBrushColor(EBRUSHOBJ *pebo, ULONG iSolidColor); + +VOID +FASTCALL +EBRUSHOBJ_vUpdate(EBRUSHOBJ *pebo, PBRUSH pbrush, XLATEOBJ *pxlo); + +BOOL +FASTCALL +EBRUSHOBJ_bRealizeBrush(EBRUSHOBJ *pebo); + #endif diff --git a/reactos/subsystems/win32/win32k/include/dc.h b/reactos/subsystems/win32/win32k/include/dc.h index 2764f284dd8..d6da1862953 100644 --- a/reactos/subsystems/win32/win32k/include/dc.h +++ b/reactos/subsystems/win32/win32k/include/dc.h @@ -190,10 +190,10 @@ typedef struct _DC PVOID prgnVis; PVOID prgnRao; POINTL ptlFillOrigin; - unsigned eboFill_[23]; /* EBRUSHOBJ */ - unsigned eboLine_[23]; - unsigned eboText_[23]; - unsigned eboBackground_[23]; + EBRUSHOBJ eboFill; + EBRUSHOBJ eboLine; + EBRUSHOBJ eboText; + EBRUSHOBJ eboBackground; HFONT hlfntCur; FLONG flSimulationFlags; LONG lEscapement; diff --git a/reactos/subsystems/win32/win32k/include/gdiobj.h b/reactos/subsystems/win32/win32k/include/gdiobj.h index 38e562c51ec..ba0068a31b1 100644 --- a/reactos/subsystems/win32/win32k/include/gdiobj.h +++ b/reactos/subsystems/win32/win32k/include/gdiobj.h @@ -61,7 +61,7 @@ BOOL INTERNAL_CALL GDIOBJ_OwnedByCurrentProcess(HGDIOBJ ObjectHandle); BOOL INTERNAL_CALL GDIOBJ_SetOwnership(HGDIOBJ ObjectHandle, PEPROCESS Owner); BOOL INTERNAL_CALL GDIOBJ_CopyOwnership(HGDIOBJ CopyFrom, HGDIOBJ CopyTo); BOOL INTERNAL_CALL GDIOBJ_ConvertToStockObj(HGDIOBJ *hObj); -VOID INTERNAL_CALL GDIOBJ_ShareUnlockObjByPtr(POBJ Object); +//VOID INTERNAL_CALL GDIOBJ_ShareUnlockObjByPtr(POBJ Object); BOOL INTERNAL_CALL GDIOBJ_ValidateHandle(HGDIOBJ hObj, ULONG ObjectType); POBJ INTERNAL_CALL GDIOBJ_AllocObj(UCHAR ObjectType); POBJ INTERNAL_CALL GDIOBJ_AllocObjWithHandle(ULONG ObjectType); @@ -99,4 +99,22 @@ GDIOBJ_UnlockObjByPtr(POBJ Object) return cLocks; } +ULONG +FORCEINLINE +GDIOBJ_ShareUnlockObjByPtr(POBJ Object) +{ + INT cLocks = InterlockedDecrement((PLONG)&Object->ulShareCount); + ASSERT(cLocks >= 0); + return cLocks; +} + +ULONG +FORCEINLINE +GDIOBJ_IncrementShareCount(POBJ Object) +{ + INT cLocks = InterlockedIncrement((PLONG)&Object->ulShareCount); + ASSERT(cLocks >= 1); + return cLocks; +} + #endif diff --git a/reactos/subsystems/win32/win32k/include/pen.h b/reactos/subsystems/win32/win32k/include/pen.h index 531b46a3a8d..b6d85c5ba02 100644 --- a/reactos/subsystems/win32/win32k/include/pen.h +++ b/reactos/subsystems/win32/win32k/include/pen.h @@ -6,26 +6,30 @@ /* Internal interface */ -#define PENOBJ_AllocPen() ((HPEN)GDIOBJ_AllocObj(GDIObjType_BRUSH_TYPE)) -#define PENOBJ_AllocPenWithHandle() ((PBRUSH)GDIOBJ_AllocObjWithHandle(GDI_OBJECT_TYPE_PEN)) +#define PEN_AllocPen() ((HPEN)GDIOBJ_AllocObj(GDIObjType_BRUSH_TYPE)) +#define PEN_AllocPenWithHandle() ((PBRUSH)GDIOBJ_AllocObjWithHandle(GDI_OBJECT_TYPE_PEN)) -#define PENOBJ_FreePen(pBMObj) GDIOBJ_FreeObj((POBJ) pBMObj, GDIObjType_BRUSH_TYPE) -#define PENOBJ_FreePenByHandle(hBMObj) GDIOBJ_FreeObjByHandle((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_PEN) +#define PEN_FreePen(pBMObj) GDIOBJ_FreeObj((POBJ) pBMObj, GDIObjType_BRUSH_TYPE) +#define PEN_FreePenByHandle(hBMObj) GDIOBJ_FreeObjByHandle((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_PEN) -//#define PENOBJ_LockPen(hBMObj) ((PBRUSH)GDIOBJ_LockObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_PEN)) +//#define PEN_LockPen(hBMObj) ((PBRUSH)GDIOBJ_LockObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_PEN)) -#define PENOBJ_AllocExtPen() ((PBRUSH)GDIOBJ_AllocObj(GDIObjType_BRUSH_TYPE)) -#define PENOBJ_AllocExtPenWithHandle() ((PBRUSH)GDIOBJ_AllocObjWithHandle(GDI_OBJECT_TYPE_EXTPEN)) +#define PEN_AllocExtPen() ((PBRUSH)GDIOBJ_AllocObj(GDIObjType_BRUSH_TYPE)) +#define PEN_AllocExtPenWithHandle() ((PBRUSH)GDIOBJ_AllocObjWithHandle(GDI_OBJECT_TYPE_EXTPEN)) -#define PENOBJ_FreeExtPen(pBMObj) GDIOBJ_FreeObj((POBJ) pBMObj, GDIObjType_BRUSH_TYPE) -#define PENOBJ_FreeExtPenByHandle(hBMObj) GDIOBJ_FreeObjByHandle((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_EXTPEN) +#define PEN_FreeExtPen(pBMObj) GDIOBJ_FreeObj((POBJ) pBMObj, GDIObjType_BRUSH_TYPE) +#define PEN_FreeExtPenByHandle(hBMObj) GDIOBJ_FreeObjByHandle((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_EXTPEN) -//#define PENOBJ_LockExtPen(hBMObj) ((PBRUSH)GDIOBJ_LockObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_EXTPEN)) +//#define PEN_LockExtPen(hBMObj) ((PBRUSH)GDIOBJ_LockObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_EXTPEN)) -#define PENOBJ_UnlockPen(pPenObj) GDIOBJ_UnlockObjByPtr((POBJ)pPenObj) +#define PEN_UnlockPen(pPenObj) GDIOBJ_UnlockObjByPtr((POBJ)pPenObj) + +#define PEN_ShareUnlockPen(ppen) GDIOBJ_ShareUnlockObjByPtr((POBJ)ppen) -PBRUSH FASTCALL PENOBJ_LockPen(HGDIOBJ); +PBRUSH FASTCALL PEN_LockPen(HGDIOBJ); +PBRUSH FASTCALL PEN_ShareLockPen(HGDIOBJ); + INT APIENTRY PEN_GetObject(PBRUSH pPen, INT Count, PLOGPEN Buffer); #endif diff --git a/reactos/subsystems/win32/win32k/objects/arc.c b/reactos/subsystems/win32/win32k/objects/arc.c index 600c0637b91..d2590ea7d2d 100644 --- a/reactos/subsystems/win32/win32k/objects/arc.c +++ b/reactos/subsystems/win32/win32k/objects/arc.c @@ -45,7 +45,6 @@ IntArc( DC *dc, PDC_ATTR pdcattr; RECTL RectBounds, RectSEpts; PBRUSH pbrushPen; - EBRUSHOBJ eboPen; SURFACE *psurf; BOOL ret = TRUE; LONG PenWidth, PenOrigWidth; @@ -70,7 +69,7 @@ IntArc( DC *dc, pdcattr = dc->pdcattr; - pbrushPen = PENOBJ_LockPen(pdcattr->hpen); + pbrushPen = PEN_LockPen(pdcattr->hpen); if (!pbrushPen) { DPRINT1("Arc Fail 1\n"); @@ -161,24 +160,24 @@ IntArc( DC *dc, if (NULL == psurf) { DPRINT1("Arc Fail 2\n"); - PENOBJ_UnlockPen(pbrushPen); + PEN_UnlockPen(pbrushPen); SetLastWin32Error(ERROR_INTERNAL_ERROR); return FALSE; } - EBRUSHOBJ_vInit(&eboPen, pbrushPen, dc->rosdc.XlatePen); + EBRUSHOBJ_vInit(&dc->eboLine, pbrushPen, dc->rosdc.XlatePen); if (arctype == GdiTypePie) { - PUTLINE(CenterX, CenterY, SfCx + CenterX, SfCy + CenterY, eboPen); - PUTLINE(EfCx + CenterX, EfCy + CenterY, CenterX, CenterY, eboPen); + PUTLINE(CenterX, CenterY, SfCx + CenterX, SfCy + CenterY, dc->eboLine); + PUTLINE(EfCx + CenterX, EfCy + CenterY, CenterX, CenterY, dc->eboLine); } if (arctype == GdiTypeChord) - PUTLINE(EfCx + CenterX, EfCy + CenterY, SfCx + CenterX, SfCy + CenterY, eboPen); + PUTLINE(EfCx + CenterX, EfCy + CenterY, SfCx + CenterX, SfCy + CenterY, dc->eboLine); pbrushPen->ptPenWidth.x = PenOrigWidth; SURFACE_UnlockSurface(psurf); - PENOBJ_UnlockPen(pbrushPen); + PEN_UnlockPen(pbrushPen); DPRINT("IntArc Exit.\n"); return ret; } diff --git a/reactos/subsystems/win32/win32k/objects/bitmaps.c b/reactos/subsystems/win32/win32k/objects/bitmaps.c index 3140d86832c..dd71fc8092d 100644 --- a/reactos/subsystems/win32/win32k/objects/bitmaps.c +++ b/reactos/subsystems/win32/win32k/objects/bitmaps.c @@ -960,11 +960,15 @@ NtGdiSelectBitmap( DC_UnlockDc(pDC); return NULL; } + hOrgBmp = pDC->rosdc.hBitmap; - /* Release the old bitmap, lock the new one and convert it to a SURF */ pDC->rosdc.hBitmap = hBmp; + /* Release the old bitmap */ + if (pDC->dclevel.pSurface) + SURFACE_ShareUnlockSurface(pDC->dclevel.pSurface); + // If Info DC this is zero and pSurface is moved to DC->pSurfInfo. pDC->dclevel.pSurface = psurfBmp; psurfBmp->hDC = hDC; @@ -985,6 +989,9 @@ NtGdiSelectBitmap( 0, psurfBmp->SurfObj.sizlBitmap.cx, psurfBmp->SurfObj.sizlBitmap.cy); + + /* Keep a shared reference on the bitmap */ + GDIOBJ_IncrementShareCount((POBJ)psurfBmp); SURFACE_UnlockSurface(psurfBmp); /* Regenerate the XLATEOBJs. */ @@ -999,7 +1006,7 @@ NtGdiSelectBitmap( BRUSH_UnlockBrush(pbrush); } - pbrush = PENOBJ_LockPen(pdcattr->hpen); + pbrush = PEN_LockPen(pdcattr->hpen); if (pbrush) { if (pDC->rosdc.XlatePen) @@ -1007,7 +1014,7 @@ NtGdiSelectBitmap( EngDeleteXlate(pDC->rosdc.XlatePen); } pDC->rosdc.XlatePen = IntGdiCreateBrushXlate(pDC, pbrush, &bFailed); - PENOBJ_UnlockPen(pbrush); + PEN_UnlockPen(pbrush); } DC_UnlockDc(pDC); diff --git a/reactos/subsystems/win32/win32k/objects/dc.c b/reactos/subsystems/win32/win32k/objects/dc.c index 0cffd0c2eed..732e7809e19 100644 --- a/reactos/subsystems/win32/win32k/objects/dc.c +++ b/reactos/subsystems/win32/win32k/objects/dc.c @@ -2422,8 +2422,6 @@ DC_AllocDC(PUNICODE_STRING Driver) } pdcattr = NewDC->pdcattr; - NewDC->BaseObject.hHmgr = (HGDIOBJ) hDC; // Save the handle for this DC object. - xformTemplate.eM11 = 1.0f; xformTemplate.eM12 = 0.0f; xformTemplate.eM21 = 0.0f; @@ -2461,9 +2459,18 @@ DC_AllocDC(PUNICODE_STRING Driver) pdcattr->crBrushClr = RGB( 255, 255, 255 ); //// This fixes the default brush and pen settings. See DC_InitDC. + + /* Create the default fill brush */ pdcattr->hbrush = NtGdiGetStockObject( WHITE_BRUSH ); + NewDC->dclevel.pbrFill = BRUSH_ShareLockBrush(pdcattr->hbrush); + EBRUSHOBJ_vInit(&NewDC->eboFill, NewDC->dclevel.pbrFill, NULL); + + /* Create the default pen / line brush */ pdcattr->hpen = NtGdiGetStockObject( BLACK_PEN ); -//// + NewDC->dclevel.pbrLine = PEN_ShareLockPen(pdcattr->hpen); + EBRUSHOBJ_vInit(&NewDC->eboLine, NewDC->dclevel.pbrFill, NULL); + + pdcattr->hlfntNew = NtGdiGetStockObject(SYSTEM_FONT); TextIntRealizeFont(pdcattr->hlfntNew,NULL); @@ -2743,7 +2750,7 @@ IntIsPrimarySurface(SURFOBJ *SurfObj) { return FALSE; } - return SurfObj->hsurf == PrimarySurface.pSurface; + return SurfObj->hsurf == PrimarySurface.pSurface; // <- FIXME: WTF? } // @@ -3466,4 +3473,157 @@ NtGdiMakeInfoDC( return FALSE; } +VOID +FASTCALL +DC_vUpdateFillBrush(PDC pdc) +{ + PDC_ATTR pdcattr = pdc->pdcattr; + PBRUSH pbrFill; + XLATEOBJ *pxlo; + ULONG iSolidColor; + + /* Check if update of eboFill is needed */ + if (pdcattr->ulDirty_ & DIRTY_FILL) + { + /* ROS HACK, should use surf xlate */ + pxlo = pdc->rosdc.XlatePen; + + /* 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; + + /* Update eboFill, realizing it, if needed */ + EBRUSHOBJ_vUpdate(&pdc->eboFill, pbrFill, pxlo); + } + else + { + /* Invalid brush handle, restore old one */ + pdcattr->hbrush = pdc->dclevel.pbrFill->BaseObject.hHmgr; + } + } + + /* Check for DC brush */ + if (pdcattr->hbrush == StockObjects[DC_BRUSH]) + { + /* Translate the color to the target format */ + iSolidColor = XLATEOBJ_iXlate(pxlo, pdcattr->crPenClr); + + /* Update the eboFill's solid color */ + EBRUSHOBJ_vSetSolidBrushColor(&pdc->eboFill, iSolidColor); + } + + /* Clear flag */ + pdcattr->ulDirty_ &= ~DIRTY_FILL; + } +} + +VOID +FASTCALL +DC_vUpdateLineBrush(PDC pdc) +{ + PDC_ATTR pdcattr = pdc->pdcattr; + PBRUSH pbrLine; + XLATEOBJ *pxlo; + ULONG iSolidColor; + + /* Check if update of eboLine is needed */ + if (pdcattr->ulDirty_ & DIRTY_LINE) + { + /* ROS HACK, should use surf xlate */ + pxlo = pdc->rosdc.XlatePen; + + /* Check if the pen handle has changed */ + if (pdcattr->hpen != pdc->dclevel.pbrLine->BaseObject.hHmgr) + { + /* Try to lock the new pen */ + pbrLine = BRUSH_ShareLockBrush(pdcattr->hpen); + if (pbrLine) + { + /* Unlock old brush, set new brush */ + BRUSH_ShareUnlockBrush(pdc->dclevel.pbrLine); + pdc->dclevel.pbrLine = pbrLine; + + /* Update eboLine, realizing it, if needed */ + EBRUSHOBJ_vUpdate(&pdc->eboLine, pbrLine, pxlo); + } + else + { + /* Invalid pen handle, restore old one */ + pdcattr->hpen = pdc->dclevel.pbrLine->BaseObject.hHmgr; + } + } + + /* Check for DC pen */ + if (pdcattr->hpen == StockObjects[DC_PEN]) + { + /* Translate the color to the target format */ + iSolidColor = XLATEOBJ_iXlate(pxlo, pdcattr->crPenClr); + + /* Update the eboLine's solid color */ + EBRUSHOBJ_vSetSolidBrushColor(&pdc->eboLine, iSolidColor); + } + + /* Clear flag */ + pdcattr->ulDirty_ &= ~DIRTY_LINE; + } +} + +VOID +FASTCALL +DC_vUpdateTextBrush(PDC pdc) +{ + PDC_ATTR pdcattr = pdc->pdcattr; + XLATEOBJ *pxlo; + ULONG iSolidColor; + + /* Check if update of eboText is needed */ + if (pdcattr->ulDirty_ & DIRTY_TEXT) + { + /* ROS HACK, should use surf xlate */ + pxlo = pdc->rosdc.XlatePen; + + /* Translate the color to the target format */ + iSolidColor = XLATEOBJ_iXlate(pxlo, pdcattr->crForegroundClr); + + /* Update the eboText's solid color */ + EBRUSHOBJ_vSetSolidBrushColor(&pdc->eboText, iSolidColor); + + /* Clear flag */ + pdcattr->ulDirty_ &= ~DIRTY_TEXT; + } +} + +VOID +FASTCALL +DC_vUpdateBackgroundBrush(PDC pdc) +{ + PDC_ATTR pdcattr = pdc->pdcattr; + XLATEOBJ *pxlo; + ULONG iSolidColor; + + /* Check if update of eboBackground is needed */ + if (pdcattr->ulDirty_ & DIRTY_BACKGROUND) + { + /* ROS HACK, should use surf xlate */ + pxlo = pdc->rosdc.XlatePen; + + /* Translate the color to the target format */ + iSolidColor = XLATEOBJ_iXlate(pxlo, pdcattr->crBackgroundClr); + + /* Update the eboBackground's solid color */ + EBRUSHOBJ_vSetSolidBrushColor(&pdc->eboBackground, iSolidColor); + + /* Clear flag */ + pdcattr->ulDirty_ &= ~DIRTY_BACKGROUND; + } +} + + /* EOF */ diff --git a/reactos/subsystems/win32/win32k/objects/fillshap.c b/reactos/subsystems/win32/win32k/objects/fillshap.c index aace370ae78..38796f22a71 100644 --- a/reactos/subsystems/win32/win32k/objects/fillshap.c +++ b/reactos/subsystems/win32/win32k/objects/fillshap.c @@ -96,7 +96,7 @@ IntGdiPolygon(PDC dc, /* Special locking order to avoid lock-ups */ pbrushFill = BRUSH_LockBrush(pdcattr->hbrush); - pbrushLine = PENOBJ_LockPen(pdcattr->hpen); + pbrushLine = PEN_LockPen(pdcattr->hpen); psurf = SURFACE_LockSurface(dc->rosdc.hBitmap); /* FIXME - psurf can be NULL!!!! don't assert but handle this case gracefully! */ ASSERT(psurf); @@ -154,7 +154,7 @@ IntGdiPolygon(PDC dc, } } if (pbrushLine) - PENOBJ_UnlockPen(pbrushLine); + PEN_UnlockPen(pbrushLine); } SURFACE_UnlockSurface(psurf); @@ -252,7 +252,7 @@ NtGdiEllipse( if (pdcattr->ulDirty_ & DC_PEN_DIRTY) IntGdiSelectPen(dc,pdcattr->hpen); - pbrush = PENOBJ_LockPen(pdcattr->hpen); + pbrush = PEN_LockPen(pdcattr->hpen); if (!pbrush) { DPRINT1("Ellipse Fail 1\n"); @@ -333,7 +333,7 @@ NtGdiEllipse( pbrush); pbrush->ptPenWidth.x = PenOrigWidth; - PENOBJ_UnlockPen(pbrush); + PEN_UnlockPen(pbrush); DC_UnlockDc(dc); DPRINT("Ellipse Exit.\n"); return ret; @@ -580,7 +580,7 @@ IntRectangle(PDC dc, /* Special locking order to avoid lock-ups! */ pbrushFill = BRUSH_LockBrush(pdcattr->hbrush); - pbrushLine = PENOBJ_LockPen(pdcattr->hpen); + pbrushLine = PEN_LockPen(pdcattr->hpen); if (!pbrushLine) { ret = FALSE; @@ -658,7 +658,7 @@ cleanup: BRUSH_UnlockBrush(pbrushFill); if (pbrushLine) - PENOBJ_UnlockPen(pbrushLine); + PEN_UnlockPen(pbrushLine); if (psurf) SURFACE_UnlockSurface(psurf); @@ -746,7 +746,7 @@ IntRoundRect( if (pdcattr->ulDirty_ & DC_PEN_DIRTY) IntGdiSelectPen(dc,pdcattr->hpen); - pbrushLine = PENOBJ_LockPen(pdcattr->hpen); + pbrushLine = PEN_LockPen(pdcattr->hpen); if (!pbrushLine) { /* Nothing to do, as we don't have a bitmap */ @@ -816,7 +816,7 @@ IntRoundRect( pbrushLine); pbrushLine->ptPenWidth.x = PenOrigWidth; - PENOBJ_UnlockPen(pbrushLine); + PEN_UnlockPen(pbrushLine); return ret; } diff --git a/reactos/subsystems/win32/win32k/objects/gdiobj.c b/reactos/subsystems/win32/win32k/objects/gdiobj.c index 55b6d1c039d..31786ccf884 100644 --- a/reactos/subsystems/win32/win32k/objects/gdiobj.c +++ b/reactos/subsystems/win32/win32k/objects/gdiobj.c @@ -1013,16 +1013,6 @@ GDIOBJ_ShareLockObj(HGDIOBJ hObj, DWORD ExpectedType) return Object; } - -VOID INTERNAL_CALL -GDIOBJ_ShareUnlockObjByPtr(POBJ Object) -{ - if (InterlockedDecrement((PLONG)&Object->ulShareCount) < 0) - { - DPRINT1("Trying to unlock non-existant object\n"); - } -} - BOOL INTERNAL_CALL GDIOBJ_OwnedByCurrentProcess(HGDIOBJ ObjectHandle) { diff --git a/reactos/subsystems/win32/win32k/objects/line.c b/reactos/subsystems/win32/win32k/objects/line.c index 48fff26a460..e70998d760c 100644 --- a/reactos/subsystems/win32/win32k/objects/line.c +++ b/reactos/subsystems/win32/win32k/objects/line.c @@ -144,11 +144,11 @@ IntGdiLineTo(DC *dc, Bounds.bottom = max(Points[0].y, Points[1].y); /* get BRUSH from current pen. */ - pbrushLine = PENOBJ_LockPen( pdcattr->hpen ); + pbrushLine = PEN_LockPen( pdcattr->hpen ); if (!pbrushLine) { /* default to BLACK_PEN */ - pbrushLine = PENOBJ_LockPen(NtGdiGetStockObject(BLACK_PEN)); + pbrushLine = PEN_LockPen(NtGdiGetStockObject(BLACK_PEN)); ASSERT(pbrushLine); } @@ -165,7 +165,7 @@ IntGdiLineTo(DC *dc, } SURFACE_UnlockSurface(psurf); - PENOBJ_UnlockPen( pbrushLine ); + PEN_UnlockPen( pbrushLine ); } if (Ret) @@ -268,7 +268,7 @@ IntGdiPolyline(DC *dc, IntGdiSelectPen(dc,pdcattr->hpen); /* Get BRUSHOBJ from current pen. */ - pbrushLine = PENOBJ_LockPen(pdcattr->hpen); + pbrushLine = PEN_LockPen(pdcattr->hpen); /* FIXME - pbrushLine can be NULL! Don't assert here! */ ASSERT(pbrushLine); @@ -309,7 +309,7 @@ IntGdiPolyline(DC *dc, } } - PENOBJ_UnlockPen(pbrushLine); + PEN_UnlockPen(pbrushLine); return Ret; } diff --git a/reactos/subsystems/win32/win32k/objects/pen.c b/reactos/subsystems/win32/win32k/objects/pen.c index 3ab9251d997..7a7f6ead5fe 100644 --- a/reactos/subsystems/win32/win32k/objects/pen.c +++ b/reactos/subsystems/win32/win32k/objects/pen.c @@ -29,7 +29,7 @@ PBRUSH FASTCALL -PENOBJ_LockPen(HGDIOBJ hBMObj) +PEN_LockPen(HGDIOBJ hBMObj) { if (GDI_HANDLE_GET_TYPE(hBMObj) == GDI_OBJECT_TYPE_EXTPEN) return GDIOBJ_LockObj( hBMObj, GDI_OBJECT_TYPE_EXTPEN); @@ -37,6 +37,16 @@ PENOBJ_LockPen(HGDIOBJ hBMObj) return GDIOBJ_LockObj( hBMObj, GDI_OBJECT_TYPE_PEN); } +PBRUSH +FASTCALL +PEN_ShareLockPen(HGDIOBJ hBMObj) +{ + if (GDI_HANDLE_GET_TYPE(hBMObj) == GDI_OBJECT_TYPE_EXTPEN) + return GDIOBJ_ShareLockObj( hBMObj, GDI_OBJECT_TYPE_EXTPEN); + else + return GDIOBJ_ShareLockObj( hBMObj, GDI_OBJECT_TYPE_PEN); +} + HPEN APIENTRY IntGdiExtCreatePen( DWORD dwPenStyle, @@ -68,11 +78,11 @@ IntGdiExtCreatePen( if (bOldStylePen) { - pbrushPen = PENOBJ_AllocPenWithHandle(); + pbrushPen = PEN_AllocPenWithHandle(); } else { - pbrushPen = PENOBJ_AllocExtPenWithHandle(); + pbrushPen = PEN_AllocExtPenWithHandle(); } if (!pbrushPen) @@ -173,17 +183,17 @@ IntGdiExtCreatePen( default: DPRINT1("IntGdiExtCreatePen unknown penstyle %x\n", dwPenStyle); } - PENOBJ_UnlockPen(pbrushPen); + PEN_UnlockPen(pbrushPen); return hPen; ExitCleanup: SetLastWin32Error(ERROR_INVALID_PARAMETER); pbrushPen->pStyle = NULL; - PENOBJ_UnlockPen(pbrushPen); + PEN_UnlockPen(pbrushPen); if (bOldStylePen) - PENOBJ_FreePenByHandle(hPen); + PEN_FreePenByHandle(hPen); else - PENOBJ_FreeExtPenByHandle(hPen); + PEN_FreeExtPenByHandle(hPen); return NULL; } @@ -192,14 +202,14 @@ IntGdiSetSolidPenColor(HPEN hPen, COLORREF Color) { PBRUSH pbrushPen; - pbrushPen = PENOBJ_LockPen(hPen); + pbrushPen = PEN_LockPen(hPen); if (pbrushPen) { if (pbrushPen->flAttrs & GDIBRUSH_IS_SOLID) { pbrushPen->BrushAttr.lbColor = Color & 0xFFFFFF; } - PENOBJ_UnlockPen(pbrushPen); + PEN_UnlockPen(pbrushPen); } } @@ -282,14 +292,14 @@ IntGdiSelectPen( pdcattr = pDC->pdcattr; - pbrushPen = PENOBJ_LockPen(hPen); + pbrushPen = PEN_LockPen(hPen); if (pbrushPen == NULL) { return NULL; } XlateObj = IntGdiCreateBrushXlate(pDC, pbrushPen, &bFailed); - PENOBJ_UnlockPen(pbrushPen); + PEN_UnlockPen(pbrushPen); if (bFailed) { SetLastWin32Error(ERROR_NO_SYSTEM_RESOURCES); diff --git a/reactos/subsystems/win32/win32k/objects/stockobj.c b/reactos/subsystems/win32/win32k/objects/stockobj.c index 4faab1ed7c4..9c9a606d166 100644 --- a/reactos/subsystems/win32/win32k/objects/stockobj.c +++ b/reactos/subsystems/win32/win32k/objects/stockobj.c @@ -118,7 +118,7 @@ IntCreateStockPen( DWORD dwPenStyle, ULONG ulColor) { HPEN hPen; - PBRUSH pbrushPen = PENOBJ_AllocPenWithHandle(); + PBRUSH pbrushPen = PEN_AllocPenWithHandle(); if ((dwPenStyle & PS_STYLE_MASK) == PS_NULL) dwWidth = 1; @@ -143,7 +143,7 @@ IntCreateStockPen( DWORD dwPenStyle, break; } hPen = pbrushPen->BaseObject.hHmgr; - PENOBJ_UnlockPen(pbrushPen); + PEN_UnlockPen(pbrushPen); return hPen; }