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
;
179 ULARGE_INTEGER start
;
183 if (ICOM_VTBL(pMemLockBytes
) == &HGLOBALLockBytesImpl_Vtbl
) {
184 *phglobal
= pMemLockBytes
->supportHandle
;
189 /* It is not our lockbytes implementation, so use a more generic way */
190 hres
= ILockBytes_Stat(plkbyt
,&stbuf
,0);
192 ERR("Cannot ILockBytes_Stat, %lx\n",hres
);
195 FIXME("cbSize is %ld\n",stbuf
.cbSize
.s
.LowPart
);
196 *phglobal
= GlobalAlloc( GMEM_MOVEABLE
|GMEM_SHARE
, stbuf
.cbSize
.s
.LowPart
);
199 memset(&start
,0,sizeof(start
));
200 hres
= ILockBytes_ReadAt(plkbyt
, start
, GlobalLock(*phglobal
), stbuf
.cbSize
.s
.LowPart
, &xread
);
201 GlobalUnlock(*phglobal
);
203 FIXME("%p->ReadAt failed with %lx\n",plkbyt
,hres
);
206 if (stbuf
.cbSize
.s
.LowPart
!= xread
) {
207 FIXME("Read size is not requested size %ld vs %ld?\n",stbuf
.cbSize
.s
.LowPart
, xread
);
212 /******************************************************************************
214 * HGLOBALLockBytesImpl implementation
218 /******************************************************************************
219 * This is the constructor for the HGLOBALLockBytesImpl class.
222 * hGlobal - Handle that will support the stream. can be NULL.
223 * fDeleteOnRelease - Flag set to TRUE if the HGLOBAL will be released
224 * when the IStream object is destroyed.
226 HGLOBALLockBytesImpl
* HGLOBALLockBytesImpl_Construct(HGLOBAL hGlobal
,
227 BOOL fDeleteOnRelease
)
229 HGLOBALLockBytesImpl
* newLockBytes
;
230 newLockBytes
= HeapAlloc(GetProcessHeap(), 0, sizeof(HGLOBALLockBytesImpl
));
235 * Set up the virtual function table and reference count.
237 ICOM_VTBL(newLockBytes
) = &HGLOBALLockBytesImpl_Vtbl
;
238 newLockBytes
->ref
= 0;
241 * Initialize the support.
243 newLockBytes
->supportHandle
= hGlobal
;
244 newLockBytes
->deleteOnRelease
= fDeleteOnRelease
;
247 * This method will allocate a handle if one is not supplied.
249 if (newLockBytes
->supportHandle
== 0)
251 newLockBytes
->supportHandle
= GlobalAlloc(GMEM_MOVEABLE
|
257 * Initialize the size of the array to the size of the handle.
259 newLockBytes
->byteArraySize
.s
.HighPart
= 0;
260 newLockBytes
->byteArraySize
.s
.LowPart
= GlobalSize(
261 newLockBytes
->supportHandle
);
267 /******************************************************************************
268 * This is the destructor of the HGLOBALStreamImpl class.
270 * This method will clean-up all the resources used-up by the given
271 * HGLOBALLockBytesImpl class. The pointer passed-in to this function will be
272 * freed and will not be valid anymore.
274 void HGLOBALLockBytesImpl_Destroy(HGLOBALLockBytesImpl
* This
)
277 * Release the HGlobal if the constructor asked for that.
279 if (This
->deleteOnRelease
)
281 GlobalFree(This
->supportHandle
);
282 This
->supportHandle
= 0;
286 * Finally, free the memory used-up by the class.
288 HeapFree(GetProcessHeap(), 0, This
);
291 /******************************************************************************
292 * This implements the IUnknown method QueryInterface for this
295 HRESULT WINAPI
HGLOBALLockBytesImpl_QueryInterface(
297 REFIID riid
, /* [in] */
298 void** ppvObject
) /* [iid_is][out] */
300 HGLOBALLockBytesImpl
* const This
=(HGLOBALLockBytesImpl
*)iface
;
303 * Perform a sanity check on the parameters.
309 * Initialize the return parameter.
314 * Compare the riid with the interface IDs implemented by this object.
316 if (memcmp(&IID_IUnknown
, riid
, sizeof(IID_IUnknown
)) == 0)
318 *ppvObject
= (ILockBytes
*)This
;
320 else if (memcmp(&IID_ILockBytes
, riid
, sizeof(IID_ILockBytes
)) == 0)
322 *ppvObject
= (ILockBytes
*)This
;
326 * Check that we obtained an interface.
329 return E_NOINTERFACE
;
332 * Query Interface always increases the reference count by one when it is
335 HGLOBALLockBytesImpl_AddRef(iface
);
340 /******************************************************************************
341 * This implements the IUnknown method AddRef for this
344 ULONG WINAPI
HGLOBALLockBytesImpl_AddRef(ILockBytes
* iface
)
346 HGLOBALLockBytesImpl
* const This
=(HGLOBALLockBytesImpl
*)iface
;
353 /******************************************************************************
354 * This implements the IUnknown method Release for this
357 ULONG WINAPI
HGLOBALLockBytesImpl_Release(ILockBytes
* iface
)
359 HGLOBALLockBytesImpl
* const This
=(HGLOBALLockBytesImpl
*)iface
;
368 * If the reference count goes down to 0, perform suicide.
372 HGLOBALLockBytesImpl_Destroy(This
);
378 /******************************************************************************
379 * This method is part of the ILockBytes interface.
381 * It reads a block of information from the byte array at the specified
384 * See the documentation of ILockBytes for more info.
386 HRESULT WINAPI
HGLOBALLockBytesImpl_ReadAt(
388 ULARGE_INTEGER ulOffset
, /* [in] */
389 void* pv
, /* [length_is][size_is][out] */
391 ULONG
* pcbRead
) /* [out] */
393 HGLOBALLockBytesImpl
* const This
=(HGLOBALLockBytesImpl
*)iface
;
396 ULONG bytesReadBuffer
= 0;
397 ULONG bytesToReadFromBuffer
;
400 * If the caller is not interested in the number of bytes read,
401 * we use another buffer to avoid "if" statements in the code.
404 pcbRead
= &bytesReadBuffer
;
407 * Make sure the offset is valid.
409 if (ulOffset
.s
.LowPart
> This
->byteArraySize
.s
.LowPart
)
413 * Using the known size of the array, calculate the number of bytes
416 bytesToReadFromBuffer
= min(This
->byteArraySize
.s
.LowPart
-
417 ulOffset
.s
.LowPart
, cb
);
420 * Lock the buffer in position and copy the data.
422 supportBuffer
= GlobalLock(This
->supportHandle
);
425 (char *) supportBuffer
+ ulOffset
.s
.LowPart
,
426 bytesToReadFromBuffer
);
429 * Return the number of bytes read.
431 *pcbRead
= bytesToReadFromBuffer
;
436 GlobalUnlock(This
->supportHandle
);
439 * The function returns S_OK if the specified number of bytes were read
440 * or the end of the array was reached.
441 * It returns STG_E_READFAULT if the number of bytes to read does not equal
442 * the number of bytes actually read.
447 return STG_E_READFAULT
;
450 /******************************************************************************
451 * This method is part of the ILockBytes interface.
453 * It writes the specified bytes at the specified offset.
454 * position. If the array is too small, it will be resized.
456 * See the documentation of ILockBytes for more info.
458 HRESULT WINAPI
HGLOBALLockBytesImpl_WriteAt(
460 ULARGE_INTEGER ulOffset
, /* [in] */
461 const void* pv
, /* [size_is][in] */
463 ULONG
* pcbWritten
) /* [out] */
465 HGLOBALLockBytesImpl
* const This
=(HGLOBALLockBytesImpl
*)iface
;
468 ULARGE_INTEGER newSize
;
469 ULONG bytesWritten
= 0;
472 * If the caller is not interested in the number of bytes written,
473 * we use another buffer to avoid "if" statements in the code.
476 pcbWritten
= &bytesWritten
;
484 newSize
.s
.HighPart
= 0;
485 newSize
.s
.LowPart
= ulOffset
.s
.LowPart
+ cb
;
489 * Verify if we need to grow the stream
491 if (newSize
.s
.LowPart
> This
->byteArraySize
.s
.LowPart
)
494 if (HGLOBALLockBytesImpl_SetSize(iface
, newSize
) == STG_E_MEDIUMFULL
)
495 return STG_E_MEDIUMFULL
;
499 * Lock the buffer in position and copy the data.
501 supportBuffer
= GlobalLock(This
->supportHandle
);
503 memcpy((char *) supportBuffer
+ ulOffset
.s
.LowPart
, pv
, cb
);
506 * Return the number of bytes written.
513 GlobalUnlock(This
->supportHandle
);
518 /******************************************************************************
519 * This method is part of the ILockBytes interface.
521 * See the documentation of ILockBytes for more info.
523 HRESULT WINAPI
HGLOBALLockBytesImpl_Flush(ILockBytes
* iface
)
528 /******************************************************************************
529 * This method is part of the ILockBytes interface.
531 * It will change the size of the byte array.
533 * See the documentation of ILockBytes for more info.
535 HRESULT WINAPI
HGLOBALLockBytesImpl_SetSize(
537 ULARGE_INTEGER libNewSize
) /* [in] */
539 HGLOBALLockBytesImpl
* const This
=(HGLOBALLockBytesImpl
*)iface
;
544 if (libNewSize
.s
.HighPart
!= 0)
545 return STG_E_INVALIDFUNCTION
;
547 if (This
->byteArraySize
.s
.LowPart
== libNewSize
.s
.LowPart
)
551 * Re allocate the HGlobal to fit the new size of the stream.
553 This
->supportHandle
= GlobalReAlloc(This
->supportHandle
,
554 libNewSize
.s
.LowPart
,
557 if (This
->supportHandle
== 0)
558 return STG_E_MEDIUMFULL
;
560 This
->byteArraySize
.s
.LowPart
= libNewSize
.s
.LowPart
;
565 /******************************************************************************
566 * This method is part of the ILockBytes interface.
568 * The global memory implementation of ILockBytes does not support locking.
570 * See the documentation of ILockBytes for more info.
572 HRESULT WINAPI
HGLOBALLockBytesImpl_LockRegion(
574 ULARGE_INTEGER libOffset
, /* [in] */
575 ULARGE_INTEGER cb
, /* [in] */
576 DWORD dwLockType
) /* [in] */
578 return STG_E_INVALIDFUNCTION
;
581 /******************************************************************************
582 * This method is part of the ILockBytes interface.
584 * The global memory implementation of ILockBytes does not support locking.
586 * See the documentation of ILockBytes for more info.
588 HRESULT WINAPI
HGLOBALLockBytesImpl_UnlockRegion(
590 ULARGE_INTEGER libOffset
, /* [in] */
591 ULARGE_INTEGER cb
, /* [in] */
592 DWORD dwLockType
) /* [in] */
594 return STG_E_INVALIDFUNCTION
;
597 /******************************************************************************
598 * This method is part of the ILockBytes interface.
600 * This method returns information about the current
603 * See the documentation of ILockBytes for more info.
605 HRESULT WINAPI
HGLOBALLockBytesImpl_Stat(
607 STATSTG
* pstatstg
, /* [out] */
608 DWORD grfStatFlag
) /* [in] */
610 HGLOBALLockBytesImpl
* const This
=(HGLOBALLockBytesImpl
*)iface
;
612 memset(pstatstg
, 0, sizeof(STATSTG
));
614 pstatstg
->pwcsName
= NULL
;
615 pstatstg
->type
= STGTY_LOCKBYTES
;
616 pstatstg
->cbSize
= This
->byteArraySize
;