1 /******************************************************************************
3 * Global memory implementation of ILockBytes.
5 * Copyright 1999 Thuy Nguyen
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
32 #include "wine/debug.h"
34 WINE_DEFAULT_DEBUG_CHANNEL(ole);
36 /******************************************************************************
37 * HGLOBALLockBytesImpl definition.
39 * This class imlements the ILockBytes inteface and represents a byte array
40 * object supported by an HGLOBAL pointer.
42 struct HGLOBALLockBytesImpl
45 * Needs to be the first item in the stuct
46 * since we want to cast this in an ILockBytes pointer
48 ICOM_VFIELD(ILockBytes);
56 * Support for the LockBytes object
58 HGLOBAL supportHandle;
61 * This flag is TRUE if the HGLOBAL is destroyed when the object
62 * is finally released.
67 * Helper variable that contains the size of the byte array
69 ULARGE_INTEGER byteArraySize;
72 typedef struct HGLOBALLockBytesImpl HGLOBALLockBytesImpl;
75 * Method definition for the HGLOBALLockBytesImpl class.
77 HGLOBALLockBytesImpl* HGLOBALLockBytesImpl_Construct(
79 BOOL fDeleteOnRelease);
81 void HGLOBALLockBytesImpl_Destroy(HGLOBALLockBytesImpl* This);
83 HRESULT WINAPI HGLOBALLockBytesImpl_QueryInterface(
85 REFIID riid, /* [in] */
86 void** ppvObject); /* [iid_is][out] */
88 ULONG WINAPI HGLOBALLockBytesImpl_AddRef(
91 ULONG WINAPI HGLOBALLockBytesImpl_Release(
94 HRESULT WINAPI HGLOBALLockBytesImpl_ReadAt(
96 ULARGE_INTEGER ulOffset, /* [in] */
97 void* pv, /* [length_is][size_is][out] */
99 ULONG* pcbRead); /* [out] */
101 HRESULT WINAPI HGLOBALLockBytesImpl_WriteAt(
103 ULARGE_INTEGER ulOffset, /* [in] */
104 const void* pv, /* [size_is][in] */
106 ULONG* pcbWritten); /* [out] */
108 HRESULT WINAPI HGLOBALLockBytesImpl_Flush(
111 HRESULT WINAPI HGLOBALLockBytesImpl_SetSize(
113 ULARGE_INTEGER libNewSize); /* [in] */
115 HRESULT WINAPI HGLOBALLockBytesImpl_LockRegion(
117 ULARGE_INTEGER libOffset, /* [in] */
118 ULARGE_INTEGER cb, /* [in] */
119 DWORD dwLockType); /* [in] */
121 HRESULT WINAPI HGLOBALLockBytesImpl_UnlockRegion(
123 ULARGE_INTEGER libOffset, /* [in] */
124 ULARGE_INTEGER cb, /* [in] */
125 DWORD dwLockType); /* [in] */
127 HRESULT WINAPI HGLOBALLockBytesImpl_Stat(
129 STATSTG* pstatstg, /* [out] */
130 DWORD grfStatFlag); /* [in] */
133 * Virtual function table for the HGLOBALLockBytesImpl class.
135 static ICOM_VTABLE(ILockBytes) HGLOBALLockBytesImpl_Vtbl =
137 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
138 HGLOBALLockBytesImpl_QueryInterface,
139 HGLOBALLockBytesImpl_AddRef,
140 HGLOBALLockBytesImpl_Release,
141 HGLOBALLockBytesImpl_ReadAt,
142 HGLOBALLockBytesImpl_WriteAt,
143 HGLOBALLockBytesImpl_Flush,
144 HGLOBALLockBytesImpl_SetSize,
145 HGLOBALLockBytesImpl_LockRegion,
146 HGLOBALLockBytesImpl_UnlockRegion,
147 HGLOBALLockBytesImpl_Stat,
150 /******************************************************************************
151 * CreateILockBytesOnHGlobal [OLE32.57]
153 HRESULT WINAPI CreateILockBytesOnHGlobal(HGLOBAL hGlobal,
154 BOOL fDeleteOnRelease,
155 LPLOCKBYTES* ppLkbyt)
157 HGLOBALLockBytesImpl* newLockBytes;
159 newLockBytes = HGLOBALLockBytesImpl_Construct(hGlobal, fDeleteOnRelease);
161 if (newLockBytes != NULL)
163 return IUnknown_QueryInterface((IUnknown*)newLockBytes,
168 return E_OUTOFMEMORY;
171 /******************************************************************************
172 * GetHGlobalFromILockBytes [OLE32.70]
174 HRESULT WINAPI GetHGlobalFromILockBytes(ILockBytes* plkbyt, HGLOBAL* phglobal)
176 HGLOBALLockBytesImpl* const pMemLockBytes = (HGLOBALLockBytesImpl*)plkbyt;
178 if (ICOM_VTBL(pMemLockBytes) == &HGLOBALLockBytesImpl_Vtbl)
179 *phglobal = pMemLockBytes->supportHandle;
189 /******************************************************************************
191 * HGLOBALLockBytesImpl implementation
195 /******************************************************************************
196 * This is the constructor for the HGLOBALLockBytesImpl class.
199 * hGlobal - Handle that will support the stream. can be NULL.
200 * fDeleteOnRelease - Flag set to TRUE if the HGLOBAL will be released
201 * when the IStream object is destroyed.
203 HGLOBALLockBytesImpl* HGLOBALLockBytesImpl_Construct(HGLOBAL hGlobal,
204 BOOL fDeleteOnRelease)
206 HGLOBALLockBytesImpl* newLockBytes;
207 newLockBytes = HeapAlloc(GetProcessHeap(), 0, sizeof(HGLOBALLockBytesImpl));
212 * Set up the virtual function table and reference count.
214 ICOM_VTBL(newLockBytes) = &HGLOBALLockBytesImpl_Vtbl;
215 newLockBytes->ref = 0;
218 * Initialize the support.
220 newLockBytes->supportHandle = hGlobal;
221 newLockBytes->deleteOnRelease = fDeleteOnRelease;
224 * This method will allocate a handle if one is not supplied.
226 if (newLockBytes->supportHandle == 0)
228 newLockBytes->supportHandle = GlobalAlloc(GMEM_MOVEABLE |
234 * Initialize the size of the array to the size of the handle.
236 newLockBytes->byteArraySize.s.HighPart = 0;
237 newLockBytes->byteArraySize.s.LowPart = GlobalSize(
238 newLockBytes->supportHandle);
244 /******************************************************************************
245 * This is the destructor of the HGLOBALStreamImpl class.
247 * This method will clean-up all the resources used-up by the given
248 * HGLOBALLockBytesImpl class. The pointer passed-in to this function will be
249 * freed and will not be valid anymore.
251 void HGLOBALLockBytesImpl_Destroy(HGLOBALLockBytesImpl* This)
254 * Release the HGlobal if the constructor asked for that.
256 if (This->deleteOnRelease)
258 GlobalFree(This->supportHandle);
259 This->supportHandle = 0;
263 * Finally, free the memory used-up by the class.
265 HeapFree(GetProcessHeap(), 0, This);
268 /******************************************************************************
269 * This implements the IUnknown method QueryInterface for this
272 HRESULT WINAPI HGLOBALLockBytesImpl_QueryInterface(
274 REFIID riid, /* [in] */
275 void** ppvObject) /* [iid_is][out] */
277 HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
280 * Perform a sanity check on the parameters.
286 * Initialize the return parameter.
291 * Compare the riid with the interface IDs implemented by this object.
293 if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
295 *ppvObject = (ILockBytes*)This;
297 else if (memcmp(&IID_ILockBytes, riid, sizeof(IID_ILockBytes)) == 0)
299 *ppvObject = (ILockBytes*)This;
303 * Check that we obtained an interface.
306 return E_NOINTERFACE;
309 * Query Interface always increases the reference count by one when it is
312 HGLOBALLockBytesImpl_AddRef(iface);
317 /******************************************************************************
318 * This implements the IUnknown method AddRef for this
321 ULONG WINAPI HGLOBALLockBytesImpl_AddRef(ILockBytes* iface)
323 HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
330 /******************************************************************************
331 * This implements the IUnknown method Release for this
334 ULONG WINAPI HGLOBALLockBytesImpl_Release(ILockBytes* iface)
336 HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
345 * If the reference count goes down to 0, perform suicide.
349 HGLOBALLockBytesImpl_Destroy(This);
355 /******************************************************************************
356 * This method is part of the ILockBytes interface.
358 * It reads a block of information from the byte array at the specified
361 * See the documentation of ILockBytes for more info.
363 HRESULT WINAPI HGLOBALLockBytesImpl_ReadAt(
365 ULARGE_INTEGER ulOffset, /* [in] */
366 void* pv, /* [length_is][size_is][out] */
368 ULONG* pcbRead) /* [out] */
370 HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
373 ULONG bytesReadBuffer = 0;
374 ULONG bytesToReadFromBuffer;
377 * If the caller is not interested in the number of bytes read,
378 * we use another buffer to avoid "if" statements in the code.
381 pcbRead = &bytesReadBuffer;
384 * Make sure the offset is valid.
386 if (ulOffset.s.LowPart > This->byteArraySize.s.LowPart)
390 * Using the known size of the array, calculate the number of bytes
393 bytesToReadFromBuffer = min(This->byteArraySize.s.LowPart -
394 ulOffset.s.LowPart, cb);
397 * Lock the buffer in position and copy the data.
399 supportBuffer = GlobalLock(This->supportHandle);
402 (char *) supportBuffer + ulOffset.s.LowPart,
403 bytesToReadFromBuffer);
406 * Return the number of bytes read.
408 *pcbRead = bytesToReadFromBuffer;
413 GlobalUnlock(This->supportHandle);
416 * The function returns S_OK if the specified number of bytes were read
417 * or the end of the array was reached.
418 * It returns STG_E_READFAULT if the number of bytes to read does not equal
419 * the number of bytes actually read.
424 return STG_E_READFAULT;
427 /******************************************************************************
428 * This method is part of the ILockBytes interface.
430 * It writes the specified bytes at the specified offset.
431 * position. If the array is too small, it will be resized.
433 * See the documentation of ILockBytes for more info.
435 HRESULT WINAPI HGLOBALLockBytesImpl_WriteAt(
437 ULARGE_INTEGER ulOffset, /* [in] */
438 const void* pv, /* [size_is][in] */
440 ULONG* pcbWritten) /* [out] */
442 HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
445 ULARGE_INTEGER newSize;
446 ULONG bytesWritten = 0;
449 * If the caller is not interested in the number of bytes written,
450 * we use another buffer to avoid "if" statements in the code.
453 pcbWritten = &bytesWritten;
461 newSize.s.HighPart = 0;
462 newSize.s.LowPart = ulOffset.s.LowPart + cb;
466 * Verify if we need to grow the stream
468 if (newSize.s.LowPart > This->byteArraySize.s.LowPart)
471 if (HGLOBALLockBytesImpl_SetSize(iface, newSize) == STG_E_MEDIUMFULL)
472 return STG_E_MEDIUMFULL;
476 * Lock the buffer in position and copy the data.
478 supportBuffer = GlobalLock(This->supportHandle);
480 memcpy((char *) supportBuffer + ulOffset.s.LowPart, pv, cb);
483 * Return the number of bytes written.
490 GlobalUnlock(This->supportHandle);
495 /******************************************************************************
496 * This method is part of the ILockBytes interface.
498 * See the documentation of ILockBytes for more info.
500 HRESULT WINAPI HGLOBALLockBytesImpl_Flush(ILockBytes* iface)
505 /******************************************************************************
506 * This method is part of the ILockBytes interface.
508 * It will change the size of the byte array.
510 * See the documentation of ILockBytes for more info.
512 HRESULT WINAPI HGLOBALLockBytesImpl_SetSize(
514 ULARGE_INTEGER libNewSize) /* [in] */
516 HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
521 if (libNewSize.s.HighPart != 0)
522 return STG_E_INVALIDFUNCTION;
524 if (This->byteArraySize.s.LowPart == libNewSize.s.LowPart)
528 * Re allocate the HGlobal to fit the new size of the stream.
530 This->supportHandle = GlobalReAlloc(This->supportHandle,
531 libNewSize.s.LowPart,
534 if (This->supportHandle == 0)
535 return STG_E_MEDIUMFULL;
537 This->byteArraySize.s.LowPart = libNewSize.s.LowPart;
542 /******************************************************************************
543 * This method is part of the ILockBytes interface.
545 * The global memory implementation of ILockBytes does not support locking.
547 * See the documentation of ILockBytes for more info.
549 HRESULT WINAPI HGLOBALLockBytesImpl_LockRegion(
551 ULARGE_INTEGER libOffset, /* [in] */
552 ULARGE_INTEGER cb, /* [in] */
553 DWORD dwLockType) /* [in] */
555 return STG_E_INVALIDFUNCTION;
558 /******************************************************************************
559 * This method is part of the ILockBytes interface.
561 * The global memory implementation of ILockBytes does not support locking.
563 * See the documentation of ILockBytes for more info.
565 HRESULT WINAPI HGLOBALLockBytesImpl_UnlockRegion(
567 ULARGE_INTEGER libOffset, /* [in] */
568 ULARGE_INTEGER cb, /* [in] */
569 DWORD dwLockType) /* [in] */
571 return STG_E_INVALIDFUNCTION;
574 /******************************************************************************
575 * This method is part of the ILockBytes interface.
577 * This method returns information about the current
580 * See the documentation of ILockBytes for more info.
582 HRESULT WINAPI HGLOBALLockBytesImpl_Stat(
584 STATSTG* pstatstg, /* [out] */
585 DWORD grfStatFlag) /* [in] */
587 HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
589 memset(pstatstg, 0, sizeof(STATSTG));
591 pstatstg->pwcsName = NULL;
592 pstatstg->type = STGTY_LOCKBYTES;
593 pstatstg->cbSize = This->byteArraySize;