*/
struct HGLOBALLockBytesImpl
{
- /*
- * Needs to be the first item in the struct
- * since we want to cast this in an ILockBytes pointer
- */
- const ILockBytesVtbl *lpVtbl;
-
- /*
- * Reference count
- */
- LONG ref;
+ ILockBytes ILockBytes_iface;
+ LONG ref;
/*
* Support for the LockBytes object
typedef struct HGLOBALLockBytesImpl HGLOBALLockBytesImpl;
-/*
- * Method definition for the HGLOBALLockBytesImpl class.
- */
-static HGLOBALLockBytesImpl* HGLOBALLockBytesImpl_Construct(
- HGLOBAL hGlobal,
- BOOL fDeleteOnRelease);
-
-static void HGLOBALLockBytesImpl_Destroy(HGLOBALLockBytesImpl* This);
-
-static HRESULT WINAPI HGLOBALLockBytesImpl_SetSize( ILockBytes* iface, ULARGE_INTEGER libNewSize );
+static inline HGLOBALLockBytesImpl *impl_from_ILockBytes( ILockBytes *iface )
+{
+ return CONTAINING_RECORD(iface, HGLOBALLockBytesImpl, ILockBytes_iface);
+}
static const ILockBytesVtbl HGLOBALLockBytesImpl_Vtbl;
* This object supports a COM implementation of the ILockBytes interface.
*
* PARAMS
- * hGlobal [ I] Global memory handle
- * fDeleteOnRelease [ I] Whether the handle should be freed when the object is released.
- * ppLkbyt [ O] Address of ILockBytes pointer that receives
+ * global [ I] Global memory handle
+ * delete_on_release [ I] Whether the handle should be freed when the object is released.
+ * ret [ O] Address of ILockBytes pointer that receives
* the interface pointer to the new byte array object.
*
* RETURNS
* The ILockBytes interface instance calls the GlobalReAlloc function to grow
* the memory block as required.
*/
-HRESULT WINAPI CreateILockBytesOnHGlobal(HGLOBAL hGlobal,
- BOOL fDeleteOnRelease,
- LPLOCKBYTES* ppLkbyt)
+HRESULT WINAPI CreateILockBytesOnHGlobal(HGLOBAL global, BOOL delete_on_release, ILockBytes **ret)
{
- HGLOBALLockBytesImpl* newLockBytes;
+ HGLOBALLockBytesImpl* lockbytes;
- newLockBytes = HGLOBALLockBytesImpl_Construct(hGlobal, fDeleteOnRelease);
+ lockbytes = HeapAlloc(GetProcessHeap(), 0, sizeof(HGLOBALLockBytesImpl));
+ if (!lockbytes) return E_OUTOFMEMORY;
- if (newLockBytes != NULL)
- {
- return IUnknown_QueryInterface((IUnknown*)newLockBytes,
- &IID_ILockBytes,
- (void**)ppLkbyt);
- }
+ lockbytes->ILockBytes_iface.lpVtbl = &HGLOBALLockBytesImpl_Vtbl;
+ lockbytes->ref = 1;
+
+ /*
+ * Initialize the support.
+ */
+ lockbytes->supportHandle = global;
+ lockbytes->deleteOnRelease = delete_on_release;
+
+ /*
+ * This method will allocate a handle if one is not supplied.
+ */
+ if (lockbytes->supportHandle == 0)
+ lockbytes->supportHandle = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD, 0);
+
+ /*
+ * Initialize the size of the array to the size of the handle.
+ */
+ lockbytes->byteArraySize.u.HighPart = 0;
+ lockbytes->byteArraySize.u.LowPart = GlobalSize(lockbytes->supportHandle);
- return E_OUTOFMEMORY;
+ *ret = &lockbytes->ILockBytes_iface;
+
+ return S_OK;
}
/******************************************************************************
* E_INVALIDARG if any parameters are invalid
*
*/
-HRESULT WINAPI GetHGlobalFromILockBytes(ILockBytes* plkbyt, HGLOBAL* phglobal)
+HRESULT WINAPI GetHGlobalFromILockBytes(ILockBytes* iface, HGLOBAL* phglobal)
{
- HGLOBALLockBytesImpl* const pMemLockBytes = (HGLOBALLockBytesImpl*)plkbyt;
+ HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
STATSTG stbuf;
HRESULT hres;
ULARGE_INTEGER start;
ULONG xread;
*phglobal = 0;
- if (pMemLockBytes->lpVtbl == &HGLOBALLockBytesImpl_Vtbl) {
- *phglobal = pMemLockBytes->supportHandle;
+ if (This->ILockBytes_iface.lpVtbl == &HGLOBALLockBytesImpl_Vtbl) {
+ *phglobal = This->supportHandle;
if (*phglobal == 0)
return E_INVALIDARG;
return S_OK;
}
/* It is not our lockbytes implementation, so use a more generic way */
- hres = ILockBytes_Stat(plkbyt,&stbuf,STATFLAG_NONAME);
+ hres = ILockBytes_Stat(iface,&stbuf,STATFLAG_NONAME);
if (hres != S_OK) {
ERR("Cannot ILockBytes_Stat, %x\n",hres);
return hres;
if (!*phglobal)
return E_INVALIDARG;
memset(&start,0,sizeof(start));
- hres = ILockBytes_ReadAt(plkbyt, start, GlobalLock(*phglobal), stbuf.cbSize.u.LowPart, &xread);
+ hres = ILockBytes_ReadAt(iface, start, GlobalLock(*phglobal), stbuf.cbSize.u.LowPart, &xread);
GlobalUnlock(*phglobal);
if (hres != S_OK) {
- FIXME("%p->ReadAt failed with %x\n",plkbyt,hres);
+ FIXME("%p->ReadAt failed with %x\n",iface,hres);
return hres;
}
if (stbuf.cbSize.u.LowPart != xread) {
*
*/
-/******************************************************************************
- * This is the constructor for the HGLOBALLockBytesImpl class.
- *
- * PARAMS
- * hGlobal [ I] Handle that will support the stream. can be NULL.
- * fDeleteOnRelease [ I] Flag set to TRUE if the HGLOBAL will be released
- * when the IStream object is destroyed.
- */
-static HGLOBALLockBytesImpl* HGLOBALLockBytesImpl_Construct(HGLOBAL hGlobal,
- BOOL fDeleteOnRelease)
-{
- HGLOBALLockBytesImpl* newLockBytes;
- newLockBytes = HeapAlloc(GetProcessHeap(), 0, sizeof(HGLOBALLockBytesImpl));
-
- if (newLockBytes!=0)
- {
- /*
- * Set up the virtual function table and reference count.
- */
- newLockBytes->lpVtbl = &HGLOBALLockBytesImpl_Vtbl;
- newLockBytes->ref = 0;
-
- /*
- * Initialize the support.
- */
- newLockBytes->supportHandle = hGlobal;
- newLockBytes->deleteOnRelease = fDeleteOnRelease;
-
- /*
- * This method will allocate a handle if one is not supplied.
- */
- if (newLockBytes->supportHandle == 0)
- {
- newLockBytes->supportHandle = GlobalAlloc(GMEM_MOVEABLE |
- GMEM_NODISCARD,
- 0);
- }
-
- /*
- * Initialize the size of the array to the size of the handle.
- */
- newLockBytes->byteArraySize.u.HighPart = 0;
- newLockBytes->byteArraySize.u.LowPart = GlobalSize(
- newLockBytes->supportHandle);
- }
-
- return newLockBytes;
-}
-
-/******************************************************************************
- * This is the destructor of the HGLOBALStreamImpl class.
- *
- * This method will clean-up all the resources used-up by the given
- * HGLOBALLockBytesImpl class. The pointer passed-in to this function will be
- * freed and will not be valid anymore.
- */
-static void HGLOBALLockBytesImpl_Destroy(HGLOBALLockBytesImpl* This)
-{
- /*
- * Release the HGlobal if the constructor asked for that.
- */
- if (This->deleteOnRelease)
- {
- GlobalFree(This->supportHandle);
- This->supportHandle = 0;
- }
-
- /*
- * Finally, free the memory used-up by the class.
- */
- HeapFree(GetProcessHeap(), 0, This);
-}
-
/******************************************************************************
* This implements the IUnknown method QueryInterface for this
* class
REFIID riid, /* [in] */
void** ppvObject) /* [iid_is][out] */
{
- HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
+ HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
- /*
- * Perform a sanity check on the parameters.
- */
if (ppvObject==0)
return E_INVALIDARG;
- /*
- * Initialize the return parameter.
- */
*ppvObject = 0;
- /*
- * Compare the riid with the interface IDs implemented by this object.
- */
if (IsEqualIID(riid, &IID_IUnknown) ||
IsEqualIID(riid, &IID_ILockBytes))
{
- *ppvObject = This;
+ *ppvObject = &This->ILockBytes_iface;
}
-
- /*
- * Check that we obtained an interface.
- */
- if ((*ppvObject)==0)
+ else
return E_NOINTERFACE;
- /*
- * Query Interface always increases the reference count by one when it is
- * successful
- */
- IUnknown_AddRef(iface);
+ ILockBytes_AddRef(iface);
return S_OK;
}
*/
static ULONG WINAPI HGLOBALLockBytesImpl_AddRef(ILockBytes* iface)
{
- HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
+ HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
return InterlockedIncrement(&This->ref);
}
*/
static ULONG WINAPI HGLOBALLockBytesImpl_Release(ILockBytes* iface)
{
- HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
+ HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
ULONG ref;
ref = InterlockedDecrement(&This->ref);
-
- /*
- * If the reference count goes down to 0, perform suicide.
- */
- if (ref==0)
+ if (!ref)
{
- HGLOBALLockBytesImpl_Destroy(This);
+ if (This->deleteOnRelease)
+ {
+ GlobalFree(This->supportHandle);
+ This->supportHandle = 0;
+ }
+ HeapFree(GetProcessHeap(), 0, This);
}
return ref;
ULONG cb, /* [in] */
ULONG* pcbRead) /* [out] */
{
- HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
+ HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
void* supportBuffer;
ULONG bytesReadBuffer = 0;
ULONG cb, /* [in] */
ULONG* pcbWritten) /* [out] */
{
- HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
+ HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
void* supportBuffer;
ULARGE_INTEGER newSize;
if (newSize.u.LowPart > This->byteArraySize.u.LowPart)
{
/* grow stream */
- if (HGLOBALLockBytesImpl_SetSize(iface, newSize) == STG_E_MEDIUMFULL)
+ if (ILockBytes_SetSize(iface, newSize) == STG_E_MEDIUMFULL)
return STG_E_MEDIUMFULL;
}
ILockBytes* iface,
ULARGE_INTEGER libNewSize) /* [in] */
{
- HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
+ HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
HGLOBAL supportHandle;
/*
STATSTG* pstatstg, /* [out] */
DWORD grfStatFlag) /* [in] */
{
- HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
+ HGLOBALLockBytesImpl* This = impl_from_ILockBytes(iface);
memset(pstatstg, 0, sizeof(STATSTG));
projects / reactos.git / blobdiff