Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-05 06:33:01 +00:00
Code Issues Projects Releases Packages Wiki Activity

Brush rewrite part 1/x

Browse source 
- 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
This commit is contained in:
Timo Kreuzer 2009-03-23 00:38:59 +00:00
parent 7eafa4dee6
commit e2a450fc3f
16 changed files with 461 additions and 114 deletions
Download patch file Download diff file Expand all files Collapse all files

12
reactos/subsystems/win32/win32k/eng/bitblt.c
View file

@ -92,7 +92,7 @@ BltMask(SURFOBJ* Dest,
BYTE *tMask, *lMask; BYTE *tMask, *lMask;
static BYTE maskbit[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 }; static BYTE maskbit[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
/* Pattern brushes */ /* Pattern brushes */
PEBRUSHOBJ GdiBrush = NULL; PEBRUSHOBJ pebo = NULL;
SURFOBJ *psoPattern = NULL; SURFOBJ *psoPattern = NULL;
PSURFACE psurfPattern; PSURFACE psurfPattern;
ULONG PatternWidth = 0, PatternHeight = 0, PatternY = 0; ULONG PatternWidth = 0, PatternHeight = 0, PatternY = 0;
@ -107,12 +107,12 @@ BltMask(SURFOBJ* Dest,
if (pbo && pbo->iSolidColor == 0xFFFFFFFF) if (pbo && pbo->iSolidColor == 0xFFFFFFFF)
{ {
GdiBrush = CONTAINING_RECORD( pebo = CONTAINING_RECORD(
pbo, pbo,
EBRUSHOBJ, EBRUSHOBJ,
BrushObject); BrushObject);
psurfPattern = SURFACE_LockSurface(GdiBrush->GdiBrushObject->hbmPattern); psurfPattern = SURFACE_LockSurface(pebo->pbrush->hbmPattern);
if (psurfPattern != NULL) if (psurfPattern != NULL)
{ {
psoPattern = &psurfPattern->SurfObj; psoPattern = &psurfPattern->SurfObj;
@ -145,7 +145,7 @@ BltMask(SURFOBJ* Dest,
{ {
DibFunctionsForBitmapFormat[Dest->iBitmapFormat].DIB_PutPixel( DibFunctionsForBitmapFormat[Dest->iBitmapFormat].DIB_PutPixel(
Dest, DestRect->left + i, DestRect->top + j, 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++; c8++;
@ -220,7 +220,7 @@ CallDibBitBlt(SURFOBJ* OutputObj,
if (ROP4_USES_PATTERN(Rop4) && pbo && pbo->iSolidColor == 0xFFFFFFFF) if (ROP4_USES_PATTERN(Rop4) && pbo && pbo->iSolidColor == 0xFFFFFFFF)
{ {
GdiBrush = CONTAINING_RECORD(pbo, EBRUSHOBJ, BrushObject); GdiBrush = CONTAINING_RECORD(pbo, EBRUSHOBJ, BrushObject);
if ((psurfPattern = SURFACE_LockSurface(GdiBrush->GdiBrushObject->hbmPattern))) if ((psurfPattern = SURFACE_LockSurface(GdiBrush->pbrush->hbmPattern)))
{ {
BltInfo.PatternSurface = &psurfPattern->SurfObj; BltInfo.PatternSurface = &psurfPattern->SurfObj;
} }
@ -763,7 +763,7 @@ CallDibStretchBlt(SURFOBJ* psoDest,
if (ROP4_USES_PATTERN(Rop4) && pbo && pbo->iSolidColor == 0xFFFFFFFF) if (ROP4_USES_PATTERN(Rop4) && pbo && pbo->iSolidColor == 0xFFFFFFFF)
{ {
GdiBrush = CONTAINING_RECORD(pbo, EBRUSHOBJ, BrushObject); GdiBrush = CONTAINING_RECORD(pbo, EBRUSHOBJ, BrushObject);
psurfPattern = SURFACE_LockSurface(GdiBrush->GdiBrushObject->hbmPattern); psurfPattern = SURFACE_LockSurface(GdiBrush->pbrush->hbmPattern);
if (psurfPattern) if (psurfPattern)
{ {
PatternSurface = &psurfPattern->SurfObj; PatternSurface = &psurfPattern->SurfObj;

140
reactos/subsystems/win32/win32k/eng/engbrush.c
View file

@ -4,8 +4,7 @@
* PURPOSE: GDI Driver Brush Functions * PURPOSE: GDI Driver Brush Functions
* FILE: subsystem/win32/win32k/eng/engbrush.c * FILE: subsystem/win32/win32k/eng/engbrush.c
* PROGRAMER: Jason Filby * PROGRAMER: Jason Filby
* REVISION HISTORY: * Timo Kreuzer
* 3/7/1999: Created
*/ */
#include <w32k.h> #include <w32k.h>
@ -15,9 +14,29 @@
/** Internal functions ********************************************************/ /** 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) EBRUSHOBJ_vInit(EBRUSHOBJ *pebo, PBRUSH pbrush, XLATEOBJ *pxlo)
{ {
ULONG iSolidColor;
ASSERT(pebo); ASSERT(pebo);
ASSERT(pbrush); ASSERT(pbrush);
@ -27,20 +46,109 @@ EBRUSHOBJ_vInit(EBRUSHOBJ *pebo, PBRUSH pbrush, XLATEOBJ *pxlo)
} }
else if (pbrush->flAttrs & GDIBRUSH_IS_SOLID) 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 else
{ {
/* This is a pattern brush that needs realization */
pebo->BrushObject.iSolidColor = 0xFFFFFFFF; pebo->BrushObject.iSolidColor = 0xFFFFFFFF;
// FIXME: What about calling DrvRealizeBrush? // EBRUSHOBJ_bRealizeBrush(pebo);
} }
pebo->BrushObject.pvRbrush = pbrush->ulRealization; pebo->BrushObject.pvRbrush = pbrush->ulRealization;
pebo->BrushObject.flColorType = 0; pebo->BrushObject.flColorType = 0;
pebo->GdiBrushObject = pbrush; pebo->pbrush = pbrush;
pebo->XlateObject = pxlo; 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 ****************************************************/ /** Exported DDI functions ****************************************************/
@ -48,30 +156,34 @@ EBRUSHOBJ_vInit(EBRUSHOBJ *pebo, PBRUSH pbrush, XLATEOBJ *pxlo)
* @implemented * @implemented
*/ */
PVOID APIENTRY PVOID APIENTRY
BRUSHOBJ_pvAllocRbrush(IN BRUSHOBJ *BrushObj, BRUSHOBJ_pvAllocRbrush(
IN ULONG ObjSize) IN BRUSHOBJ *pbo,
IN ULONG cj)
{ {
BrushObj->pvRbrush=EngAllocMem(0, ObjSize, 0); pbo->pvRbrush = EngAllocMem(0, cj, 'rbdG');
return(BrushObj->pvRbrush); return pbo->pvRbrush;
} }
/* /*
* @implemented * @implemented
*/ */
PVOID APIENTRY PVOID APIENTRY
BRUSHOBJ_pvGetRbrush(IN BRUSHOBJ *BrushObj) BRUSHOBJ_pvGetRbrush(
IN BRUSHOBJ *pbo)
{ {
// FIXME: this is wrong! Read msdn. // FIXME: this is wrong! Read msdn.
return(BrushObj->pvRbrush); return pbo->pvRbrush;
} }
/* /*
* @implemented * @implemented
*/ */
ULONG APIENTRY 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 */ /* EOF */

4
reactos/subsystems/win32/win32k/eng/lineto.c
View file

@ -530,9 +530,9 @@ IntEngLineTo(SURFOBJ *psoDest,
EBRUSHOBJ, EBRUSHOBJ,
BrushObject); BrushObject);
ASSERT(GdiBrush); ASSERT(GdiBrush);
ASSERT(GdiBrush->GdiBrushObject); ASSERT(GdiBrush->pbrush);
if (GdiBrush->GdiBrushObject->flAttrs & GDIBRUSH_IS_NULL) if (GdiBrush->pbrush->flAttrs & GDIBRUSH_IS_NULL)
return TRUE; return TRUE;
/* No success yet */ /* No success yet */

48
reactos/subsystems/win32/win32k/eng/surface.c
View file

@ -506,27 +506,33 @@ EngCreateDeviceSurface(IN DHSURF dhsurf,
/* /*
* @implemented * @implemented
*/ */
BOOL APIENTRY BOOL
EngAssociateSurface(IN HSURF hsurf, APIENTRY
IN HDEV hdev, EngAssociateSurface(
IN ULONG Hooks) IN HSURF hsurf,
IN HDEV hdev,
IN FLONG flHooks)
{ {
SURFOBJ *pso; SURFOBJ *pso;
PSURFACE psurf; PSURFACE psurf;
PDEVOBJ* Device; PDEVOBJ* ppdev;
Device = (PDEVOBJ*)hdev; ppdev = (PDEVOBJ*)hdev;
/* Lock the surface */
psurf = SURFACE_LockSurface(hsurf); psurf = SURFACE_LockSurface(hsurf);
ASSERT(psurf); if (!psurf)
{
return FALSE;
}
pso = &psurf->SurfObj; pso = &psurf->SurfObj;
/* Associate the hdev */ /* Associate the hdev */
pso->hdev = hdev; pso->hdev = hdev;
pso->dhpdev = Device->hPDev; pso->dhpdev = ppdev->hPDev;
/* Hook up specified functions */ /* Hook up specified functions */
psurf->flHooks = Hooks; psurf->flHooks = flHooks;
SURFACE_UnlockSurface(psurf); SURFACE_UnlockSurface(psurf);
@ -548,25 +554,29 @@ EngModifySurface(
IN VOID *pvReserved) IN VOID *pvReserved)
{ {
SURFOBJ *pso; SURFOBJ *pso;
PSURFACE psurf;
PDEVOBJ* ppdev;
pso = EngLockSurface(hsurf); psurf = SURFACE_LockSurface(hsurf);
if (pso == NULL) if (psurf == NULL)
{ {
return FALSE; return FALSE;
} }
if (!EngAssociateSurface(hsurf, hdev, flHooks)) ppdev = (PDEVOBJ*)hdev;
{ pso = &psurf->SurfObj;
EngUnlockSurface(pso);
return FALSE;
}
pso->dhsurf = dhsurf; pso->dhsurf = dhsurf;
pso->lDelta = lDelta; pso->lDelta = lDelta;
pso->pvScan0 = pvScan0; 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; return TRUE;
} }

47
reactos/subsystems/win32/win32k/include/brush.h
View file

@ -15,7 +15,7 @@
* A MAILING LIST FIRST. * A MAILING LIST FIRST.
*/ */
typedef struct typedef struct _BRUSH
{ {
/* Header for all gdi objects in the handle table. /* Header for all gdi objects in the handle table.
Do not (re)move this. */ Do not (re)move this. */
@ -44,11 +44,33 @@ typedef struct
ULONG Unknown6C; ULONG Unknown6C;
} BRUSH, *PBRUSH; } BRUSH, *PBRUSH;
typedef struct typedef struct _EBRUSHOBJ
{ {
BRUSHOBJ BrushObject; BRUSHOBJ BrushObject;
PBRUSH GdiBrushObject;
XLATEOBJ *XlateObject; 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; } EBRUSHOBJ, *PEBRUSHOBJ;
/* GDI Brush Attributes */ /* GDI Brush Attributes */
@ -78,10 +100,25 @@ typedef struct
#define BRUSH_LockBrush(hBrush) ((PBRUSH)GDIOBJ_LockObj((HGDIOBJ)hBrush, GDI_OBJECT_TYPE_BRUSH)) #define BRUSH_LockBrush(hBrush) ((PBRUSH)GDIOBJ_LockObj((HGDIOBJ)hBrush, GDI_OBJECT_TYPE_BRUSH))
#define BRUSH_UnlockBrush(pBrush) GDIOBJ_UnlockObjByPtr((POBJ)pBrush) #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); INT FASTCALL BRUSH_GetObject (PBRUSH GdiObject, INT Count, LPLOGBRUSH Buffer);
BOOL INTERNAL_CALL BRUSH_Cleanup(PVOID ObjectBody); BOOL INTERNAL_CALL BRUSH_Cleanup(PVOID ObjectBody);
VOID FASTCALL VOID FASTCALL
EBRUSHOBJ_vInit(EBRUSHOBJ *BrushInst, PBRUSH BrushObj, XLATEOBJ *XlateObj); 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 #endif

8
reactos/subsystems/win32/win32k/include/dc.h
View file

@ -190,10 +190,10 @@ typedef struct _DC
PVOID prgnVis; PVOID prgnVis;
PVOID prgnRao; PVOID prgnRao;
POINTL ptlFillOrigin; POINTL ptlFillOrigin;
unsigned eboFill_[23]; /* EBRUSHOBJ */ EBRUSHOBJ eboFill;
unsigned eboLine_[23]; EBRUSHOBJ eboLine;
unsigned eboText_[23]; EBRUSHOBJ eboText;
unsigned eboBackground_[23]; EBRUSHOBJ eboBackground;
HFONT hlfntCur; HFONT hlfntCur;
FLONG flSimulationFlags; FLONG flSimulationFlags;
LONG lEscapement; LONG lEscapement;

20
reactos/subsystems/win32/win32k/include/gdiobj.h
View file

@ -61,7 +61,7 @@ BOOL INTERNAL_CALL GDIOBJ_OwnedByCurrentProcess(HGDIOBJ ObjectHandle);
BOOL INTERNAL_CALL GDIOBJ_SetOwnership(HGDIOBJ ObjectHandle, PEPROCESS Owner); BOOL INTERNAL_CALL GDIOBJ_SetOwnership(HGDIOBJ ObjectHandle, PEPROCESS Owner);
BOOL INTERNAL_CALL GDIOBJ_CopyOwnership(HGDIOBJ CopyFrom, HGDIOBJ CopyTo); BOOL INTERNAL_CALL GDIOBJ_CopyOwnership(HGDIOBJ CopyFrom, HGDIOBJ CopyTo);
BOOL INTERNAL_CALL GDIOBJ_ConvertToStockObj(HGDIOBJ *hObj); 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); BOOL INTERNAL_CALL GDIOBJ_ValidateHandle(HGDIOBJ hObj, ULONG ObjectType);
POBJ INTERNAL_CALL GDIOBJ_AllocObj(UCHAR ObjectType); POBJ INTERNAL_CALL GDIOBJ_AllocObj(UCHAR ObjectType);
POBJ INTERNAL_CALL GDIOBJ_AllocObjWithHandle(ULONG ObjectType); POBJ INTERNAL_CALL GDIOBJ_AllocObjWithHandle(ULONG ObjectType);
@ -99,4 +99,22 @@ GDIOBJ_UnlockObjByPtr(POBJ Object)
return cLocks; 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 #endif

28
reactos/subsystems/win32/win32k/include/pen.h
View file

@ -6,26 +6,30 @@
/* Internal interface */ /* Internal interface */
#define PENOBJ_AllocPen() ((HPEN)GDIOBJ_AllocObj(GDIObjType_BRUSH_TYPE)) #define PEN_AllocPen() ((HPEN)GDIOBJ_AllocObj(GDIObjType_BRUSH_TYPE))
#define PENOBJ_AllocPenWithHandle() ((PBRUSH)GDIOBJ_AllocObjWithHandle(GDI_OBJECT_TYPE_PEN)) #define PEN_AllocPenWithHandle() ((PBRUSH)GDIOBJ_AllocObjWithHandle(GDI_OBJECT_TYPE_PEN))
#define PENOBJ_FreePen(pBMObj) GDIOBJ_FreeObj((POBJ) pBMObj, GDIObjType_BRUSH_TYPE) #define PEN_FreePen(pBMObj) GDIOBJ_FreeObj((POBJ) pBMObj, GDIObjType_BRUSH_TYPE)
#define PENOBJ_FreePenByHandle(hBMObj) GDIOBJ_FreeObjByHandle((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_PEN) #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 PEN_AllocExtPen() ((PBRUSH)GDIOBJ_AllocObj(GDIObjType_BRUSH_TYPE))
#define PENOBJ_AllocExtPenWithHandle() ((PBRUSH)GDIOBJ_AllocObjWithHandle(GDI_OBJECT_TYPE_EXTPEN)) #define PEN_AllocExtPenWithHandle() ((PBRUSH)GDIOBJ_AllocObjWithHandle(GDI_OBJECT_TYPE_EXTPEN))
#define PENOBJ_FreeExtPen(pBMObj) GDIOBJ_FreeObj((POBJ) pBMObj, GDIObjType_BRUSH_TYPE) #define PEN_FreeExtPen(pBMObj) GDIOBJ_FreeObj((POBJ) pBMObj, GDIObjType_BRUSH_TYPE)
#define PENOBJ_FreeExtPenByHandle(hBMObj) GDIOBJ_FreeObjByHandle((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_EXTPEN) #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); INT APIENTRY PEN_GetObject(PBRUSH pPen, INT Count, PLOGPEN Buffer);
#endif #endif

15
reactos/subsystems/win32/win32k/objects/arc.c
View file

@ -45,7 +45,6 @@ IntArc( DC *dc,
PDC_ATTR pdcattr; PDC_ATTR pdcattr;
RECTL RectBounds, RectSEpts; RECTL RectBounds, RectSEpts;
PBRUSH pbrushPen; PBRUSH pbrushPen;
EBRUSHOBJ eboPen;
SURFACE *psurf; SURFACE *psurf;
BOOL ret = TRUE; BOOL ret = TRUE;
LONG PenWidth, PenOrigWidth; LONG PenWidth, PenOrigWidth;
@ -70,7 +69,7 @@ IntArc( DC *dc,
pdcattr = dc->pdcattr; pdcattr = dc->pdcattr;
pbrushPen = PENOBJ_LockPen(pdcattr->hpen); pbrushPen = PEN_LockPen(pdcattr->hpen);
if (!pbrushPen) if (!pbrushPen)
{ {
DPRINT1("Arc Fail 1\n"); DPRINT1("Arc Fail 1\n");
@ -161,24 +160,24 @@ IntArc( DC *dc,
if (NULL == psurf) if (NULL == psurf)
{ {
DPRINT1("Arc Fail 2\n"); DPRINT1("Arc Fail 2\n");
PENOBJ_UnlockPen(pbrushPen); PEN_UnlockPen(pbrushPen);
SetLastWin32Error(ERROR_INTERNAL_ERROR); SetLastWin32Error(ERROR_INTERNAL_ERROR);
return FALSE; return FALSE;
} }
EBRUSHOBJ_vInit(&eboPen, pbrushPen, dc->rosdc.XlatePen); EBRUSHOBJ_vInit(&dc->eboLine, pbrushPen, dc->rosdc.XlatePen);
if (arctype == GdiTypePie) if (arctype == GdiTypePie)
{ {
PUTLINE(CenterX, CenterY, SfCx + CenterX, SfCy + CenterY, eboPen); PUTLINE(CenterX, CenterY, SfCx + CenterX, SfCy + CenterY, dc->eboLine);
PUTLINE(EfCx + CenterX, EfCy + CenterY, CenterX, CenterY, eboPen); PUTLINE(EfCx + CenterX, EfCy + CenterY, CenterX, CenterY, dc->eboLine);
} }
if (arctype == GdiTypeChord) 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; pbrushPen->ptPenWidth.x = PenOrigWidth;
SURFACE_UnlockSurface(psurf); SURFACE_UnlockSurface(psurf);
PENOBJ_UnlockPen(pbrushPen); PEN_UnlockPen(pbrushPen);
DPRINT("IntArc Exit.\n"); DPRINT("IntArc Exit.\n");
return ret; return ret;
} }

13
reactos/subsystems/win32/win32k/objects/bitmaps.c
View file

@ -960,11 +960,15 @@ NtGdiSelectBitmap(
DC_UnlockDc(pDC); DC_UnlockDc(pDC);
return NULL; return NULL;
} }
hOrgBmp = pDC->rosdc.hBitmap; hOrgBmp = pDC->rosdc.hBitmap;
/* Release the old bitmap, lock the new one and convert it to a SURF */
pDC->rosdc.hBitmap = hBmp; 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. // If Info DC this is zero and pSurface is moved to DC->pSurfInfo.
pDC->dclevel.pSurface = psurfBmp; pDC->dclevel.pSurface = psurfBmp;
psurfBmp->hDC = hDC; psurfBmp->hDC = hDC;
@ -985,6 +989,9 @@ NtGdiSelectBitmap(
0, 0,
psurfBmp->SurfObj.sizlBitmap.cx, psurfBmp->SurfObj.sizlBitmap.cx,
psurfBmp->SurfObj.sizlBitmap.cy); psurfBmp->SurfObj.sizlBitmap.cy);
/* Keep a shared reference on the bitmap */
GDIOBJ_IncrementShareCount((POBJ)psurfBmp);
SURFACE_UnlockSurface(psurfBmp); SURFACE_UnlockSurface(psurfBmp);
/* Regenerate the XLATEOBJs. */ /* Regenerate the XLATEOBJs. */
@ -999,7 +1006,7 @@ NtGdiSelectBitmap(
BRUSH_UnlockBrush(pbrush); BRUSH_UnlockBrush(pbrush);
} }
pbrush = PENOBJ_LockPen(pdcattr->hpen); pbrush = PEN_LockPen(pdcattr->hpen);
if (pbrush) if (pbrush)
{ {
if (pDC->rosdc.XlatePen) if (pDC->rosdc.XlatePen)
@ -1007,7 +1014,7 @@ NtGdiSelectBitmap(
EngDeleteXlate(pDC->rosdc.XlatePen); EngDeleteXlate(pDC->rosdc.XlatePen);
} }
pDC->rosdc.XlatePen = IntGdiCreateBrushXlate(pDC, pbrush, &bFailed); pDC->rosdc.XlatePen = IntGdiCreateBrushXlate(pDC, pbrush, &bFailed);
PENOBJ_UnlockPen(pbrush); PEN_UnlockPen(pbrush);
} }
DC_UnlockDc(pDC); DC_UnlockDc(pDC);

168
reactos/subsystems/win32/win32k/objects/dc.c
View file

@ -2422,8 +2422,6 @@ DC_AllocDC(PUNICODE_STRING Driver)
} }
pdcattr = NewDC->pdcattr; pdcattr = NewDC->pdcattr;
NewDC->BaseObject.hHmgr = (HGDIOBJ) hDC; // Save the handle for this DC object.
xformTemplate.eM11 = 1.0f; xformTemplate.eM11 = 1.0f;
xformTemplate.eM12 = 0.0f; xformTemplate.eM12 = 0.0f;
xformTemplate.eM21 = 0.0f; xformTemplate.eM21 = 0.0f;
@ -2461,9 +2459,18 @@ DC_AllocDC(PUNICODE_STRING Driver)
pdcattr->crBrushClr = RGB( 255, 255, 255 ); pdcattr->crBrushClr = RGB( 255, 255, 255 );
//// This fixes the default brush and pen settings. See DC_InitDC. //// This fixes the default brush and pen settings. See DC_InitDC.
/* Create the default fill brush */
pdcattr->hbrush = NtGdiGetStockObject( WHITE_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 ); 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); pdcattr->hlfntNew = NtGdiGetStockObject(SYSTEM_FONT);
TextIntRealizeFont(pdcattr->hlfntNew,NULL); TextIntRealizeFont(pdcattr->hlfntNew,NULL);
@ -2743,7 +2750,7 @@ IntIsPrimarySurface(SURFOBJ *SurfObj)
{ {
return FALSE; return FALSE;
} }
return SurfObj->hsurf == PrimarySurface.pSurface; return SurfObj->hsurf == PrimarySurface.pSurface; // <- FIXME: WTF?
} }
// //
@ -3466,4 +3473,157 @@ NtGdiMakeInfoDC(
return FALSE; 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 */ /* EOF */

16
reactos/subsystems/win32/win32k/objects/fillshap.c
View file

@ -96,7 +96,7 @@ IntGdiPolygon(PDC dc,
/* Special locking order to avoid lock-ups */ /* Special locking order to avoid lock-ups */
pbrushFill = BRUSH_LockBrush(pdcattr->hbrush); pbrushFill = BRUSH_LockBrush(pdcattr->hbrush);
pbrushLine = PENOBJ_LockPen(pdcattr->hpen); pbrushLine = PEN_LockPen(pdcattr->hpen);
psurf = SURFACE_LockSurface(dc->rosdc.hBitmap); psurf = SURFACE_LockSurface(dc->rosdc.hBitmap);
/* FIXME - psurf can be NULL!!!! don't assert but handle this case gracefully! */ /* FIXME - psurf can be NULL!!!! don't assert but handle this case gracefully! */
ASSERT(psurf); ASSERT(psurf);
@ -154,7 +154,7 @@ IntGdiPolygon(PDC dc,
} }
} }
if (pbrushLine) if (pbrushLine)
PENOBJ_UnlockPen(pbrushLine); PEN_UnlockPen(pbrushLine);
} }
SURFACE_UnlockSurface(psurf); SURFACE_UnlockSurface(psurf);
@ -252,7 +252,7 @@ NtGdiEllipse(
if (pdcattr->ulDirty_ & DC_PEN_DIRTY) if (pdcattr->ulDirty_ & DC_PEN_DIRTY)
IntGdiSelectPen(dc,pdcattr->hpen); IntGdiSelectPen(dc,pdcattr->hpen);
pbrush = PENOBJ_LockPen(pdcattr->hpen); pbrush = PEN_LockPen(pdcattr->hpen);
if (!pbrush) if (!pbrush)
{ {
DPRINT1("Ellipse Fail 1\n"); DPRINT1("Ellipse Fail 1\n");
@ -333,7 +333,7 @@ NtGdiEllipse(
pbrush); pbrush);
pbrush->ptPenWidth.x = PenOrigWidth; pbrush->ptPenWidth.x = PenOrigWidth;
PENOBJ_UnlockPen(pbrush); PEN_UnlockPen(pbrush);
DC_UnlockDc(dc); DC_UnlockDc(dc);
DPRINT("Ellipse Exit.\n"); DPRINT("Ellipse Exit.\n");
return ret; return ret;
@ -580,7 +580,7 @@ IntRectangle(PDC dc,
/* Special locking order to avoid lock-ups! */ /* Special locking order to avoid lock-ups! */
pbrushFill = BRUSH_LockBrush(pdcattr->hbrush); pbrushFill = BRUSH_LockBrush(pdcattr->hbrush);
pbrushLine = PENOBJ_LockPen(pdcattr->hpen); pbrushLine = PEN_LockPen(pdcattr->hpen);
if (!pbrushLine) if (!pbrushLine)
{ {
ret = FALSE; ret = FALSE;
@ -658,7 +658,7 @@ cleanup:
BRUSH_UnlockBrush(pbrushFill); BRUSH_UnlockBrush(pbrushFill);
if (pbrushLine) if (pbrushLine)
PENOBJ_UnlockPen(pbrushLine); PEN_UnlockPen(pbrushLine);
if (psurf) if (psurf)
SURFACE_UnlockSurface(psurf); SURFACE_UnlockSurface(psurf);
@ -746,7 +746,7 @@ IntRoundRect(
if (pdcattr->ulDirty_ & DC_PEN_DIRTY) if (pdcattr->ulDirty_ & DC_PEN_DIRTY)
IntGdiSelectPen(dc,pdcattr->hpen); IntGdiSelectPen(dc,pdcattr->hpen);
pbrushLine = PENOBJ_LockPen(pdcattr->hpen); pbrushLine = PEN_LockPen(pdcattr->hpen);
if (!pbrushLine) if (!pbrushLine)
{ {
/* Nothing to do, as we don't have a bitmap */ /* Nothing to do, as we don't have a bitmap */
@ -816,7 +816,7 @@ IntRoundRect(
pbrushLine); pbrushLine);
pbrushLine->ptPenWidth.x = PenOrigWidth; pbrushLine->ptPenWidth.x = PenOrigWidth;
PENOBJ_UnlockPen(pbrushLine); PEN_UnlockPen(pbrushLine);
return ret; return ret;
} }

10
reactos/subsystems/win32/win32k/objects/gdiobj.c
View file

@ -1013,16 +1013,6 @@ GDIOBJ_ShareLockObj(HGDIOBJ hObj, DWORD ExpectedType)
return Object; 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 BOOL INTERNAL_CALL
GDIOBJ_OwnedByCurrentProcess(HGDIOBJ ObjectHandle) GDIOBJ_OwnedByCurrentProcess(HGDIOBJ ObjectHandle)
{ {

10
reactos/subsystems/win32/win32k/objects/line.c
View file

@ -144,11 +144,11 @@ IntGdiLineTo(DC *dc,
Bounds.bottom = max(Points[0].y, Points[1].y); Bounds.bottom = max(Points[0].y, Points[1].y);
/* get BRUSH from current pen. */ /* get BRUSH from current pen. */
pbrushLine = PENOBJ_LockPen( pdcattr->hpen ); pbrushLine = PEN_LockPen( pdcattr->hpen );
if (!pbrushLine) if (!pbrushLine)
{ {
/* default to BLACK_PEN */ /* default to BLACK_PEN */
pbrushLine = PENOBJ_LockPen(NtGdiGetStockObject(BLACK_PEN)); pbrushLine = PEN_LockPen(NtGdiGetStockObject(BLACK_PEN));
ASSERT(pbrushLine); ASSERT(pbrushLine);
} }
@ -165,7 +165,7 @@ IntGdiLineTo(DC *dc,
} }
SURFACE_UnlockSurface(psurf); SURFACE_UnlockSurface(psurf);
PENOBJ_UnlockPen( pbrushLine ); PEN_UnlockPen( pbrushLine );
} }
if (Ret) if (Ret)
@ -268,7 +268,7 @@ IntGdiPolyline(DC *dc,
IntGdiSelectPen(dc,pdcattr->hpen); IntGdiSelectPen(dc,pdcattr->hpen);
/* Get BRUSHOBJ from current pen. */ /* Get BRUSHOBJ from current pen. */
pbrushLine = PENOBJ_LockPen(pdcattr->hpen); pbrushLine = PEN_LockPen(pdcattr->hpen);
/* FIXME - pbrushLine can be NULL! Don't assert here! */ /* FIXME - pbrushLine can be NULL! Don't assert here! */
ASSERT(pbrushLine); ASSERT(pbrushLine);
@ -309,7 +309,7 @@ IntGdiPolyline(DC *dc,
} }
} }
PENOBJ_UnlockPen(pbrushLine); PEN_UnlockPen(pbrushLine);
return Ret; return Ret;
} }

32
reactos/subsystems/win32/win32k/objects/pen.c
View file

@ -29,7 +29,7 @@
PBRUSH PBRUSH
FASTCALL FASTCALL
PENOBJ_LockPen(HGDIOBJ hBMObj) PEN_LockPen(HGDIOBJ hBMObj)
{ {
if (GDI_HANDLE_GET_TYPE(hBMObj) == GDI_OBJECT_TYPE_EXTPEN) if (GDI_HANDLE_GET_TYPE(hBMObj) == GDI_OBJECT_TYPE_EXTPEN)
return GDIOBJ_LockObj( 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); 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 HPEN APIENTRY
IntGdiExtCreatePen( IntGdiExtCreatePen(
DWORD dwPenStyle, DWORD dwPenStyle,
@ -68,11 +78,11 @@ IntGdiExtCreatePen(
if (bOldStylePen) if (bOldStylePen)
{ {
pbrushPen = PENOBJ_AllocPenWithHandle(); pbrushPen = PEN_AllocPenWithHandle();
} }
else else
{ {
pbrushPen = PENOBJ_AllocExtPenWithHandle(); pbrushPen = PEN_AllocExtPenWithHandle();
} }
if (!pbrushPen) if (!pbrushPen)
@ -173,17 +183,17 @@ IntGdiExtCreatePen(
default: default:
DPRINT1("IntGdiExtCreatePen unknown penstyle %x\n", dwPenStyle); DPRINT1("IntGdiExtCreatePen unknown penstyle %x\n", dwPenStyle);
} }
PENOBJ_UnlockPen(pbrushPen); PEN_UnlockPen(pbrushPen);
return hPen; return hPen;
ExitCleanup: ExitCleanup:
SetLastWin32Error(ERROR_INVALID_PARAMETER); SetLastWin32Error(ERROR_INVALID_PARAMETER);
pbrushPen->pStyle = NULL; pbrushPen->pStyle = NULL;
PENOBJ_UnlockPen(pbrushPen); PEN_UnlockPen(pbrushPen);
if (bOldStylePen) if (bOldStylePen)
PENOBJ_FreePenByHandle(hPen); PEN_FreePenByHandle(hPen);
else else
PENOBJ_FreeExtPenByHandle(hPen); PEN_FreeExtPenByHandle(hPen);
return NULL; return NULL;
} }
@ -192,14 +202,14 @@ IntGdiSetSolidPenColor(HPEN hPen, COLORREF Color)
{ {
PBRUSH pbrushPen; PBRUSH pbrushPen;
pbrushPen = PENOBJ_LockPen(hPen); pbrushPen = PEN_LockPen(hPen);
if (pbrushPen) if (pbrushPen)
{ {
if (pbrushPen->flAttrs & GDIBRUSH_IS_SOLID) if (pbrushPen->flAttrs & GDIBRUSH_IS_SOLID)
{ {
pbrushPen->BrushAttr.lbColor = Color & 0xFFFFFF; pbrushPen->BrushAttr.lbColor = Color & 0xFFFFFF;
} }
PENOBJ_UnlockPen(pbrushPen); PEN_UnlockPen(pbrushPen);
} }
} }
@ -282,14 +292,14 @@ IntGdiSelectPen(
pdcattr = pDC->pdcattr; pdcattr = pDC->pdcattr;
pbrushPen = PENOBJ_LockPen(hPen); pbrushPen = PEN_LockPen(hPen);
if (pbrushPen == NULL) if (pbrushPen == NULL)
{ {
return NULL; return NULL;
} }
XlateObj = IntGdiCreateBrushXlate(pDC, pbrushPen, &bFailed); XlateObj = IntGdiCreateBrushXlate(pDC, pbrushPen, &bFailed);
PENOBJ_UnlockPen(pbrushPen); PEN_UnlockPen(pbrushPen);
if (bFailed) if (bFailed)
{ {
SetLastWin32Error(ERROR_NO_SYSTEM_RESOURCES); SetLastWin32Error(ERROR_NO_SYSTEM_RESOURCES);

4
reactos/subsystems/win32/win32k/objects/stockobj.c
View file

@ -118,7 +118,7 @@ IntCreateStockPen( DWORD dwPenStyle,
ULONG ulColor) ULONG ulColor)
{ {
HPEN hPen; HPEN hPen;
PBRUSH pbrushPen = PENOBJ_AllocPenWithHandle(); PBRUSH pbrushPen = PEN_AllocPenWithHandle();
if ((dwPenStyle & PS_STYLE_MASK) == PS_NULL) dwWidth = 1; if ((dwPenStyle & PS_STYLE_MASK) == PS_NULL) dwWidth = 1;
@ -143,7 +143,7 @@ IntCreateStockPen( DWORD dwPenStyle,
break; break;
} }
hPen = pbrushPen->BaseObject.hHmgr; hPen = pbrushPen->BaseObject.hHmgr;
PENOBJ_UnlockPen(pbrushPen); PEN_UnlockPen(pbrushPen);
return hPen; return hPen;
} }