-/*
- * ReactOS W32 Subsystem
- * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
}
BOOL INTERNAL_CALL
-BITMAPOBJ_InitBitsLock(BITMAPOBJ *BitmapObj)
+SURFACE_Cleanup(PVOID ObjectBody)
{
- BitmapObj->BitsLock = ExAllocatePoolWithTag(NonPagedPool,
+ PSURFACE psurf = (PSURFACE)ObjectBody;
+ PVOID pvBits = psurf->SurfObj.pvBits;
+
+ /* If this is an API bitmap, free the bits */
+ if (pvBits != NULL &&
+ (psurf->flFlags & BITMAPOBJ_IS_APIBITMAP))
+ {
+ /* Check if we have a DIB section */
+ if (psurf->hSecure)
+ {
+ // FIXME: IMPLEMENT ME!
+ // MmUnsecureVirtualMemory(psurf->hSecure);
+ if (psurf->hDIBSection)
+ {
+ /* DIB was created from a section */
+ NTSTATUS Status;
+
+ pvBits = (PVOID)((ULONG_PTR)pvBits - psurf->dwOffset);
+ Status = ZwUnmapViewOfSection(NtCurrentProcess(), pvBits);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Could not unmap section view!\n");
+ // Should we BugCheck here?
+ }
+ }
+ else
+ {
+ /* DIB was allocated */
+ EngFreeUserMem(pvBits);
+ }
+ }
+ else
+ {
+ // FIXME: use TAG
+ ExFreePool(psurf->SurfObj.pvBits);
+ }
+
+ if (psurf->hDIBPalette != NULL)
+ {
+ GreDeleteObject(psurf->hDIBPalette);
+ }
+ }
+
+ if (NULL != psurf->BitsLock)
+ {
+ ExFreePoolWithTag(psurf->BitsLock, TAG_SURFACE);
+ psurf->BitsLock = NULL;
+ }
+
+ return TRUE;
+}
+
+BOOL INTERNAL_CALL
+SURFACE_InitBitsLock(PSURFACE psurf)
+{
+ psurf->BitsLock = ExAllocatePoolWithTag(NonPagedPool,
sizeof(FAST_MUTEX),
- TAG_BITMAPOBJ);
- if (NULL == BitmapObj->BitsLock)
+ TAG_SURFACE);
+ if (NULL == psurf->BitsLock)
{
return FALSE;
}
- ExInitializeFastMutex(BitmapObj->BitsLock);
+ ExInitializeFastMutex(psurf->BitsLock);
return TRUE;
}
void INTERNAL_CALL
-BITMAPOBJ_CleanupBitsLock(BITMAPOBJ *BitmapObj)
+SURFACE_CleanupBitsLock(PSURFACE psurf)
{
- if (NULL != BitmapObj->BitsLock)
+ if (NULL != psurf->BitsLock)
{
- ExFreePoolWithTag(BitmapObj->BitsLock, TAG_BITMAPOBJ);
- BitmapObj->BitsLock = NULL;
+ ExFreePoolWithTag(psurf->BitsLock, TAG_SURFACE);
+ psurf->BitsLock = NULL;
}
}
/*
* @implemented
*/
-HBITMAP STDCALL
+HBITMAP APIENTRY
EngCreateDeviceBitmap(IN DHSURF dhsurf,
IN SIZEL Size,
IN ULONG Format)
{
HBITMAP NewBitmap;
- SURFOBJ *SurfObj;
+ SURFOBJ *pso;
NewBitmap = EngCreateBitmap(Size, DIB_GetDIBWidthBytes(Size.cx, BitsPerFormat(Format)), Format, 0, NULL);
if (!NewBitmap)
return 0;
}
- SurfObj = EngLockSurface((HSURF)NewBitmap);
- SurfObj->dhsurf = dhsurf;
- EngUnlockSurface(SurfObj);
+ pso = EngLockSurface((HSURF)NewBitmap);
+ if (!pso)
+ {
+ DPRINT1("EngLockSurface failed on newly created bitmap!\n");
+ GreDeleteObject(NewBitmap);
+ return NULL;
+ }
+
+ pso->dhsurf = dhsurf;
+ EngUnlockSurface(pso);
return NewBitmap;
}
IN ULONG Flags,
IN PVOID Bits)
{
- HBITMAP NewBitmap;
- SURFOBJ *SurfObj;
- BITMAPOBJ *BitmapObj;
+ HBITMAP hbmp;
+ SURFOBJ *pso;
+ PSURFACE psurf;
PVOID UncompressedBits;
ULONG UncompressedFormat;
if (Format == 0)
return 0;
- BitmapObj = BITMAPOBJ_AllocBitmapWithHandle();
- if (BitmapObj == NULL)
+ psurf = SURFACE_AllocSurfaceWithHandle();
+ if (psurf == NULL)
{
return 0;
}
- NewBitmap = BitmapObj->BaseObject.hHmgr;
+ hbmp = psurf->BaseObject.hHmgr;
- if (! BITMAPOBJ_InitBitsLock(BitmapObj))
+ if (! SURFACE_InitBitsLock(psurf))
{
- BITMAPOBJ_UnlockBitmap(BitmapObj);
- BITMAPOBJ_FreeBitmapByHandle(NewBitmap);
+ SURFACE_UnlockSurface(psurf);
+ SURFACE_FreeSurfaceByHandle(hbmp);
return 0;
}
- SurfObj = &BitmapObj->SurfObj;
+ pso = &psurf->SurfObj;
if (Format == BMF_4RLE)
{
- SurfObj->lDelta = DIB_GetDIBWidthBytes(Size.cx, BitsPerFormat(BMF_4BPP));
- SurfObj->cjBits = SurfObj->lDelta * Size.cy;
+ pso->lDelta = DIB_GetDIBWidthBytes(Size.cx, BitsPerFormat(BMF_4BPP));
+ pso->cjBits = pso->lDelta * Size.cy;
UncompressedFormat = BMF_4BPP;
- UncompressedBits = EngAllocMem(FL_ZERO_MEMORY, SurfObj->cjBits, TAG_DIB);
- Decompress4bpp(Size, (BYTE *)Bits, (BYTE *)UncompressedBits, SurfObj->lDelta);
+ UncompressedBits = EngAllocMem(FL_ZERO_MEMORY, pso->cjBits, TAG_DIB);
+ Decompress4bpp(Size, (BYTE *)Bits, (BYTE *)UncompressedBits, pso->lDelta);
}
else if (Format == BMF_8RLE)
{
- SurfObj->lDelta = DIB_GetDIBWidthBytes(Size.cx, BitsPerFormat(BMF_8BPP));
- SurfObj->cjBits = SurfObj->lDelta * Size.cy;
+ pso->lDelta = DIB_GetDIBWidthBytes(Size.cx, BitsPerFormat(BMF_8BPP));
+ pso->cjBits = pso->lDelta * Size.cy;
UncompressedFormat = BMF_8BPP;
- UncompressedBits = EngAllocMem(FL_ZERO_MEMORY, SurfObj->cjBits, TAG_DIB);
- Decompress8bpp(Size, (BYTE *)Bits, (BYTE *)UncompressedBits, SurfObj->lDelta);
+ UncompressedBits = EngAllocMem(FL_ZERO_MEMORY, pso->cjBits, TAG_DIB);
+ Decompress8bpp(Size, (BYTE *)Bits, (BYTE *)UncompressedBits, pso->lDelta);
}
else
{
- SurfObj->lDelta = abs(Width);
- SurfObj->cjBits = SurfObj->lDelta * Size.cy;
+ pso->lDelta = abs(Width);
+ pso->cjBits = pso->lDelta * Size.cy;
UncompressedBits = Bits;
UncompressedFormat = Format;
}
if (UncompressedBits != NULL)
{
- SurfObj->pvBits = UncompressedBits;
+ pso->pvBits = UncompressedBits;
}
else
{
- if (SurfObj->cjBits == 0)
+ if (pso->cjBits == 0)
{
- SurfObj->pvBits = NULL;
+ pso->pvBits = NULL;
}
else
{
if (0 != (Flags & BMF_USERMEM))
{
- SurfObj->pvBits = EngAllocUserMem(SurfObj->cjBits, 0);
+ pso->pvBits = EngAllocUserMem(pso->cjBits, 0);
}
else
{
- SurfObj->pvBits = EngAllocMem(0 != (Flags & BMF_NOZEROINIT) ?
+ pso->pvBits = EngAllocMem(0 != (Flags & BMF_NOZEROINIT) ?
0 : FL_ZERO_MEMORY,
- SurfObj->cjBits, TAG_DIB);
+ pso->cjBits, TAG_DIB);
}
- if (SurfObj->pvBits == NULL)
+ if (pso->pvBits == NULL)
{
- BITMAPOBJ_UnlockBitmap(BitmapObj);
- BITMAPOBJ_FreeBitmapByHandle(NewBitmap);
+ SURFACE_UnlockSurface(psurf);
+ SURFACE_FreeSurfaceByHandle(hbmp);
+ SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
return 0;
}
}
if (0 == (Flags & BMF_TOPDOWN))
{
- SurfObj->pvScan0 = (PVOID) ((ULONG_PTR) SurfObj->pvBits + SurfObj->cjBits - SurfObj->lDelta);
- SurfObj->lDelta = - SurfObj->lDelta;
+ pso->pvScan0 = (PVOID)((ULONG_PTR)pso->pvBits + pso->cjBits - pso->lDelta);
+ pso->lDelta = - pso->lDelta;
}
else
{
- SurfObj->pvScan0 = SurfObj->pvBits;
+ pso->pvScan0 = pso->pvBits;
}
- SurfObj->dhsurf = 0; /* device managed surface */
- SurfObj->hsurf = (HSURF)NewBitmap;
- SurfObj->dhpdev = NULL;
- SurfObj->hdev = NULL;
- SurfObj->sizlBitmap = Size;
- SurfObj->iBitmapFormat = UncompressedFormat;
- SurfObj->iType = STYPE_BITMAP;
- SurfObj->fjBitmap = Flags & (BMF_TOPDOWN | BMF_NOZEROINIT);
- SurfObj->iUniq = 0;
+ pso->dhsurf = 0; /* device managed surface */
+ pso->hsurf = (HSURF)hbmp;
+ pso->dhpdev = NULL;
+ pso->hdev = NULL;
+ pso->sizlBitmap = Size;
+ pso->iBitmapFormat = UncompressedFormat;
+ pso->iType = STYPE_BITMAP;
+ pso->fjBitmap = Flags & (BMF_TOPDOWN | BMF_NOZEROINIT);
+ pso->iUniq = 0;
+
+ psurf->flHooks = 0;
+ psurf->flFlags = 0;
+ psurf->dimension.cx = 0;
+ psurf->dimension.cy = 0;
+
+ psurf->hSecure = NULL;
+ psurf->hDIBSection = NULL;
+
+ SURFACE_UnlockSurface(psurf);
+
+ return hbmp;
+}
- BitmapObj->flHooks = 0;
- BitmapObj->flFlags = 0;
- BitmapObj->dimension.cx = 0;
- BitmapObj->dimension.cy = 0;
- BitmapObj->dib = NULL;
+/* Name gleaned from C++ symbol information for SURFMEM::bInitDIB */
+typedef struct _DEVBITMAPINFO
+{
+ ULONG Format;
+ ULONG Width;
+ ULONG Height;
+ ULONG Flags;
+ ULONG Size;
+} DEVBITMAPINFO, *PDEVBITMAPINFO;
+
+SURFOBJ*
+FASTCALL
+SURFMEM_bCreateDib(IN PDEVBITMAPINFO BitmapInfo,
+ IN PVOID Bits)
+{
+ BOOLEAN Compressed = FALSE;
+ ULONG ScanLine = 0; // Compiler is dumb
+ ULONG Size;
+ SURFOBJ *pso;
+ PSURFACE psurf;
+ SIZEL LocalSize;
+ BOOLEAN AllocatedLocally = FALSE;
+
+ /*
+ * First, check the format so we can get the aligned scanline width.
+ * RLE and the newer fancy-smanshy JPG/PNG support do NOT have scanlines
+ * since they are compressed surfaces!
+ */
+ switch (BitmapInfo->Format)
+ {
+ case BMF_1BPP:
+ ScanLine = ((BitmapInfo->Width + 31) & ~31) >> 3;
+ break;
- BITMAPOBJ_UnlockBitmap(BitmapObj);
+ case BMF_4BPP:
+ ScanLine = ((BitmapInfo->Width + 7) & ~7) >> 1;
+ break;
- return NewBitmap;
+ case BMF_8BPP:
+ ScanLine = (BitmapInfo->Width + 3) & ~3;
+ break;
+
+ case BMF_16BPP:
+ ScanLine = ((BitmapInfo->Width + 1) & ~1) << 1;
+ break;
+
+ case BMF_24BPP:
+ ScanLine = ((BitmapInfo->Width * 3) + 3) & ~3;
+ break;
+
+ case BMF_32BPP:
+ ScanLine = BitmapInfo->Width << 2;
+ break;
+
+ case BMF_8RLE:
+ case BMF_4RLE:
+ case BMF_JPEG:
+ case BMF_PNG:
+ Compressed = TRUE;
+ break;
+
+ default:
+ DPRINT1("Invalid bitmap format\n");
+ return NULL;
+ }
+
+ /* Does the device manage its own surface? */
+ if (!Bits)
+ {
+ /* We need to allocate bits for the caller, figure out the size */
+ if (Compressed)
+ {
+ /* Note: we should not be seeing this scenario from ENGDDI */
+ ASSERT(FALSE);
+ Size = BitmapInfo->Size;
+ }
+ else
+ {
+ /* The height times the bytes for each scanline */
+ Size = BitmapInfo->Height * ScanLine;
+ }
+
+ if (Size)
+ {
+ /* Check for allocation flag */
+ if (BitmapInfo->Flags & BMF_USERMEM)
+ {
+ /* Get the bits from user-mode memory */
+ Bits = EngAllocUserMem(Size, 'mbuG');
+ }
+ else
+ {
+ /* Get kernel bits (zeroed out if requested) */
+ Bits = EngAllocMem((BitmapInfo->Flags & BMF_NOZEROINIT) ? 0 : FL_ZERO_MEMORY,
+ Size,
+ TAG_DIB);
+ }
+ AllocatedLocally = TRUE;
+ /* Bail out if that failed */
+ if (!Bits) return NULL;
+ }
+ }
+ else
+ {
+ /* Should not have asked for user memory */
+ ASSERT((BitmapInfo->Flags & BMF_USERMEM) == 0);
+ }
+
+ /* Allocate the actual surface object structure */
+ psurf = SURFACE_AllocSurfaceWithHandle();
+ if (!psurf)
+ {
+ if(Bits && AllocatedLocally)
+ {
+ if(BitmapInfo->Flags & BMF_USERMEM)
+ EngFreeUserMem(Bits);
+ else
+ EngFreeMem(Bits);
+ }
+ return NULL;
+ }
+
+ /* Lock down the surface */
+ if (!SURFACE_InitBitsLock(psurf))
+ {
+ /* Bail out if that failed */
+ SURFACE_UnlockSurface(psurf);
+ SURFACE_FreeSurfaceByHandle(psurf->BaseObject.hHmgr);
+ return NULL;
+ }
+
+ /* We should now have our surface object */
+ pso = &psurf->SurfObj;
+
+ /* Save format and flags */
+ pso->iBitmapFormat = BitmapInfo->Format;
+ pso->fjBitmap = BitmapInfo->Flags & (BMF_TOPDOWN | BMF_UMPDMEM | BMF_USERMEM);
+
+ /* Save size and type */
+ LocalSize.cy = BitmapInfo->Height;
+ LocalSize.cx = BitmapInfo->Width;
+ pso->sizlBitmap = LocalSize;
+ pso->iType = STYPE_BITMAP;
+
+ /* Device-managed surface, no flags or dimension */
+ pso->dhsurf = 0;
+ pso->dhpdev = NULL;
+ pso->hdev = NULL;
+ psurf->flFlags = 0;
+ psurf->dimension.cx = 0;
+ psurf->dimension.cy = 0;
+ psurf->hSecure = NULL;
+ psurf->hDIBSection = NULL;
+ psurf->flHooks = 0;
+
+ /* Set bits */
+ pso->pvBits = Bits;
+
+ /* Check for bitmap type */
+ if (!Compressed)
+ {
+ /* Number of bits is based on the height times the scanline */
+ pso->cjBits = BitmapInfo->Height * ScanLine;
+ if (BitmapInfo->Flags & BMF_TOPDOWN)
+ {
+ /* For topdown, the base address starts with the bits */
+ pso->pvScan0 = pso->pvBits;
+ pso->lDelta = ScanLine;
+ }
+ else
+ {
+ /* Otherwise we start with the end and go up */
+ pso->pvScan0 = (PVOID)((ULONG_PTR)pso->pvBits + pso->cjBits - ScanLine);
+ pso->lDelta = -ScanLine;
+ }
+ }
+ else
+ {
+ /* Compressed surfaces don't have scanlines! */
+ pso->lDelta = 0;
+ pso->cjBits = BitmapInfo->Size;
+
+ /* Check for JPG or PNG */
+ if ((BitmapInfo->Format != BMF_JPEG) && (BitmapInfo->Format != BMF_PNG))
+ {
+ /* Wherever the bit data is */
+ pso->pvScan0 = pso->pvBits;
+ }
+ else
+ {
+ /* Fancy formats don't use a base address */
+ pso->pvScan0 = NULL;
+ ASSERT(FALSE); // ENGDDI shouldn't be creating PNGs for drivers ;-)
+ }
+ }
+
+ /* Finally set the handle and uniq */
+ pso->hsurf = (HSURF)psurf->BaseObject.hHmgr;
+ pso->iUniq = 0;
+
+ /* Unlock and return the surface */
+ SURFACE_UnlockSurface(psurf);
+ return pso;
}
/*
* @implemented
*/
-HBITMAP STDCALL
+HBITMAP
+APIENTRY
EngCreateBitmap(IN SIZEL Size,
IN LONG Width,
IN ULONG Format,
IN ULONG Flags,
IN PVOID Bits)
{
- HBITMAP NewBitmap;
-
- NewBitmap = IntCreateBitmap(Size, Width, Format, Flags, Bits);
- if ( !NewBitmap )
- return 0;
-
- GDIOBJ_SetOwnership(NewBitmap, NULL);
-
- return NewBitmap;
+ SURFOBJ* Surface;
+ DEVBITMAPINFO BitmapInfo;
+
+ /* Capture the parameters */
+ BitmapInfo.Format = Format;
+ BitmapInfo.Width = Size.cx;
+ BitmapInfo.Height = Size.cy;
+ BitmapInfo.Flags = Flags;
+
+ /*
+ * If the display driver supports framebuffer access, use the scanline width
+ * to determine the actual width of the bitmap, and convert it to pels instead
+ * of bytes.
+ */
+ if ((Bits) && (Width))
+ {
+ switch (BitmapInfo.Format)
+ {
+ /* Do the conversion for each bit depth we support */
+ case BMF_1BPP:
+ BitmapInfo.Width = Width * 8;
+ break;
+ case BMF_4BPP:
+ BitmapInfo.Width = Width * 2;
+ break;
+ case BMF_8BPP:
+ BitmapInfo.Width = Width;
+ break;
+ case BMF_16BPP:
+ BitmapInfo.Width = Width / 2;
+ break;
+ case BMF_24BPP:
+ BitmapInfo.Width = Width / 3;
+ break;
+ case BMF_32BPP:
+ BitmapInfo.Width = Width / 4;
+ break;
+ }
+ }
+
+ /* Now create the surface */
+ Surface = SURFMEM_bCreateDib(&BitmapInfo, Bits);
+ if (!Surface) return 0;
+
+ /* Set public ownership and reutrn the handle */
+ GDIOBJ_SetOwnership(Surface->hsurf, NULL);
+ return Surface->hsurf;
}
/*
* @unimplemented
*/
-HSURF STDCALL
+HSURF APIENTRY
EngCreateDeviceSurface(IN DHSURF dhsurf,
IN SIZEL Size,
IN ULONG Format)
{
- HSURF NewSurface;
- SURFOBJ *SurfObj;
- BITMAPOBJ *BitmapObj;
+ HSURF hsurf;
+ SURFOBJ *pso;
+ PSURFACE psurf;
- BitmapObj = BITMAPOBJ_AllocBitmapWithHandle();
- if (!BitmapObj)
+ psurf = SURFACE_AllocSurfaceWithHandle();
+ if (!psurf)
{
return 0;
}
- NewSurface = BitmapObj->BaseObject.hHmgr;
- GDIOBJ_SetOwnership(NewSurface, NULL);
+ hsurf = psurf->BaseObject.hHmgr;
+ GDIOBJ_SetOwnership(hsurf, NULL);
- if (!BITMAPOBJ_InitBitsLock(BitmapObj))
+ if (!SURFACE_InitBitsLock(psurf))
{
- BITMAPOBJ_UnlockBitmap(BitmapObj);
- BITMAPOBJ_FreeBitmapByHandle(NewSurface);
+ SURFACE_UnlockSurface(psurf);
+ SURFACE_FreeSurfaceByHandle(hsurf);
return 0;
}
- SurfObj = &BitmapObj->SurfObj;
+ pso = &psurf->SurfObj;
- SurfObj->dhsurf = dhsurf;
- SurfObj->hsurf = NewSurface;
- SurfObj->sizlBitmap = Size;
- SurfObj->iBitmapFormat = Format;
- SurfObj->lDelta = DIB_GetDIBWidthBytes(Size.cx, BitsPerFormat(Format));
- SurfObj->iType = STYPE_DEVICE;
- SurfObj->iUniq = 0;
+ pso->dhsurf = dhsurf;
+ pso->hsurf = hsurf;
+ pso->sizlBitmap = Size;
+ pso->iBitmapFormat = Format;
+ pso->lDelta = DIB_GetDIBWidthBytes(Size.cx, BitsPerFormat(Format));
+ pso->iType = STYPE_DEVICE;
+ pso->iUniq = 0;
- BitmapObj->flHooks = 0;
+ psurf->flHooks = 0;
- BITMAPOBJ_UnlockBitmap(BitmapObj);
+ SURFACE_UnlockSurface(psurf);
- return NewSurface;
-}
-
-PFN FASTCALL DriverFunction(DRVENABLEDATA *DED, ULONG DriverFunc)
-{
- ULONG i;
-
- for (i=0; i<DED->c; i++)
- {
- if (DED->pdrvfn[i].iFunc == DriverFunc)
- {
- return DED->pdrvfn[i].pfn;
- }
- }
- return NULL;
+ return hsurf;
}
/*
* @implemented
*/
-BOOL STDCALL
-EngAssociateSurface(IN HSURF Surface,
- IN HDEV Dev,
- IN ULONG Hooks)
+BOOL
+APIENTRY
+EngAssociateSurface(
+ IN HSURF hsurf,
+ IN HDEV hdev,
+ IN FLONG flHooks)
{
- SURFOBJ *SurfObj;
- BITMAPOBJ *BitmapObj;
- GDIDEVICE* Device;
+ SURFOBJ *pso;
+ PSURFACE psurf;
+ PDEVOBJ* ppdev;
- Device = (GDIDEVICE*)Dev;
+ ppdev = (PDEVOBJ*)hdev;
- BitmapObj = BITMAPOBJ_LockBitmap(Surface);
- ASSERT(BitmapObj);
- SurfObj = &BitmapObj->SurfObj;
+ /* Lock the surface */
+ psurf = SURFACE_LockSurface(hsurf);
+ if (!psurf)
+ {
+ return FALSE;
+ }
+ pso = &psurf->SurfObj;
/* Associate the hdev */
- SurfObj->hdev = Dev;
- SurfObj->dhpdev = Device->hPDev;
+ pso->hdev = hdev;
+ pso->dhpdev = ppdev->dhpdev;
/* Hook up specified functions */
- BitmapObj->flHooks = Hooks;
+ psurf->flHooks = flHooks;
- BITMAPOBJ_UnlockBitmap(BitmapObj);
+ SURFACE_UnlockSurface(psurf);
return TRUE;
}
/*
* @implemented
*/
-BOOL STDCALL
+BOOL APIENTRY
EngModifySurface(
IN HSURF hsurf,
IN HDEV hdev,
IN VOID *pvReserved)
{
SURFOBJ *pso;
+ PSURFACE psurf;
+ PDEVOBJ* ppdev;
- pso = EngLockSurface(hsurf);
- if (pso == NULL)
+ psurf = SURFACE_LockSurface(hsurf);
+ if (psurf == NULL)
{
return FALSE;
}
- if (!EngAssociateSurface(hsurf, hdev, flHooks))
- {
- EngUnlockSurface(pso);
-
- return FALSE;
- }
-
+ ppdev = (PDEVOBJ*)hdev;
+ pso = &psurf->SurfObj;
pso->dhsurf = dhsurf;
pso->lDelta = lDelta;
pso->pvScan0 = pvScan0;
- EngUnlockSurface(pso);
+ /* Associate the hdev */
+ pso->hdev = hdev;
+ pso->dhpdev = ppdev->dhpdev;
+
+ /* Hook up specified functions */
+ psurf->flHooks = flHooks;
+
+ SURFACE_UnlockSurface(psurf);
return TRUE;
}
/*
* @implemented
*/
-BOOL STDCALL
-EngDeleteSurface(IN HSURF Surface)
+BOOL APIENTRY
+EngDeleteSurface(IN HSURF hsurf)
{
- GDIOBJ_SetOwnership(Surface, PsGetCurrentProcess());
- BITMAPOBJ_FreeBitmapByHandle(Surface);
+ GDIOBJ_SetOwnership(hsurf, PsGetCurrentProcess());
+ SURFACE_FreeSurfaceByHandle(hsurf);
return TRUE;
}
/*
* @implemented
*/
-BOOL STDCALL
-EngEraseSurface(SURFOBJ *Surface,
+BOOL APIENTRY
+EngEraseSurface(SURFOBJ *pso,
RECTL *Rect,
ULONG iColor)
{
- ASSERT(Surface);
+ ASSERT(pso);
ASSERT(Rect);
- return FillSolid(Surface, Rect, iColor);
+ return FillSolid(pso, Rect, iColor);
}
-#define GDIBdyToHdr(body) \
- ((PGDIOBJHDR)(body) - 1)
-
-
/*
* @implemented
*/
-SURFOBJ * STDCALL
-NtGdiEngLockSurface(IN HSURF Surface)
+SURFOBJ * APIENTRY
+NtGdiEngLockSurface(IN HSURF hsurf)
{
- return EngLockSurface(Surface);
+ return EngLockSurface(hsurf);
}
/*
* @implemented
*/
-SURFOBJ * STDCALL
-EngLockSurface(IN HSURF Surface)
+SURFOBJ * APIENTRY
+EngLockSurface(IN HSURF hsurf)
{
- BITMAPOBJ *bmp = GDIOBJ_ShareLockObj(Surface, GDI_OBJECT_TYPE_BITMAP);
+ SURFACE *psurf = GDIOBJ_ShareLockObj(hsurf, GDI_OBJECT_TYPE_BITMAP);
- if (bmp != NULL)
- return &bmp->SurfObj;
+ if (psurf != NULL)
+ return &psurf->SurfObj;
return NULL;
}
/*
* @implemented
*/
-VOID STDCALL
-NtGdiEngUnlockSurface(IN SURFOBJ *Surface)
+VOID APIENTRY
+NtGdiEngUnlockSurface(IN SURFOBJ *pso)
{
- EngUnlockSurface(Surface);
+ EngUnlockSurface(pso);
}
/*
* @implemented
*/
-VOID STDCALL
-EngUnlockSurface(IN SURFOBJ *Surface)
+VOID APIENTRY
+EngUnlockSurface(IN SURFOBJ *pso)
{
- if (Surface != NULL)
+ if (pso != NULL)
{
- BITMAPOBJ *bmp = CONTAINING_RECORD(Surface, BITMAPOBJ, SurfObj);
- GDIOBJ_ShareUnlockObjByPtr((POBJ)bmp);
+ SURFACE *psurf = CONTAINING_RECORD(pso, SURFACE, SurfObj);
+ GDIOBJ_ShareUnlockObjByPtr((POBJ)psurf);
}
}
projects / reactos.git / blobdiff