gdi32: Remove unused variable.
[wine] / dlls / ole2.dll16 / memlockbytes.c
1 /*
2  * Global memory implementation of ILockBytes.
3  *
4  * Copyright 1999 Thuy Nguyen
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22
23 #include <assert.h>
24 #include <stdarg.h>
25 #include <string.h>
26
27 #define NONAMELESSUNION
28 #define NONAMELESSSTRUCT
29 #include "windef.h"
30 #include "winbase.h"
31 #include "wine/winbase16.h"
32 #include "winuser.h"
33 #include "objbase.h"
34 #include "ole2.h"
35 #include "winerror.h"
36
37 #include "ifs.h"
38
39 #include "wine/debug.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(ole);
42
43 /******************************************************************************
44  * HGLOBALLockBytesImpl16 definition.
45  *
46  * This class implements the ILockBytes interface and represents a byte array
47  * object supported by an HGLOBAL pointer.
48  */
49 struct HGLOBALLockBytesImpl16
50 {
51   ILockBytes16 ILockBytes16_iface;
52   LONG ref;
53
54   /*
55    * Support for the LockBytes object
56    */
57   HGLOBAL16 supportHandle;
58
59   /*
60    * This flag is TRUE if the HGLOBAL is destroyed when the object
61    * is finally released.
62    */
63   BOOL    deleteOnRelease;
64   /*
65    * Helper variable that contains the size of the byte array
66    */
67   ULARGE_INTEGER     byteArraySize;
68 };
69
70 typedef struct HGLOBALLockBytesImpl16 HGLOBALLockBytesImpl16;
71
72 /******************************************************************************
73  *
74  * HGLOBALLockBytesImpl16 implementation
75  *
76  */
77
78 static inline HGLOBALLockBytesImpl16 *impl_from_ILockBytes16(ILockBytes16 *iface)
79 {
80   return CONTAINING_RECORD(iface, HGLOBALLockBytesImpl16, ILockBytes16_iface);
81 }
82
83 /******************************************************************************
84  * This is the constructor for the HGLOBALLockBytesImpl16 class.
85  *
86  * Params:
87  *    hGlobal          - Handle that will support the stream. can be NULL.
88  *    fDeleteOnRelease - Flag set to TRUE if the HGLOBAL16 will be released
89  *                       when the IStream object is destroyed.
90  */
91 static HGLOBALLockBytesImpl16*
92 HGLOBALLockBytesImpl16_Construct(HGLOBAL16 hGlobal,
93                                  BOOL16 fDeleteOnRelease)
94 {
95   HGLOBALLockBytesImpl16* newLockBytes;
96
97   static ILockBytes16Vtbl vt16;
98   static SEGPTR msegvt16;
99   HMODULE16 hcomp = GetModuleHandle16("OLE2");
100
101
102   TRACE("(%x,%d)\n",hGlobal,fDeleteOnRelease);
103   newLockBytes = HeapAlloc(GetProcessHeap(), 0, sizeof(HGLOBALLockBytesImpl16));
104   if (newLockBytes == NULL)
105     return NULL;
106
107   /*
108    * Set up the virtual function table and reference count.
109    */
110   if (!msegvt16)
111   {
112 #define VTENT(x) vt16.x = (void*)GetProcAddress16(hcomp,"HGLOBALLockBytesImpl16_"#x);assert(vt16.x)
113       VTENT(QueryInterface);
114       VTENT(AddRef);
115       VTENT(Release);
116       VTENT(ReadAt);
117       VTENT(WriteAt);
118       VTENT(Flush);
119       VTENT(SetSize);
120       VTENT(LockRegion);
121       VTENT(UnlockRegion);
122       VTENT(Stat);
123 #undef VTENT
124       msegvt16 = MapLS( &vt16 );
125   }
126   newLockBytes->ILockBytes16_iface.lpVtbl = (const ILockBytes16Vtbl*)msegvt16;
127   newLockBytes->ref = 0;
128   /*
129    * Initialize the support.
130    */
131   newLockBytes->supportHandle = hGlobal;
132   newLockBytes->deleteOnRelease = fDeleteOnRelease;
133
134   /*
135    * This method will allocate a handle if one is not supplied.
136    */
137   if (newLockBytes->supportHandle == 0)
138     newLockBytes->supportHandle = GlobalAlloc16(GMEM_MOVEABLE | GMEM_NODISCARD, 0);
139
140   /*
141    * Initialize the size of the array to the size of the handle.
142    */
143   newLockBytes->byteArraySize.u.HighPart = 0;
144   newLockBytes->byteArraySize.u.LowPart  = GlobalSize16(
145                                             newLockBytes->supportHandle);
146
147   return (HGLOBALLockBytesImpl16*)MapLS(newLockBytes);
148 }
149
150 /******************************************************************************
151  * This is the destructor of the HGLOBALStreamImpl class.
152  *
153  * This method will clean-up all the resources used-up by the given
154  * HGLOBALLockBytesImpl16 class. The pointer passed-in to this function will be
155  * freed and will not be valid anymore.
156  */
157 static void HGLOBALLockBytesImpl16_Destroy(HGLOBALLockBytesImpl16* This)
158 {
159   TRACE("()\n");
160   /*
161    * Release the HGlobal if the constructor asked for that.
162    */
163   if (This->deleteOnRelease)
164   {
165     GlobalFree16(This->supportHandle);
166     This->supportHandle = 0;
167   }
168
169   /*
170    * Finally, free the memory used-up by the class.
171    */
172   HeapFree(GetProcessHeap(), 0, This);
173 }
174
175 /******************************************************************************
176  * This implements the IUnknown method AddRef for this
177  * class
178  */
179 ULONG CDECL HGLOBALLockBytesImpl16_AddRef(ILockBytes16* iface)
180 {
181   HGLOBALLockBytesImpl16* const This = impl_from_ILockBytes16(iface);
182
183   TRACE("(%p)\n",This);
184
185   return InterlockedIncrement(&This->ref);
186 }
187
188
189 /******************************************************************************
190  * This implements the IUnknown method QueryInterface for this
191  * class
192  */
193 HRESULT CDECL HGLOBALLockBytesImpl16_QueryInterface(
194       ILockBytes16*  iface,     /* [in] SEGPTR */
195       REFIID       riid,        /* [in] */
196       void**       ppvObject)   /* [out][iid_is] (ptr to SEGPTR!) */
197 {
198   HGLOBALLockBytesImpl16* const This = MapSL((SEGPTR)iface);
199
200   TRACE("(%p,%s,%p)\n",iface,debugstr_guid(riid),ppvObject);
201   /*
202    * Perform a sanity check on the parameters.
203    */
204   if (ppvObject==0)
205     return E_INVALIDARG;
206
207   /*
208    * Initialize the return parameter.
209    */
210   *ppvObject = 0;
211   /*
212    * Compare the riid with the interface IDs implemented by this object.
213    */
214   if (  !memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) ||
215         !memcmp(&IID_ILockBytes, riid, sizeof(IID_ILockBytes))
216   )
217     *ppvObject = (void*)iface;
218
219   /*
220    * Check that we obtained an interface.
221    */
222   if ((*ppvObject)==0) {
223     FIXME("Unknown IID %s\n", debugstr_guid(riid));
224     return E_NOINTERFACE;
225   }
226
227   /*
228    * Query Interface always increases the reference count by one when it is
229    * successful
230    */
231   HGLOBALLockBytesImpl16_AddRef(&This->ILockBytes16_iface);
232
233   return S_OK;
234 }
235
236 /******************************************************************************
237  * This implements the IUnknown method Release for this
238  * class
239  */
240 ULONG CDECL HGLOBALLockBytesImpl16_Release(ILockBytes16* iface)
241 {
242   HGLOBALLockBytesImpl16* const This = impl_from_ILockBytes16(iface);
243   ULONG ref;
244
245   TRACE("(%p)\n",This);
246
247   ref = InterlockedDecrement(&This->ref);
248
249   /*
250    * If the reference count goes down to 0, perform suicide.
251    */
252   if (ref==0)
253     HGLOBALLockBytesImpl16_Destroy(This);
254   return ref;
255 }
256
257 /******************************************************************************
258  * This method is part of the ILockBytes interface.
259  *
260  * It reads a block of information from the byte array at the specified
261  * offset.
262  *
263  * See the documentation of ILockBytes for more info.
264  */
265 HRESULT CDECL HGLOBALLockBytesImpl16_ReadAt(
266       ILockBytes16*  iface,
267       ULARGE_INTEGER ulOffset,  /* [in] */
268       void*          pv,        /* [out][length_is][size_is] */
269       ULONG          cb,        /* [in] */
270       ULONG*         pcbRead)   /* [out] */
271 {
272   HGLOBALLockBytesImpl16* const This = impl_from_ILockBytes16(iface);
273
274   void* supportBuffer;
275   ULONG bytesReadBuffer = 0;
276   ULONG bytesToReadFromBuffer;
277
278   TRACE("(%p,%d,%p,%d,%p)\n",This,ulOffset.u.LowPart,pv,cb,pcbRead);
279   /*
280    * If the caller is not interested in the number of bytes read,
281    * we use another buffer to avoid "if" statements in the code.
282    */
283   if (pcbRead == 0)
284     pcbRead = &bytesReadBuffer;
285
286   /*
287    * Make sure the offset is valid.
288    */
289   if (ulOffset.u.LowPart > This->byteArraySize.u.LowPart)
290     return E_FAIL;
291
292   /*
293    * Using the known size of the array, calculate the number of bytes
294    * to read.
295    */
296   bytesToReadFromBuffer = min(This->byteArraySize.u.LowPart -
297                               ulOffset.u.LowPart, cb);
298
299   /*
300    * Lock the buffer in position and copy the data.
301    */
302   supportBuffer = GlobalLock16(This->supportHandle);
303
304   memcpy(pv,
305          (char *) supportBuffer + ulOffset.u.LowPart,
306          bytesToReadFromBuffer);
307
308   /*
309    * Return the number of bytes read.
310    */
311   *pcbRead = bytesToReadFromBuffer;
312
313   /*
314    * Cleanup
315    */
316   GlobalUnlock16(This->supportHandle);
317
318   /*
319    * The function returns S_OK if the specified number of bytes were read
320    * or the end of the array was reached.
321    * It returns STG_E_READFAULT if the number of bytes to read does not equal
322    * the number of bytes actually read.
323    */
324   if(*pcbRead == cb)
325     return S_OK;
326
327   return STG_E_READFAULT;
328 }
329
330 /******************************************************************************
331  * This method is part of the ILockBytes interface.
332  *
333  * It will change the size of the byte array.
334  *
335  * See the documentation of ILockBytes for more info.
336  */
337 HRESULT CDECL HGLOBALLockBytesImpl16_SetSize(
338       ILockBytes16*   iface,
339       ULARGE_INTEGER  libNewSize)   /* [in] */
340 {
341   HGLOBALLockBytesImpl16* const This = impl_from_ILockBytes16(iface);
342   HGLOBAL16 supportHandle;
343
344   TRACE("(%p,%d)\n",This,libNewSize.u.LowPart);
345   /*
346    * As documented.
347    */
348   if (libNewSize.u.HighPart != 0)
349     return STG_E_INVALIDFUNCTION;
350
351   if (This->byteArraySize.u.LowPart == libNewSize.u.LowPart)
352     return S_OK;
353
354   /*
355    * Re allocate the HGlobal to fit the new size of the stream.
356    */
357   supportHandle = GlobalReAlloc16(This->supportHandle, libNewSize.u.LowPart, 0);
358
359   if (supportHandle == 0)
360     return STG_E_MEDIUMFULL;
361
362   This->supportHandle = supportHandle;
363   This->byteArraySize.u.LowPart = libNewSize.u.LowPart;
364
365   return S_OK;
366 }
367
368 /******************************************************************************
369  * This method is part of the ILockBytes interface.
370  *
371  * It writes the specified bytes at the specified offset.
372  * position. If the array is too small, it will be resized.
373  *
374  * See the documentation of ILockBytes for more info.
375  */
376 HRESULT CDECL HGLOBALLockBytesImpl16_WriteAt(
377       ILockBytes16*  iface,
378       ULARGE_INTEGER ulOffset,    /* [in] */
379       const void*    pv,          /* [in][size_is] */
380       ULONG          cb,          /* [in] */
381       ULONG*         pcbWritten)  /* [out] */
382 {
383   HGLOBALLockBytesImpl16* const This = impl_from_ILockBytes16(iface);
384
385   void*          supportBuffer;
386   ULARGE_INTEGER newSize;
387   ULONG          bytesWritten = 0;
388
389   TRACE("(%p,%d,%p,%d,%p)\n",This,ulOffset.u.LowPart,pv,cb,pcbWritten);
390   /*
391    * If the caller is not interested in the number of bytes written,
392    * we use another buffer to avoid "if" statements in the code.
393    */
394   if (pcbWritten == 0)
395     pcbWritten = &bytesWritten;
396
397   if (cb == 0)
398     return S_OK;
399
400   newSize.u.HighPart = 0;
401   newSize.u.LowPart = ulOffset.u.LowPart + cb;
402
403   /*
404    * Verify if we need to grow the stream
405    */
406   if (newSize.u.LowPart > This->byteArraySize.u.LowPart)
407   {
408     /* grow stream */
409     if (HGLOBALLockBytesImpl16_SetSize(iface, newSize) == STG_E_MEDIUMFULL)
410       return STG_E_MEDIUMFULL;
411   }
412
413   /*
414    * Lock the buffer in position and copy the data.
415    */
416   supportBuffer = GlobalLock16(This->supportHandle);
417
418   memcpy((char *) supportBuffer + ulOffset.u.LowPart, pv, cb);
419
420   /*
421    * Return the number of bytes written.
422    */
423   *pcbWritten = cb;
424
425   /*
426    * Cleanup
427    */
428   GlobalUnlock16(This->supportHandle);
429
430   return S_OK;
431 }
432
433 /******************************************************************************
434  * This method is part of the ILockBytes interface.
435  *
436  * See the documentation of ILockBytes for more info.
437  */
438 HRESULT CDECL HGLOBALLockBytesImpl16_Flush(ILockBytes16* iface)
439 {
440   TRACE("(%p)\n",iface);
441   return S_OK;
442 }
443
444 /******************************************************************************
445  * This method is part of the ILockBytes interface.
446  *
447  * The global memory implementation of ILockBytes does not support locking.
448  *
449  * See the documentation of ILockBytes for more info.
450  */
451 HRESULT CDECL HGLOBALLockBytesImpl16_LockRegion(
452       ILockBytes16*  iface,
453       ULARGE_INTEGER libOffset,   /* [in] */
454       ULARGE_INTEGER cb,          /* [in] */
455       DWORD          dwLockType)  /* [in] */
456 {
457   return STG_E_INVALIDFUNCTION;
458 }
459
460 /******************************************************************************
461  * This method is part of the ILockBytes interface.
462  *
463  * The global memory implementation of ILockBytes does not support locking.
464  *
465  * See the documentation of ILockBytes for more info.
466  */
467 HRESULT CDECL HGLOBALLockBytesImpl16_UnlockRegion(
468       ILockBytes16*  iface,
469       ULARGE_INTEGER libOffset,   /* [in] */
470       ULARGE_INTEGER cb,          /* [in] */
471       DWORD          dwLockType)  /* [in] */
472 {
473   return STG_E_INVALIDFUNCTION;
474 }
475
476 /******************************************************************************
477  * This method is part of the ILockBytes interface.
478  *
479  * This method returns information about the current
480  * byte array object.
481  *
482  * See the documentation of ILockBytes for more info.
483  */
484 HRESULT CDECL HGLOBALLockBytesImpl16_Stat(
485       ILockBytes16*iface,
486       STATSTG16*   pstatstg,     /* [out] */
487       DWORD        grfStatFlag)  /* [in] */
488 {
489   HGLOBALLockBytesImpl16* const This = impl_from_ILockBytes16(iface);
490
491   memset(pstatstg, 0, sizeof(STATSTG16));
492
493   pstatstg->pwcsName = NULL;
494   pstatstg->type     = STGTY_LOCKBYTES;
495   pstatstg->cbSize   = This->byteArraySize;
496
497   return S_OK;
498 }
499
500 /******************************************************************************
501  *           CreateILockBytesOnHGlobal     [OLE2.54]
502  *
503  * Creates an ILockBytes interface for a HGLOBAL handle.
504  *
505  * PARAMS
506  *      hGlobal                 the global handle (16bit)
507  *      fDeleteOnRelease        delete handle on release.
508  *      ppLkbyt                 pointer to ILockBytes interface.
509  *
510  * RETURNS
511  *      Staddard OLE error return codes.
512  *
513  */
514 HRESULT WINAPI CreateILockBytesOnHGlobal16(
515         HGLOBAL16      hGlobal,          /* [in] */
516         BOOL16         fDeleteOnRelease, /* [in] */
517         LPLOCKBYTES16 *ppLkbyt)          /* [out] (ptr to SEGPTR!) */
518 {
519   HGLOBALLockBytesImpl16* newLockBytes; /* SEGPTR */
520
521   newLockBytes = HGLOBALLockBytesImpl16_Construct(hGlobal, fDeleteOnRelease);
522
523   if (newLockBytes != NULL)
524     return HGLOBALLockBytesImpl16_QueryInterface(&newLockBytes->ILockBytes16_iface,
525             &IID_ILockBytes, (void**)ppLkbyt);
526   return E_OUTOFMEMORY;
527 }