- Fix a few invalid lock cases.
- Add support for shared GDI object locks and use it for locking surfaces.
svn path=/trunk/; revision=15830
((HBITMAP) GDIOBJ_AllocObj (GDI_OBJECT_TYPE_BITMAP))
#define BITMAPOBJ_FreeBitmap(hBMObj) \
GDIOBJ_FreeObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_BITMAP)
-#define BITMAPOBJ_LockBitmap(hBMObj) GDIOBJ_LockObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_BITMAP)
-#define BITMAPOBJ_UnlockBitmap(hBMObj) GDIOBJ_UnlockObj((HGDIOBJ) hBMObj)
+/* NOTE: Use shared locks! */
+#define BITMAPOBJ_LockBitmap(hBMObj) (PBITMAPOBJ)EngLockSurface((HSURF)hBMObj)
+#define BITMAPOBJ_UnlockBitmap(pBMObj) EngUnlockSurface(&pBMObj->SurfObj)
BOOL INTERNAL_CALL BITMAP_Cleanup(PVOID ObjectBody);
INT FASTCALL BITMAPOBJ_GetWidthBytes (INT bmWidth, INT bpp);
#define BRUSHOBJ_AllocBrush() ((HBRUSH) GDIOBJ_AllocObj (GDI_OBJECT_TYPE_BRUSH))
#define BRUSHOBJ_FreeBrush(hBrush) GDIOBJ_FreeObj((HGDIOBJ)hBrush, GDI_OBJECT_TYPE_BRUSH)
#define BRUSHOBJ_LockBrush(hBrush) ((PGDIBRUSHOBJ)GDIOBJ_LockObj((HGDIOBJ)hBrush, GDI_OBJECT_TYPE_BRUSH))
-#define BRUSHOBJ_UnlockBrush(hBrush) GDIOBJ_UnlockObj((HGDIOBJ)hBrush)
+#define BRUSHOBJ_UnlockBrush(pBrush) GDIOBJ_UnlockObjByPtr(pBrush)
BOOL INTERNAL_CALL BRUSH_Cleanup(PVOID ObjectBody);
#ifdef __USE_W32API
#define DC_LockDc(hDC) \
((PDC) GDIOBJ_LockObj ((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC))
-#define DC_UnlockDc(hDC) \
- GDIOBJ_UnlockObj ((HGDIOBJ) hDC)
+#define DC_UnlockDc(pDC) \
+ GDIOBJ_UnlockObjByPtr (pDC)
HDC FASTCALL RetrieveDisplayHDC(VOID);
HDC FASTCALL DC_AllocDC(PUNICODE_STRING Driver);
void INTERNAL_CALL GDIOBJ_SetOwnership(HGDIOBJ ObjectHandle, PEPROCESS Owner);
void INTERNAL_CALL GDIOBJ_CopyOwnership(HGDIOBJ CopyFrom, HGDIOBJ CopyTo);
BOOL INTERNAL_CALL GDIOBJ_ConvertToStockObj(HGDIOBJ *hObj);
+VOID INTERNAL_CALL GDIOBJ_UnlockObjByPtr(PGDIOBJ Object);
#define GDIOBJ_GetObjectType(Handle) \
GDI_HANDLE_GET_TYPE(Handle)
#define GDIOBJ_AllocObj(ty) GDIOBJ_AllocObjDbg(__FILE__,__LINE__,ty)
#define GDIOBJ_FreeObj(obj,ty) GDIOBJ_FreeObjDbg(__FILE__,__LINE__,obj,ty)
#define GDIOBJ_LockObj(obj,ty) GDIOBJ_LockObjDbg(__FILE__,__LINE__,obj,ty)
-#define GDIOBJ_UnlockObj(obj) GDIOBJ_UnlockObjDbg(__FILE__,__LINE__,obj)
+#define GDIOBJ_ShareLockObj(obj,ty) GDIOBJ_ShareLockObjDbg(__FILE__,__LINE__,obj,ty)
HGDIOBJ INTERNAL_CALL GDIOBJ_AllocObjDbg(const char* file, int line, ULONG ObjectType);
BOOL INTERNAL_CALL GDIOBJ_FreeObjDbg (const char* file, int line, HGDIOBJ hObj, DWORD ObjectType);
PGDIOBJ INTERNAL_CALL GDIOBJ_LockObjDbg (const char* file, int line, HGDIOBJ hObj, DWORD ObjectType);
-BOOL INTERNAL_CALL GDIOBJ_UnlockObjDbg (const char* file, int line, HGDIOBJ hObj);
+PGDIOBJ INTERNAL_CALL GDIOBJ_ShareLockObjDbg (const char* file, int line, HGDIOBJ hObj, DWORD ObjectType);
#else /* !GDI_DEBUG */
HGDIOBJ INTERNAL_CALL GDIOBJ_AllocObj(ULONG ObjectType);
BOOL INTERNAL_CALL GDIOBJ_FreeObj (HGDIOBJ hObj, DWORD ObjectType);
-PGDIOBJ INTERNAL_CALL GDIOBJ_LockObj (HGDIOBJ hObj, DWORD ObjectType);
-BOOL INTERNAL_CALL GDIOBJ_UnlockObj (HGDIOBJ hObj);
+PGDIOBJ INTERNAL_CALL GDIOBJ_ShareLockObj (HGDIOBJ hObj, DWORD ObjectType);
#endif /* GDI_DEBUG */
#define PENOBJ_AllocPen() ((HPEN)GDIOBJ_AllocObj(GDI_OBJECT_TYPE_PEN))
#define PENOBJ_FreePen(hBMObj) GDIOBJ_FreeObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_PEN)
#define PENOBJ_LockPen(hBMObj) ((PGDIBRUSHOBJ)GDIOBJ_LockObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_PEN))
-#define PENOBJ_UnlockPen(hBMObj) GDIOBJ_UnlockObj((HGDIOBJ) hBMObj)
+#define PENOBJ_UnlockPen(pPenObj) GDIOBJ_UnlockObjByPtr(pPenObj)
HPEN STDCALL
NtGdiCreatePen(
#define RGNDATA_FreeRgn(hRgn) GDIOBJ_FreeObj((HGDIOBJ)hRgn, GDI_OBJECT_TYPE_REGION)
#define RGNDATA_LockRgn(hRgn) ((PROSRGNDATA)GDIOBJ_LockObj((HGDIOBJ)hRgn, GDI_OBJECT_TYPE_REGION))
-#define RGNDATA_UnlockRgn(hRgn) GDIOBJ_UnlockObj((HGDIOBJ)hRgn)
+#define RGNDATA_UnlockRgn(pRgn) GDIOBJ_UnlockObjByPtr(pRgn)
HRGN FASTCALL RGNDATA_AllocRgn(INT n);
BOOL INTERNAL_CALL RGNDATA_Cleanup(PVOID ObjectBody);
((HFONT) GDIOBJ_AllocObj (GDI_OBJECT_TYPE_FONT))
#define TEXTOBJ_FreeText(hBMObj) GDIOBJ_FreeObj((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_FONT)
#define TEXTOBJ_LockText(hBMObj) ((PTEXTOBJ) GDIOBJ_LockObj ((HGDIOBJ) hBMObj, GDI_OBJECT_TYPE_FONT))
-#define TEXTOBJ_UnlockText(hBMObj) GDIOBJ_UnlockObj ((HGDIOBJ) hBMObj)
+#define TEXTOBJ_UnlockText(pBMObj) GDIOBJ_UnlockObjByPtr (pBMObj)
NTSTATUS FASTCALL TextIntRealizeFont(HFONT FontHandle);
NTSTATUS FASTCALL TextIntCreateFontIndirect(CONST LPLOGFONTW lf, HFONT *NewFont);
static BYTE maskbit[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
/* Pattern brushes */
PGDIBRUSHINST GdiBrush = NULL;
- HBITMAP PatternSurface = NULL;
SURFOBJ *PatternObj = NULL;
PBITMAPOBJ PatternBitmap;
ULONG PatternWidth = 0, PatternHeight = 0, PatternY = 0;
GDIBRUSHINST,
BrushObject);
- PatternSurface = GdiBrush->GdiBrushObject->hbmPattern;
PatternBitmap = BITMAPOBJ_LockBitmap(GdiBrush->GdiBrushObject->hbmPattern);
if(PatternBitmap != NULL)
{
}
if (PatternBitmap != NULL)
- BITMAPOBJ_UnlockBitmap(PatternSurface);
+ BITMAPOBJ_UnlockBitmap(PatternBitmap);
return TRUE;
}
/* Pattern brush */
if (bmPattern != NULL)
{
- BITMAPOBJ_UnlockBitmap(BltInfo.PatternSurface->hsurf);
+ BITMAPOBJ_UnlockBitmap(bmPattern);
}
return Result;
{
EngDeleteClip(EnterLeave->TrivialClipObj);
EngFreeMem((*OutputObj)->pvBits);
+ EngUnlockSurface(*OutputObj);
EngDeleteSurface((HSURF)EnterLeave->OutputBitmap);
return FALSE;
}
}
if (SurfObj->pvBits == NULL)
{
- BITMAPOBJ_UnlockBitmap(NewBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
BITMAPOBJ_FreeBitmap(NewBitmap);
return 0;
}
BitmapObj->dimension.cy = 0;
BitmapObj->dib = NULL;
- BITMAPOBJ_UnlockBitmap(NewBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
return NewBitmap;
}
BitmapObj->flHooks = 0;
- BITMAPOBJ_UnlockBitmap(NewSurface);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
return NewSurface;
}
/* Hook up specified functions */
BitmapObj->flHooks = Hooks;
- BITMAPOBJ_UnlockBitmap(Surface);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
return TRUE;
}
return FillSolid(Surface, Rect, iColor);
}
+#define GDIBdyToHdr(body) \
+ ((PGDIOBJHDR)(body) - 1)
+
/*
* @implemented
*/
SURFOBJ * STDCALL
EngLockSurface(IN HSURF Surface)
{
- BITMAPOBJ *bmp = (BITMAPOBJ*)BITMAPOBJ_LockBitmap(Surface);
- if(bmp != NULL)
- {
- return &bmp->SurfObj;
- }
+ BITMAPOBJ *bmp = GDIOBJ_ShareLockObj(Surface, GDI_OBJECT_TYPE_BITMAP);
- return NULL;
+ if (bmp != NULL)
+ return &bmp->SurfObj;
+
+ return NULL;
}
/*
VOID STDCALL
EngUnlockSurface(IN SURFOBJ *Surface)
{
- ASSERT (Surface);
- BITMAPOBJ_UnlockBitmap (Surface->hsurf);
+ if (Surface != NULL)
+ GDIOBJ_UnlockObjByPtr(Surface);
}
/* EOF */
}\r
}\r
}\r
- RGNDATA_UnlockRgn(hVisRgn);\r
+ RGNDATA_UnlockRgn(visRgn);\r
}\r
else\r
{\r
end:
if (PaletteSource != NULL)
- PALETTE_UnlockPalette(PaletteSource);
+ PALETTE_UnlockPalette(SourcePalGDI);
if (PaletteDest != NULL && PaletteDest != PaletteSource)
- PALETTE_UnlockPalette(PaletteDest);
+ PALETTE_UnlockPalette(DestPalGDI);
return XlateObj;
}
break;
}
- PALETTE_UnlockPalette(PaletteSource);
+ PALETTE_UnlockPalette(SourcePalGDI);
return XlateObj;
}
XlateGDI = EngAllocMem(0, sizeof(XLATEGDI), TAG_XLATEOBJ);
if (XlateGDI == NULL)
{
- PALETTE_UnlockPalette(PaletteDest);
+ PALETTE_UnlockPalette(DestPalGDI);
DPRINT1("Failed to allocate memory for a XLATE structure!\n");
return NULL;
}
XlateGDI->translationTable = EngAllocMem(0, sizeof(ULONG) * 2, 0);
if (XlateGDI->translationTable == NULL)
{
- PALETTE_UnlockPalette(PaletteDest);
+ PALETTE_UnlockPalette(DestPalGDI);
EngFreeMem(XlateGDI);
return NULL;
}
DestPalGDI->NumColors);
}
- PALETTE_UnlockPalette(PaletteDest);
+ PALETTE_UnlockPalette(DestPalGDI);
return XlateObj;
}
{
/* Return closest match for the given color. */
Closest = ClosestColorMatch(XlateGDI, (LPPALETTEENTRY)&Color, PalGDI->IndexedColors, PalGDI->NumColors);
- PALETTE_UnlockPalette(XlateGDI->DestPal);
+ PALETTE_UnlockPalette(PalGDI);
return Closest;
}
}
*OutPal = *InPal;
}
- PALETTE_UnlockPalette(hPalette);
+ PALETTE_UnlockPalette(PalGDI);
return cPal;
}
((HDCE) GDIOBJ_AllocObj (GDI_OBJECT_TYPE_DCE))
#define DCEOBJ_FreeDCE(hDCE) GDIOBJ_FreeObj((HGDIOBJ)hDCE, GDI_OBJECT_TYPE_DCE)
#define DCEOBJ_LockDCE(hDCE) ((PDCE)GDIOBJ_LockObj((HGDIOBJ)hDCE, GDI_OBJECT_TYPE_DCE))
-#define DCEOBJ_UnlockDCE(hDCE) GDIOBJ_UnlockObj((HGDIOBJ)hDCE)
+#define DCEOBJ_UnlockDCE(pDCE) GDIOBJ_UnlockObjByPtr(pDCE)
BOOL INTERNAL_CALL DCE_Cleanup(PVOID ObjectBody);
PDCE FASTCALL DceAllocDCE(HWND hWnd, DCE_TYPE Type);
CONST RGBQUAD *Colors);
#define PALETTE_FreePalette(hPalette) GDIOBJ_FreeObj((HGDIOBJ)hPalette, GDI_OBJECT_TYPE_PALETTE)
#define PALETTE_LockPalette(hPalette) ((PPALGDI)GDIOBJ_LockObj((HGDIOBJ)hPalette, GDI_OBJECT_TYPE_PALETTE))
-#define PALETTE_UnlockPalette(hPalette) GDIOBJ_UnlockObj((HGDIOBJ)hPalette)
+#define PALETTE_UnlockPalette(pPalette) GDIOBJ_UnlockObjByPtr(pPalette)
BOOL INTERNAL_CALL PALETTE_Cleanup(PVOID ObjectBody);
HPALETTE FASTCALL PALETTE_Init (VOID);
if (!pDC->DriverFunctions.EnableDirectDraw)
{
// Driver doesn't support DirectDraw
- DC_UnlockDc(hdc);
+ DC_UnlockDc(pDC);
return NULL;
}
if (!success)
{
// DirectDraw creation failed
- DC_UnlockDc(hdc);
+ DC_UnlockDc(pDC);
return NULL;
}
if (palette_callbacks.dwFlags & DDHAL_PALCB32_SETENTRIES)
pDirectDraw->DdSetEntries = palette_callbacks.SetEntries;
- GDIOBJ_UnlockObj(hDirectDraw);
- DC_UnlockDc(hdc);
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+ DC_UnlockDc(pDC);
return hDirectDraw;
}
if (!success)
{
- GDIOBJ_UnlockObj(hDirectDrawLocal);
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
return FALSE;
}
}
- GDIOBJ_UnlockObj(hDirectDrawLocal);
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
return TRUE;
}
// FIXME: figure out how to use this
pSurface->bComplete = bComplete;
- GDIOBJ_UnlockObj(hSurface);
- GDIOBJ_UnlockObj(hDirectDrawLocal);
+ GDIOBJ_UnlockObjByPtr(pSurface);
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
return hSurface;
}
PDD_SURFACE pSurfaceTo = GDIOBJ_LockObj(hSurfaceTo, GDI_OBJECT_TYPE_DD_SURFACE);
if (!pSurfaceTo)
{
- GDIOBJ_UnlockObj(hSurfaceFrom);
+ GDIOBJ_UnlockObjByPtr(pSurfaceFrom);
return FALSE;
}
pSurfaceFrom->Local.lpAttachListFrom = pSurfaceFrom->AttachListFrom;
}
- GDIOBJ_UnlockObj(hSurfaceFrom);
- GDIOBJ_UnlockObj(hSurfaceTo);
+ GDIOBJ_UnlockObjByPtr(pSurfaceFrom);
+ GDIOBJ_UnlockObjByPtr(pSurfaceTo);
return TRUE;
}
*/
pDirectDraw->Global.dhpdev,(PDD_HALINFO) puGetDriverInfoData,
&pdwNumHeaps, pvmList, &pdwNumFourCC, pdwFourCC);
- GDIOBJ_UnlockObj(hDirectDrawLocal);
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
return ddRVal;
}
ddRVal = pDirectDraw->DdWaitForVerticalBlank(puWaitForVerticalBlankData);
- GDIOBJ_UnlockObj(hDirectDrawLocal);
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
return ddRVal;
}
ddRVal = pDirectDraw->DdCanCreateSurface(puCanCreateSurfaceData);
- GDIOBJ_UnlockObj(hDirectDrawLocal);
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
return ddRVal;
}
ddRVal = pDirectDraw->DdBlt(puBltData);
- GDIOBJ_UnlockObj(hSurfaceDest);
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
return ddRVal;
}
{
HDC hDC;
PDC dc;
- HBITMAP hBitmap;
- BITMAPOBJ *BitmapObj;
- SURFOBJ *SurfObj;
+ GDIDEVICE *GDIDevice;
#if 1
/* FIXME - get the screen dc from the window station or desktop */
if (!(dc = DC_LockDc(hDC)))
return FALSE;
+ GDIDevice = (GDIDEVICE *)dc->GDIDevice;
+ DC_UnlockDc(dc);
- hBitmap = dc->w.hBitmap;
- DC_UnlockDc(hDC);
- if (!(BitmapObj = BITMAPOBJ_LockBitmap(hBitmap)))
- return FALSE;
-
- SurfObj = &BitmapObj->SurfObj;
- loc->x = GDIDEV(SurfObj)->Pointer.Pos.x;
- loc->y = GDIDEV(SurfObj)->Pointer.Pos.y;
+ loc->x = GDIDevice->Pointer.Pos.x;
+ loc->y = GDIDevice->Pointer.Pos.y;
- BITMAPOBJ_UnlockBitmap(hBitmap);
return TRUE;
}
}
dcbmp = dc->w.hBitmap;
DevInfo = dc->DevInfo;
- DC_UnlockDc(Screen);
+ DC_UnlockDc(dc);
BitmapObj = BITMAPOBJ_LockBitmap(dcbmp);
if ( !BitmapObj )
CurInfo->CurrentCursorObject = NewCursor; /* i.e. CurrentCursorObject = NULL */
CurInfo->ShowingCursor = 0;
- BITMAPOBJ_UnlockBitmap(dcbmp);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
return Ret;
}
if (!NewCursor)
{
- BITMAPOBJ_UnlockBitmap(dcbmp);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
return Ret;
}
if (MaskBmpObj)
{
const int maskBpp = BitsPerFormat(MaskBmpObj->SurfObj.iBitmapFormat);
- BITMAPOBJ_UnlockBitmap(NewCursor->IconInfo.hbmMask);
+ BITMAPOBJ_UnlockBitmap(MaskBmpObj);
if (maskBpp != 1)
{
DPRINT1("SetCursor: The Mask bitmap must have 1BPP!\n");
- BITMAPOBJ_UnlockBitmap(dcbmp);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
return Ret;
}
NULL);
if ( !hMask )
{
- BITMAPOBJ_UnlockBitmap(NewCursor->IconInfo.hbmMask);
- BITMAPOBJ_UnlockBitmap(dcbmp);
+ BITMAPOBJ_UnlockBitmap(MaskBmpObj);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
return (HCURSOR)0;
}
soMask = EngLockSurface((HSURF)hMask);
EngCopyBits(soMask, &MaskBmpObj->SurfObj, NULL, NULL,
&DestRect, &SourcePoint);
- BITMAPOBJ_UnlockBitmap(NewCursor->IconInfo.hbmMask);
+ BITMAPOBJ_UnlockBitmap(MaskBmpObj);
}
}
}
GDIDEV(SurfObj)->Pointer.MovePointer = GDIDEVFUNCS(SurfObj).MovePointer;
}
- BITMAPOBJ_UnlockBitmap(dcbmp);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
if(hMask)
{
EngUnlockSurface(soMask);
{
CurIconObject->Size.cx = bmp->SurfObj.sizlBitmap.cx;
CurIconObject->Size.cy = bmp->SurfObj.sizlBitmap.cy;
- BITMAPOBJ_UnlockBitmap(CurIconObject->IconInfo.hbmColor);
+ BITMAPOBJ_UnlockBitmap(bmp);
GDIOBJ_SetOwnership(CurIconObject->IconInfo.hbmColor, NULL);
}
if(CurIconObject->IconInfo.hbmMask &&
CurIconObject->Size.cx = bmp->SurfObj.sizlBitmap.cx;
CurIconObject->Size.cy = bmp->SurfObj.sizlBitmap.cy / 2;
}
- BITMAPOBJ_UnlockBitmap(CurIconObject->IconInfo.hbmMask);
+ BITMAPOBJ_UnlockBitmap(bmp);
GDIOBJ_SetOwnership(CurIconObject->IconInfo.hbmMask, NULL);
}
}
else
SetLastNtError(Status);
- BITMAPOBJ_UnlockBitmap(CurIconObject->IconInfo.hbmColor);
+ BITMAPOBJ_UnlockBitmap(bmp);
done:
IntReleaseCurIconObject(CurIconObject);
{
CurIconObject->Size.cx = bmp->SurfObj.sizlBitmap.cx;
CurIconObject->Size.cy = bmp->SurfObj.sizlBitmap.cy;
- BITMAPOBJ_UnlockBitmap(CurIconObject->IconInfo.hbmColor);
+ BITMAPOBJ_UnlockBitmap(bmp);
GDIOBJ_SetOwnership(CurIconObject->IconInfo.hbmColor, NULL);
}
else
CurIconObject->Size.cx = bmp->SurfObj.sizlBitmap.cx;
CurIconObject->Size.cy = bmp->SurfObj.sizlBitmap.cy / 2;
- BITMAPOBJ_UnlockBitmap(CurIconObject->IconInfo.hbmMask);
+ BITMAPOBJ_UnlockBitmap(bmp);
GDIOBJ_SetOwnership(CurIconObject->IconInfo.hbmMask, NULL);
}
{
Ret->right = BitmapObj->SurfObj.sizlBitmap.cx;
Ret->bottom = BitmapObj->SurfObj.sizlBitmap.cy;
- BITMAPOBJ_UnlockBitmap(dc->w.hBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
}
- DC_UnlockDc(ScreenDeviceContext);
+ DC_UnlockDc(dc);
}
if(Rect)
if (dc)
{
hBitmap = dc->w.hBitmap;
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
BitmapObj = BITMAPOBJ_LockBitmap(hBitmap);
if (BitmapObj)
GDIDEV(SurfObj)->Pointer.Pos.x = MousePos.x;
GDIDEV(SurfObj)->Pointer.Pos.y = MousePos.y;
- BITMAPOBJ_UnlockBitmap(hBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
}
}
}
{
Width = ScreenDC->GDIInfo->ulHorzRes;
Height = ScreenDC->GDIInfo->ulVertRes;
- DC_UnlockDc(ScreenDCHandle);
+ DC_UnlockDc(ScreenDC);
}
NtGdiDeleteDC(ScreenDCHandle);
}
WinStaObject->cxWallpaper = bmp->SurfObj.sizlBitmap.cx;
WinStaObject->cyWallpaper = bmp->SurfObj.sizlBitmap.cy;
- BITMAPOBJ_UnlockBitmap(hNewBitmap);
+ BITMAPOBJ_UnlockBitmap(bmp);
/* change the bitmap's ownership */
GDIOBJ_SetOwnership(hNewBitmap, NULL);
return -1;
}
dcVisRgn = dc->w.hVisRgn;
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
regionType = NtGdiGetRgnBox(dcVisRgn, &dcRect);
if (regionType == 0)
if (NULL != Rgn)
{
UnsafeIntGetRgnBox(Rgn, &Ps.rcPaint);
- RGNDATA_UnlockRgn(Window->UpdateRegion);
+ RGNDATA_UnlockRgn(Rgn);
IntGdiOffsetRect(&Ps.rcPaint,
Window->WindowRect.left - Window->ClientRect.left,
Window->WindowRect.top - Window->ClientRect.top);
ASSERT(RgnData != NULL);
RegionType = UnsafeIntGetRgnBox(RgnData, &Rect);
ASSERT(RegionType != ERROR);
- RGNDATA_UnlockRgn(Window->UpdateRegion);
+ RGNDATA_UnlockRgn(RgnData);
}
AlwaysPaint = (Window->Flags & WINDOWOBJECT_NEED_NCPAINT) ||
(Window->Flags & WINDOWOBJECT_NEED_INTERNALPAINT);
IntGdiOffsetRect(&rSrc_lp, offset.left - offset.right, offset.top - offset.bottom);
IntDPtoLP(DC, (LPPOINT)&rDst_lp, 2);
IntDPtoLP(DC, (LPPOINT)&rSrc_lp, 2);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(DC);
if (!NtGdiBitBlt(hDC, rDst_lp.left, rDst_lp.top, rDst_lp.right - rDst_lp.left,
rDst_lp.bottom - rDst_lp.top, hDC, rSrc_lp.left, rSrc_lp.top,
}
else
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(DC);
}
/*
Dce = DCEOBJ_LockDCE(DceHandle);
/* No real locking, just get the pointer */
- DCEOBJ_UnlockDCE(DceHandle);
+ DCEOBJ_UnlockDCE(Dce);
Dce->Self = DceHandle;
Dce->hDC = IntGdiCreateDC(&DriverName, NULL, NULL, NULL, FALSE);
if (NULL == defaultDCstate)
dc->w.DCOrgY = WindowObject->ClientRect.top;
}
}
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
}
NtGdiOffsetRgn(pDCE->hClipRgn, DeltaX, DeltaY);
}
}
- DC_UnlockDc(pDCE->hDC);
+ DC_UnlockDc(dc);
DceUpdateVisRgn(pDCE, CurrentWindow, pDCE->DCXFlags);
if((pRgn = RGNDATA_LockRgn(hRgn)))
{
Ret = pRgn->rdh.iType;
- RGNDATA_UnlockRgn(hRgn);
+ RGNDATA_UnlockRgn(pRgn);
}
else
Ret = ERROR;
{
Ret = pRgn->rdh.iType;
*Rect = pRgn->rdh.rcBound;
- RGNDATA_UnlockRgn(VisRgn);
+ RGNDATA_UnlockRgn(pRgn);
}
else
Ret = ERROR;
if (VisBefore != NULL && (VisRgn = (PROSRGNDATA)RGNDATA_LockRgn(VisBefore)) &&
UnsafeIntGetRgnBox(VisRgn, &TempRect) == NULLREGION)
{
- RGNDATA_UnlockRgn(VisBefore);
+ RGNDATA_UnlockRgn(VisRgn);
NtGdiDeleteObject(VisBefore);
VisBefore = NULL;
}
else if(VisRgn)
{
- RGNDATA_UnlockRgn(VisBefore);
+ RGNDATA_UnlockRgn(VisRgn);
}
}
}
if (VisAfter != NULL && (VisRgn = (PROSRGNDATA)RGNDATA_LockRgn(VisAfter)) &&
UnsafeIntGetRgnBox(VisRgn, &TempRect) == NULLREGION)
{
- RGNDATA_UnlockRgn(VisAfter);
+ RGNDATA_UnlockRgn(VisRgn);
NtGdiDeleteObject(VisAfter);
VisAfter = NULL;
}
else if(VisRgn)
{
- RGNDATA_UnlockRgn(VisAfter);
+ RGNDATA_UnlockRgn(VisRgn);
}
/*
UnsafeIntGetRgnBox(VisRgn, &CopyRect) == NULLREGION)
{
/* Nothing to copy, clean up */
- RGNDATA_UnlockRgn(CopyRgn);
+ RGNDATA_UnlockRgn(VisRgn);
NtGdiDeleteObject(CopyRgn);
CopyRgn = NULL;
}
{
if(VisRgn)
{
- RGNDATA_UnlockRgn(CopyRgn);
+ RGNDATA_UnlockRgn(VisRgn);
}
/*
* Small trick here: there is no function to bitblt a region. So
}
else if(VisRgn)
{
- RGNDATA_UnlockRgn(CopyRgn);
+ RGNDATA_UnlockRgn(VisRgn);
}
}
else
}
if (DCDest->IsIC)
{
- DC_UnlockDc(hDCDest);
+ DC_UnlockDc(DCDest);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
DCSrc = DC_LockDc(hDCSrc);
if (NULL == DCSrc)
{
- DC_UnlockDc(hDCDest);
+ DC_UnlockDc(DCDest);
DPRINT1("Invalid source dc handle (0x%08x) passed to NtGdiBitBlt\n", hDCSrc);
SetLastWin32Error(ERROR_INVALID_HANDLE);
return FALSE;
}
if (DCSrc->IsIC)
{
- DC_UnlockDc(hDCSrc);
- DC_UnlockDc(hDCDest);
+ DC_UnlockDc(DCSrc);
+ DC_UnlockDc(DCDest);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
{
if (UsesSource && hDCSrc != hDCDest)
{
- DC_UnlockDc(hDCSrc);
+ DC_UnlockDc(DCSrc);
}
if(BitmapDest != NULL)
{
- BITMAPOBJ_UnlockBitmap(DCDest->w.hBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapDest);
}
if(BitmapSrc != NULL && BitmapSrc != BitmapDest)
{
- BITMAPOBJ_UnlockBitmap(DCSrc->w.hBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapSrc);
}
- DC_UnlockDc(hDCDest);
+ DC_UnlockDc(DCDest);
SetLastWin32Error(ERROR_INVALID_HANDLE);
return FALSE;
}
{
if (UsesSource && hDCSrc != hDCDest)
{
- DC_UnlockDc(hDCSrc);
+ DC_UnlockDc(DCSrc);
}
- DC_UnlockDc(hDCDest);
+ DC_UnlockDc(DCDest);
if(BitmapDest != NULL)
{
- BITMAPOBJ_UnlockBitmap(DCDest->w.hBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapDest);
}
if(BitmapSrc != NULL && BitmapSrc != BitmapDest)
{
- BITMAPOBJ_UnlockBitmap(DCSrc->w.hBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapSrc);
}
if(BrushObj != NULL)
{
- BRUSHOBJ_UnlockBrush(DCDest->w.hBrush);
+ BRUSHOBJ_UnlockBrush(BrushObj);
}
SetLastWin32Error(ERROR_NO_SYSTEM_RESOURCES);
return FALSE;
if(BitmapDest != NULL)
{
- BITMAPOBJ_UnlockBitmap(DCDest->w.hBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapDest);
}
if (UsesSource && BitmapSrc != BitmapDest)
{
- BITMAPOBJ_UnlockBitmap(DCSrc->w.hBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapSrc);
}
if (BrushObj != NULL)
{
- BRUSHOBJ_UnlockBrush(DCDest->w.hBrush);
+ BRUSHOBJ_UnlockBrush(BrushObj);
}
if (UsesSource && hDCSrc != hDCDest)
{
- DC_UnlockDc(hDCSrc);
+ DC_UnlockDc(DCSrc);
}
- DC_UnlockDc(hDCDest);
+ DC_UnlockDc(DCDest);
return Status;
}
}
if (DCDest->IsIC)
{
- DC_UnlockDc(hdcDst);
+ DC_UnlockDc(DCDest);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
if((hdcDst != hdcSrc) && !(DCSrc = DC_LockDc(hdcSrc)))
{
- DC_UnlockDc(hdcDst);
+ DC_UnlockDc(DCDest);
DPRINT1("Invalid source dc handle (0x%08x) passed to NtGdiTransparentBlt\n", hdcSrc);
SetLastWin32Error(ERROR_INVALID_HANDLE);
return FALSE;
}
if (DCSrc->IsIC)
{
- DC_UnlockDc(hdcSrc);
+ DC_UnlockDc(DCSrc);
if(hdcDst != hdcSrc)
{
- DC_UnlockDc(hdcDst);
+ DC_UnlockDc(DCDest);
}
/* Yes, Windows really returns TRUE in this case */
return TRUE;
if(!(PalSourceGDI = PALETTE_LockPalette(SourcePalette)))
{
- DC_UnlockDc(hdcSrc);
- DC_UnlockDc(hdcDst);
+ DC_UnlockDc(DCSrc);
+ DC_UnlockDc(DCDest);
SetLastWin32Error(ERROR_INVALID_HANDLE);
return FALSE;
}
if((DestPalette != SourcePalette) && !(PalDestGDI = PALETTE_LockPalette(DestPalette)))
{
- PALETTE_UnlockPalette(SourcePalette);
- DC_UnlockDc(hdcSrc);
- DC_UnlockDc(hdcDst);
+ PALETTE_UnlockPalette(PalSourceGDI);
+ DC_UnlockDc(DCSrc);
+ DC_UnlockDc(DCDest);
SetLastWin32Error(ERROR_INVALID_HANDLE);
return FALSE;
}
{
PalDestMode = PalDestGDI->Mode;
PalSrcMode = PalSourceGDI->Mode;
- PALETTE_UnlockPalette(DestPalette);
+ PALETTE_UnlockPalette(PalDestGDI);
}
else
{
PalDestMode = PalSrcMode = PalSourceGDI->Mode;
}
- PALETTE_UnlockPalette(SourcePalette);
+ PALETTE_UnlockPalette(PalSourceGDI);
/* Translate Transparent (RGB) Color to the source palette */
if((XlateObj = (XLATEOBJ*)IntEngCreateXlate(PalSrcMode, PAL_RGB, SourcePalette, NULL)))
TransparentColor, 0);
done:
- BITMAPOBJ_UnlockBitmap(DCDest->w.hBitmap);
- BITMAPOBJ_UnlockBitmap(DCSrc->w.hBitmap);
- DC_UnlockDc(hdcSrc);
+ BITMAPOBJ_UnlockBitmap(BitmapDest);
+ BITMAPOBJ_UnlockBitmap(BitmapSrc);
+ DC_UnlockDc(DCSrc);
if(hdcDst != hdcSrc)
{
- DC_UnlockDc(hdcDst);
+ DC_UnlockDc(DCDest);
}
if(XlateObj)
{
bmp = BITMAPOBJ_LockBitmap( hBitmap );
/* FIXME - bmp can be NULL!!!!!! */
bmp->flFlags = BITMAPOBJ_IS_APIBITMAP;
- BITMAPOBJ_UnlockBitmap( hBitmap );
+ BITMAPOBJ_UnlockBitmap( bmp );
/*
* NOTE: It's ugly practice, but we are using the object even
Bmp = IntCreateCompatibleBitmap(Dc, Width, Height);
DPRINT ("\t\t%04x\n", Bmp);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(Dc);
return Bmp;
}
*Dimension = bmp->dimension;
- BITMAPOBJ_UnlockBitmap(hBitmap);
+ BITMAPOBJ_UnlockBitmap(bmp);
return TRUE;
}
}
if (dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return Result;
}
XPos += dc->w.DCOrgX;
}
EngDeleteXlate(XlateObj);
}
- BITMAPOBJ_UnlockBitmap(dc->w.hBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapObject);
}
}
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
// if Result is still CLR_INVALID, then the "quick" method above didn't work
if ( bInRect && Result == CLR_INVALID )
if ( bmpobj )
{
Result = *(COLORREF*)bmpobj->SurfObj.pvScan0;
- BITMAPOBJ_UnlockBitmap ( hBmpTmp );
+ BITMAPOBJ_UnlockBitmap ( bmpobj );
}
}
NtGdiDeleteObject ( hBmpTmp );
ret = Bytes;
}
- BITMAPOBJ_UnlockBitmap(hBitmap);
+ BITMAPOBJ_UnlockBitmap(bmp);
return ret;
}
bmp->dimension.cx = Width;
bmp->dimension.cy = Height;
- BITMAPOBJ_UnlockBitmap (hBitmap);
+ BITMAPOBJ_UnlockBitmap (bmp);
return TRUE;
}
}
if (DCDest->IsIC)
{
- DC_UnlockDc(hDCDest);
+ DC_UnlockDc(DCDest);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
DCSrc = DC_LockDc(hDCSrc);
if (NULL == DCSrc)
{
- DC_UnlockDc(hDCDest);
+ DC_UnlockDc(DCDest);
DPRINT1("Invalid source dc handle (0x%08x) passed to NtGdiStretchBlt\n", hDCSrc);
SetLastWin32Error(ERROR_INVALID_HANDLE);
return FALSE;
}
if (DCSrc->IsIC)
{
- DC_UnlockDc(hDCSrc);
- DC_UnlockDc(hDCDest);
+ DC_UnlockDc(DCSrc);
+ DC_UnlockDc(DCDest);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
{
if (UsesSource && hDCSrc != hDCDest)
{
- DC_UnlockDc(hDCSrc);
+ DC_UnlockDc(DCSrc);
}
- DC_UnlockDc(hDCDest);
+ DC_UnlockDc(DCDest);
SetLastWin32Error(ERROR_INVALID_HANDLE);
return FALSE;
}
{
if (UsesSource && hDCSrc != hDCDest)
{
- DC_UnlockDc(hDCSrc);
+ DC_UnlockDc(DCSrc);
}
- DC_UnlockDc(hDCDest);
+ DC_UnlockDc(DCDest);
SetLastWin32Error(ERROR_NO_SYSTEM_RESOURCES);
return FALSE;
}
EngDeleteXlate(XlateObj);
if (UsesPattern)
{
- BRUSHOBJ_UnlockBrush(DCDest->w.hBrush);
+ BRUSHOBJ_UnlockBrush(BrushObj);
}
failed:
if (UsesSource && DCSrc->w.hBitmap != DCDest->w.hBitmap)
{
- BITMAPOBJ_UnlockBitmap(DCSrc->w.hBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapSrc);
}
- BITMAPOBJ_UnlockBitmap(DCDest->w.hBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapDest);
if (UsesSource && hDCSrc != hDCDest)
{
- DC_UnlockDc(hDCSrc);
+ DC_UnlockDc(DCSrc);
}
- DC_UnlockDc(hDCDest);
+ DC_UnlockDc(DCDest);
return Status;
}
ExFreePool (buf);
}
- GDIOBJ_UnlockObj(hBitmap);
+ GDIOBJ_UnlockObjByPtr(Bitmap);
return res;
}
Result = IntEngCreateXlate(0, 0, Dc->w.hPalette, Pattern->hDIBPalette);
}
- BITMAPOBJ_UnlockBitmap(BrushObj->hbmPattern);
+ BITMAPOBJ_UnlockBitmap(Pattern);
*Failed = FALSE;
}
BitmapObject = BITMAPOBJ_LockBitmap(hPattern);
ASSERT(BitmapObject != NULL);
BitmapObject->hDIBPalette = BuildDIBPalette(BitmapInfo, &PaletteType);
- BITMAPOBJ_UnlockBitmap(hPattern);
+ BITMAPOBJ_UnlockBitmap(BitmapObject);
hBrush = BRUSHOBJ_AllocBrush();
if (hBrush == NULL)
GDIOBJ_SetOwnership(hPattern, NULL);
- BRUSHOBJ_UnlockBrush(hBrush);
+ BRUSHOBJ_UnlockBrush(BrushObject);
return hBrush;
}
GDIOBJ_SetOwnership(hPattern, NULL);
- BRUSHOBJ_UnlockBrush(hBrush);
+ BRUSHOBJ_UnlockBrush(BrushObject);
return hBrush;
}
GDIOBJ_SetOwnership(hPattern, NULL);
- BRUSHOBJ_UnlockBrush(hBrush);
+ BRUSHOBJ_UnlockBrush(BrushObject);
return hBrush;
}
BrushObject->BrushAttr.lbColor = Color & 0xFFFFFF;
/* FIXME: Fill in the rest of fields!!! */
- BRUSHOBJ_UnlockBrush(hBrush);
+ BRUSHOBJ_UnlockBrush(BrushObject);
return hBrush;
}
BrushObject = BRUSHOBJ_LockBrush(hBrush);
ASSERT(BrushObject != NULL);
BrushObject->flAttrs |= GDIBRUSH_IS_NULL;
- BRUSHOBJ_UnlockBrush(hBrush);
+ BRUSHOBJ_UnlockBrush(BrushObject);
return hBrush;
}
ROP3_TO_ROP4(ROP));
}
- BITMAPOBJ_UnlockBitmap(dc->w.hBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
return ret;
}
}
if (dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
r->r.bottom,
dwRop,
BrushObj);
- BRUSHOBJ_UnlockBrush(r->hBrush);
+ BRUSHOBJ_UnlockBrush(BrushObj);
}
r++;
}
- DC_UnlockDc( hDC );
+ DC_UnlockDc(dc);
return TRUE;
}
Status = MmCopyToCaller(Point, &SafePoint, sizeof(POINT));
if(!NT_SUCCESS(Status))
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastNtError(Status);
return FALSE;
}
dc->w.brushOrgX = XOrg;
dc->w.brushOrgY = YOrg;
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return TRUE;
}
}
if (dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
if (BrushObj == NULL)
{
SetLastWin32Error(ERROR_INVALID_HANDLE);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return FALSE;
}
ROP,
BrushObj);
- BRUSHOBJ_UnlockBrush(dc->w.hBrush);
- DC_UnlockDc(hDC);
+ BRUSHOBJ_UnlockBrush(BrushObj);
+ DC_UnlockDc(dc);
return ret;
}
(PRECTL)CombinedRegion->Buffer,
(PRECTL)&CombinedRegion->rdh.rcBound);
- RGNDATA_UnlockRgn(Dc->w.hGCClipRgn);
+ RGNDATA_UnlockRgn(CombinedRegion);
}
if ( NULL == Dc->CombinedClip )
return NtGdiOffsetRgn(Dc->w.hGCClipRgn, -Dc->w.DCOrgX, -Dc->w.DCOrgY);
}
-HRGN WINAPI SaveVisRgn(HDC hdc)
-{
- HRGN copy;
- PROSRGNDATA obj;/*, copyObj;*/
- PDC dc = DC_LockDc(hdc);
-
- if (!dc) return 0;
-
- obj = RGNDATA_LockRgn(dc->w.hVisRgn);
- /* FIXME - Handle obj == NULL!!! */
-
- if(!(copy = NtGdiCreateRectRgn(0, 0, 0, 0)))
- {
- RGNDATA_UnlockRgn(dc->w.hVisRgn);
- DC_UnlockDc(hdc);
- return 0;
- }
- NtGdiCombineRgn(copy, dc->w.hVisRgn, 0, RGN_COPY);
- /* copyObj = RGNDATA_LockRgn(copy); */
-/* copyObj->header.hNext = obj->header.hNext;
- header.hNext = copy; */
- DC_UnlockDc(hdc);
- return copy;
-}
-
INT STDCALL
NtGdiSelectVisRgn(HDC hdc, HRGN hrgn)
{
retval = NtGdiCombineRgn(dc->w.hVisRgn, hrgn, 0, RGN_COPY);
if ( retval != ERROR )
CLIPPING_UpdateGCRegion(dc);
- DC_UnlockDc( hdc );
+ DC_UnlockDc(dc);
return retval;
}
}
else
{
- DC_UnlockDc( hDC );
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return ERROR;
}
if((Rgn = RGNDATA_LockRgn(dc->w.hVisRgn)))
{
UnsafeIntGetRgnBox(Rgn, &rect);
- RGNDATA_UnlockRgn(dc->w.hVisRgn);
+ RGNDATA_UnlockRgn(Rgn);
dc->w.hClipRgn = UnsafeIntCreateRectRgnIndirect(&rect);
}
else
}
retval = CLIPPING_UpdateGCRegion(dc);
- DC_UnlockDc( hDC );
+ DC_UnlockDc(dc);
return retval;
}
if (!(Rgn = RGNDATA_LockRgn(dc->w.hGCClipRgn)))
{
- DC_UnlockDc( hDC );
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INVALID_HANDLE);
return ERROR;
}
retval = UnsafeIntGetRgnBox(Rgn, rc);
- RGNDATA_UnlockRgn(dc->w.hGCClipRgn);
+ RGNDATA_UnlockRgn(Rgn);
IntDPtoLP(dc, (LPPOINT)rc, 2);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return retval;
}
if (Result != ERROR)
CLIPPING_UpdateGCRegion(dc);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return Result;
}
if (Result != ERROR)
CLIPPING_UpdateGCRegion(dc);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return Result;
}
}
rgn = dc->w.hGCClipRgn;
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return (rgn ? NtGdiPtInRegion(rgn, X, Y) : FALSE);
}
Status = MmCopyFromCaller(&Rect, UnsafeRect, sizeof(RECT));
if(!NT_SUCCESS(Status))
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return FALSE;
}
{
IntLPtoDP(dc, (LPPOINT)&Rect, 2);
Result = UnsafeIntRectInRegion(Rgn, &Rect);
- RGNDATA_UnlockRgn(dc->w.hGCClipRgn);
+ RGNDATA_UnlockRgn(Rgn);
}
}
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return Result;
}
pal_entries = palPtr->NumColors;
if (StartIndex >= pal_entries)
{
- PALETTE_UnlockPalette(hPal);
+ PALETTE_UnlockPalette(palPtr);
return FALSE;
}
if (StartIndex+NumEntries > pal_entries) NumEntries = pal_entries - StartIndex;
}
}
- PALETTE_UnlockPalette(hPal);
+ PALETTE_UnlockPalette(palPtr);
/* Immediately apply the new palette if current window uses it */
hHwd = NtUserGetDesktopWindow();
{
if (dc->w.hPalette == hPal)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
NtGdiRealizePalette(hDC);
}
else
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
}
NtUserReleaseDC(hHwd,hDC);
}
PALETTE_ValidateFlags(PalGDI->IndexedColors, PalGDI->NumColors);
PalGDI->logicalToSystem = NULL;
- PALETTE_UnlockPalette(NewPalette);
+ PALETTE_UnlockPalette(PalGDI);
return NewPalette;
}
palGDI = (PPALGDI) PALETTE_LockPalette(hpal);
if (!palGDI)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return nearest;
}
(GetBValue(Color) >> BBits) << BBits);
break;
}
- PALETTE_UnlockPalette(hpal);
- DC_UnlockDc(hDC);
+ PALETTE_UnlockPalette(palGDI);
+ DC_UnlockDc(dc);
}
return nearest;
{
/* Return closest match for the given RGB color */
index = COLOR_PaletteLookupPixel(palGDI->IndexedColors, palGDI->NumColors, NULL, Color, FALSE);
- PALETTE_UnlockPalette(hpal);
+ PALETTE_UnlockPalette(palGDI);
}
return index;
{
if (numEntries <= StartIndex)
{
- PALETTE_UnlockPalette(hpal);
+ PALETTE_UnlockPalette(palGDI);
return 0;
}
memcpy(pe, palGDI->IndexedColors + StartIndex, Entries * sizeof(PALETTEENTRY));
}
}
- PALETTE_UnlockPalette(hpal);
+ PALETTE_UnlockPalette(palGDI);
return Entries;
}
// need to pass this to IntEngCreateXlate with palettes unlocked
sysMode = sysGDI->Mode;
palMode = palGDI->Mode;
- PALETTE_UnlockPalette(systemPalette);
- PALETTE_UnlockPalette(dc->w.hPalette);
+ PALETTE_UnlockPalette(sysGDI);
+ PALETTE_UnlockPalette(palGDI);
// Step 3: Create the XLATEOBJ for device managed DCs
if(dc->w.flags != DC_MEMORY)
palGDI->logicalToSystem = IntEngCreateXlate(sysMode, palMode, systemPalette, dc->w.hPalette);
}
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return realized;
}
if ((dc->w.bitsPerPixel <= 8 && PAL_INDEXED == PalGDI->Mode)
|| (8 < dc->w.bitsPerPixel && PAL_INDEXED != PalGDI->Mode))
{
- PALETTE_UnlockPalette(hpal);
+ PALETTE_UnlockPalette(PalGDI);
oldPal = dc->w.hPalette;
dc->w.hPalette = hpal;
}
else
{
- PALETTE_UnlockPalette(hpal);
+ PALETTE_UnlockPalette(PalGDI);
oldPal = NULL;
}
}
{
oldPal = NULL;
}
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
}
return oldPal;
numEntries = palGDI->NumColors;
if (Start >= numEntries)
{
- PALETTE_UnlockPalette(hpal);
+ PALETTE_UnlockPalette(palGDI);
return 0;
}
if (numEntries < Start + Entries)
PALETTE_ValidateFlags(palGDI->IndexedColors, palGDI->NumColors);
ExFreePool(palGDI->logicalToSystem);
palGDI->logicalToSystem = NULL;
- PALETTE_UnlockPalette(hpal);
+ PALETTE_UnlockPalette(palGDI);
return Entries;
}
if (!UnsafePoints || Count <= 0)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return FALSE;
}
Points = (LPPOINT)ExAllocatePoolWithTag(PagedPool, Size, TAG_COORD);
if(!Points)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
Status = MmCopyFromCaller(Points, UnsafePoints, Size);
if(!NT_SUCCESS(Status))
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
ExFreePool(Points);
SetLastNtError(Status);
return FALSE;
Status = MmCopyToCaller(UnsafePoints, Points, Size);
if(!NT_SUCCESS(Status))
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
ExFreePool(Points);
SetLastNtError(Status);
return FALSE;
}
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
ExFreePool(Points);
return TRUE;
}
GraphicsMode = dc->w.GraphicsMode;
- DC_UnlockDc ( hDC );
+ DC_UnlockDc(dc);
return GraphicsMode;
}
}
if (!XForm)
{
- DC_UnlockDc ( hDC );
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return FALSE;
}
Status = MmCopyToCaller(XForm, &dc->w.xformWorld2Wnd, sizeof(XFORM));
- DC_UnlockDc ( hDC );
+ DC_UnlockDc(dc);
return NT_SUCCESS(Status);
}
if (!UnsafePoints || Count <= 0)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return FALSE;
}
Points = (LPPOINT)ExAllocatePoolWithTag(PagedPool, Size, TAG_COORD);
if(!Points)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
Status = MmCopyFromCaller(Points, UnsafePoints, Size);
if(!NT_SUCCESS(Status))
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
ExFreePool(Points);
SetLastNtError(Status);
return FALSE;
Status = MmCopyToCaller(UnsafePoints, Points, Size);
if(!NT_SUCCESS(Status))
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
ExFreePool(Points);
SetLastNtError(Status);
return FALSE;
}
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
ExFreePool(Points);
return TRUE;
}
if (!UnsafeXForm)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return FALSE;
}
Status = MmCopyFromCaller(&SafeXForm, UnsafeXForm, sizeof(XFORM));
if(!NT_SUCCESS(Status))
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastNtError(Status);
return FALSE;
}
break;
default:
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return FALSE;
}
DC_UpdateXforms(dc);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return TRUE;
}
if ( !NT_SUCCESS(Status) )
{
SetLastNtError(Status);
- DC_UnlockDc ( hDC );
+ DC_UnlockDc(dc);
return FALSE;
}
}
dc->vportOrgY += YOffset;
DC_UpdateXforms(dc);
- DC_UnlockDc ( hDC );
+ DC_UnlockDc(dc);
return TRUE;
}
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return FALSE;
}
}
dc->wndOrgY += YOffset;
DC_UpdateXforms(dc);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return TRUE;
}
if ((Mode != GM_COMPATIBLE) && (Mode != GM_ADVANCED))
{
- DC_UnlockDc( hDC );
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return 0;
}
ret = dc->w.GraphicsMode;
dc->w.GraphicsMode = Mode;
- DC_UnlockDc( hDC );
+ DC_UnlockDc(dc);
return ret;
}
PrevMapMode = dc->w.MapMode;
dc->w.MapMode = MapMode;
- DC_UnlockDc ( hDC );
+ DC_UnlockDc(dc);
return PrevMapMode;
}
case MM_LOMETRIC:
case MM_TEXT:
case MM_TWIPS:
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return FALSE;
case MM_ISOTROPIC:
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return FALSE;
}
}
dc->vportExtY = YExtent;
DC_UpdateXforms(dc);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return TRUE;
}
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return FALSE;
}
}
dc->vportOrgY = Y;
DC_UpdateXforms(dc);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return TRUE;
}
case MM_LOMETRIC:
case MM_TEXT:
case MM_TWIPS:
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return FALSE;
}
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return FALSE;
}
}
dc->wndExtY = YExtent;
DC_UpdateXforms(dc);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return TRUE;
}
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return FALSE;
}
}
dc->wndOrgY = Y;
DC_UpdateXforms(dc);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return TRUE;
}
if (!XForm)
{
- DC_UnlockDc( hDC );
+ DC_UnlockDc(dc);
/* Win doesn't set LastError */
return FALSE;
}
/* Check that graphics mode is GM_ADVANCED */
if ( dc->w.GraphicsMode != GM_ADVANCED )
{
- DC_UnlockDc( hDC );
+ DC_UnlockDc(dc);
return FALSE;
}
Status = MmCopyFromCaller(&dc->w.xformWorld2Wnd, XForm, sizeof(XFORM));
if(!NT_SUCCESS(Status))
{
- DC_UnlockDc( hDC );
+ DC_UnlockDc(dc);
return FALSE;
}
- DC_UpdateXforms (dc);
- DC_UnlockDc( hDC );
+ DC_UpdateXforms(dc);
+ DC_UnlockDc(dc);
return TRUE;
}
return 0; \
} \
ft = dc->dc_field; \
- DC_UnlockDc( hdc ); \
+ DC_UnlockDc(dc); \
return ft; \
}
return FALSE; \
} \
Int##FuncName( dc, &Safept); \
- DC_UnlockDc(hdc); \
+ DC_UnlockDc(dc); \
Status = MmCopyToCaller(pt, &Safept, sizeof( type )); \
if(!NT_SUCCESS(Status)) \
{ \
} \
prevMode = dc->dc_field; \
dc->dc_field = mode; \
- DC_UnlockDc ( hdc ); \
+ DC_UnlockDc ( dc ); \
return prevMode; \
}
if (NULL == hNewDC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(OrigDC);
if (NULL != DisplayDC)
{
NtGdiDeleteDC(DisplayDC);
/* Create default bitmap */
if (!(hBitmap = NtGdiCreateBitmap( 1, 1, 1, NewDC->w.bitsPerPixel, NULL )))
{
- DC_UnlockDc( hDC );
- DC_UnlockDc( hNewDC );
+ DC_UnlockDc( OrigDC );
+ DC_UnlockDc( NewDC );
DC_FreeDC( hNewDC );
if (NULL != DisplayDC)
{
NewDC->w.backgroundColor = OrigDC->w.backgroundColor;
NewDC->w.backgroundMode = OrigDC->w.backgroundMode;
NewDC->w.ROPmode = OrigDC->w.ROPmode;
- DC_UnlockDc( hDC );
+ DC_UnlockDc(NewDC);
+ DC_UnlockDc(OrigDC);
if (NULL != DisplayDC)
{
NtGdiDeleteDC(DisplayDC);
}
- DC_UnlockDc(hNewDC);
hVisRgn = NtGdiCreateRectRgn(0, 0, 1, 1);
NtGdiSelectVisRgn(hNewDC, hVisRgn);
NewDC->w.hPalette = NewDC->DevInfo->hpalDefault;
NewDC->w.ROPmode = R2_COPYPEN;
- DC_UnlockDc( hNewDC );
+ DC_UnlockDc( NewDC );
hVisRgn = NtGdiCreateRectRgn(0, 0, NewDC->GDIInfo->ulHorzRes,
NewDC->GDIInfo->ulVertRes);
}
else
{
- DC_UnlockDc( hNewDC );
+ DC_UnlockDc( NewDC );
}
return hNewDC;
}
DC_SetNextDC (DCToDelete, DC_GetNextDC (savedDC));
DCToDelete->saveLevel--;
- DC_UnlockDc( savedHDC );
+ DC_UnlockDc( savedDC );
NtGdiDeleteDC (savedHDC);
}
#if 0 /* FIXME */
PATH_DestroyGdiPath (&DCToDelete->w.path);
#endif
- DC_UnlockDc( DCHandle );
+ DC_UnlockDc( DCToDelete );
DC_FreeDC ( DCHandle );
return TRUE;
break;
}
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return SelObject;
}
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return FALSE;
}
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return Ret;
}
oldColor = dc->w.backgroundColor;
dc->w.backgroundColor = color;
hBrush = dc->w.hBrush;
- DC_UnlockDc ( hDC );
+ DC_UnlockDc(dc);
NtGdiSelectObject(hDC, hBrush);
return oldColor;
}
hnewdc = DC_AllocDC(NULL);
if (hnewdc == NULL)
{
- DC_UnlockDc( hDC );
+ DC_UnlockDc(dc);
return 0;
}
newdc = DC_LockDc( hnewdc );
newdc->w.hClipRgn = NtGdiCreateRectRgn( 0, 0, 0, 0 );
NtGdiCombineRgn( newdc->w.hClipRgn, dc->w.hClipRgn, 0, RGN_COPY );
}
- DC_UnlockDc( hnewdc );
- DC_UnlockDc( hDC );
+ DC_UnlockDc( newdc );
+ DC_UnlockDc( dc );
return hnewdc;
}
res = CLIPPING_UpdateGCRegion( dc );
ASSERT ( res != ERROR );
}
- DC_UnlockDc ( hDC );
+ DC_UnlockDc ( dc );
#else
- DC_UnlockDc ( hDC );
+ DC_UnlockDc ( dc );
NtGdiSelectClipRgn(hDC, dcs->w.hClipRgn);
#endif
GDISelectPalette16( hDC, dcs->w.hPalette, FALSE );
#endif
} else {
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
}
- DC_UnlockDc ( hDCSave );
+ DC_UnlockDc ( dcs );
} else {
- DC_UnlockDc ( hDC );
+ DC_UnlockDc ( dc );
SetLastWin32Error(ERROR_INVALID_HANDLE);
}
}
DPRINT("(%04x,%d): returning %d\n", hDC, Index, ret);
- DC_UnlockDc( hDC );
+ DC_UnlockDc( dc );
return ret;
}
break;
}
- GDIOBJ_UnlockObj(Handle);
+ GDIOBJ_UnlockObjByPtr(GdiObject);
return Result;
}
result = 0;
break;
}
- GDIOBJ_UnlockObj(handle);
+ GDIOBJ_UnlockObjByPtr(ptr);
return result;
}
if ((SaveLevel < 1) || (SaveLevel > dc->saveLevel))
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return FALSE;
}
dcs = DC_LockDc (hdcs);
if (dcs == NULL)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return FALSE;
}
DC_SetNextDC (dcs, DC_GetNextDC (dcs));
if (--dc->saveLevel < SaveLevel)
{
- DC_UnlockDc( hDC );
- DC_UnlockDc( hdcs );
+ DC_UnlockDc( dc );
+ DC_UnlockDc( dcs );
NtGdiSetDCState(hDC, hdcs);
#if 0
if (!PATH_AssignGdiPath( &dc->w.path, &dcs->w.path ))
}
else
{
- DC_UnlockDc( hdcs );
+ DC_UnlockDc( dcs );
}
NtGdiDeleteDC (hdcs);
}
- DC_UnlockDc( hDC );
+ DC_UnlockDc( dc );
return success;
}
dc = DC_LockDc (hDC);
if (dc == NULL)
{
- DC_UnlockDc(hdcs);
+ DC_UnlockDc(dcs);
SetLastWin32Error(ERROR_INVALID_HANDLE);
return 0;
}
DC_SetNextDC (dcs, DC_GetNextDC (dc));
DC_SetNextDC (dc, hdcs);
ret = ++dc->saveLevel;
- DC_UnlockDc( hdcs );
- DC_UnlockDc( hDC );
+ DC_UnlockDc( dcs );
+ DC_UnlockDc( dc );
return ret;
}
}
XlateObj = IntGdiCreateBrushXlate(dc, pen, &Failed);
- PENOBJ_UnlockPen(hGDIObj);
+ PENOBJ_UnlockPen(pen);
if (Failed)
{
SetLastWin32Error(ERROR_NO_SYSTEM_RESOURCES);
}
XlateObj = IntGdiCreateBrushXlate(dc, brush, &Failed);
- BRUSHOBJ_UnlockBrush(hGDIObj);
+ BRUSHOBJ_UnlockBrush(brush);
if (Failed)
{
SetLastWin32Error(ERROR_NO_SYSTEM_RESOURCES);
// must be memory dc to select bitmap
if (!(dc->w.flags & DC_MEMORY))
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return NULL;
}
pb = BITMAPOBJ_LockBitmap(hGDIObj);
if (NULL == pb)
{
SetLastWin32Error(ERROR_INVALID_HANDLE);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return NULL;
}
objOrg = (HGDIOBJ)dc->w.hBitmap;
NtGdiSelectObject ( hDC, dc->w.hBrush );
NtGdiSelectObject ( hDC, dc->w.hPen );
- DC_UnlockDc ( hDC );
+ DC_UnlockDc ( dc );
hVisRgn = NtGdiCreateRectRgn ( 0, 0, pb->SurfObj.sizlBitmap.cx, pb->SurfObj.sizlBitmap.cy );
- BITMAPOBJ_UnlockBitmap( hGDIObj );
+ BITMAPOBJ_UnlockBitmap( pb );
NtGdiSelectVisRgn ( hDC, hVisRgn );
NtGdiDeleteObject ( hVisRgn );
return objOrg;
case GDI_OBJECT_TYPE_REGION:
- DC_UnlockDc (hDC);
+ DC_UnlockDc (dc);
/*
* The return value is one of the following values:
* SIMPLEREGION
default:
break;
}
- DC_UnlockDc( hDC );
+ DC_UnlockDc( dc );
return objOrg;
}
dc->w.flags &= ~DC_DIRTY;
}
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return wRet;
}
NewDC->w.hPalette = NtGdiGetStockObject(DEFAULT_PALETTE);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(NewDC);
return hDC;
}
{
GDIOBJ_CopyOwnership(hDC, DC->w.hGCClipRgn);
}
- DC_UnlockDc(hDC);
+ DC_UnlockDc(DC);
}
}
if (!(dc = DC_LockDc(hDC))) return 0;
if (dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return 0;
}
BitmapObj = BITMAPOBJ_LockBitmap(dc->w.hBitmap);
if (BitmapObj == NULL)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return 0;
}
if (BitmapObj->dib == NULL)
{
- BITMAPOBJ_UnlockBitmap(dc->w.hBitmap);
- DC_UnlockDc(hDC);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return 0;
}
Entries = 0;
}
_SEH_END
- PALETTE_UnlockPalette(BitmapObj->hDIBPalette);
+ PALETTE_UnlockPalette(PalGDI);
}
else
Entries = 0;
- BITMAPOBJ_UnlockBitmap(dc->w.hBitmap);
- DC_UnlockDc(hDC);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
+ DC_UnlockDc(dc);
return Entries;
}
if (!(dc = DC_LockDc(hDC))) return 0;
if (dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return 0;
}
BitmapObj = BITMAPOBJ_LockBitmap(dc->w.hBitmap);
if (BitmapObj == NULL)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return 0;
}
if (BitmapObj->dib == NULL)
{
- BITMAPOBJ_UnlockBitmap(dc->w.hBitmap);
- DC_UnlockDc(hDC);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return 0;
}
Entries = 0;
}
_SEH_END
- PALETTE_UnlockPalette(BitmapObj->hDIBPalette);
+ PALETTE_UnlockPalette(PalGDI);
}
else
Entries = 0;
- BITMAPOBJ_UnlockBitmap(dc->w.hBitmap);
- DC_UnlockDc(hDC);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
+ DC_UnlockDc(dc);
return Entries;
}
(PVOID) Bits);
if (0 == SourceBitmap)
{
- BITMAPOBJ_UnlockBitmap(hBitmap);
+ BITMAPOBJ_UnlockBitmap(bitmap);
SetLastWin32Error(ERROR_NO_SYSTEM_RESOURCES);
return 0;
}
SourceSurf = EngLockSurface((HSURF)SourceBitmap);
if (NULL == SourceSurf)
{
- EngDeleteSurface((HSURF)SourceBitmap);
- BITMAPOBJ_UnlockBitmap(hBitmap);
+ EngDeleteSurface((HSURF)SourceBitmap);
+ BITMAPOBJ_UnlockBitmap(bitmap);
SetLastWin32Error(ERROR_NO_SYSTEM_RESOURCES);
return 0;
}
{
EngUnlockSurface(SourceSurf);
EngDeleteSurface((HSURF)SourceBitmap);
- BITMAPOBJ_UnlockBitmap(hBitmap);
+ BITMAPOBJ_UnlockBitmap(bitmap);
SetLastWin32Error(ERROR_INVALID_HANDLE);
return 0;
}
DDB_Palette_Type = hDCPalette->Mode;
DDB_Palette = DC->DevInfo->hpalDefault;
- PALETTE_UnlockPalette(DC->DevInfo->hpalDefault);
+ PALETTE_UnlockPalette(hDCPalette);
// Source palette obtained from the BITMAPINFO
DIB_Palette = BuildDIBPalette ( (PBITMAPINFO)bmi, (PINT)&DIB_Palette_Type );
{
EngUnlockSurface(SourceSurf);
EngDeleteSurface((HSURF)SourceBitmap);
- BITMAPOBJ_UnlockBitmap(hBitmap);
+ BITMAPOBJ_UnlockBitmap(bitmap);
SetLastWin32Error(ERROR_NO_SYSTEM_RESOURCES);
return 0;
}
PALETTE_FreePalette(DIB_Palette);
EngUnlockSurface(SourceSurf);
EngDeleteSurface((HSURF)SourceBitmap);
- BITMAPOBJ_UnlockBitmap(hBitmap);
+ BITMAPOBJ_UnlockBitmap(bitmap);
SetLastWin32Error(ERROR_NO_SYSTEM_RESOURCES);
return 0;
}
// if (ColorUse == DIB_PAL_COLORS)
// WinFree((LPSTR)lpRGB);
- BITMAPOBJ_UnlockBitmap(hBitmap);
+ BITMAPOBJ_UnlockBitmap(bitmap);
return result;
}
}
if (Dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(Dc);
return 0;
}
Ret = IntSetDIBits(Dc, hBitmap, StartScan, ScanLines, Bits, bmi, ColorUse);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(Dc);
return Ret;
}
}
if (Dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(Dc);
return 0;
}
hSourcePalette = Dc->w.hPalette;
/* FIXME: This is incorrect. hDestPalette should be something other. */
hDestPalette = Dc->DevInfo->hpalDefault;
- DC_UnlockDc(hDC);
+ DC_UnlockDc(Dc);
/* Get pointer to the source bitmap object. */
BitmapObj = BITMAPOBJ_LockBitmap(hBitmap);
/* FIXME - SourcePalette can be NULL!!! Don't assert here! */
ASSERT(SourcePalette);
SourcePaletteType = SourcePalette->Mode;
- PALETTE_UnlockPalette(hSourcePalette);
+ PALETTE_UnlockPalette(SourcePalette);
DestPalette = PALETTE_LockPalette(hDestPalette);
/* FIXME - DestPalette can be NULL!!!! Don't assert here!!! */
}
}
- PALETTE_UnlockPalette(hDestPalette);
+ PALETTE_UnlockPalette(DestPalette);
XlateObj = IntEngCreateXlate(
DestPaletteType, SourcePaletteType, hDestPalette, hSourcePalette);
}
}
- BITMAPOBJ_UnlockBitmap(hBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
return Result;
}
if (Bits == NULL)
{
ret = bmp->SurfObj.cjBits;
- BITMAPOBJ_UnlockBitmap (hBitmap);
+ BITMAPOBJ_UnlockBitmap (bmp);
return ret;
}
if (Count == 0)
{
DPRINT("Less then one entire line requested\n");
- BITMAPOBJ_UnlockBitmap (hBitmap);
+ BITMAPOBJ_UnlockBitmap (bmp);
return 0;
}
ret = Count;
}
- BITMAPOBJ_UnlockBitmap (hBitmap);
+ BITMAPOBJ_UnlockBitmap (bmp);
return ret;
}
Bmp = IntCreateDIBitmap(Dc, Header, Init, Bits, Data, ColorUse);
- DC_UnlockDc(hDc);
+ DC_UnlockDc(Dc);
return Bmp;
}
{
hbitmap = DIB_CreateDIBSection ( dc, (BITMAPINFO*)bmi, Usage, Bits,
hSection, dwOffset, 0);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
}
else
{
if (bmp)
{
- BITMAPOBJ_UnlockBitmap(res);
+ BITMAPOBJ_UnlockBitmap(bmp);
}
// Return BITMAP handle and storage location
lpIndex++;
}
// RELEASEDCINFO(hDC);
- PALETTE_UnlockPalette(dc->w.hPalette);
+ PALETTE_UnlockPalette(palGDI);
return lpRGB;
}
IntGdiInitBrushInstance(&FillBrushInst, FillBrushObj, dc->XlateBrush);
ret = FillPolygon ( dc, BitmapObj, &FillBrushInst.BrushObject, ROP2_TO_MIX(dc->w.ROPmode), UnsafePoints, Count, DestRect );
}
- BRUSHOBJ_UnlockBrush(dc->w.hBrush);
+ BRUSHOBJ_UnlockBrush(FillBrushObj);
/* get BRUSHOBJ from current pen. */
PenBrushObj = PENOBJ_LockPen(dc->w.hPen);
ROP2_TO_MIX(dc->w.ROPmode)); /* MIX */
}
}
- PENOBJ_UnlockPen( dc->w.hPen );
+ PENOBJ_UnlockPen(PenBrushObj);
}
- BITMAPOBJ_UnlockBitmap(dc->w.hBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
return ret;
}
}
if (dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
FillBrush = BRUSHOBJ_LockBrush(dc->w.hBrush);
if (NULL == FillBrush)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INTERNAL_ERROR);
return FALSE;
}
PenBrush = PENOBJ_LockPen(dc->w.hPen);
if (NULL == PenBrush)
{
- BRUSHOBJ_UnlockBrush(dc->w.hBrush);
- DC_UnlockDc(hDC);
+ BRUSHOBJ_UnlockBrush(FillBrush);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INTERNAL_ERROR);
return FALSE;
}
BitmapObj = BITMAPOBJ_LockBitmap(dc->w.hBitmap);
if (NULL == BitmapObj)
{
- BRUSHOBJ_UnlockBrush(dc->w.hBrush);
- BITMAPOBJ_UnlockBitmap(dc->w.hBitmap);
- DC_UnlockDc(hDC);
+ BRUSHOBJ_UnlockBrush(FillBrush);
+ PENOBJ_UnlockPen(PenBrush);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INTERNAL_ERROR);
return FALSE;
}
}
} while (B > A);
- BITMAPOBJ_UnlockBitmap(dc->w.hBitmap);
- BRUSHOBJ_UnlockBrush(dc->w.hBrush);
- PENOBJ_UnlockPen(dc->w.hPen);
- DC_UnlockDc(hDC);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
+ BRUSHOBJ_UnlockBrush(FillBrush);
+ PENOBJ_UnlockPen(PenBrush);
+ DC_UnlockDc(dc);
return ret;
}
}
if (dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
FillBrushObj = BRUSHOBJ_LockBrush(dc->w.hBrush);
if (NULL == FillBrushObj)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INTERNAL_ERROR);
return FALSE;
}
ShapePoints = ExAllocatePoolWithTag(PagedPool, 8 * (Right - Left + 1) / 2 * sizeof(SHAPEPOINT), TAG_SHAPE);
if (NULL == ShapePoints)
{
- BRUSHOBJ_UnlockBrush(dc->w.hBrush);
- DC_UnlockDc(hDC);
+ BRUSHOBJ_UnlockBrush(FillBrushObj);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
if (Left == Right)
{
PUTPIXEL(Left, Top, &PenBrushObj);
- BRUSHOBJ_UnlockBrush(dc->w.hBrush);
- DC_UnlockDc(hDC);
+ BRUSHOBJ_UnlockBrush(FillBrushObj);
+ DC_UnlockDc(dc);
return ret;
}
}
ExFreePool(ShapePoints);
- BRUSHOBJ_UnlockBrush(dc->w.hBrush);
- DC_UnlockDc(hDC);
+ BRUSHOBJ_UnlockBrush(FillBrushObj);
+ DC_UnlockDc(dc);
return ret;
#else
{
if (dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
ExFreePool(Safept);
}
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
}
return Ret;
}
if (dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
Safept = ExAllocatePoolWithTag(PagedPool, (sizeof(POINT) + sizeof(INT)) * Count, TAG_SHAPE);
if(!Safept)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
Status = MmCopyFromCaller(Safept, Points, sizeof(POINT) * Count);
if(!NT_SUCCESS(Status))
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
ExFreePool(Safept);
SetLastNtError(Status);
return FALSE;
Status = MmCopyFromCaller(SafePolyPoints, PolyCounts, sizeof(INT) * Count);
if(!NT_SUCCESS(Status))
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
ExFreePool(Safept);
SetLastNtError(Status);
return FALSE;
}
else
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return FALSE;
}
Ret = IntGdiPolyPolygon(dc, Safept, SafePolyPoints, Count);
ExFreePool(Safept);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return Ret;
}
}
}
- BRUSHOBJ_UnlockBrush(dc->w.hBrush);
+ BRUSHOBJ_UnlockBrush(FillBrushObj);
/* get BRUSHOBJ from current pen. */
PenBrushObj = PENOBJ_LockPen(dc->w.hPen);
if (PenBrushObj == NULL)
{
SetLastWin32Error(ERROR_INVALID_HANDLE);
- BITMAPOBJ_UnlockBitmap(dc->w.hBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
return FALSE;
}
Mix);
}
- PENOBJ_UnlockPen(dc->w.hPen);
+ PENOBJ_UnlockPen(PenBrushObj);
}
- BITMAPOBJ_UnlockBitmap(dc->w.hBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
/* Move current position in DC?
MSDN: The current position is neither used nor updated by Rectangle. */
}
if (dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
ret = IntRectangle ( dc, LeftRect, TopRect, RightRect, BottomRect );
- DC_UnlockDc ( hDC );
+ DC_UnlockDc ( dc );
return ret;
}
if (!BitmapObj)
{
/* Nothing to do, as we don't have a bitmap */
- BITMAPOBJ_UnlockBitmap(dc->w.hBitmap);
SetLastWin32Error(ERROR_INTERNAL_ERROR);
return FALSE;
}
if (FillBrushObj->flAttrs & GDIBRUSH_IS_NULL)
{
/* make null brush check simpler... */
- BRUSHOBJ_UnlockBrush(dc->w.hBrush);
+ BRUSHOBJ_UnlockBrush(FillBrushObj);
FillBrushObj = NULL;
}
else
if (PenBrushObj->flAttrs & GDIBRUSH_IS_NULL)
{
/* make null pen check simpler... */
- PENOBJ_UnlockPen(dc->w.hPen);
+ PENOBJ_UnlockPen(PenBrushObj);
PenBrushObj = NULL;
}
else
PUTLINE ( left, y2, left, y1, PenBrushInst );
}
- BITMAPOBJ_UnlockBitmap(dc->w.hBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
if(PenBrushObj != NULL)
- PENOBJ_UnlockPen(dc->w.hPen);
+ PENOBJ_UnlockPen(PenBrushObj);
if(FillBrushObj != NULL)
- BRUSHOBJ_UnlockBrush(dc->w.hBrush);
+ BRUSHOBJ_UnlockBrush(FillBrushObj);
return ret;
}
}
else if (dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
/* Yes, Windows really returns TRUE in this case */
ret = TRUE;
}
else
{
ret = IntRoundRect ( dc, LeftRect, TopRect, RightRect, BottomRect, Width, Height );
- DC_UnlockDc ( hDC );
+ DC_UnlockDc ( dc );
}
return ret;
/* FIXME - PalDestGDI can be NULL!!! Don't assert but handle this case gracefully! */
ASSERT(PalDestGDI);
Mode = PalDestGDI->Mode;
- PALETTE_UnlockPalette(dc->w.hPalette);
+ PALETTE_UnlockPalette(PalDestGDI);
XlateObj = (XLATEOBJ*)IntEngCreateXlate(Mode, PAL_RGB, dc->w.hPalette, NULL);
ASSERT(XlateObj);
&DitherOrg,
ulMode);
- BITMAPOBJ_UnlockBitmap(dc->w.hBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
EngDeleteXlate(XlateObj);
return Ret;
}
if (dc->IsIC)
{
- DC_UnlockDc(hdc);
+ DC_UnlockDc(dc);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
if(!pVertex || !uVertex || !pMesh || !uMesh)
{
- DC_UnlockDc(hdc);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return FALSE;
}
SizeMesh = uMesh * sizeof(TRIVERTEX);
break;
default:
- DC_UnlockDc(hdc);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return FALSE;
}
if(!(SafeVertex = ExAllocatePoolWithTag(PagedPool, (uVertex * sizeof(TRIVERTEX)) + SizeMesh, TAG_SHAPE)))
{
- DC_UnlockDc(hdc);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
Status = MmCopyFromCaller(SafeVertex, pVertex, uVertex * sizeof(TRIVERTEX));
if(!NT_SUCCESS(Status))
{
- DC_UnlockDc(hdc);
+ DC_UnlockDc(dc);
ExFreePool(SafeVertex);
SetLastNtError(Status);
return FALSE;
Status = MmCopyFromCaller(SafeMesh, pMesh, SizeMesh);
if(!NT_SUCCESS(Status))
{
- DC_UnlockDc(hdc);
+ DC_UnlockDc(dc);
ExFreePool(SafeVertex);
SetLastNtError(Status);
return FALSE;
Ret = IntGdiGradientFill(dc, SafeVertex, uVertex, SafeMesh, uMesh, ulMode);
- DC_UnlockDc(hdc);
+ DC_UnlockDc(dc);
ExFreePool(SafeVertex);
return Ret;
}
for ( j = 0; j < GDI_STACK_LEVELS; j++ )
{
ULONG Addr = GDIHandleAllocator[h[i].idx][j];
- if ( !KeRosPrintAddress ( (PVOID)Addr ) )
+ if ( !KiRosPrintAddress ( (PVOID)Addr ) )
DbgPrint ( "<%X>", Addr );
}
DbgPrint ( "\n" );
GdiHdr = GDIBdyToHdr(Entry->KernelData);
- if(GdiHdr->LockingThread == NULL)
+ if(GdiHdr->Locks == 0)
{
BOOL Ret;
PW32PROCESS W32Process = PsGetWin32Process();
}
else
{
- /* the object is currently locked. just clear the type field so when the
- object gets unlocked it will be finally deleted from the table. Also
- incrment the reuse counter! */
- Entry->Type = ((Entry->Type >> GDI_HANDLE_REUSECNT_SHIFT) + 1) << GDI_HANDLE_REUSECNT_SHIFT;
-
- /* unlock the handle slot */
- InterlockedExchangePointer(&Entry->ProcessId, NULL);
-
- /* report a successful deletion as the object is actually removed from the table */
- return TRUE;
+ /*
+ * The object is currently locked, so freeing is forbidden!
+ */
+ DPRINT1("GdiHdr->Locks: %d\n", GdiHdr->Locks);
+ ASSERT(FALSE);
}
}
else
GDIOBJ_LockObj (HGDIOBJ hObj, DWORD ObjectType)
#endif /* GDI_DEBUG */
{
- PGDI_TABLE_ENTRY Entry;
- PETHREAD Thread;
- HANDLE ProcessId, LockedProcessId, PrevProcId;
- LONG ExpectedType;
+ USHORT HandleIndex;
+ PGDI_TABLE_ENTRY HandleEntry;
+ HANDLE ProcessId, HandleProcessId, LockedProcessId, PrevProcId;
+ PGDIOBJ Object = NULL;
+
+ HandleIndex = GDI_HANDLE_GET_INDEX(hObj);
+
+ /* Check that the handle index is valid. */
+ if (HandleIndex >= GDI_HANDLE_COUNT)
+ return NULL;
+
+ HandleEntry = &HandleTable->Entries[HandleIndex];
+
+ ProcessId = (HANDLE)((ULONG_PTR)PsGetCurrentProcessId() & ~1);
+ HandleProcessId = (HANDLE)((ULONG_PTR)HandleEntry->ProcessId & ~1);
+
+ /* Check for invalid owner. */
+ if (ProcessId != HandleProcessId && HandleProcessId != NULL)
+ {
+ return NULL;
+ }
+
+ /*
+ * Prevent the thread from being terminated during the locking process.
+ * It would result in undesired effects and inconsistency of the global
+ * handle table.
+ */
+
+ KeEnterCriticalRegion();
+
+ /*
+ * Loop until we either successfully lock the handle entry & object or
+ * fail some of the check.
+ */
+
+ for (;;)
+ {
+ /* Lock the handle table entry. */
+ LockedProcessId = (HANDLE)((ULONG_PTR)HandleProcessId | 0x1);
+ PrevProcId = InterlockedCompareExchangePointer(&HandleEntry->ProcessId,
+ LockedProcessId,
+ HandleProcessId);
+
+ if (PrevProcId == HandleProcessId)
+ {
+ LONG HandleType = HandleEntry->Type << 16;
+
+ /*
+ * We're locking an object that belongs to our process or it's a
+ * global object if HandleProcessId is 0 here.
+ */
+
+ /* FIXME: Check the upper 16-bits of handle number! */
+ if (HandleType != 0 && HandleEntry->KernelData != NULL &&
+ (ObjectType == GDI_OBJECT_TYPE_DONTCARE ||
+ HandleType == ObjectType))
+ {
+ PGDIOBJHDR GdiHdr = GDIBdyToHdr(HandleEntry->KernelData);
+ PETHREAD Thread = PsGetCurrentThread();
+
+ if (GdiHdr->Locks == 0)
+ {
+ GdiHdr->LockingThread = Thread;
+ GdiHdr->Locks = 1;
+ Object = HandleEntry->KernelData;
+ }
+ else
+ {
+ InterlockedIncrement(&GdiHdr->Locks);
+ if (GdiHdr->LockingThread != Thread)
+ {
+ InterlockedDecrement(&GdiHdr->Locks);
+
+ /* Unlock the handle table entry. */
+ InterlockedExchangePointer(&HandleEntry->ProcessId, PrevProcId);
+
+ DelayExecution();
+ continue;
+ }
+ Object = HandleEntry->KernelData;
+ }
+ }
+ else
+ {
+ /*
+ * Debugging code. Report attempts to lock deleted handles and
+ * locking type mismatches.
+ */
+
+ if ((HandleType & ~GDI_HANDLE_REUSE_MASK) == 0)
+ {
+ DPRINT1("Attempted to lock object 0x%x that is deleted!\n", hObj);
#ifdef GDI_DEBUG
- ULONG Attempts = 0;
+ KeRosDumpStackFrames(NULL, 20);
#endif
-
- DPRINT("GDIOBJ_LockObj: hObj: 0x%08x\n", hObj);
-
- Thread = PsGetCurrentThread();
-
- ProcessId = PsGetCurrentProcessId();
- LockedProcessId = (HANDLE)((ULONG_PTR)ProcessId | 0x1);
-
- ExpectedType = ((ObjectType != GDI_OBJECT_TYPE_DONTCARE) ? ObjectType : 0);
-
- Entry = GDI_HANDLE_GET_ENTRY(HandleTable, hObj);
-
-LockHandle:
- /* lock the object, we must not delete stock objects, so don't check!!! */
- PrevProcId = InterlockedCompareExchangePointer(&Entry->ProcessId, LockedProcessId, ProcessId);
- if(PrevProcId == ProcessId)
- {
- LONG EntryType = Entry->Type << 16;
-
- /* we're locking an object that belongs to our process or it's a global
- object if ProcessId == 0 here. ProcessId can only be 0 here if it previously
- failed to lock the object and it turned out to be a global object. */
- if(EntryType != 0 && Entry->KernelData != NULL &&
- (ExpectedType == 0 || (EntryType == ExpectedType)))
- {
- PETHREAD PrevThread;
- PGDIOBJHDR GdiHdr;
-
- GdiHdr = GDIBdyToHdr(Entry->KernelData);
-
- /* save the pointer to the calling thread so we know it was this thread
- that locked the object. There's no need to do this atomically as we're
- holding the lock of the handle slot, but this way it's easier ;) */
- PrevThread = InterlockedCompareExchangePointer(&GdiHdr->LockingThread, Thread, NULL);
-
- if(PrevThread == NULL || PrevThread == Thread)
- {
- if(++GdiHdr->Locks == 1)
- {
+ }
+ else
+ {
+ DPRINT1("Attempted to lock object 0x%x, type mismatch (0x%x : 0x%x)\n",
+ hObj, HandleType & ~GDI_HANDLE_REUSE_MASK, ObjectType & ~GDI_HANDLE_REUSE_MASK);
#ifdef GDI_DEBUG
- GdiHdr->lockfile = file;
- GdiHdr->lockline = line;
+ KeRosDumpStackFrames(NULL, 20);
#endif
- }
-
- InterlockedExchangePointer(&Entry->ProcessId, PrevProcId);
-
- /* we're done, return the object body */
- return GDIHdrToBdy(GdiHdr);
- }
- else
- {
- InterlockedExchangePointer(&Entry->ProcessId, PrevProcId);
-
+ }
#ifdef GDI_DEBUG
- if(++Attempts > 20)
- {
- DPRINT1("[%d]Waiting at %s:%i as 0x%x on 0x%x\n", Attempts, file, line, Thread, PrevThread);
- }
+ DPRINT1("-> called from %s:%i\n", file, line);
#endif
+ }
- DelayExecution();
- goto LockHandle;
- }
- }
- else
- {
- InterlockedExchangePointer(&Entry->ProcessId, PrevProcId);
+ /* Unlock the handle table entry. */
+ InterlockedExchangePointer(&HandleEntry->ProcessId, PrevProcId);
- if((EntryType & ~GDI_HANDLE_REUSE_MASK) == 0)
- {
- DPRINT1("Attempted to lock object 0x%x that is deleted!\n", hObj);
-#ifdef GDI_DEBUG
- KeRosDumpStackFrames ( NULL, 20 );
-#endif
+ break;
}
else
{
- DPRINT1("Attempted to lock object 0x%x, type mismatch (0x%x : 0x%x)\n",
- hObj, EntryType & ~GDI_HANDLE_REUSE_MASK, ExpectedType & ~GDI_HANDLE_REUSE_MASK);
-#ifdef GDI_DEBUG
- KeRosDumpStackFrames ( NULL, 20 );
-#endif
+ /*
+ * The handle is currently locked, wait some time and try again.
+ */
+
+ DelayExecution();
+ continue;
}
-#ifdef GDI_DEBUG
- DPRINT1("-> called from %s:%i\n", file, line);
-#endif
- }
- }
- else if(PrevProcId == LockedProcessId)
- {
-#ifdef GDI_DEBUG
- if(++Attempts > 20)
- {
- DPRINT1("[%d]Waiting from %s:%i on 0x%x\n", Attempts, file, line, hObj);
- }
-#endif
- /* the handle is currently locked, wait some time and try again.
- FIXME - we shouldn't loop forever! Give up after some time! */
- DelayExecution();
- /* try again */
- goto LockHandle;
- }
- else if(((ULONG_PTR)PrevProcId & ~0x1) == 0)
- {
- /* we're trying to lock a global object, change the ProcessId to 0 and try again */
- ProcessId = NULL;
- LockedProcessId = (HANDLE)((ULONG_PTR)ProcessId | 0x1);
+ }
- goto LockHandle;
- }
- else
- {
- DPRINT1("Attempted to lock foreign handle: 0x%x, Owner: 0x%x locked: 0x%x Caller: 0x%x, stockobj: 0x%x\n", hObj, (ULONG_PTR)PrevProcId & ~0x1, (ULONG_PTR)PrevProcId & 0x1, PsGetCurrentProcessId(), GDI_HANDLE_IS_STOCKOBJ(hObj));
-#ifdef GDI_DEBUG
- KeRosDumpStackFrames ( NULL, 20 );
- DPRINT1("-> called from %s:%i\n", file, line);
-#endif
- }
+ KeLeaveCriticalRegion();
- return NULL;
+ return Object;
}
/*!
- * Release GDI object. Every object locked by GDIOBJ_LockObj() must be unlocked. You should unlock the object
- * as soon as you don't need to have access to it's data.
-
+ * Return pointer to the object by handle (and allow sharing of the handle
+ * across threads).
+ *
* \param hObj Object handle
+ * \return Pointer to the object.
*
- * \note This function performs delayed cleanup. If the object is locked when GDI_FreeObj() is called
- * then \em this function frees the object when reference count is zero.
+ * \note Process can only get pointer to the objects it created or global objects.
+ *
+ * \todo Get rid of the ObjectType parameter!
*/
-BOOL INTERNAL_CALL
+PGDIOBJ INTERNAL_CALL
#ifdef GDI_DEBUG
-GDIOBJ_UnlockObjDbg (const char* file, int line, HGDIOBJ hObj)
+GDIOBJ_ShareLockObjDbg (const char* file, int line, HGDIOBJ hObj, DWORD ObjectType)
#else /* !GDI_DEBUG */
-GDIOBJ_UnlockObj (HGDIOBJ hObj)
+GDIOBJ_ShareLockObj (HGDIOBJ hObj, DWORD ObjectType)
#endif /* GDI_DEBUG */
{
- PGDI_TABLE_ENTRY Entry;
- PETHREAD Thread;
- HANDLE ProcessId, LockedProcessId, PrevProcId;
+ USHORT HandleIndex;
+ PGDI_TABLE_ENTRY HandleEntry;
+ HANDLE ProcessId, HandleProcessId, LockedProcessId, PrevProcId;
+ PGDIOBJ Object = NULL;
+
+ HandleIndex = GDI_HANDLE_GET_INDEX(hObj);
+
+ /* Check that the handle index is valid. */
+ if (HandleIndex >= GDI_HANDLE_COUNT)
+ return NULL;
+
+ HandleEntry = &HandleTable->Entries[HandleIndex];
+
+ ProcessId = (HANDLE)((ULONG_PTR)PsGetCurrentProcessId() & ~1);
+ HandleProcessId = (HANDLE)((ULONG_PTR)HandleEntry->ProcessId & ~1);
+
+ /* Check for invalid owner. */
+ if (ProcessId != HandleProcessId && HandleProcessId != NULL)
+ {
+ return NULL;
+ }
+
+ /*
+ * Prevent the thread from being terminated during the locking process.
+ * It would result in undesired effects and inconsistency of the global
+ * handle table.
+ */
+
+ KeEnterCriticalRegion();
+
+ /*
+ * Loop until we either successfully lock the handle entry & object or
+ * fail some of the check.
+ */
+
+ for (;;)
+ {
+ /* Lock the handle table entry. */
+ LockedProcessId = (HANDLE)((ULONG_PTR)HandleProcessId | 0x1);
+ PrevProcId = InterlockedCompareExchangePointer(&HandleEntry->ProcessId,
+ LockedProcessId,
+ HandleProcessId);
+
+ if (PrevProcId == HandleProcessId)
+ {
+ LONG HandleType = HandleEntry->Type << 16;
+
+ /*
+ * We're locking an object that belongs to our process or it's a
+ * global object if HandleProcessId is 0 here.
+ */
+
+ /* FIXME: Check the upper 16-bits of handle number! */
+ if (HandleType != 0 && HandleEntry->KernelData != NULL &&
+ (ObjectType == GDI_OBJECT_TYPE_DONTCARE ||
+ HandleType == ObjectType))
+ {
+ PGDIOBJHDR GdiHdr = GDIBdyToHdr(HandleEntry->KernelData);
+
+ InterlockedIncrement(&GdiHdr->Locks);
+ Object = HandleEntry->KernelData;
+ }
+ else
+ {
+ /*
+ * Debugging code. Report attempts to lock deleted handles and
+ * locking type mismatches.
+ */
+
+ if ((HandleType & ~GDI_HANDLE_REUSE_MASK) == 0)
+ {
+ DPRINT1("Attempted to lock object 0x%x that is deleted!\n", hObj);
#ifdef GDI_DEBUG
- ULONG Attempts = 0;
+ KeRosDumpStackFrames(NULL, 20);
#endif
-
- DPRINT("GDIOBJ_UnlockObj: hObj: 0x%08x\n", hObj);
- Thread = PsGetCurrentThread();
-
- ProcessId = PsGetCurrentProcessId();
- LockedProcessId = (HANDLE)((ULONG_PTR)ProcessId | 0x1);
-
- Entry = GDI_HANDLE_GET_ENTRY(HandleTable, hObj);
-
-LockHandle:
- /* lock the handle, we must not delete stock objects, so don't check!!! */
- PrevProcId = InterlockedCompareExchangePointer(&Entry->ProcessId, LockedProcessId, ProcessId);
- if(PrevProcId == ProcessId)
- {
- /* we're unlocking an object that belongs to our process or it's a global
- object if ProcessId == 0 here. ProcessId can only be 0 here if it previously
- failed to lock the object and it turned out to be a global object. */
- if(Entry->KernelData != NULL)
- {
- PETHREAD PrevThread;
- PGDIOBJHDR GdiHdr;
-
- GdiHdr = GDIBdyToHdr(Entry->KernelData);
-
- PrevThread = GdiHdr->LockingThread;
- if(PrevThread == Thread)
- {
- BOOL Ret;
-
- if(--GdiHdr->Locks == 0)
- {
- GdiHdr->LockingThread = NULL;
-
+ }
+ else
+ {
+ DPRINT1("Attempted to lock object 0x%x, type mismatch (0x%x : 0x%x)\n",
+ hObj, HandleType & ~GDI_HANDLE_REUSE_MASK, ObjectType & ~GDI_HANDLE_REUSE_MASK);
#ifdef GDI_DEBUG
- GdiHdr->lockfile = NULL;
- GdiHdr->lockline = 0;
+ KeRosDumpStackFrames(NULL, 20);
#endif
- }
-
- if((Entry->Type & ~GDI_HANDLE_REUSE_MASK) == 0 && GdiHdr->Locks == 0)
- {
- PPAGED_LOOKASIDE_LIST LookasideList;
- PW32PROCESS W32Process = PsGetWin32Process();
- DWORD Type = GDI_HANDLE_GET_TYPE(hObj);
+ }
+#ifdef GDI_DEBUG
+ DPRINT1("-> called from %s:%i\n", file, line);
+#endif
+ }
- ASSERT(ProcessId != 0); /* must not delete a global handle!!!! */
+ /* Unlock the handle table entry. */
+ InterlockedExchangePointer(&HandleEntry->ProcessId, PrevProcId);
- /* we should delete the handle */
- Entry->KernelData = NULL;
- InterlockedExchangePointer(&Entry->ProcessId, 0);
+ break;
+ }
+ else
+ {
+ /*
+ * The handle is currently locked, wait some time and try again.
+ */
- InterlockedPushEntrySList(&HandleTable->FreeEntriesHead,
- &HandleTable->FreeEntries[GDI_ENTRY_TO_INDEX(HandleTable, Entry)]);
+ DelayExecution();
+ continue;
+ }
+ }
- if(W32Process != NULL)
- {
- InterlockedDecrement(&W32Process->GDIObjects);
- }
+ KeLeaveCriticalRegion();
- /* call the cleanup routine. */
- Ret = RunCleanupCallback(GDIHdrToBdy(GdiHdr), Type);
+ return Object;
+}
- /* Now it's time to free the memory */
- LookasideList = FindLookasideList(Type);
- if(LookasideList != NULL)
- {
- ExFreeToPagedLookasideList(LookasideList, GdiHdr);
- }
- }
- else
- {
- /* remove the handle slot lock */
- InterlockedExchangePointer(&Entry->ProcessId, PrevProcId);
- Ret = TRUE;
- }
- /* we're done*/
- return Ret;
- }
-#ifdef GDI_DEBUG
- else if(PrevThread != NULL)
- {
- DPRINT1("Attempted to unlock object 0x%x, previously locked by other thread (0x%x) from %s:%i (called from %s:%i)\n",
- hObj, PrevThread, GdiHdr->lockfile, GdiHdr->lockline, file, line);
- InterlockedExchangePointer(&Entry->ProcessId, PrevProcId);
- }
-#endif
- else
- {
-#ifdef GDI_DEBUG
- if(++Attempts > 20)
- {
- DPRINT1("[%d]Waiting at %s:%i as 0x%x on 0x%x\n", Attempts, file, line, Thread, PrevThread);
- }
-#endif
- /* FIXME - we should give up after some time unless we want to wait forever! */
- InterlockedExchangePointer(&Entry->ProcessId, PrevProcId);
+/*!
+ * Release GDI object. Every object locked by GDIOBJ_LockObj() must be unlocked. You should unlock the object
+ * as soon as you don't need to have access to it's data.
- DelayExecution();
- goto LockHandle;
- }
- }
- else
- {
- InterlockedExchangePointer(&Entry->ProcessId, PrevProcId);
- DPRINT1("Attempted to unlock object 0x%x that is deleted!\n", hObj);
- }
- }
- else if(PrevProcId == LockedProcessId)
- {
+ * \param Object Object pointer (as returned by GDIOBJ_LockObj).
+ */
+VOID INTERNAL_CALL
+GDIOBJ_UnlockObjByPtr(PGDIOBJ Object)
+{
+ PGDIOBJHDR GdiHdr = GDIBdyToHdr(Object);
#ifdef GDI_DEBUG
- if(++Attempts > 20)
- {
- DPRINT1("[%d]Waiting from %s:%i on 0x%x\n", Attempts, file, line, hObj);
- }
+ if (InterlockedDecrement(&GdiHdr->Locks) == 0)
+ {
+ GdiHdr->lockfile = NULL;
+ GdiHdr->lockline = 0;
+ }
+#else
+ InterlockedDecrement(&GdiHdr->Locks);
#endif
- /* the handle is currently locked, wait some time and try again.
- FIXME - we shouldn't loop forever! Give up after some time! */
- DelayExecution();
- /* try again */
- goto LockHandle;
- }
- else if(((ULONG_PTR)PrevProcId & ~0x1) == 0)
- {
- /* we're trying to unlock a global object, change the ProcessId to 0 and try again */
- ProcessId = NULL;
- LockedProcessId = (HANDLE)((ULONG_PTR)ProcessId | 0x1);
-
- goto LockHandle;
- }
- else
- {
- DPRINT1("Attempted to unlock foreign handle: 0x%x, Owner: 0x%x locked: 0x%x Caller: 0x%x, stockobj: 0x%x\n", hObj, (ULONG_PTR)PrevProcId & ~0x1, (ULONG_PTR)PrevProcId & 0x1, PsGetCurrentProcessId(), GDI_HANDLE_IS_STOCKOBJ(hObj));
- }
-
- return FALSE;
}
+
BOOL INTERNAL_CALL
GDIOBJ_OwnedByCurrentProcess(HGDIOBJ ObjectHandle)
{
GdiHdr = GDIBdyToHdr(Entry->KernelData);
PrevThread = GdiHdr->LockingThread;
- if(PrevThread == NULL || PrevThread == Thread)
+ if(GdiHdr->Locks == 0 || PrevThread == Thread)
{
/* dereference the process' object counter */
if(PrevProcId != GDI_GLOBAL_PROCESS)
PGDIOBJHDR GdiHdr = GDIBdyToHdr(Entry->KernelData);
PrevThread = GdiHdr->LockingThread;
- if(PrevThread == NULL || PrevThread == Thread)
+ if(GdiHdr->Locks == 0 || PrevThread == Thread)
{
PEPROCESS OldProcess;
PW32PROCESS W32Process;
/* save the pointer to the calling thread so we know it was this thread
that locked the object */
PrevThread = GdiHdr->LockingThread;
- if(PrevThread == NULL || PrevThread == Thread)
+ if(GdiHdr->Locks == 0 || PrevThread == Thread)
{
/* now let's change the ownership of the target object */
ROP2_TO_MIX(dc->w.ROPmode));
}
- BITMAPOBJ_UnlockBitmap ( dc->w.hBitmap );
- PENOBJ_UnlockPen( dc->w.hPen );
+ BITMAPOBJ_UnlockBitmap ( BitmapObj );
+ PENOBJ_UnlockPen( PenBrushObj );
}
if (Ret)
&PenBrushInst.BrushObject, Points, Count,
ROP2_TO_MIX(dc->w.ROPmode));
- BITMAPOBJ_UnlockBitmap(dc->w.hBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
EngFreeMem(Points);
}
else
}
}
- PENOBJ_UnlockPen(dc->w.hPen);
+ PENOBJ_UnlockPen(PenBrushObj);
return Ret;
}
}
if (dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
XEndArc,
YEndArc);
- DC_UnlockDc( hDC );
+ DC_UnlockDc( dc );
return Ret;
}
}
if (dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
// Line from current position to starting point of arc
if ( !IntGdiLineTo(dc, XRadial1, YRadial1) )
{
- DC_UnlockDc( hDC );
+ DC_UnlockDc(dc);
return FALSE;
}
result = IntGdiArc(dc, LeftRect, TopRect, RightRect, BottomRect,
XRadial1, YRadial1, XRadial2, YRadial2);
- //DC_UnlockDc( hDC );
+ //DC_UnlockDc(dc);
// If no error occured, the current position is moved to the ending point of the arc.
if(result)
IntGdiMoveToEx(dc, XRadial2, YRadial2, NULL);
- DC_UnlockDc( hDC );
+ DC_UnlockDc(dc);
return result;
}
if ( dc )
{
ret = IntGdiGetArcDirection ( dc );
- DC_UnlockDc( hDC );
+ DC_UnlockDc(dc);
}
else
{
}
if (dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
Ret = IntGdiLineTo(dc, XEnd, YEnd);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return Ret;
}
}
if (dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
Status = MmCopyFromCaller(&SafePoint, Point, sizeof(POINT));
if(!NT_SUCCESS(Status))
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastNtError(Status);
return FALSE;
}
Ret = IntGdiMoveToEx(dc, X, Y, (Point ? &SafePoint : NULL));
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return Ret;
}
}
if (dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
Safept = ExAllocatePoolWithTag(PagedPool, sizeof(POINT) * Count, TAG_BEZIER);
if(!Safept)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
Status = MmCopyFromCaller(Safept, pt, sizeof(POINT) * Count);
if(!NT_SUCCESS(Status))
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastNtError(Status);
return FALSE;
}
}
else
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return FALSE;
}
Ret = IntGdiPolyBezier(dc, Safept, Count);
ExFreePool(Safept);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return Ret;
}
}
if (dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
Safept = ExAllocatePoolWithTag(PagedPool, sizeof(POINT) * Count, TAG_BEZIER);
if(!Safept)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
Status = MmCopyFromCaller(Safept, pt, sizeof(POINT) * Count);
if(!NT_SUCCESS(Status))
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastNtError(Status);
return FALSE;
}
}
else
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return FALSE;
}
Ret = IntGdiPolyBezierTo(dc, Safept, Count);
ExFreePool(Safept);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return Ret;
}
}
if (dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
Safept = ExAllocatePoolWithTag(PagedPool, sizeof(POINT) * Count, TAG_SHAPE);
if(!Safept)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
Status = MmCopyFromCaller(Safept, pt, sizeof(POINT) * Count);
if(!NT_SUCCESS(Status))
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastNtError(Status);
return FALSE;
}
}
else
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return FALSE;
}
Ret = IntGdiPolyline(dc, Safept, Count);
ExFreePool(Safept);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return Ret;
}
}
if (dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
Safept = ExAllocatePoolWithTag(PagedPool, sizeof(POINT) * Count, TAG_SHAPE);
if(!Safept)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
Status = MmCopyFromCaller(Safept, pt, sizeof(POINT) * Count);
if(!NT_SUCCESS(Status))
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastNtError(Status);
return FALSE;
}
}
else
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return FALSE;
}
Ret = IntGdiPolylineTo(dc, Safept, Count);
ExFreePool(Safept);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return Ret;
}
}
if (dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
Safept = ExAllocatePoolWithTag(PagedPool, (sizeof(POINT) + sizeof(DWORD)) * Count, TAG_SHAPE);
if(!Safept)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
Status = MmCopyFromCaller(Safept, pt, sizeof(POINT) * Count);
if(!NT_SUCCESS(Status))
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
ExFreePool(Safept);
SetLastNtError(Status);
return FALSE;
Status = MmCopyFromCaller(SafePolyPoints, PolyPoints, sizeof(DWORD) * Count);
if(!NT_SUCCESS(Status))
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
ExFreePool(Safept);
SetLastNtError(Status);
return FALSE;
}
else
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return FALSE;
}
Ret = IntGdiPolyPolyline(dc, Safept, SafePolyPoints, Count);
ExFreePool(Safept);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return Ret;
}
dc->w.ArcDirection = ArcDirection;
}
- DC_UnlockDc( hDC );
+ DC_UnlockDc( dc );
return nOldDirection;
}
/* EOF */
PalGDI->IndexedColors = ExAllocatePoolWithTag(PagedPool, sizeof(PALETTEENTRY) * NumColors, TAG_PALETTE);
if (NULL == PalGDI->IndexedColors)
{
- PALETTE_UnlockPalette(NewPalette);
+ PALETTE_UnlockPalette(PalGDI);
PALETTE_FreePalette(NewPalette);
return NULL;
}
PalGDI->BlueMask = Blue;
}
- PALETTE_UnlockPalette(NewPalette);
+ PALETTE_UnlockPalette(PalGDI);
return NewPalette;
}
PalGDI->IndexedColors = ExAllocatePoolWithTag(PagedPool, sizeof(PALETTEENTRY) * NumColors, TAG_PALETTE);
if (NULL == PalGDI->IndexedColors)
{
- PALETTE_UnlockPalette(NewPalette);
+ PALETTE_UnlockPalette(PalGDI);
PALETTE_FreePalette(NewPalette);
return NULL;
}
PalGDI->NumColors = NumColors;
- PALETTE_UnlockPalette(NewPalette);
+ PALETTE_UnlockPalette(PalGDI);
return NewPalette;
}
DbgPrint("Win32k: Can not create palette mapping -- out of memory!");
return FALSE;
}
- PALETTE_UnlockPalette(hpalette);
+ PALETTE_UnlockPalette(palObj);
}
#endif
/* FIXME - handle pSysPal == NULL!!!!!!! */
COLOR_sysPal = pSysPal->IndexedColors;
- PALETTE_UnlockPalette(hSysPal); // FIXME: Is this a right way to obtain pointer to the system palette?
+ PALETTE_UnlockPalette(pSysPal); // FIXME: Is this a right way to obtain pointer to the system palette?
// reset dynamic system palette entries
if ( dc )
{
ret = IntCloseFigure ( dc );
- DC_UnlockDc ( hDC );
+ DC_UnlockDc ( dc );
}
return ret;
DPRINT1("FIXME: IntGdiCreatePenIndirect is UNIMPLEMENTED\n");
}
- PENOBJ_UnlockPen(hPen);
+ PENOBJ_UnlockPen(PenObject);
return hPen;
}
/* TODO FIXME - don't pass umode buffer to an Int function */
ret = IntGdiEscape(dc, Escape, InSize, InData, OutData);
- DC_UnlockDc( hDC );
+ DC_UnlockDc( dc );
return ret;
}
OutSize,
(PVOID)OutData );
}
- BITMAPOBJ_UnlockBitmap(dc->w.hBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
return Result;
}
}
if ( pDC->IsIC )
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(pDC);
return 0;
}
SafeInData = ExAllocatePoolWithTag ( PagedPool, InSize, TAG_PRINT );
if ( !SafeInData )
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(pDC);
SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
return -1;
}
if ( !NT_SUCCESS(Status) )
{
ExFreePool ( SafeInData );
- DC_UnlockDc(hDC);
+ DC_UnlockDc(pDC);
SetLastNtError(Status);
return -1;
}
{
if ( SafeInData )
ExFreePool ( SafeInData );
- DC_UnlockDc(hDC);
+ DC_UnlockDc(pDC);
SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
return -1;
}
Result = IntGdiExtEscape ( pDC, Escape, InSize, SafeInData, OutSize, SafeOutData );
- DC_UnlockDc(hDC);
+ DC_UnlockDc(pDC);
if ( SafeInData )
ExFreePool ( SafeInData );
Data->rdh.rcBound.bottom,
Data->rdh.iType);
- RGNDATA_UnlockRgn(hRgn);
+ RGNDATA_UnlockRgn(Data);
}
#endif /* NDEBUG */
objSrc = RGNDATA_LockRgn(hSrc);
if(objSrc == NULL)
{
- RGNDATA_UnlockRgn(hDst);
+ RGNDATA_UnlockRgn(rgnDst);
return NULL;
}
if(!lpPt)
hRet = hDst;
}
- RGNDATA_UnlockRgn(hSrc);
- RGNDATA_UnlockRgn(hDst);
+ RGNDATA_UnlockRgn(objSrc);
+ RGNDATA_UnlockRgn(rgnDst);
return hRet;
}
trb = RGNDATA_LockRgn( htrb );
if( !trb ){
- RGNDATA_UnlockRgn( htra );
+ RGNDATA_UnlockRgn( tra );
NtGdiDeleteObject( htra );
NtGdiDeleteObject( htrb );
return;
REGION_SubtractRegion(tra,sra,srb);
REGION_SubtractRegion(trb,srb,sra);
REGION_UnionRegion(dr,tra,trb);
- RGNDATA_UnlockRgn( htra );
- RGNDATA_UnlockRgn( htrb );
+ RGNDATA_UnlockRgn( tra );
+ RGNDATA_UnlockRgn( trb );
NtGdiDeleteObject( htra );
NtGdiDeleteObject( htrb );
}
if (!REGION_NOT_EMPTY(srcObj))
{
- RGNDATA_UnlockRgn(hSrc);
+ RGNDATA_UnlockRgn(srcObj);
return FALSE;
}
if (!(destObj = (PROSRGNDATA)RGNDATA_LockRgn(hDest)))
{
- RGNDATA_UnlockRgn(hSrc);
+ RGNDATA_UnlockRgn(srcObj);
return FALSE;
}
EMPTY_REGION(destObj);
if (!REGION_CopyRegion(destObj, srcObj))
{
- RGNDATA_UnlockRgn(hDest);
- RGNDATA_UnlockRgn(hSrc);
+ RGNDATA_UnlockRgn(destObj);
+ RGNDATA_UnlockRgn(srcObj);
return FALSE;
}
}
REGION_SubtractRegion(destObj, srcObj, destObj);
- RGNDATA_UnlockRgn(hDest);
- RGNDATA_UnlockRgn(hSrc);
+ RGNDATA_UnlockRgn(destObj);
+ RGNDATA_UnlockRgn(srcObj);
return TRUE;
}
goto done;
if(!( destObj = (PROSRGNDATA) RGNDATA_LockRgn( hDest ) ))
{
- RGNDATA_UnlockRgn( hSrc );
+ RGNDATA_UnlockRgn( srcObj );
goto done;
}
EMPTY_REGION(destObj);
}
ret = TRUE;
- RGNDATA_UnlockRgn( hSrc );
- RGNDATA_UnlockRgn( hDest );
+ RGNDATA_UnlockRgn( srcObj );
+ RGNDATA_UnlockRgn( destObj );
done:
- DC_UnlockDc( hdc );
+ DC_UnlockDc( dc );
return ret;
}
{
HRGN hReg;
PROSRGNDATA pReg;
- BOOL bRet;
if ((hReg = (HRGN) GDIOBJ_AllocObj(GDI_OBJECT_TYPE_REGION)))
{
pReg->rdh.nCount = n;
pReg->rdh.nRgnSize = n*sizeof(RECT);
- bRet = RGNDATA_UnlockRgn(hReg);
- ASSERT(bRet);
+ RGNDATA_UnlockRgn(pReg);
return hReg;
}
REGION_SubtractRegion(destRgn, src1Rgn, src2Rgn);
break;
}
- RGNDATA_UnlockRgn(hSrc2);
+ RGNDATA_UnlockRgn(src2Rgn);
result = destRgn->rdh.iType;
}
else if(hSrc2 == NULL)
}
}
- RGNDATA_UnlockRgn(hSrc1);
+ RGNDATA_UnlockRgn(src1Rgn);
}
- RGNDATA_UnlockRgn(hDest);
+ RGNDATA_UnlockRgn(destRgn);
}
else
{
rect.bottom = bottom;
UnsafeIntUnionRectWithRgn( obj, &rect );
}
- RGNDATA_UnlockRgn( hrgn );
+ RGNDATA_UnlockRgn( obj );
return hrgn;
}
return ERROR;
if( !(rgn2 = RGNDATA_LockRgn(hSrcRgn2))){
- RGNDATA_UnlockRgn( hSrcRgn1 );
+ RGNDATA_UnlockRgn( rgn1 );
return ERROR;
}
bRet = TRUE;
exit:
- RGNDATA_UnlockRgn( hSrcRgn1 );
- RGNDATA_UnlockRgn( hSrcRgn2 );
+ RGNDATA_UnlockRgn( rgn1 );
+ RGNDATA_UnlockRgn( rgn2 );
return bRet;
}
if (!NT_SUCCESS(Status))
{
SetLastWin32Error(ERROR_INVALID_PARAMETER);
- RGNDATA_UnlockRgn(hRgn);
+ RGNDATA_UnlockRgn(Region);
NtGdiDeleteObject(hRgn);
return NULL;
}
- RGNDATA_UnlockRgn(hRgn);
+ RGNDATA_UnlockRgn(Region);
return hRgn;
}
if (NULL == (oldhBrush = NtGdiSelectObject(hDC, hBrush)))
{
- RGNDATA_UnlockRgn(hRgn);
+ RGNDATA_UnlockRgn(rgn);
return FALSE;
}
NtGdiPatBlt(hDC, r->left, r->top, r->right - r->left, r->bottom - r->top, PATCOPY);
}
- RGNDATA_UnlockRgn( hRgn );
+ RGNDATA_UnlockRgn( rgn );
NtGdiSelectObject(hDC, oldhBrush);
return TRUE;
}
ret = UnsafeIntGetRgnBox(Rgn, &SafeRect);
- RGNDATA_UnlockRgn(hRgn);
+ RGNDATA_UnlockRgn(Rgn);
if (ERROR == ret)
{
return ret;
if(!NtGdiPatBlt(hDC, rc->left, rc->top, rc->right - rc->left, rc->bottom - rc->top, DSTINVERT))
{
- RGNDATA_UnlockRgn(hRgn);
+ RGNDATA_UnlockRgn(RgnData);
return FALSE;
}
rc++;
}
- RGNDATA_UnlockRgn(hRgn);
+ RGNDATA_UnlockRgn(RgnData);
return TRUE;
}
}
}
ret = rgn->rdh.iType;
- RGNDATA_UnlockRgn( hRgn );
+ RGNDATA_UnlockRgn( rgn );
return ret;
}
return FALSE;
if(!(tmpVisRgn = NtGdiCreateRectRgn(0, 0, 0, 0))){
- DC_UnlockDc( hDC );
+ DC_UnlockDc( dc );
return FALSE;
}
// Transform region into device co-ords
if(!REGION_LPTODP(hDC, tmpVisRgn, hRgn) || NtGdiOffsetRgn(tmpVisRgn, dc->w.DCOrgX, dc->w.DCOrgY) == ERROR) {
NtGdiDeleteObject( tmpVisRgn );
- DC_UnlockDc( hDC );
+ DC_UnlockDc( dc );
return FALSE;
}
*/
visrgn = RGNDATA_LockRgn(hRgn);
if (visrgn == NULL)
{
- DC_UnlockDc( hDC );
+ DC_UnlockDc( dc );
return FALSE;
}
&BrushOrigin,
0xFFFF);//FIXME:don't know what to put here
- BITMAPOBJ_UnlockBitmap(dc->w.hBitmap);
- RGNDATA_UnlockRgn( hRgn );
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
+ RGNDATA_UnlockRgn( visrgn );
// Fill the region
- DC_UnlockDc( hDC );
+ DC_UnlockDc( dc );
return TRUE;
}
r = (PRECT) rgn->Buffer;
for(i = 0; i < rgn->rdh.nCount; i++) {
if(INRECT(*r, X, Y)){
- RGNDATA_UnlockRgn(hRgn);
+ RGNDATA_UnlockRgn(rgn);
return TRUE;
}
r++;
}
}
- RGNDATA_UnlockRgn(hRgn);
+ RGNDATA_UnlockRgn(rgn);
return FALSE;
}
if (!NT_SUCCESS(MmCopyFromCaller(&rc, unsaferc, sizeof(RECT))))
{
- RGNDATA_UnlockRgn(hRgn);
+ RGNDATA_UnlockRgn(Rgn);
DPRINT1("NtGdiRectInRegion: bogus rc\n");
return ERROR;
}
Ret = UnsafeIntRectInRegion(Rgn, &rc);
- RGNDATA_UnlockRgn(hRgn);
+ RGNDATA_UnlockRgn(Rgn);
return Ret;
}
} else
EMPTY_REGION(rgn);
- RGNDATA_UnlockRgn( hRgn );
+ RGNDATA_UnlockRgn( rgn );
return TRUE;
}
if (! NT_SUCCESS(MmCopyFromCaller(&SafeRect, UnsafeRect, sizeof(RECT))))
{
- RGNDATA_UnlockRgn(hDest);
+ RGNDATA_UnlockRgn(Rgn);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
return NULL;
}
UnsafeIntUnionRectWithRgn(Rgn, &SafeRect);
- RGNDATA_UnlockRgn(hDest);
+ RGNDATA_UnlockRgn(Rgn);
return hDest;
}
size = obj->rdh.nCount * sizeof(RECT);
if(count < (size + sizeof(RGNDATAHEADER)) || rgndata == NULL)
{
- RGNDATA_UnlockRgn( hrgn );
+ RGNDATA_UnlockRgn( obj );
if (rgndata) /* buffer is too small, signal it by return 0 */
return 0;
else /* user requested buffer size with rgndata NULL */
//first we copy the header then we copy buffer
if( !NT_SUCCESS( MmCopyToCaller( rgndata, obj, sizeof( RGNDATAHEADER )))){
- RGNDATA_UnlockRgn( hrgn );
+ RGNDATA_UnlockRgn( obj );
return 0;
}
if( !NT_SUCCESS( MmCopyToCaller( (char*)rgndata+sizeof( RGNDATAHEADER ), obj->Buffer, size ))){
- RGNDATA_UnlockRgn( hrgn );
+ RGNDATA_UnlockRgn( obj );
return 0;
}
- RGNDATA_UnlockRgn( hrgn );
+ RGNDATA_UnlockRgn( obj );
return size + sizeof(RGNDATAHEADER);
}
(Pts[2].x == Pts[3].x) &&
(Pts[3].y == Pts[0].y))))
{
- RGNDATA_UnlockRgn( hrgn );
+ RGNDATA_UnlockRgn( region );
NtGdiSetRectRgn( hrgn, min(Pts[0].x, Pts[2].x), min(Pts[0].y, Pts[2].y),
max(Pts[0].x, Pts[2].x), max(Pts[0].y, Pts[2].y) );
return hrgn;
curPtBlock = tmpPtBlock;
}
ExFreePool( pETEs );
- RGNDATA_UnlockRgn( hrgn );
+ RGNDATA_UnlockRgn( region );
return hrgn;
}
EMPTY_REGION(rgn);
- RGNDATA_UnlockRgn(hRgn);
+ RGNDATA_UnlockRgn(rgn);
return hRgn;
}
/* this should really depend on whether GM_ADVANCED is set */
TextObj->logfont.lfOrientation = TextObj->logfont.lfEscapement;
}
- TEXTOBJ_UnlockText(*NewFont);
+ TEXTOBJ_UnlockText(TextObj);
}
else
{
}
if (dc->IsIC)
{
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
/* Yes, Windows really returns TRUE in this case */
return TRUE;
}
else
{
Mode = PalDestGDI->Mode;
- PALETTE_UnlockPalette(dc->w.hPalette);
+ PALETTE_UnlockPalette(PalDestGDI);
}
XlateObj = (XLATEOBJ*)IntEngCreateXlate(Mode, PAL_RGB, dc->w.hPalette, NULL);
if ( !XlateObj )
EngDeleteXlate(XlateObj);
EngDeleteXlate(XlateObj2);
- BITMAPOBJ_UnlockBitmap(dc->w.hBitmap);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
if(TextObj != NULL)
- TEXTOBJ_UnlockText(dc->w.hFont);
+ TEXTOBJ_UnlockText(TextObj);
if (hBrushBg != NULL)
{
- BRUSHOBJ_UnlockBrush(hBrushBg);
+ BRUSHOBJ_UnlockBrush(BrushBg);
NtGdiDeleteObject(hBrushBg);
}
- BRUSHOBJ_UnlockBrush(hBrushFg);
+ BRUSHOBJ_UnlockBrush(BrushFg);
NtGdiDeleteObject(hBrushFg);
if (NULL != Dx)
{
ExFreePool(Dx);
}
- DC_UnlockDc( hDC );
+ DC_UnlockDc( dc );
return TRUE;
if ( XlateObj != NULL )
EngDeleteXlate(XlateObj);
if(TextObj != NULL)
- TEXTOBJ_UnlockText(dc->w.hFont);
- BITMAPOBJ_UnlockBitmap(dc->w.hBitmap);
+ TEXTOBJ_UnlockText(TextObj);
+ BITMAPOBJ_UnlockBitmap(BitmapObj);
if (hBrushBg != NULL)
{
- BRUSHOBJ_UnlockBrush(hBrushBg);
+ BRUSHOBJ_UnlockBrush(BrushBg);
NtGdiDeleteObject(hBrushBg);
}
if (hBrushFg != NULL)
{
- BRUSHOBJ_UnlockBrush(hBrushFg);
+ BRUSHOBJ_UnlockBrush(BrushFg);
NtGdiDeleteObject(hBrushFg);
}
if (NULL != Dx)
{
ExFreePool(Dx);
}
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
return FALSE;
}
}
hFont = dc->w.hFont;
TextObj = TEXTOBJ_LockText(hFont);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
if (TextObj == NULL)
{
SafeBuffer[i - FirstChar] = (face->glyph->advance.x + 32) >> 6;
}
IntUnLockFreeType;
- TEXTOBJ_UnlockText(hFont);
+ TEXTOBJ_UnlockText(TextObj);
MmCopyToCaller(Buffer, SafeBuffer, BufferSize);
ExFreePool(SafeBuffer);
return TRUE;
}
else
Result = FALSE;
- TEXTOBJ_UnlockText(dc->w.hFont);
- DC_UnlockDc(hDC);
+ TEXTOBJ_UnlockText(TextObj);
+ DC_UnlockDc(dc);
ExFreePool(String);
if (! Result)
{
Result = TextIntGetTextExtentPoint (
dc, TextObj, String, Count, 0, NULL, NULL, &Size);
- TEXTOBJ_UnlockText(dc->w.hFont);
+ TEXTOBJ_UnlockText(TextObj);
}
else
Result = FALSE;
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
ExFreePool(String);
if (! Result)
return FALSE;
}
TextObj = TEXTOBJ_LockText(Dc->w.hFont);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(Dc);
Count = min(Count, wcslen(TextObj->logfont.lfFaceName));
Status = MmCopyToCaller(FaceName, TextObj->logfont.lfFaceName, Count * sizeof(WCHAR));
Status = MmCopyToCaller(tm, &SafeTm, sizeof(TEXTMETRICW));
}
}
- TEXTOBJ_UnlockText(dc->w.hFont);
+ TEXTOBJ_UnlockText(TextObj);
}
else
{
Status = STATUS_INVALID_HANDLE;
}
- DC_UnlockDc(hDC);
+ DC_UnlockDc(dc);
if(!NT_SUCCESS(Status))
{
}
prevAlign = dc->w.textAlign;
dc->w.textAlign = Mode;
- DC_UnlockDc( hDC );
+ DC_UnlockDc( dc );
return prevAlign;
}
oldColor = dc->w.textColor;
dc->w.textColor = color;
hBrush = dc->w.hBrush;
- DC_UnlockDc( hDC );
+ DC_UnlockDc( dc );
NtGdiSelectObject(hDC, hBrush);
return oldColor;
}
}
hFont = Dc->w.hFont;
TextObj = TEXTOBJ_LockText(hFont);
- DC_UnlockDc(hDC);
+ DC_UnlockDc(Dc);
if (TextObj == NULL)
{
IntUnLockFreeType;
- TEXTOBJ_UnlockText(hFont);
+ TEXTOBJ_UnlockText(TextObj);
return Result;
}
if (TextObj->Initialized)
{
- TEXTOBJ_UnlockText(FontHandle);
+ TEXTOBJ_UnlockText(TextObj);
return STATUS_SUCCESS;
}
if (! RtlCreateUnicodeString(&FaceName, TextObj->logfont.lfFaceName))
{
- TEXTOBJ_UnlockText(FontHandle);
+ TEXTOBJ_UnlockText(TextObj);
return STATUS_NO_MEMORY;
}
SubstituteFontFamily(&FaceName, 0);
}
RtlFreeUnicodeString(&FaceName);
- TEXTOBJ_UnlockText(FontHandle);
+ TEXTOBJ_UnlockText(TextObj);
ASSERT((NT_SUCCESS(Status) ^ (NULL == TextObj->Font)) != 0);
projects / reactos.git / commitdiff