960 lines
33 KiB
C++
960 lines
33 KiB
C++
/******************************Module*Header*******************************\
|
||
* Module Name: surfobj.hxx
|
||
*
|
||
* Surface Object
|
||
*
|
||
* Created: Tue 25-Jan-1991
|
||
*
|
||
* Author: Patrick Haluptzok [patrickh]
|
||
*
|
||
* Copyright (c) 1990-1999 Microsoft Corporation
|
||
\**************************************************************************/
|
||
|
||
#define BMF_DEVICE 0
|
||
|
||
#ifndef _SURFOBJ_HXX
|
||
|
||
#ifndef GDIFLAGS_ONLY // used for gdikdx
|
||
|
||
|
||
#if TRACE_SURFACE_ALLOCS
|
||
|
||
#define TRACE_SURFACE_USER_CHAIN_IN_UM (DBG || 1)
|
||
|
||
#define TRACE_SURFACE_MIN_KERNEL_CHAIN 7
|
||
#define TRACE_SURFACE_MIN_USER_CHAIN 5
|
||
#define TRACE_SURFACE_CHAIN_LENGTH (TRACE_SURFACE_MIN_KERNEL_CHAIN + TRACE_SURFACE_MIN_USER_CHAIN)
|
||
|
||
typedef struct _SurfaceTrace {
|
||
PEPROCESS pProcess;
|
||
PETHREAD pThread;
|
||
ULONG KernelLength;
|
||
ULONG UserLength:16;
|
||
#if TRACE_SURFACE_USER_CHAIN_IN_UM
|
||
ULONG UserReserved:14;
|
||
ULONG UserChainNotRead:1;
|
||
ULONG UserChainAllocated:1;
|
||
#else
|
||
ULONG UserChainFromUMIsDisabled:16;
|
||
#endif
|
||
PFN Chain[TRACE_SURFACE_CHAIN_LENGTH];
|
||
} SurfaceTrace;
|
||
|
||
#define lengthof(array) ((sizeof(array)) / (sizeof(array[0])))
|
||
|
||
|
||
#if TRACE_SURFACE_USER_CHAIN_IN_UM
|
||
|
||
typedef struct _SurfaceUserTrace {
|
||
ULONG MaxLength;
|
||
ULONG UserLength;
|
||
PFN Chain[TRACE_SURFACE_MIN_USER_CHAIN];
|
||
} SurfaceUserTrace;
|
||
|
||
#endif
|
||
|
||
class TRACED_SURFACE;
|
||
|
||
#endif
|
||
|
||
|
||
#define SURFOBJ_TO_SURFACE(pso) (pso == (SURFOBJ *)NULL ? (SURFACE *)NULL : (SURFACE *)((PBYTE)pso - offsetof(SURFACE,so)))
|
||
#define SURFOBJ_TO_SURFACE_NOT_NULL(pso) ((SURFACE *)((PBYTE)pso - offsetof(SURFACE,so)))
|
||
|
||
// Forward Class declarations needed in this file
|
||
|
||
class EWNDOBJ;
|
||
|
||
#endif // GDIFLAGS_ONLY used for gdikdx
|
||
|
||
// WARNING: These flag bits are shared with the HOOK_ definitions!
|
||
|
||
#define USE_DEVLOCK_SURFACE 0x00004000 // All drawing to this surface should
|
||
// be done under the Devlock (this
|
||
// flag was formerly known as
|
||
// HOOK_SYNCHRONIZEACCESS)
|
||
#define PDEV_SURFACE 0x80000000 // Specifies the surface is for a pdev
|
||
#define ABORT_SURFACE 0x40000000 // Abort operations on the surface
|
||
#define DYNAMIC_MODE_PALETTE 0x20000000 // The surface is a Device Dependent
|
||
// Bitmap whose palette was added
|
||
// by GreDynamicModeChange
|
||
#define UNREADABLE_SURFACE 0x10000000 // Reads not allowed from this surface
|
||
#define PALETTE_SELECT_SET 0x08000000 // We wrote palette in at select time
|
||
#define API_BITMAP 0x04000000 // Surface is an application bitmap
|
||
// (it may be selected into a DC
|
||
// using SelectObject, it may be
|
||
// called with via GetObject, etc.)
|
||
#define BANDING_SURFACE 0x02000000 // used for banding
|
||
#define INCLUDE_SPRITES_SURFACE 0x02000000 // Signals SpBitBlt that sprite layers should
|
||
// be included in the blt. Used for capturing
|
||
// the screen - note this flag is shared
|
||
// with BANDING_SURFACE
|
||
#define LAZY_DELETE_SURFACE 0x01000000 // DeleteObject has been called
|
||
#define DDB_SURFACE 0x00800000 // Non-monochrome Device Dependent
|
||
// Bitmap surface
|
||
#define ENG_CREATE_DEVICE_SURFACE 0x00400000// This surface was created by driver
|
||
// in a call to EngCreateDeviceBitmap
|
||
#define DRIVER_CREATED_SURFACE 0x00200000 // This surface was created by
|
||
// EngCreateBitmap, EngCreateDeviceSurface,
|
||
// or EngCreateDeviceBitmap
|
||
#define DIRECTDRAW_SURFACE 0x00100000 // Surface created for DirectDraw
|
||
// GetDC call
|
||
#define MIRROR_SURFACE 0x00080000 // This surface is a DDML 'mirrored'
|
||
// surface that shadows a normal
|
||
// DDML surface
|
||
#define UMPD_SURFACE 0x00040000 // This is a device surface created by UMPD
|
||
#define REDIRECTION_SURFACE 0x00000800 // Redirection surface (can be selected into multiple
|
||
// redirection DCs). This flag is reusing the bit of
|
||
// the former HOOK_MOVEPANNING flag.
|
||
#define SHAREACCESS_SURFACE 0x00000200 // Acquire shared access to devlock
|
||
|
||
#define SURF_FLAGS 0xfffc4a00 // Logical OR of all above flags
|
||
|
||
#ifndef GDIFLAGS_ONLY // used for gdikdx
|
||
|
||
#if (SURF_FLAGS & HOOK_FLAGS)
|
||
#error HOOK_ and _SURFACE flags overlap! Must fix!
|
||
#endif
|
||
|
||
#endif // GDIFLAGS_ONLY used for gdikdx
|
||
|
||
//
|
||
// New SURFOBJ fjBitmap flags we are considering adding to the public DDI
|
||
//
|
||
|
||
// BMF_SPRITE was added per request from 3DLabs to help them with double buffer
|
||
// OpenGL applications. 3DLabs has failed to confirm that they are using this
|
||
// support so we are temporarily removing it from Whistler. If they confirm
|
||
// that they need the support by 1/1/01 then we will add it back in otherwise
|
||
// this code will be nuked.
|
||
//#define BMF_SPRITE 0x0100
|
||
|
||
// BMF_ISREADONLY and BMF_MAKEREADWRITE are new flags to support stock bitmaps
|
||
// BMF_ISREADONLY will be made public in Whistler+1 release. BMF_MAKEREADWRITE
|
||
// should not be a BMF flag and instead should be a flag stored in a SURFACE flag
|
||
|
||
#define BMF_ISREADONLY 0x0200
|
||
#define BMF_MAKEREADWRITE 0x0400
|
||
|
||
|
||
#ifndef GDIFLAGS_ONLY // used for gdikdx
|
||
|
||
/**************************************************************************\
|
||
*
|
||
* Reference to SURFOBJ structure in winddi.h
|
||
*
|
||
* typedef struct _SURFOBJ
|
||
* {
|
||
* DHSURF dhsurf;
|
||
* HSURF hsurf;
|
||
* DHPDEV dhpdev;
|
||
* HDEV hdev;
|
||
* SIZEL sizlBitmap;
|
||
* ULONG cjBits;
|
||
* PVOID pvBits;
|
||
* PVOID pvScan0;
|
||
* LONG lDelta;
|
||
* ULONG iUniq;
|
||
* ULONG iBitmapFormat;
|
||
* USHORT iType;
|
||
* USHORT fjBitmap;
|
||
* } SURFOBJ;
|
||
*
|
||
\**************************************************************************/
|
||
|
||
|
||
|
||
/********************************Struct************************************\
|
||
* EBITMAP
|
||
*
|
||
* Description:
|
||
*
|
||
* Bitmap Struct, contains data common to DIBs and DDBs
|
||
*
|
||
* Fields:
|
||
*
|
||
* silzDim - Numbers set with SetBitmapDimensionEx
|
||
* hdc - DC this bitmap is selected into
|
||
* cRef - Number of times is this bitmap selected
|
||
* hpalHint - handle of last logical palette associated with this surface
|
||
*
|
||
\**************************************************************************/
|
||
|
||
typedef struct _EBITMAP
|
||
{
|
||
SIZEL sizlDim;
|
||
HDC hdc;
|
||
ULONG cRef;
|
||
HPALETTE hpalHint; // Handle may be invalid at any time
|
||
}EBITMAP,*PEBITMAP;
|
||
|
||
/********************************Struct************************************\
|
||
* DIB
|
||
*
|
||
* Dsecription
|
||
*
|
||
* DIB Class, A DIBSection with a section created by GDI will have a non-NULL
|
||
* hDIBSection, but a DIBSection with a section created bt the user will
|
||
* have a NULL hDIBSectio. This means GDIis not responsible for closing
|
||
* it when this structure is deleted. hSecure will always be non-zerp for
|
||
* a DIBSection, so this is used to tell if the surface is a DIBSection.
|
||
*
|
||
* Fields:
|
||
*
|
||
* hDIBSection - handle to the DIB section
|
||
* hSecure - handle of mem secure object
|
||
*
|
||
*
|
||
\**************************************************************************/
|
||
|
||
typedef struct _DIB
|
||
{
|
||
HANDLE hDIBSection;
|
||
HANDLE hSecure;
|
||
DWORD dwOffset;
|
||
ULONG_PTR dwDIBColorSpace; // indentifier of client side data color space data
|
||
}DIB,*PDIB;
|
||
|
||
|
||
|
||
/*********************************Class************************************\
|
||
* class SURFACE *
|
||
* *
|
||
* Description: *
|
||
* *
|
||
* Object for management of all GDI surfaces. This class will alwasy be *
|
||
* used as a PSURFACE, never allocated as a SURFACE. *
|
||
* *
|
||
* Fields: *
|
||
* *
|
||
* <OBJECT> - Inherit base OBJECT class *
|
||
* so - SURFOBJ from DDI *
|
||
* flags - Indicates functions a driver has hooked, other flags *
|
||
* pldevOwner - Pointer to LDEV for dispatching *
|
||
* ppal - Pointer to palette for device *
|
||
* pWo - Pointer to the WNDOBJ for printer/bitmap *
|
||
* EBitmap - Fields for memory bitmap management *
|
||
* DIB - Fields for DIB Section management *
|
||
* *
|
||
\**************************************************************************/
|
||
|
||
class SURFACE : public OBJECT
|
||
{
|
||
public:
|
||
|
||
SURFOBJ so;
|
||
class XDCOBJ *pdcoAA; // For antialiased text suppot
|
||
FLONG SurfFlags;
|
||
PPALETTE pPal;
|
||
EWNDOBJ *pWo;
|
||
|
||
union {
|
||
HANDLE hSecureUMPD; // Valid when UMPD_SURFACE set, used for UMPD
|
||
// when EngCreateBitmap passed in pvBits
|
||
HANDLE hDDSurface; // Valid when DIRECTDRAW_SURFACE set, and is a
|
||
// handle of the associated DirectDraw surface
|
||
HANDLE hMirrorParent;// Valid when MIRROR_SURFACE is set, and is a
|
||
// handle tothe master GDI surface associated
|
||
// with this DDML mirrored surface
|
||
};
|
||
EBITMAP EBitmap;
|
||
DIB DIB;
|
||
|
||
private:
|
||
// Default size of SURFACE allocations
|
||
static SIZE_T tSize;
|
||
#if TRACE_SURFACE_ALLOCS
|
||
friend class TRACED_SURFACE;
|
||
#endif
|
||
|
||
public:
|
||
|
||
static SIZE_T tSizeOf()
|
||
{
|
||
return tSize;
|
||
}
|
||
|
||
//
|
||
// the default bitmap pointer
|
||
//
|
||
|
||
static SURFACE *pdibDefault;
|
||
|
||
VOID vAltUnlockFast()
|
||
{
|
||
if (this != (SURFACE *) NULL)
|
||
{
|
||
DEC_SHARE_REF_CNT(this);
|
||
}
|
||
}
|
||
|
||
BOOL bDeleteSurface(CLEANUPTYPE cutype = CLEANUP_NONE);
|
||
|
||
//
|
||
// SURFOBJ Fields
|
||
//
|
||
|
||
BOOL bValid() { return(this != (SURFACE *) NULL); }
|
||
|
||
SURFOBJ *pSurfobj()
|
||
{
|
||
if (this == (SURFACE *)NULL)
|
||
{
|
||
return((SURFOBJ *) NULL);
|
||
}
|
||
else
|
||
{
|
||
return((SURFOBJ *) &so);
|
||
}
|
||
}
|
||
|
||
DHSURF dhsurf() { return(so.dhsurf); }
|
||
VOID dhsurf(DHSURF dhsurf) { so.dhsurf = dhsurf; }
|
||
|
||
HSURF hsurf() { return(so.hsurf); }
|
||
VOID hsurf(HANDLE h) { so.hsurf = (HSURF)h; }
|
||
|
||
DHPDEV dhpdev() { return(so.dhpdev); }
|
||
DHPDEV dhpdev(DHPDEV dhpdev_) { return(so.dhpdev = dhpdev_); }
|
||
|
||
HDEV hdev() { return(so.hdev); }
|
||
VOID hdev(HDEV hdevNew) { so.hdev = hdevNew; }
|
||
|
||
SIZEL& sizl() { return(so.sizlBitmap); }
|
||
VOID sizl(SIZEL& sizlNew) { so.sizlBitmap = sizlNew; }
|
||
|
||
ULONG cjBits() { return(so.cjBits); }
|
||
VOID cjBits(ULONG cj) { so.cjBits = cj; }
|
||
|
||
PVOID pvBits() { return(so.pvBits); }
|
||
VOID pvBits(PVOID pj) { so.pvBits = pj; }
|
||
|
||
PVOID pvScan0() { return(so.pvScan0); }
|
||
VOID pvScan0(PVOID pv) { so.pvScan0 = pv; }
|
||
|
||
LONG lDelta() { return(so.lDelta); }
|
||
VOID lDelta(LONG lNew) { so.lDelta = lNew; }
|
||
|
||
ULONG iUniq() { return(so.iUniq); }
|
||
VOID iUniq(ULONG iNew) { so.iUniq = iNew; }
|
||
|
||
ULONG iFormat() { return(so.iBitmapFormat); }
|
||
VOID iFormat(ULONG i) { so.iBitmapFormat = i; }
|
||
|
||
ULONG iType() { return((ULONG) so.iType); }
|
||
VOID iType(ULONG i) { so.iType = (USHORT) i; }
|
||
|
||
ULONG fjBitmap() { return((ULONG) so.fjBitmap); }
|
||
VOID fjBitmap(ULONG i) { so.fjBitmap = (USHORT) i; }
|
||
|
||
ULONG cjScan()
|
||
{
|
||
return(so.lDelta > 0 ? so.lDelta : -(so.lDelta));
|
||
}
|
||
|
||
//
|
||
// Private fields
|
||
//
|
||
|
||
FLONG flags() { return(SurfFlags); }
|
||
VOID flags(FLONG flNew) { SurfFlags = flNew; }
|
||
|
||
BOOL bReadable() { return(!(SurfFlags & UNREADABLE_SURFACE)); }
|
||
BOOL bAbort() { return(SurfFlags & ABORT_SURFACE);}
|
||
BOOL bBanding() { return(SurfFlags & BANDING_SURFACE); }
|
||
BOOL bIncludeSprites() { return(SurfFlags & INCLUDE_SPRITES_SURFACE); }
|
||
BOOL bLazyDelete() { return(SurfFlags & LAZY_DELETE_SURFACE); }
|
||
BOOL bPDEVSurface() { return(SurfFlags & PDEV_SURFACE); }
|
||
BOOL bDynamicModePalette() { return(SurfFlags & DYNAMIC_MODE_PALETTE); }
|
||
BOOL bDeviceDependentBitmap() { return(SurfFlags & DDB_SURFACE); }
|
||
BOOL bEngCreateDeviceBitmap() { return(SurfFlags & ENG_CREATE_DEVICE_SURFACE);}
|
||
BOOL bDriverCreated() { return(SurfFlags & DRIVER_CREATED_SURFACE); }
|
||
|
||
BOOL bDirectDraw() { return(SurfFlags & DIRECTDRAW_SURFACE); }
|
||
BOOL bApiBitmap() { return(SurfFlags & API_BITMAP); }
|
||
BOOL bMirrorSurface() { return(SurfFlags & MIRROR_SURFACE); }
|
||
BOOL bUseDevlock() { return(SurfFlags & USE_DEVLOCK_SURFACE); }
|
||
BOOL bUMPD() { return(SurfFlags & UMPD_SURFACE); }
|
||
BOOL bRedirection() { return(SurfFlags & REDIRECTION_SURFACE); }
|
||
BOOL bShareAccess() { return(SurfFlags & SHAREACCESS_SURFACE); }
|
||
|
||
VOID vSetReadOnly() { fjBitmap(fjBitmap() | BMF_ISREADONLY); }
|
||
VOID vSetMakeReadWrite() { fjBitmap(fjBitmap() | BMF_MAKEREADWRITE); }
|
||
|
||
VOID vClearReadOnly() { fjBitmap(fjBitmap() & ~BMF_ISREADONLY); }
|
||
VOID vClearMakeReadWrite() { fjBitmap(fjBitmap() & ~BMF_MAKEREADWRITE); }
|
||
|
||
BOOL bReadOnly() { return (fjBitmap() & BMF_ISREADONLY); }
|
||
BOOL bMakeReadWrite() { return (fjBitmap() & BMF_MAKEREADWRITE); }
|
||
|
||
BOOL bStockSurface() { return(HmgStockObj(hGet()) && (bReadOnly()));}
|
||
BOOL bUndoStockSurfaceDelayed() { return(HmgStockObj(hGet()) && (bMakeReadWrite()));}
|
||
|
||
VOID vPDEVSurface() { SurfFlags |= PDEV_SURFACE; }
|
||
VOID vSetAbort() { SurfFlags |= ABORT_SURFACE; }
|
||
VOID vSetBanding() { SurfFlags |= BANDING_SURFACE; }
|
||
VOID vSetIncludeSprites() { SurfFlags |= INCLUDE_SPRITES_SURFACE; }
|
||
VOID vLazyDelete() { SurfFlags |= LAZY_DELETE_SURFACE; }
|
||
VOID vSetDynamicModePalette() { SurfFlags |= DYNAMIC_MODE_PALETTE; }
|
||
VOID vSetDeviceDependentBitmap() { SurfFlags |= DDB_SURFACE; }
|
||
VOID vSetEngCreateDeviceBitmap() { SurfFlags |= ENG_CREATE_DEVICE_SURFACE; }
|
||
VOID vSetDriverCreated() { SurfFlags |= DRIVER_CREATED_SURFACE; }
|
||
VOID vSetDirectDraw() { SurfFlags |= DIRECTDRAW_SURFACE; }
|
||
VOID vSetApiBitmap() { SurfFlags |= API_BITMAP; }
|
||
VOID vSetMirror() { SurfFlags |= MIRROR_SURFACE; }
|
||
VOID vSetUseDevlock() { SurfFlags |= USE_DEVLOCK_SURFACE; }
|
||
VOID vSetUMPD() { SurfFlags |= UMPD_SURFACE; }
|
||
VOID vSetRedirection() { SurfFlags |= REDIRECTION_SURFACE; }
|
||
VOID vSetShareAccess() { SurfFlags |= SHAREACCESS_SURFACE; }
|
||
|
||
VOID vSetStockSurface() { if(HmgStockObj(hGet())) vSetReadOnly(); }
|
||
VOID vSetUndoStockSurfaceDelayed() { if(HmgStockObj(hGet())) vSetMakeReadWrite(); }
|
||
|
||
VOID vClearDynamicModePalette() { SurfFlags &= ~DYNAMIC_MODE_PALETTE; }
|
||
VOID vClearAbort() { SurfFlags &= ~ABORT_SURFACE; }
|
||
VOID vClearDirectDraw() { SurfFlags &= ~DIRECTDRAW_SURFACE; }
|
||
VOID vClearUseDevlock() { SurfFlags &= ~USE_DEVLOCK_SURFACE; }
|
||
VOID vClearIncludeSprites() { SurfFlags &= ~INCLUDE_SPRITES_SURFACE; }
|
||
VOID vClearRedirection() { SurfFlags &= ~REDIRECTION_SURFACE; }
|
||
VOID vClearShareAccess() { SurfFlags &= ~SHAREACCESS_SURFACE; }
|
||
|
||
VOID vClearStockSurface() { vClearReadOnly(); }
|
||
VOID vClearUndoStockSurfaceDelayed(){ vClearMakeReadWrite(); }
|
||
|
||
PALETTE* ppal() { return(pPal); }
|
||
VOID ppal(PPALETTE ppalNew) { pPal = ppalNew; }
|
||
|
||
PFN_DrvBitBlt pfnBitBlt()
|
||
{
|
||
return((SurfFlags & HOOK_BITBLT)
|
||
? (PFN_DrvBitBlt) ((PDEV*) so.hdev)->apfn[INDEX_DrvBitBlt]
|
||
: EngBitBlt);
|
||
}
|
||
PFN_DrvTextOut pfnTextOut()
|
||
{
|
||
return((SurfFlags & HOOK_TEXTOUT)
|
||
? (PFN_DrvTextOut) ((PDEV*) so.hdev)->apfn[INDEX_DrvTextOut]
|
||
: EngTextOut);
|
||
}
|
||
PFN_DrvDrawStream pfnDrawStream()
|
||
{
|
||
return((PFN_DrvDrawStream)((PDEV*) so.hdev)->apfn[INDEX_DrvDrawStream] ?
|
||
(PFN_DrvDrawStream)((PDEV*) so.hdev)->apfn[INDEX_DrvDrawStream] :
|
||
EngDrawStream);
|
||
|
||
}
|
||
PFN_DrvNineGrid pfnNineGrid()
|
||
{
|
||
return((PFN_DrvNineGrid)((PDEV*) so.hdev)->apfn[INDEX_DrvNineGrid] ?
|
||
(PFN_DrvNineGrid)((PDEV*) so.hdev)->apfn[INDEX_DrvNineGrid] :
|
||
EngNineGrid);
|
||
|
||
}
|
||
|
||
BOOL bIsDefault() { return(this == pdibDefault); }
|
||
|
||
VOID vStamp() { so.iUniq++; }
|
||
|
||
EWNDOBJ *pwo() { return(pWo); }
|
||
|
||
VOID pwo(EWNDOBJ *pwoNew)
|
||
{
|
||
ASSERTGDI(!bIsDefault() || pwoNew == (EWNDOBJ *)NULL,
|
||
"SURFACE::pwo(pWo): pwo set to nonnull in pdibDefault\n");
|
||
pWo = pwoNew;
|
||
}
|
||
|
||
//
|
||
// EBITMAP Specific functions
|
||
//
|
||
|
||
SIZEL& sizlDim() { return(EBitmap.sizlDim); }
|
||
VOID sizlDim(SIZEL& sizlNew) { EBitmap.sizlDim = sizlNew; }
|
||
HDC hdc() { return(EBitmap.hdc); }
|
||
VOID hdc(HDC hdcNew) { EBitmap.hdc = hdcNew; }
|
||
ULONG cRef() { return(EBitmap.cRef); }
|
||
VOID cRef(ULONG ulNew) { EBitmap.cRef = ulNew; }
|
||
HPALETTE hpalHint() { return(EBitmap.hpalHint); }
|
||
VOID hpalHint(HPALETTE hpalNew) { EBitmap.hpalHint = hpalNew; }
|
||
|
||
//
|
||
// The alt lock count on surfaces increments and decrements whenever
|
||
// the reference count does the same. This way, a surface can't be
|
||
// deleted while it's still selected into a DC. Note that surfaces can
|
||
// also be locked for GetDIBits with no DC involvement, so the alt lock
|
||
// count may be higher than the reference count.
|
||
//
|
||
|
||
VOID vInc_cRef()
|
||
{
|
||
INC_SHARE_REF_CNT(this);
|
||
EBitmap.cRef++;
|
||
}
|
||
|
||
VOID vDec_cRef()
|
||
{
|
||
DEC_SHARE_REF_CNT(this);
|
||
ASSERTGDI(EBitmap.cRef, "cRef == 0\n");
|
||
if (!--EBitmap.cRef)
|
||
{
|
||
if (bUndoStockSurfaceDelayed())
|
||
{
|
||
vClearUndoStockSurfaceDelayed();
|
||
GreMakeBitmapNonStock((HBITMAP)hGet());
|
||
}
|
||
EBitmap.hdc = (HDC) 0;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Private DIB fields
|
||
//
|
||
|
||
BOOL bDIBSection()
|
||
{
|
||
return((iType() == STYPE_BITMAP) && (DIB.hSecure != NULL));
|
||
}
|
||
|
||
HANDLE hDIBSection()
|
||
{
|
||
return(DIB.hDIBSection);
|
||
}
|
||
|
||
ULONG_PTR dwDIBColorSpace()
|
||
{
|
||
return(DIB.dwDIBColorSpace);
|
||
}
|
||
|
||
DWORD dwOffset()
|
||
{
|
||
return(DIB.dwOffset);
|
||
}
|
||
|
||
PVOID pvBitsBase()
|
||
{
|
||
return((PVOID)((PBYTE)so.pvBits - (DIB.dwOffset & 0x0000ffff)));
|
||
}
|
||
|
||
VOID vDIBSethSecure(HANDLE hSec)
|
||
{
|
||
DIB.hSecure = hSec;
|
||
}
|
||
|
||
HANDLE hDIBGethSecure()
|
||
{
|
||
return(DIB.hSecure);
|
||
}
|
||
|
||
#if DBG
|
||
VOID vDump();
|
||
#endif
|
||
};
|
||
|
||
typedef SURFACE *PSURFACE;
|
||
|
||
|
||
#if TRACE_SURFACE_ALLOCS
|
||
|
||
class TRACED_SURFACE : public SURFACE
|
||
{
|
||
public:
|
||
SurfaceTrace Trace;
|
||
|
||
private:
|
||
// Enable ststus if SURFACE stack tracing
|
||
typedef enum {
|
||
SURFACE_TRACING_UNINITIALIZED,
|
||
SURFACE_TRACING_ENABLED,
|
||
SURFACE_TRACING_DISABLED
|
||
} SurfaceTraceStatus;
|
||
|
||
static SurfaceTraceStatus eTraceStatus;
|
||
|
||
static VOID vInit();
|
||
|
||
friend BOOLEAN InitializeGre(VOID);
|
||
|
||
public:
|
||
static BOOL bEnabled()
|
||
{
|
||
// Tracing is enabled based on how much memory will be allocated
|
||
// for each SURFACE (always through SURFMEM::bCreateDIB).
|
||
return (tSizeOf() == sizeof(TRACED_SURFACE));
|
||
};
|
||
|
||
|
||
#if TRACE_SURFACE_USER_CHAIN_IN_UM
|
||
private:
|
||
|
||
// Is User mode visible stack tracing enabled
|
||
static SurfaceTraceStatus eUMTraceStatus;
|
||
|
||
public:
|
||
static BOOL bUMEnabled()
|
||
{
|
||
return (eUMTraceStatus == SURFACE_TRACING_ENABLED);
|
||
}
|
||
|
||
VOID vProcessStackFromUM(BOOL bFreeUserMem);
|
||
#endif
|
||
};
|
||
|
||
#endif TRACE_SURFACE_ALLOCS
|
||
|
||
|
||
#if TRACE_SURFACE_USER_CHAIN_IN_UM
|
||
#define PROCESS_UM_TRACE(pSurface, bFreeUserMem) \
|
||
do \
|
||
{ \
|
||
if (TRACED_SURFACE::bEnabled()) \
|
||
{ \
|
||
((TRACED_SURFACE *)pSurface)->vProcessStackFromUM(bFreeUserMem); \
|
||
} \
|
||
} while (0)
|
||
#else
|
||
#define PROCESS_UM_TRACE(pSuface, bFreeUserMem)
|
||
#endif
|
||
|
||
|
||
|
||
/*********************************Class************************************\
|
||
* class SURFREF *
|
||
* *
|
||
* Description: *
|
||
* *
|
||
* Creates a new reference to a SURFACE *
|
||
* *
|
||
* Fields: *
|
||
* *
|
||
* pSurface - Surface allocated *
|
||
* AllocationFlags - Keep allocation *
|
||
* *
|
||
\**************************************************************************/
|
||
|
||
class SURFREF
|
||
{
|
||
public:
|
||
|
||
SURFACE *ps;
|
||
|
||
public:
|
||
|
||
SURFREF()
|
||
{
|
||
ps = (SURFACE *)NULL;
|
||
}
|
||
|
||
SURFREF(HSURF hsurf)
|
||
{
|
||
ps = (SURFACE *) HmgShareCheckLock((HOBJ)hsurf,SURF_TYPE);
|
||
}
|
||
|
||
SURFREF(SURFACE *pSurf)
|
||
{
|
||
ps = pSurf;
|
||
}
|
||
|
||
SURFREF(SURFOBJ *pso)
|
||
{
|
||
if (pso == (SURFOBJ *)NULL)
|
||
{
|
||
ps = (SURFACE *)NULL;
|
||
}
|
||
else
|
||
{
|
||
ps = (SURFACE *)((PBYTE)pso - offsetof(SURFACE,so));
|
||
}
|
||
}
|
||
|
||
|
||
~SURFREF()
|
||
{
|
||
if (ps != (SURFACE *) NULL)
|
||
{
|
||
DEC_SHARE_REF_CNT(ps);
|
||
}
|
||
}
|
||
|
||
VOID vLock(HSURF hsurf)
|
||
{
|
||
ps = (SURFACE *) HmgShareCheckLock((HOBJ)hsurf,SURF_TYPE);
|
||
}
|
||
|
||
BOOL bDeleteSurface(CLEANUPTYPE cutype = CLEANUP_NONE)
|
||
{
|
||
BOOL bStatus = ps->bDeleteSurface(cutype);
|
||
if (bStatus)
|
||
{
|
||
ps = (SURFACE *)NULL;
|
||
}
|
||
return(bStatus);
|
||
}
|
||
|
||
VOID vUnlock() { vAltUnlockFast(); }
|
||
BOOL bValid() { return(ps != (SURFACE *)NULL); }
|
||
|
||
SURFOBJ *pSurfobj()
|
||
{
|
||
if (ps == (SURFACE *)NULL)
|
||
{
|
||
return((SURFOBJ *)NULL);
|
||
}
|
||
else
|
||
{
|
||
return(&ps->so);
|
||
}
|
||
}
|
||
|
||
VOID vKeepIt() { INC_SHARE_REF_CNT(ps); }
|
||
|
||
//
|
||
// Object management
|
||
//
|
||
|
||
VOID vSetPID(W32PID pid)
|
||
{
|
||
PROCESS_UM_TRACE(ps, (pid == OBJECT_OWNER_PUBLIC) || (pid == OBJECT_OWNER_NONE));
|
||
HmgSetOwner((HOBJ)ps->hsurf(),
|
||
pid,
|
||
SURF_TYPE);
|
||
}
|
||
|
||
VOID vUnreference()
|
||
{
|
||
DEC_SHARE_REF_CNT(ps);
|
||
ps = (SURFACE *) NULL;
|
||
}
|
||
|
||
VOID vAltCheckLock(HSURF hsurf)
|
||
{
|
||
ps = (SURFACE *) HmgShareCheckLock((HOBJ)hsurf, SURF_TYPE);
|
||
}
|
||
|
||
VOID vAltCheckLockIgnoreStockBit(HSURF hsurf)
|
||
{
|
||
ps = (SURFACE *) HmgShareCheckLockIgnoreStockBit((HOBJ)hsurf,SURF_TYPE);
|
||
}
|
||
|
||
VOID vAltLock(HSURF hsurf)
|
||
{
|
||
ps = (SURFACE *) HmgShareLock((HOBJ)hsurf, SURF_TYPE);
|
||
}
|
||
|
||
VOID vAltLockIgnoreStockBit(HSURF hsurf)
|
||
{
|
||
ps = (SURFACE *) HmgShareLockIgnoreStockBit((HOBJ)hsurf, SURF_TYPE);
|
||
}
|
||
|
||
VOID vAltUnlockFast()
|
||
{
|
||
if (ps != (SURFACE *) NULL)
|
||
{
|
||
DEC_SHARE_REF_CNT(ps);
|
||
}
|
||
}
|
||
|
||
VOID vMultiLock(HSURF hsurf)
|
||
{
|
||
ps = (SURFACE *) HmgShareCheckLock((HOBJ)hsurf, SURF_TYPE);
|
||
}
|
||
|
||
};
|
||
|
||
/*********************************Class************************************\
|
||
* class SURFREFAPI *
|
||
* *
|
||
* Description: *
|
||
* *
|
||
* Creates a new reference to a SURFACE from the API level *
|
||
* From the API level means we have to take an Exclusive lock *
|
||
* *
|
||
* Fields: *
|
||
* *
|
||
* pSurface - Surface allocated *
|
||
* *
|
||
\**************************************************************************/
|
||
|
||
class SURFREFAPI
|
||
{
|
||
|
||
public:
|
||
SURFACE *ps;
|
||
|
||
public:
|
||
SURFREFAPI()
|
||
{
|
||
ps = (SURFACE *)NULL;
|
||
}
|
||
|
||
SURFREFAPI(HSURF hsurf)
|
||
{
|
||
ps = (SURFACE *) HmgLock((HOBJ)hsurf,SURF_TYPE);
|
||
}
|
||
|
||
BOOL bValid() { return(ps != (SURFACE *)NULL); }
|
||
|
||
SURFOBJ *pSurfobj()
|
||
{
|
||
if (ps == (SURFACE *)NULL)
|
||
{
|
||
return((SURFOBJ *)NULL);
|
||
}
|
||
else
|
||
{
|
||
return(&ps->so);
|
||
}
|
||
}
|
||
|
||
VOID vSetPID(W32PID pid)
|
||
{
|
||
PROCESS_UM_TRACE(ps, (pid == OBJECT_OWNER_PUBLIC) || (pid == OBJECT_OWNER_NONE));
|
||
HmgSetOwner((HOBJ)ps->hsurf(),
|
||
pid,
|
||
SURF_TYPE);
|
||
}
|
||
|
||
~SURFREFAPI()
|
||
{
|
||
if (ps != (SURFACE *) NULL)
|
||
{
|
||
DEC_EXCLUSIVE_REF_CNT(ps);
|
||
}
|
||
}
|
||
};
|
||
|
||
|
||
|
||
typedef struct _DEVBITMAPINFO /* dbmi */
|
||
{
|
||
ULONG iFormat; /* Format (eg. BITMAP_FORMAT_DEVICE)*/
|
||
ULONG cxBitmap; /* Bitmap width in pels */
|
||
ULONG cyBitmap; /* Bitmap height in pels */
|
||
ULONG cjBits; /* Size of bitmap in bytes */
|
||
HPALETTE hpal; /* handle to palette */
|
||
FLONG fl; /* How to orient the bitmap */
|
||
} DEVBITMAPINFO, *PDEVBITMAPINFO;
|
||
|
||
#endif // GDIFLAGS_ONLY used for gdikdx
|
||
|
||
|
||
/*********************************Class************************************\
|
||
* class SURFMEM *
|
||
* *
|
||
* Description: *
|
||
* *
|
||
* SURFACE memory allocation object *
|
||
* *
|
||
* Fields: *
|
||
* *
|
||
* ps - Surface allocated *
|
||
* AllocationFlags - Keep allocation *
|
||
* *
|
||
\**************************************************************************/
|
||
|
||
#define SURFACE_KEEP 0x01
|
||
#define SURFACE_DEVSURF 0x02
|
||
#define SURFACE_DDB 0x04
|
||
#define SURFACE_DIB 0x08
|
||
|
||
#ifndef GDIFLAGS_ONLY // used for gdikdx
|
||
|
||
class SURFMEM
|
||
{
|
||
public:
|
||
|
||
SURFACE *ps;
|
||
UCHAR AllocationFlags;
|
||
|
||
public:
|
||
|
||
SURFMEM()
|
||
{
|
||
ps = (SURFACE *)NULL;
|
||
AllocationFlags = 0;
|
||
}
|
||
|
||
~SURFMEM();
|
||
|
||
VOID vKeepIt() {AllocationFlags |= SURFACE_KEEP; }
|
||
|
||
SURFOBJ *pSurfobj()
|
||
{
|
||
if (ps == (SURFACE *)NULL)
|
||
{
|
||
return((SURFOBJ *)NULL);
|
||
}
|
||
else
|
||
{
|
||
return(&ps->so);
|
||
}
|
||
}
|
||
|
||
BOOL bValid() { return(ps != (SURFACE *) NULL); }
|
||
|
||
//
|
||
// DIB allocations
|
||
//
|
||
|
||
BOOL bCreateDIB(PDEVBITMAPINFO,PVOID,
|
||
HANDLE hDIBSection = NULL,
|
||
DWORD dwOffset = 0,
|
||
HANDLE hSecure = NULL,
|
||
ULONG_PTR dwColorSpace = 0);
|
||
|
||
//
|
||
// Object management
|
||
//
|
||
|
||
VOID vSetPID(W32PID pid)
|
||
{
|
||
PROCESS_UM_TRACE(ps, (pid == OBJECT_OWNER_PUBLIC) || (pid == OBJECT_OWNER_NONE));
|
||
HmgSetOwner((HOBJ)ps->hsurf(),
|
||
pid,
|
||
SURF_TYPE);
|
||
}
|
||
|
||
VOID vUnreference()
|
||
{
|
||
DEC_SHARE_REF_CNT(ps);
|
||
ps = (SURFACE *) NULL;
|
||
}
|
||
|
||
VOID vAltCheckLock(HSURF hsurf)
|
||
{
|
||
ps = (SURFACE *) HmgShareCheckLock((HOBJ)hsurf, SURF_TYPE);
|
||
}
|
||
|
||
VOID vAltLock(HSURF hsurf)
|
||
{
|
||
ps = (SURFACE *) HmgShareLock((HOBJ)hsurf, SURF_TYPE);
|
||
}
|
||
|
||
VOID vAltUnlockFast()
|
||
{
|
||
if (ps != (SURFACE *) NULL)
|
||
{
|
||
DEC_SHARE_REF_CNT(ps);
|
||
}
|
||
}
|
||
|
||
};
|
||
|
||
|
||
|
||
HBITMAP hbmCreateClone(SURFACE*,ULONG,ULONG);
|
||
BOOL bConvertDfbDcToDib(XDCOBJ*);
|
||
SURFACE *pConvertDfbSurfaceToDib(HDEV,SURFACE*,LONG);
|
||
|
||
typedef struct _KMSECTIONHEADER
|
||
{
|
||
PVOID pSection;
|
||
ULONG Tag;
|
||
}KMSECTIONHEADER,*PKMSECTIONHEADER;
|
||
|
||
|
||
#define _SURFOBJ_HXX
|
||
|
||
#endif // GDIFLAGS_ONLY used for gdikdx
|
||
|
||
#endif // _SURFOBJ_HXX
|