dwrite: Stub for CreateMonitorRenderingParams().
[wine] / dlls / ole32 / hglobalstream.c
1 /*
2  * HGLOBAL Stream implementation
3  *
4  * This file contains the implementation of the stream interface
5  * for streams contained supported by an HGLOBAL pointer.
6  *
7  * Copyright 1999 Francis Beaudet
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22  */
23
24 #include "config.h"
25
26 #include <assert.h>
27 #include <stdlib.h>
28 #include <stdarg.h>
29 #include <stdio.h>
30 #include <string.h>
31
32 #define COBJMACROS
33 #define NONAMELESSUNION
34 #define NONAMELESSSTRUCT
35
36 #include "windef.h"
37 #include "winbase.h"
38 #include "winuser.h"
39 #include "objbase.h"
40 #include "ole2.h"
41 #include "winerror.h"
42 #include "winternl.h"
43
44 #include "wine/debug.h"
45
46 WINE_DEFAULT_DEBUG_CHANNEL(storage);
47
48 /****************************************************************************
49  * HGLOBALStreamImpl definition.
50  *
51  * This class implements the IStream interface and represents a stream
52  * supported by an HGLOBAL pointer.
53  */
54 typedef struct
55 {
56   IStream IStream_iface;
57   LONG ref;
58
59   /* support for the stream */
60   HGLOBAL supportHandle;
61
62   /* if TRUE the HGLOBAL is destroyed when the stream is finally released */
63   BOOL deleteOnRelease;
64
65   /* size of the stream */
66   ULARGE_INTEGER streamSize;
67
68   /* current position of the cursor */
69   ULARGE_INTEGER currentPosition;
70 } HGLOBALStreamImpl;
71
72 static inline HGLOBALStreamImpl *impl_from_IStream(IStream *iface)
73 {
74   return CONTAINING_RECORD(iface, HGLOBALStreamImpl, IStream_iface);
75 }
76
77 static HRESULT WINAPI HGLOBALStreamImpl_QueryInterface(
78                   IStream*     iface,
79                   REFIID         riid,        /* [in] */
80                   void**         ppvObject)   /* [iid_is][out] */
81 {
82   HGLOBALStreamImpl* This = impl_from_IStream(iface);
83
84   if (ppvObject==0)
85     return E_INVALIDARG;
86
87   *ppvObject = 0;
88
89   if (IsEqualIID(&IID_IUnknown, riid) ||
90       IsEqualIID(&IID_ISequentialStream, riid) ||
91       IsEqualIID(&IID_IStream, riid))
92   {
93     *ppvObject = This;
94   }
95
96   if ((*ppvObject)==0)
97     return E_NOINTERFACE;
98
99   IStream_AddRef(iface);
100
101   return S_OK;
102 }
103
104 static ULONG WINAPI HGLOBALStreamImpl_AddRef(IStream* iface)
105 {
106   HGLOBALStreamImpl* This = impl_from_IStream(iface);
107   return InterlockedIncrement(&This->ref);
108 }
109
110 static ULONG WINAPI HGLOBALStreamImpl_Release(
111                 IStream* iface)
112 {
113   HGLOBALStreamImpl* This= impl_from_IStream(iface);
114   ULONG ref = InterlockedDecrement(&This->ref);
115
116   if (!ref)
117   {
118     if (This->deleteOnRelease)
119     {
120       GlobalFree(This->supportHandle);
121       This->supportHandle = NULL;
122     }
123
124     HeapFree(GetProcessHeap(), 0, This);
125   }
126
127   return ref;
128 }
129
130 /***
131  * This method is part of the ISequentialStream interface.
132  *
133  * If reads a block of information from the stream at the current
134  * position. It then moves the current position at the end of the
135  * read block
136  *
137  * See the documentation of ISequentialStream for more info.
138  */
139 static HRESULT WINAPI HGLOBALStreamImpl_Read(
140                   IStream*     iface,
141                   void*          pv,        /* [length_is][size_is][out] */
142                   ULONG          cb,        /* [in] */
143                   ULONG*         pcbRead)   /* [out] */
144 {
145   HGLOBALStreamImpl* This = impl_from_IStream(iface);
146
147   void* supportBuffer;
148   ULONG bytesReadBuffer;
149   ULONG bytesToReadFromBuffer;
150
151   TRACE("(%p, %p, %d, %p)\n", iface,
152         pv, cb, pcbRead);
153
154   /*
155    * If the caller is not interested in the number of bytes read,
156    * we use another buffer to avoid "if" statements in the code.
157    */
158   if (pcbRead==0)
159     pcbRead = &bytesReadBuffer;
160
161   /*
162    * Using the known size of the stream, calculate the number of bytes
163    * to read from the block chain
164    */
165   bytesToReadFromBuffer = min( This->streamSize.u.LowPart - This->currentPosition.u.LowPart, cb);
166
167   /*
168    * Lock the buffer in position and copy the data.
169    */
170   supportBuffer = GlobalLock(This->supportHandle);
171   if (!supportBuffer)
172   {
173       WARN("read from invalid hglobal %p\n", This->supportHandle);
174       *pcbRead = 0;
175       return S_OK;
176   }
177
178   memcpy(pv, (char *) supportBuffer+This->currentPosition.u.LowPart, bytesToReadFromBuffer);
179
180   /*
181    * Move the current position to the new position
182    */
183   This->currentPosition.u.LowPart+=bytesToReadFromBuffer;
184
185   /*
186    * Return the number of bytes read.
187    */
188   *pcbRead = bytesToReadFromBuffer;
189
190   /*
191    * Cleanup
192    */
193   GlobalUnlock(This->supportHandle);
194
195   /*
196    * Always returns S_OK even if the end of the stream is reached before the
197    * buffer is filled
198    */
199
200   return S_OK;
201 }
202
203 /***
204  * This method is part of the ISequentialStream interface.
205  *
206  * It writes a block of information to the stream at the current
207  * position. It then moves the current position at the end of the
208  * written block. If the stream is too small to fit the block,
209  * the stream is grown to fit.
210  *
211  * See the documentation of ISequentialStream for more info.
212  */
213 static HRESULT WINAPI HGLOBALStreamImpl_Write(
214                   IStream*     iface,
215                   const void*    pv,          /* [size_is][in] */
216                   ULONG          cb,          /* [in] */
217                   ULONG*         pcbWritten)  /* [out] */
218 {
219   HGLOBALStreamImpl* This = impl_from_IStream(iface);
220
221   void*          supportBuffer;
222   ULARGE_INTEGER newSize;
223   ULONG          bytesWritten = 0;
224
225   TRACE("(%p, %p, %d, %p)\n", iface, pv, cb, pcbWritten);
226
227   /*
228    * If the caller is not interested in the number of bytes written,
229    * we use another buffer to avoid "if" statements in the code.
230    */
231   if (pcbWritten == 0)
232     pcbWritten = &bytesWritten;
233
234   if (cb == 0)
235     goto out;
236
237   *pcbWritten = 0;
238
239   newSize.u.HighPart = 0;
240   newSize.u.LowPart = This->currentPosition.u.LowPart + cb;
241
242   /*
243    * Verify if we need to grow the stream
244    */
245   if (newSize.u.LowPart > This->streamSize.u.LowPart)
246   {
247     /* grow stream */
248     HRESULT hr = IStream_SetSize(iface, newSize);
249     if (FAILED(hr))
250     {
251       ERR("IStream_SetSize failed with error 0x%08x\n", hr);
252       return hr;
253     }
254   }
255
256   /*
257    * Lock the buffer in position and copy the data.
258    */
259   supportBuffer = GlobalLock(This->supportHandle);
260   if (!supportBuffer)
261   {
262       WARN("write to invalid hglobal %p\n", This->supportHandle);
263       return S_OK;
264   }
265
266   memcpy((char *) supportBuffer+This->currentPosition.u.LowPart, pv, cb);
267
268   /*
269    * Move the current position to the new position
270    */
271   This->currentPosition.u.LowPart+=cb;
272
273   /*
274    * Cleanup
275    */
276   GlobalUnlock(This->supportHandle);
277
278 out:
279   /*
280    * Return the number of bytes read.
281    */
282   *pcbWritten = cb;
283
284   return S_OK;
285 }
286
287 /***
288  * This method is part of the IStream interface.
289  *
290  * It will move the current stream pointer according to the parameters
291  * given.
292  *
293  * See the documentation of IStream for more info.
294  */
295 static HRESULT WINAPI HGLOBALStreamImpl_Seek(
296                   IStream*      iface,
297                   LARGE_INTEGER   dlibMove,         /* [in] */
298                   DWORD           dwOrigin,         /* [in] */
299                   ULARGE_INTEGER* plibNewPosition) /* [out] */
300 {
301   HGLOBALStreamImpl* This = impl_from_IStream(iface);
302
303   ULARGE_INTEGER newPosition = This->currentPosition;
304   HRESULT hr = S_OK;
305
306   TRACE("(%p, %x%08x, %d, %p)\n", iface, dlibMove.u.HighPart,
307         dlibMove.u.LowPart, dwOrigin, plibNewPosition);
308
309   /*
310    * The file pointer is moved depending on the given "function"
311    * parameter.
312    */
313   switch (dwOrigin)
314   {
315     case STREAM_SEEK_SET:
316       newPosition.u.HighPart = 0;
317       newPosition.u.LowPart = 0;
318       break;
319     case STREAM_SEEK_CUR:
320       break;
321     case STREAM_SEEK_END:
322       newPosition = This->streamSize;
323       break;
324     default:
325       hr = STG_E_SEEKERROR;
326       goto end;
327   }
328
329   /*
330    * Move the actual file pointer
331    * If the file pointer ends-up after the end of the stream, the next Write operation will
332    * make the file larger. This is how it is documented.
333    */
334   newPosition.u.HighPart = 0;
335   newPosition.u.LowPart += dlibMove.QuadPart;
336
337   if (dlibMove.u.LowPart >= 0x80000000 &&
338       newPosition.u.LowPart >= dlibMove.u.LowPart)
339   {
340     /* We tried to seek backwards and went past the start. */
341     hr = STG_E_SEEKERROR;
342     goto end;
343   }
344
345   This->currentPosition = newPosition;
346
347 end:
348   if (plibNewPosition) *plibNewPosition = This->currentPosition;
349
350   return hr;
351 }
352
353 /***
354  * This method is part of the IStream interface.
355  *
356  * It will change the size of a stream.
357  *
358  * TODO: Switch from small blocks to big blocks and vice versa.
359  *
360  * See the documentation of IStream for more info.
361  */
362 static HRESULT WINAPI HGLOBALStreamImpl_SetSize(
363                                      IStream*      iface,
364                                      ULARGE_INTEGER  libNewSize)   /* [in] */
365 {
366   HGLOBALStreamImpl* This = impl_from_IStream(iface);
367   HGLOBAL supportHandle;
368
369   TRACE("(%p, %d)\n", iface, libNewSize.u.LowPart);
370
371   /*
372    * HighPart is ignored as shown in tests
373    */
374
375   if (This->streamSize.u.LowPart == libNewSize.u.LowPart)
376     return S_OK;
377
378   /*
379    * Re allocate the HGlobal to fit the new size of the stream.
380    */
381   supportHandle = GlobalReAlloc(This->supportHandle, libNewSize.u.LowPart, 0);
382
383   if (supportHandle == 0)
384     return E_OUTOFMEMORY;
385
386   This->supportHandle = supportHandle;
387   This->streamSize.u.LowPart = libNewSize.u.LowPart;
388
389   return S_OK;
390 }
391
392 /***
393  * This method is part of the IStream interface.
394  *
395  * It will copy the 'cb' Bytes to 'pstm' IStream.
396  *
397  * See the documentation of IStream for more info.
398  */
399 static HRESULT WINAPI HGLOBALStreamImpl_CopyTo(
400                                     IStream*      iface,
401                                     IStream*      pstm,         /* [unique][in] */
402                                     ULARGE_INTEGER  cb,           /* [in] */
403                                     ULARGE_INTEGER* pcbRead,      /* [out] */
404                                     ULARGE_INTEGER* pcbWritten)   /* [out] */
405 {
406   HRESULT        hr = S_OK;
407   BYTE           tmpBuffer[128];
408   ULONG          bytesRead, bytesWritten, copySize;
409   ULARGE_INTEGER totalBytesRead;
410   ULARGE_INTEGER totalBytesWritten;
411
412   TRACE("(%p, %p, %d, %p, %p)\n", iface, pstm,
413         cb.u.LowPart, pcbRead, pcbWritten);
414
415   if ( pstm == 0 )
416     return STG_E_INVALIDPOINTER;
417
418   totalBytesRead.QuadPart = 0;
419   totalBytesWritten.QuadPart = 0;
420
421   while ( cb.QuadPart > 0 )
422   {
423     if ( cb.QuadPart >= sizeof(tmpBuffer) )
424       copySize = sizeof(tmpBuffer);
425     else
426       copySize = cb.u.LowPart;
427
428     hr = IStream_Read(iface, tmpBuffer, copySize, &bytesRead);
429     if (FAILED(hr))
430         break;
431
432     totalBytesRead.QuadPart += bytesRead;
433
434     if (bytesRead)
435     {
436         hr = IStream_Write(pstm, tmpBuffer, bytesRead, &bytesWritten);
437         if (FAILED(hr))
438             break;
439
440         totalBytesWritten.QuadPart += bytesWritten;
441     }
442
443     if (bytesRead!=copySize)
444       cb.QuadPart = 0;
445     else
446       cb.QuadPart -= bytesRead;
447   }
448
449   if (pcbRead) pcbRead->QuadPart = totalBytesRead.QuadPart;
450   if (pcbWritten) pcbWritten->QuadPart = totalBytesWritten.QuadPart;
451
452   return hr;
453 }
454
455 /***
456  * This method is part of the IStream interface.
457  *
458  * For streams supported by HGLOBALS, this function does nothing.
459  * This is what the documentation tells us.
460  *
461  * See the documentation of IStream for more info.
462  */
463 static HRESULT WINAPI HGLOBALStreamImpl_Commit(
464                   IStream*      iface,
465                   DWORD         grfCommitFlags)  /* [in] */
466 {
467   return S_OK;
468 }
469
470 /***
471  * This method is part of the IStream interface.
472  *
473  * For streams supported by HGLOBALS, this function does nothing.
474  * This is what the documentation tells us.
475  *
476  * See the documentation of IStream for more info.
477  */
478 static HRESULT WINAPI HGLOBALStreamImpl_Revert(
479                   IStream* iface)
480 {
481   return S_OK;
482 }
483
484 /***
485  * This method is part of the IStream interface.
486  *
487  * For streams supported by HGLOBALS, this function does nothing.
488  * This is what the documentation tells us.
489  *
490  * See the documentation of IStream for more info.
491  */
492 static HRESULT WINAPI HGLOBALStreamImpl_LockRegion(
493                   IStream*       iface,
494                   ULARGE_INTEGER libOffset,   /* [in] */
495                   ULARGE_INTEGER cb,          /* [in] */
496                   DWORD          dwLockType)  /* [in] */
497 {
498   return STG_E_INVALIDFUNCTION;
499 }
500
501 /*
502  * This method is part of the IStream interface.
503  *
504  * For streams supported by HGLOBALS, this function does nothing.
505  * This is what the documentation tells us.
506  *
507  * See the documentation of IStream for more info.
508  */
509 static HRESULT WINAPI HGLOBALStreamImpl_UnlockRegion(
510                   IStream*       iface,
511                   ULARGE_INTEGER libOffset,   /* [in] */
512                   ULARGE_INTEGER cb,          /* [in] */
513                   DWORD          dwLockType)  /* [in] */
514 {
515   return S_OK;
516 }
517
518 /***
519  * This method is part of the IStream interface.
520  *
521  * This method returns information about the current
522  * stream.
523  *
524  * See the documentation of IStream for more info.
525  */
526 static HRESULT WINAPI HGLOBALStreamImpl_Stat(
527                   IStream*     iface,
528                   STATSTG*     pstatstg,     /* [out] */
529                   DWORD        grfStatFlag)  /* [in] */
530 {
531   HGLOBALStreamImpl* This = impl_from_IStream(iface);
532
533   memset(pstatstg, 0, sizeof(STATSTG));
534
535   pstatstg->pwcsName = NULL;
536   pstatstg->type     = STGTY_STREAM;
537   pstatstg->cbSize   = This->streamSize;
538
539   return S_OK;
540 }
541
542 static HRESULT WINAPI HGLOBALStreamImpl_Clone(
543                   IStream*     iface,
544                   IStream**    ppstm) /* [out] */
545 {
546   HGLOBALStreamImpl* This = impl_from_IStream(iface);
547   ULARGE_INTEGER dummy;
548   LARGE_INTEGER offset;
549   HRESULT hr;
550
551   TRACE(" Cloning %p (deleteOnRelease=%d seek position=%ld)\n",iface,This->deleteOnRelease,(long)This->currentPosition.QuadPart);
552   hr = CreateStreamOnHGlobal(This->supportHandle, FALSE, ppstm);
553   if(FAILED(hr))
554     return hr;
555   offset.QuadPart = (LONGLONG)This->currentPosition.QuadPart;
556   IStream_Seek(*ppstm, offset, STREAM_SEEK_SET, &dummy);
557   return S_OK;
558 }
559
560 static const IStreamVtbl HGLOBALStreamImplVtbl =
561 {
562     HGLOBALStreamImpl_QueryInterface,
563     HGLOBALStreamImpl_AddRef,
564     HGLOBALStreamImpl_Release,
565     HGLOBALStreamImpl_Read,
566     HGLOBALStreamImpl_Write,
567     HGLOBALStreamImpl_Seek,
568     HGLOBALStreamImpl_SetSize,
569     HGLOBALStreamImpl_CopyTo,
570     HGLOBALStreamImpl_Commit,
571     HGLOBALStreamImpl_Revert,
572     HGLOBALStreamImpl_LockRegion,
573     HGLOBALStreamImpl_UnlockRegion,
574     HGLOBALStreamImpl_Stat,
575     HGLOBALStreamImpl_Clone
576 };
577
578 /***********************************************************************
579  *           CreateStreamOnHGlobal     [OLE32.@]
580  */
581 HRESULT WINAPI CreateStreamOnHGlobal(
582                 HGLOBAL   hGlobal,
583                 BOOL      fDeleteOnRelease,
584                 LPSTREAM* ppstm)
585 {
586   HGLOBALStreamImpl* This;
587
588   if (!ppstm)
589     return E_INVALIDARG;
590
591   This = HeapAlloc(GetProcessHeap(), 0, sizeof(HGLOBALStreamImpl));
592   if (!This) return E_OUTOFMEMORY;
593
594   This->IStream_iface.lpVtbl = &HGLOBALStreamImplVtbl;
595   This->ref = 1;
596
597   /* initialize the support */
598   This->supportHandle = hGlobal;
599   This->deleteOnRelease = fDeleteOnRelease;
600
601   /* allocate a handle if one is not supplied */
602   if (!This->supportHandle)
603     This->supportHandle = GlobalAlloc(GMEM_MOVEABLE|GMEM_NODISCARD|GMEM_SHARE, 0);
604
605   /* start at the beginning */
606   This->currentPosition.u.HighPart = 0;
607   This->currentPosition.u.LowPart = 0;
608
609   /* initialize the size of the stream to the size of the handle */
610   This->streamSize.u.HighPart = 0;
611   This->streamSize.u.LowPart = GlobalSize(This->supportHandle);
612
613   *ppstm = &This->IStream_iface;
614
615   return S_OK;
616 }
617
618 /***********************************************************************
619  *           GetHGlobalFromStream     [OLE32.@]
620  */
621 HRESULT WINAPI GetHGlobalFromStream(IStream* pstm, HGLOBAL* phglobal)
622 {
623   HGLOBALStreamImpl* pStream;
624
625   if (pstm == NULL)
626     return E_INVALIDARG;
627
628   pStream = (HGLOBALStreamImpl*) pstm;
629
630   /*
631    * Verify that the stream object was created with CreateStreamOnHGlobal.
632    */
633   if (pStream->IStream_iface.lpVtbl == &HGLOBALStreamImplVtbl)
634     *phglobal = pStream->supportHandle;
635   else
636   {
637     *phglobal = 0;
638     return E_INVALIDARG;
639   }
640
641   return S_OK;
642 }