Ignore:
Timestamp:
Sep 15, 2001, 11:32:00 AM (24 years ago)
Author:
sandervl
Message:

restored old version + wine update

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/ole32/hglobalstream.c

    r6648 r6711  
    1 /* $Id: hglobalstream.c,v 1.2 2001-09-05 13:17:09 bird Exp $ */
    21/*
    32 * HGLOBAL Stream implementation
    … …  
    3029{
    3130  ICOM_VFIELD(IStream);  /* Needs to be the first item in the stuct
    32               * since we want to cast this in a IStream pointer */
    33 
     31                          * since we want to cast this in a IStream pointer */
     32 
    3433  /*
    3534   * Reference count
    3635   */
    37   ULONG          ref;
     36  ULONG              ref;
    3837
    3938  /*
    … …  
    6564 */
    6665HGLOBALStreamImpl* HGLOBALStreamImpl_Construct(
    67         HGLOBAL  hGlobal,
    68         BOOL     fDeleteOnRelease);
     66                HGLOBAL  hGlobal,
     67                BOOL     fDeleteOnRelease);
    6968
    7069void HGLOBALStreamImpl_Destroy(
    … …  
    7574
    7675HRESULT WINAPI HGLOBALStreamImpl_QueryInterface(
    77         IStream*      iface,
    78         REFIID         riid,        /* [in] */
    79         void**         ppvObject);  /* [iid_is][out] */
    80 
     76                IStream*      iface,
     77                REFIID         riid,            /* [in] */         
     78                void**         ppvObject);  /* [iid_is][out] */
     79       
    8180ULONG WINAPI HGLOBALStreamImpl_AddRef(
    82         IStream*      iface);
    83 
     81                IStream*      iface);
     82       
    8483ULONG WINAPI HGLOBALStreamImpl_Release(
    85         IStream*      iface);
    86 
    87 HRESULT WINAPI HGLOBALStreamImpl_Read(
    88             IStream*      iface,
    89         void*          pv,        /* [length_is][size_is][out] */
    90         ULONG          cb,        /* [in] */
    91         ULONG*         pcbRead);  /* [out] */
    92 
     84                IStream*      iface);
     85       
     86HRESULT WINAPI HGLOBALStreamImpl_Read( 
     87                IStream*      iface,
     88                void*          pv,        /* [length_is][size_is][out] */
     89                ULONG          cb,        /* [in] */                     
     90                ULONG*         pcbRead);  /* [out] */                   
     91       
    9392HRESULT WINAPI HGLOBALStreamImpl_Write(
    94         IStream*      iface,
    95         const void*    pv,          /* [size_is][in] */
    96         ULONG          cb,          /* [in] */
    97         ULONG*         pcbWritten); /* [out] */
    98 
    99 HRESULT WINAPI HGLOBALStreamImpl_Seek(
    100         IStream*      iface,
    101         LARGE_INTEGER   dlibMove,         /* [in] */
    102         DWORD           dwOrigin,         /* [in] */
    103         ULARGE_INTEGER* plibNewPosition); /* [out] */
    104 
    105 HRESULT WINAPI HGLOBALStreamImpl_SetSize(
    106             IStream*      iface,
    107         ULARGE_INTEGER  libNewSize);  /* [in] */
    108 
    109 HRESULT WINAPI HGLOBALStreamImpl_CopyTo(
    110         IStream*      iface,
    111         IStream*      pstm,         /* [unique][in] */
    112         ULARGE_INTEGER  cb,           /* [in] */
    113         ULARGE_INTEGER* pcbRead,      /* [out] */
    114         ULARGE_INTEGER* pcbWritten);  /* [out] */
    115 
    116 HRESULT WINAPI HGLOBALStreamImpl_Commit(
    117             IStream*      iface,
    118         DWORD           grfCommitFlags); /* [in] */
    119 
    120 HRESULT WINAPI HGLOBALStreamImpl_Revert(
    121         IStream*  iface);
    122 
    123 HRESULT WINAPI HGLOBALStreamImpl_LockRegion(
    124         IStream*     iface,
    125         ULARGE_INTEGER libOffset,   /* [in] */
    126         ULARGE_INTEGER cb,          /* [in] */
    127         DWORD          dwLockType); /* [in] */
    128 
    129 HRESULT WINAPI HGLOBALStreamImpl_UnlockRegion(
    130         IStream*     iface,
    131         ULARGE_INTEGER libOffset,   /* [in] */
    132             ULARGE_INTEGER cb,          /* [in] */
    133         DWORD          dwLockType); /* [in] */
    134 
    135 HRESULT WINAPI HGLOBALStreamImpl_Stat(
    136         IStream*     iface,
    137             STATSTG*       pstatstg,     /* [out] */
    138             DWORD          grfStatFlag); /* [in] */
    139 
    140 HRESULT WINAPI HGLOBALStreamImpl_Clone(
    141         IStream*     iface,
    142         IStream**    ppstm);       /* [out] */
     93                IStream*      iface,
     94                const void*    pv,          /* [size_is][in] */
     95                ULONG          cb,          /* [in] */         
     96                ULONG*         pcbWritten); /* [out] */         
     97       
     98HRESULT WINAPI HGLOBALStreamImpl_Seek( 
     99                IStream*      iface,
     100                LARGE_INTEGER   dlibMove,         /* [in] */
     101                DWORD           dwOrigin,         /* [in] */
     102                ULARGE_INTEGER* plibNewPosition); /* [out] */
     103       
     104HRESULT WINAPI HGLOBALStreamImpl_SetSize( 
     105                IStream*      iface,
     106                ULARGE_INTEGER  libNewSize);  /* [in] */
     107       
     108HRESULT WINAPI HGLOBALStreamImpl_CopyTo( 
     109                IStream*      iface,
     110                IStream*      pstm,         /* [unique][in] */
     111                ULARGE_INTEGER  cb,           /* [in] */         
     112                ULARGE_INTEGER* pcbRead,      /* [out] */       
     113                ULARGE_INTEGER* pcbWritten);  /* [out] */       
     114
     115HRESULT WINAPI HGLOBALStreamImpl_Commit( 
     116                IStream*      iface,
     117                DWORD           grfCommitFlags); /* [in] */
     118       
     119HRESULT WINAPI HGLOBALStreamImpl_Revert( 
     120                IStream*  iface);
     121       
     122HRESULT WINAPI HGLOBALStreamImpl_LockRegion( 
     123                IStream*     iface,
     124                ULARGE_INTEGER libOffset,   /* [in] */
     125                ULARGE_INTEGER cb,          /* [in] */
     126                DWORD          dwLockType); /* [in] */
     127       
     128HRESULT WINAPI HGLOBALStreamImpl_UnlockRegion( 
     129                IStream*     iface,
     130                ULARGE_INTEGER libOffset,   /* [in] */
     131                ULARGE_INTEGER cb,          /* [in] */
     132                DWORD          dwLockType); /* [in] */
     133       
     134HRESULT WINAPI HGLOBALStreamImpl_Stat( 
     135                IStream*     iface,
     136                STATSTG*       pstatstg,     /* [out] */
     137                DWORD          grfStatFlag); /* [in] */
     138       
     139HRESULT WINAPI HGLOBALStreamImpl_Clone( 
     140                IStream*     iface,
     141                IStream**    ppstm);       /* [out] */
    143142
    144143
    … …  
    169168 */
    170169HRESULT WINAPI CreateStreamOnHGlobal(
    171         HGLOBAL   hGlobal,
    172         BOOL      fDeleteOnRelease,
    173         LPSTREAM* ppstm)
     170                HGLOBAL   hGlobal,
     171                BOOL      fDeleteOnRelease,
     172                LPSTREAM* ppstm)
    174173{
    175174  HGLOBALStreamImpl* newStream;
    176175
    177176  newStream = HGLOBALStreamImpl_Construct(hGlobal,
    178                       fDeleteOnRelease);
     177                                          fDeleteOnRelease);
    179178
    180179  if (newStream!=NULL)
    181180  {
    182     return IUnknown_QueryInterface((IUnknown*)newStream,
    183                    &IID_IStream,
    184                    (void**)ppstm);
     181    return IUnknown_QueryInterface((IUnknown*)newStream, 
     182                                   &IID_IStream,
     183                                   (void**)ppstm);
    185184  }
    186185
    … …  
    223222 * Params:
    224223 *    hGlobal          - Handle that will support the stream. can be NULL.
    225  *    fDeleteOnRelease - Flag set to TRUE if the HGLOBAL will be released
     224 *    fDeleteOnRelease - Flag set to TRUE if the HGLOBAL will be released 
    226225 *                       when the IStream object is destroyed.
    227226 */
    228227HGLOBALStreamImpl* HGLOBALStreamImpl_Construct(
    229         HGLOBAL  hGlobal,
    230         BOOL     fDeleteOnRelease)
     228                HGLOBAL  hGlobal,
     229                BOOL     fDeleteOnRelease)
    231230{
    232231  HGLOBALStreamImpl* newStream;
    233232
    234233  newStream = HeapAlloc(GetProcessHeap(), 0, sizeof(HGLOBALStreamImpl));
    235 
     234 
    236235  if (newStream!=0)
    237236  {
    … …  
    241240    ICOM_VTBL(newStream) = &HGLOBALStreamImpl_Vtbl;
    242241    newStream->ref    = 0;
    243 
     242   
    244243    /*
    245244     * Initialize the support.
    … …  
    254253    {
    255254      newStream->supportHandle = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD |
    256                          GMEM_SHARE, 0);
     255                                             GMEM_SHARE, 0);
    257256    }
    258 
     257   
    259258    /*
    260259     * Start the stream at the begining.
    … …  
    262261    newStream->currentPosition.s.HighPart = 0;
    263262    newStream->currentPosition.s.LowPart = 0;
    264 
     263   
    265264    /*
    266265     * Initialize the size of the stream to the size of the handle.
    … …  
    269268    newStream->streamSize.s.LowPart  = GlobalSize(newStream->supportHandle);
    270269  }
    271 
     270 
    272271  return newStream;
    273272}
    … …  
    276275 * This is the destructor of the HGLOBALStreamImpl class.
    277276 *
    278  * This method will clean-up all the resources used-up by the given HGLOBALStreamImpl
     277 * This method will clean-up all the resources used-up by the given HGLOBALStreamImpl 
    279278 * class. The pointer passed-in to this function will be freed and will not
    280279 * be valid anymore.
    … …  
    296295   * Finally, free the memory used-up by the class.
    297296   */
    298   HeapFree(GetProcessHeap(), 0, This);
     297  HeapFree(GetProcessHeap(), 0, This); 
    299298}
    300299
    … …  
    304303 */
    305304HRESULT WINAPI HGLOBALStreamImpl_QueryInterface(
    306           IStream*     iface,
    307           REFIID         riid,        /* [in] */
    308           void**         ppvObject)   /* [iid_is][out] */
     305                  IStream*     iface,
     306                  REFIID         riid,        /* [in] */         
     307                  void**         ppvObject)   /* [iid_is][out] */
    309308{
    310309  HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
    … …  
    315314  if (ppvObject==0)
    316315    return E_INVALIDARG;
    317 
     316 
    318317  /*
    319318   * Initialize the return parameter.
    320319   */
    321320  *ppvObject = 0;
    322 
     321 
    323322  /*
    324323   * Compare the riid with the interface IDs implemented by this object.
    325324   */
    326   if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
     325  if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0) 
    327326  {
    328327    *ppvObject = (IStream*)This;
    329328  }
    330   else if (memcmp(&IID_IStream, riid, sizeof(IID_IStream)) == 0)
     329  else if (memcmp(&IID_IStream, riid, sizeof(IID_IStream)) == 0) 
    331330  {
    332331    *ppvObject = (IStream*)This;
    333332  }
    334 
     333 
    335334  /*
    336335   * Check that we obtained an interface.
    … …  
    338337  if ((*ppvObject)==0)
    339338    return E_NOINTERFACE;
    340 
     339 
    341340  /*
    342341   * Query Interface always increases the reference count by one when it is
    … …  
    344343   */
    345344  HGLOBALStreamImpl_AddRef(iface);
    346 
     345 
    347346  return S_OK;;
    348347}
    … …  
    353352 */
    354353ULONG WINAPI HGLOBALStreamImpl_AddRef(
    355         IStream* iface)
     354                IStream* iface)
    356355{
    357356  HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
    358357
    359358  This->ref++;
    360 
     359 
    361360  return This->ref;
    362361}
    … …  
    367366 */
    368367ULONG WINAPI HGLOBALStreamImpl_Release(
    369         IStream* iface)
     368                IStream* iface)
    370369{
    371370  HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
    372371
    373372  ULONG newRef;
    374 
     373 
    375374  This->ref--;
    376 
     375 
    377376  newRef = This->ref;
    378 
     377 
    379378  /*
    380379   * If the reference count goes down to 0, perform suicide.
    … …  
    384383    HGLOBALStreamImpl_Destroy(This);
    385384  }
    386 
     385 
    387386  return newRef;
    388387}
    … …  
    397396 * See the documentation of ISequentialStream for more info.
    398397 */
    399 HRESULT WINAPI HGLOBALStreamImpl_Read(
    400           IStream*     iface,
    401           void*          pv,        /* [length_is][size_is][out] */
    402           ULONG          cb,        /* [in] */
    403           ULONG*         pcbRead)   /* [out] */
     398HRESULT WINAPI HGLOBALStreamImpl_Read( 
     399                  IStream*     iface,
     400                  void*          pv,        /* [length_is][size_is][out] */
     401                  ULONG          cb,        /* [in] */                     
     402                  ULONG*         pcbRead)   /* [out] */                   
    404403{
    405404  HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
    … …  
    410409
    411410  TRACE("(%p, %p, %ld, %p)\n", iface,
    412     pv, cb, pcbRead);
    413 
    414   /*
     411        pv, cb, pcbRead);
     412 
     413  /* 
    415414   * If the caller is not interested in the nubmer of bytes read,
    416415   * we use another buffer to avoid "if" statements in the code.
    … …  
    418417  if (pcbRead==0)
    419418    pcbRead = &bytesReadBuffer;
    420 
     419 
    421420  /*
    422421   * Using the known size of the stream, calculate the number of bytes
    … …  
    446445   */
    447446  GlobalUnlock(This->supportHandle);
    448 
     447 
    449448  /*
    450449   * The function returns S_OK if the buffer was filled completely
    … …  
    454453  if(*pcbRead == cb)
    455454    return S_OK;
    456 
     455 
    457456  return S_FALSE;
    458457}
    459 
     458       
    460459/***
    461460 * This method is part of the ISequentialStream interface.
    … …  
    469468 */
    470469HRESULT WINAPI HGLOBALStreamImpl_Write(
    471               IStream*     iface,
    472           const void*    pv,          /* [size_is][in] */
    473           ULONG          cb,          /* [in] */
    474           ULONG*         pcbWritten)  /* [out] */
     470                  IStream*     iface,
     471                  const void*    pv,          /* [size_is][in] */
     472                  ULONG          cb,          /* [in] */         
     473                  ULONG*         pcbWritten)  /* [out] */         
    475474{
    476475  HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
    … …  
    481480
    482481  TRACE("(%p, %p, %ld, %p)\n", iface,
    483     pv, cb, pcbWritten);
    484 
     482        pv, cb, pcbWritten);
     483 
    485484  /*
    486485   * If the caller is not interested in the number of bytes written,
    … …  
    489488  if (pcbWritten == 0)
    490489    pcbWritten = &bytesWritten;
    491 
     490 
    492491  if (cb == 0)
    493492  {
    … …  
    499498    newSize.s.LowPart = This->currentPosition.s.LowPart + cb;
    500499  }
    501 
     500 
    502501  /*
    503502   * Verify if we need to grow the stream
    … …  
    508507   IStream_SetSize(iface, newSize);
    509508  }
    510 
     509 
    511510  /*
    512511   * Lock the buffer in position and copy the data.
    … …  
    514513  supportBuffer = GlobalLock(This->supportHandle);
    515514
    516   memcpy((char *) supportBuffer+This->currentPosition.s.LowPart, pv, cb);
     515  memcpy((char *) supportBuffer+This->currentPosition.s.LowPart, pv, cb); 
    517516
    518517  /*
    … …  
    530529   */
    531530  GlobalUnlock(This->supportHandle);
    532 
     531 
    533532  return S_OK;
    534533}
    … …  
    541540 *
    542541 * See the documentation of IStream for more info.
    543  */
    544 HRESULT WINAPI HGLOBALStreamImpl_Seek(
    545           IStream*      iface,
    546           LARGE_INTEGER   dlibMove,         /* [in] */
    547           DWORD           dwOrigin,         /* [in] */
    548           ULARGE_INTEGER* plibNewPosition) /* [out] */
     542 */       
     543HRESULT WINAPI HGLOBALStreamImpl_Seek( 
     544                  IStream*      iface,
     545                  LARGE_INTEGER   dlibMove,         /* [in] */
     546                  DWORD           dwOrigin,         /* [in] */
     547                  ULARGE_INTEGER* plibNewPosition) /* [out] */
    549548{
    550549  HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
    … …  
    553552
    554553  TRACE("(%p, %ld, %ld, %p)\n", iface,
    555     dlibMove.s.LowPart, dwOrigin, plibNewPosition);
    556 
    557   /*
     554        dlibMove.s.LowPart, dwOrigin, plibNewPosition);
     555
     556  /* 
    558557   * The caller is allowed to pass in NULL as the new position return value.
    559558   * If it happens, we assign it to a dynamic variable to avoid special cases
    … …  
    609608  plibNewPosition->s.LowPart += dlibMove.s.LowPart;
    610609  This->currentPosition = *plibNewPosition;
    611 
     610 
    612611  return S_OK;
    613612}
    … …  
    622621 * See the documentation of IStream for more info.
    623622 */
    624 HRESULT WINAPI HGLOBALStreamImpl_SetSize(
    625                      IStream*      iface,
    626                      ULARGE_INTEGER  libNewSize)   /* [in] */
     623HRESULT WINAPI HGLOBALStreamImpl_SetSize( 
     624                                     IStream*      iface,
     625                                     ULARGE_INTEGER  libNewSize)   /* [in] */
    627626{
    628627  HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
    … …  
    635634  if (libNewSize.s.HighPart != 0)
    636635    return STG_E_INVALIDFUNCTION;
    637 
     636 
    638637  if (This->streamSize.s.LowPart == libNewSize.s.LowPart)
    639638    return S_OK;
    … …  
    642641   * Re allocate the HGlobal to fit the new size of the stream.
    643642   */
    644   This->supportHandle = GlobalReAlloc(This->supportHandle,
    645                       libNewSize.s.LowPart,
    646                       0);
     643  This->supportHandle = GlobalReAlloc(This->supportHandle, 
     644                                      libNewSize.s.LowPart,
     645                                      0);
    647646
    648647  This->streamSize.s.LowPart = libNewSize.s.LowPart;
    649 
     648 
    650649  return S_OK;
    651650}
    652 
     651       
    653652/***
    654653 * This method is part of the IStream interface.
    … …  
    658657 * See the documentation of IStream for more info.
    659658 */
    660 HRESULT WINAPI HGLOBALStreamImpl_CopyTo(
    661                     IStream*      iface,
    662                     IStream*      pstm,         /* [unique][in] */
    663                     ULARGE_INTEGER  cb,           /* [in] */
    664                     ULARGE_INTEGER* pcbRead,      /* [out] */
    665                     ULARGE_INTEGER* pcbWritten)   /* [out] */
     659HRESULT WINAPI HGLOBALStreamImpl_CopyTo( 
     660                                    IStream*      iface,
     661                                    IStream*      pstm,         /* [unique][in] */
     662                                    ULARGE_INTEGER  cb,           /* [in] */         
     663                                    ULARGE_INTEGER* pcbRead,      /* [out] */       
     664                                    ULARGE_INTEGER* pcbWritten)   /* [out] */       
    666665{
    667666  HRESULT        hr = S_OK;
    … …  
    671670  ULARGE_INTEGER totalBytesWritten;
    672671
    673   TRACE("(%p, %p, %ld, %p, %p)\n", iface, pstm,
    674     cb.s.LowPart, pcbRead, pcbWritten);
     672  TRACE("(%p, %p, %ld, %p, %p)\n", iface, pstm, 
     673        cb.s.LowPart, pcbRead, pcbWritten);
    675674
    676675  /*
    … …  
    694693    else
    695694      copySize = cb.s.LowPart;
    696 
     695   
    697696    IStream_Read(iface, tmpBuffer, copySize, &bytesRead);
    698697
    699698    totalBytesRead.s.LowPart += bytesRead;
    700 
     699   
    701700    IStream_Write(pstm, tmpBuffer, bytesRead, &bytesWritten);
    702701
    … …  
    711710      break;
    712711    }
    713 
     712   
    714713    if (bytesRead!=copySize)
    715714      cb.s.LowPart = 0;
    … …  
    738737 * This method is part of the IStream interface.
    739738 *
    740  * For streams supported by HGLOBALS, this function does nothing.
     739 * For streams supported by HGLOBALS, this function does nothing. 
    741740 * This is what the documentation tells us.
    742741 *
    743742 * See the documentation of IStream for more info.
    744  */
    745 HRESULT WINAPI HGLOBALStreamImpl_Commit(
    746           IStream*      iface,
    747           DWORD         grfCommitFlags)  /* [in] */
     743 */       
     744HRESULT WINAPI HGLOBALStreamImpl_Commit( 
     745                  IStream*      iface,
     746                  DWORD         grfCommitFlags)  /* [in] */
    748747{
    749748  return S_OK;
    … …  
    753752 * This method is part of the IStream interface.
    754753 *
    755  * For streams supported by HGLOBALS, this function does nothing.
     754 * For streams supported by HGLOBALS, this function does nothing. 
    756755 * This is what the documentation tells us.
    757756 *
    758757 * See the documentation of IStream for more info.
    759  */
    760 HRESULT WINAPI HGLOBALStreamImpl_Revert(
    761           IStream* iface)
     758 */       
     759HRESULT WINAPI HGLOBALStreamImpl_Revert( 
     760                  IStream* iface)
    762761{
    763762  return S_OK;
    … …  
    767766 * This method is part of the IStream interface.
    768767 *
    769  * For streams supported by HGLOBALS, this function does nothing.
     768 * For streams supported by HGLOBALS, this function does nothing. 
    770769 * This is what the documentation tells us.
    771770 *
    772771 * See the documentation of IStream for more info.
    773  */
    774 HRESULT WINAPI HGLOBALStreamImpl_LockRegion(
    775           IStream*       iface,
    776           ULARGE_INTEGER libOffset,   /* [in] */
    777           ULARGE_INTEGER cb,          /* [in] */
    778           DWORD          dwLockType)  /* [in] */
     772 */       
     773HRESULT WINAPI HGLOBALStreamImpl_LockRegion( 
     774                  IStream*       iface,
     775                  ULARGE_INTEGER libOffset,   /* [in] */
     776                  ULARGE_INTEGER cb,          /* [in] */
     777                  DWORD          dwLockType)  /* [in] */
    779778{
    780779  return S_OK;
    … …  
    784783 * This method is part of the IStream interface.
    785784 *
    786  * For streams supported by HGLOBALS, this function does nothing.
     785 * For streams supported by HGLOBALS, this function does nothing. 
    787786 * This is what the documentation tells us.
    788787 *
    789788 * See the documentation of IStream for more info.
    790  */
    791 HRESULT WINAPI HGLOBALStreamImpl_UnlockRegion(
    792           IStream*       iface,
    793           ULARGE_INTEGER libOffset,   /* [in] */
    794           ULARGE_INTEGER cb,          /* [in] */
    795           DWORD          dwLockType)  /* [in] */
     789 */       
     790HRESULT WINAPI HGLOBALStreamImpl_UnlockRegion( 
     791                  IStream*       iface,
     792                  ULARGE_INTEGER libOffset,   /* [in] */
     793                  ULARGE_INTEGER cb,          /* [in] */
     794                  DWORD          dwLockType)  /* [in] */
    796795{
    797796  return S_OK;
    … …  
    805804 *
    806805 * See the documentation of IStream for more info.
    807  */
    808 HRESULT WINAPI HGLOBALStreamImpl_Stat(
    809           IStream*     iface,
    810           STATSTG*     pstatstg,     /* [out] */
    811           DWORD        grfStatFlag)  /* [in] */
     806 */       
     807HRESULT WINAPI HGLOBALStreamImpl_Stat( 
     808                  IStream*     iface,
     809                  STATSTG*     pstatstg,     /* [out] */
     810                  DWORD        grfStatFlag)  /* [in] */
    812811{
    813812  HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
    … …  
    821820  return S_OK;
    822821}
    823 
    824 HRESULT WINAPI HGLOBALStreamImpl_Clone(
    825           IStream*     iface,
    826           IStream**    ppstm) /* [out] */
     822       
     823HRESULT WINAPI HGLOBALStreamImpl_Clone( 
     824                  IStream*     iface,
     825                  IStream**    ppstm) /* [out] */
    827826{
    828827  FIXME("not implemented!\n");
Note: See TracChangeset for help on using the changeset viewer.