mirror of
git://source.winehq.org/git/wine.git
synced 2024-10-06 08:54:05 +00:00
ole32: Use nameless unions/structs.
This commit is contained in:
parent
34ab144f04
commit
61a06d4bcd
|
@ -22,8 +22,6 @@
|
|||
#include <string.h>
|
||||
|
||||
#define COBJMACROS
|
||||
#define NONAMELESSUNION
|
||||
|
||||
#include "windef.h"
|
||||
#include "winbase.h"
|
||||
#include "objbase.h"
|
||||
|
|
|
@ -64,8 +64,6 @@
|
|||
#include <stdio.h>
|
||||
|
||||
#define COBJMACROS
|
||||
#define NONAMELESSUNION
|
||||
|
||||
#include "windef.h"
|
||||
#include "winbase.h"
|
||||
#include "wingdi.h"
|
||||
|
@ -646,7 +644,7 @@ static HRESULT render_embed_source_hack(IDataObject *data, LPFORMATETC fmt)
|
|||
return hr;
|
||||
}
|
||||
|
||||
hr = StgCreateDocfileOnILockBytes(ptrILockBytes, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &std.u.pstg);
|
||||
hr = StgCreateDocfileOnILockBytes(ptrILockBytes, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &std.pstg);
|
||||
ILockBytes_Release(ptrILockBytes);
|
||||
|
||||
if (FAILED(hr = IDataObject_GetDataHere(theOleClipboard->src_data, fmt, &std)))
|
||||
|
@ -675,7 +673,7 @@ static HRESULT render_embed_source_hack(IDataObject *data, LPFORMATETC fmt)
|
|||
|
||||
if (SUCCEEDED(hr = IDataObject_GetData(theOleClipboard->src_data, &fmt2, &std2)))
|
||||
{
|
||||
mfp = GlobalLock(std2.u.hGlobal);
|
||||
mfp = GlobalLock(std2.hGlobal);
|
||||
}
|
||||
|
||||
if (mfp)
|
||||
|
@ -704,7 +702,7 @@ static HRESULT render_embed_source_hack(IDataObject *data, LPFORMATETC fmt)
|
|||
pdh.dwObjectExtentY = mfp->yExt;
|
||||
pdh.dwSize = nSize;
|
||||
|
||||
hr = IStorage_CreateStream(std.u.pstg, L"\2OlePres000",
|
||||
hr = IStorage_CreateStream(std.pstg, L"\2OlePres000",
|
||||
STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, 0, &pStream);
|
||||
|
||||
hr = IStream_Write(pStream, &pdh, sizeof(PresentationDataHeader), NULL);
|
||||
|
@ -718,15 +716,15 @@ static HRESULT render_embed_source_hack(IDataObject *data, LPFORMATETC fmt)
|
|||
|
||||
HeapFree(GetProcessHeap(), 0, mfBits);
|
||||
|
||||
GlobalUnlock(std2.u.hGlobal);
|
||||
GlobalUnlock(std2.hGlobal);
|
||||
ReleaseStgMedium(&std2);
|
||||
|
||||
ReadClassStg(std.u.pstg, &clsID);
|
||||
ReadClassStg(std.pstg, &clsID);
|
||||
ProgIDFromCLSID(&clsID, &strProgID);
|
||||
|
||||
WideCharToMultiByte( CP_ACP, 0, strProgID, -1, strOleTypeName, sizeof(strOleTypeName), NULL, NULL );
|
||||
STORAGE_CreateOleStream(std.u.pstg, 0);
|
||||
OLECONVERT_CreateCompObjStream(std.u.pstg, strOleTypeName);
|
||||
STORAGE_CreateOleStream(std.pstg, 0);
|
||||
OLECONVERT_CreateCompObjStream(std.pstg, strOleTypeName);
|
||||
CoTaskMemFree(strProgID);
|
||||
}
|
||||
}
|
||||
|
@ -790,7 +788,7 @@ static HRESULT get_data_from_storage(IDataObject *data, FORMATETC *fmt, HGLOBAL
|
|||
|
||||
stg_fmt = *fmt;
|
||||
med.tymed = stg_fmt.tymed = TYMED_ISTORAGE;
|
||||
med.u.pstg = stg;
|
||||
med.pstg = stg;
|
||||
med.pUnkForRelease = NULL;
|
||||
|
||||
hr = IDataObject_GetDataHere(data, &stg_fmt, &med);
|
||||
|
@ -800,7 +798,7 @@ static HRESULT get_data_from_storage(IDataObject *data, FORMATETC *fmt, HGLOBAL
|
|||
hr = IDataObject_GetData(data, &stg_fmt, &med);
|
||||
if(FAILED(hr)) goto end;
|
||||
|
||||
hr = IStorage_CopyTo(med.u.pstg, 0, NULL, NULL, stg);
|
||||
hr = IStorage_CopyTo(med.pstg, 0, NULL, NULL, stg);
|
||||
ReleaseStgMedium(&med);
|
||||
if(FAILED(hr)) goto end;
|
||||
}
|
||||
|
@ -835,7 +833,7 @@ static HRESULT get_data_from_stream(IDataObject *data, FORMATETC *fmt, HGLOBAL *
|
|||
|
||||
stm_fmt = *fmt;
|
||||
med.tymed = stm_fmt.tymed = TYMED_ISTREAM;
|
||||
med.u.pstm = stm;
|
||||
med.pstm = stm;
|
||||
med.pUnkForRelease = NULL;
|
||||
|
||||
hr = IDataObject_GetDataHere(data, &stm_fmt, &med);
|
||||
|
@ -849,9 +847,9 @@ static HRESULT get_data_from_stream(IDataObject *data, FORMATETC *fmt, HGLOBAL *
|
|||
if(FAILED(hr)) goto error;
|
||||
|
||||
offs.QuadPart = 0;
|
||||
IStream_Seek(med.u.pstm, offs, STREAM_SEEK_END, &pos);
|
||||
IStream_Seek(med.u.pstm, offs, STREAM_SEEK_SET, NULL);
|
||||
hr = IStream_CopyTo(med.u.pstm, stm, pos, NULL, NULL);
|
||||
IStream_Seek(med.pstm, offs, STREAM_SEEK_END, &pos);
|
||||
IStream_Seek(med.pstm, offs, STREAM_SEEK_SET, NULL);
|
||||
hr = IStream_CopyTo(med.pstm, stm, pos, NULL, NULL);
|
||||
ReleaseStgMedium(&med);
|
||||
if(FAILED(hr)) goto error;
|
||||
}
|
||||
|
@ -886,7 +884,7 @@ static HRESULT get_data_from_global(IDataObject *data, FORMATETC *fmt, HGLOBAL *
|
|||
hr = IDataObject_GetData(data, &mem_fmt, &med);
|
||||
if(FAILED(hr)) return hr;
|
||||
|
||||
hr = dup_global_mem(med.u.hGlobal, GMEM_DDESHARE|GMEM_MOVEABLE, &h);
|
||||
hr = dup_global_mem(med.hGlobal, GMEM_DDESHARE|GMEM_MOVEABLE, &h);
|
||||
|
||||
if(SUCCEEDED(hr)) *mem = h;
|
||||
|
||||
|
@ -914,7 +912,7 @@ static HRESULT get_data_from_enhmetafile(IDataObject *data, FORMATETC *fmt, HGLO
|
|||
hr = IDataObject_GetData(data, &mem_fmt, &med);
|
||||
if(FAILED(hr)) return hr;
|
||||
|
||||
copy = CopyEnhMetaFileW(med.u.hEnhMetaFile, NULL);
|
||||
copy = CopyEnhMetaFileW(med.hEnhMetaFile, NULL);
|
||||
if(copy) *mem = (HGLOBAL)copy;
|
||||
else hr = E_FAIL;
|
||||
|
||||
|
@ -942,7 +940,7 @@ static HRESULT get_data_from_metafilepict(IDataObject *data, FORMATETC *fmt, HGL
|
|||
hr = IDataObject_GetData(data, &mem_fmt, &med);
|
||||
if(FAILED(hr)) return hr;
|
||||
|
||||
hr = dup_metafilepict(med.u.hMetaFilePict, ©);
|
||||
hr = dup_metafilepict(med.hMetaFilePict, ©);
|
||||
|
||||
if(SUCCEEDED(hr)) *mem = copy;
|
||||
|
||||
|
@ -972,7 +970,7 @@ static HRESULT get_data_from_bitmap(IDataObject *data, FORMATETC *fmt, HBITMAP *
|
|||
hr = IDataObject_GetData(data, &mem_fmt, &med);
|
||||
if(FAILED(hr)) return hr;
|
||||
|
||||
hr = dup_bitmap(med.u.hBitmap, ©);
|
||||
hr = dup_bitmap(med.hBitmap, ©);
|
||||
|
||||
if(SUCCEEDED(hr)) *hbm = copy;
|
||||
|
||||
|
@ -1299,7 +1297,7 @@ static HRESULT get_stgmed_for_global(HGLOBAL h, STGMEDIUM *med)
|
|||
med->pUnkForRelease = NULL;
|
||||
med->tymed = TYMED_NULL;
|
||||
|
||||
hr = dup_global_mem(h, GMEM_MOVEABLE, &med->u.hGlobal);
|
||||
hr = dup_global_mem(h, GMEM_MOVEABLE, &med->hGlobal);
|
||||
|
||||
if(SUCCEEDED(hr)) med->tymed = TYMED_HGLOBAL;
|
||||
|
||||
|
@ -1322,7 +1320,7 @@ static HRESULT get_stgmed_for_stream(HGLOBAL h, STGMEDIUM *med)
|
|||
hr = dup_global_mem(h, GMEM_MOVEABLE, &dst);
|
||||
if(FAILED(hr)) return hr;
|
||||
|
||||
hr = CreateStreamOnHGlobal(dst, TRUE, &med->u.pstm);
|
||||
hr = CreateStreamOnHGlobal(dst, TRUE, &med->pstm);
|
||||
if(FAILED(hr))
|
||||
{
|
||||
GlobalFree(dst);
|
||||
|
@ -1365,7 +1363,7 @@ static HRESULT get_stgmed_for_storage(HGLOBAL h, STGMEDIUM *med)
|
|||
return SUCCEEDED(hr) ? E_FAIL : hr;
|
||||
}
|
||||
|
||||
hr = StgOpenStorageOnILockBytes(lbs, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, NULL, 0, &med->u.pstg);
|
||||
hr = StgOpenStorageOnILockBytes(lbs, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, NULL, 0, &med->pstg);
|
||||
ILockBytes_Release(lbs);
|
||||
if(FAILED(hr))
|
||||
{
|
||||
|
@ -1387,8 +1385,8 @@ static HRESULT get_stgmed_for_emf(HENHMETAFILE hemf, STGMEDIUM *med)
|
|||
med->pUnkForRelease = NULL;
|
||||
med->tymed = TYMED_NULL;
|
||||
|
||||
med->u.hEnhMetaFile = CopyEnhMetaFileW(hemf, NULL);
|
||||
if(!med->u.hEnhMetaFile) return E_OUTOFMEMORY;
|
||||
med->hEnhMetaFile = CopyEnhMetaFileW(hemf, NULL);
|
||||
if(!med->hEnhMetaFile) return E_OUTOFMEMORY;
|
||||
med->tymed = TYMED_ENHMF;
|
||||
return S_OK;
|
||||
}
|
||||
|
@ -1405,7 +1403,7 @@ static HRESULT get_stgmed_for_bitmap(HBITMAP hbmp, STGMEDIUM *med)
|
|||
med->pUnkForRelease = NULL;
|
||||
med->tymed = TYMED_NULL;
|
||||
|
||||
hr = dup_bitmap(hbmp, &med->u.hBitmap);
|
||||
hr = dup_bitmap(hbmp, &med->hBitmap);
|
||||
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
@ -1603,15 +1601,15 @@ static HRESULT WINAPI snapshot_GetDataHere(IDataObject *iface, FORMATETC *fmt,
|
|||
case TYMED_HGLOBAL:
|
||||
{
|
||||
DWORD src_size = GlobalSize(h);
|
||||
DWORD dst_size = GlobalSize(med->u.hGlobal);
|
||||
DWORD dst_size = GlobalSize(med->hGlobal);
|
||||
hr = E_FAIL;
|
||||
if(dst_size >= src_size)
|
||||
{
|
||||
void *src = GlobalLock(h);
|
||||
void *dst = GlobalLock(med->u.hGlobal);
|
||||
void *dst = GlobalLock(med->hGlobal);
|
||||
|
||||
memcpy(dst, src, src_size);
|
||||
GlobalUnlock(med->u.hGlobal);
|
||||
GlobalUnlock(med->hGlobal);
|
||||
GlobalUnlock(h);
|
||||
hr = S_OK;
|
||||
}
|
||||
|
@ -1621,7 +1619,7 @@ static HRESULT WINAPI snapshot_GetDataHere(IDataObject *iface, FORMATETC *fmt,
|
|||
{
|
||||
DWORD src_size = GlobalSize(h);
|
||||
void *src = GlobalLock(h);
|
||||
hr = IStream_Write(med->u.pstm, src, src_size, NULL);
|
||||
hr = IStream_Write(med->pstm, src, src_size, NULL);
|
||||
GlobalUnlock(h);
|
||||
break;
|
||||
}
|
||||
|
@ -1636,7 +1634,7 @@ static HRESULT WINAPI snapshot_GetDataHere(IDataObject *iface, FORMATETC *fmt,
|
|||
hr = get_stgmed_for_storage(h, ©);
|
||||
if(SUCCEEDED(hr))
|
||||
{
|
||||
hr = IStorage_CopyTo(copy.u.pstg, 0, NULL, NULL, med->u.pstg);
|
||||
hr = IStorage_CopyTo(copy.pstg, 0, NULL, NULL, med->pstg);
|
||||
ReleaseStgMedium(©);
|
||||
}
|
||||
break;
|
||||
|
|
|
@ -40,8 +40,6 @@
|
|||
#include <assert.h>
|
||||
|
||||
#define COBJMACROS
|
||||
#define NONAMELESSUNION
|
||||
|
||||
#include "ntstatus.h"
|
||||
#define WIN32_NO_STATUS
|
||||
#include "windef.h"
|
||||
|
|
|
@ -48,8 +48,6 @@
|
|||
#include <string.h>
|
||||
|
||||
#define COBJMACROS
|
||||
#define NONAMELESSUNION
|
||||
|
||||
#include "windef.h"
|
||||
#include "winbase.h"
|
||||
#include "wingdi.h"
|
||||
|
@ -557,7 +555,7 @@ static HRESULT synthesize_emf( HMETAFILEPICT data, STGMEDIUM *med )
|
|||
if ((bits = HeapAlloc( GetProcessHeap(), 0, size )))
|
||||
{
|
||||
GetMetaFileBitsEx( pict->hMF, size, bits );
|
||||
med->u.hEnhMetaFile = SetWinMetaFileBits( size, bits, NULL, pict );
|
||||
med->hEnhMetaFile = SetWinMetaFileBits( size, bits, NULL, pict );
|
||||
HeapFree( GetProcessHeap(), 0, bits );
|
||||
med->tymed = TYMED_ENHMF;
|
||||
med->pUnkForRelease = NULL;
|
||||
|
@ -617,14 +615,14 @@ static HRESULT load_mf_pict( DataCacheEntry *cache_entry, IStream *stm )
|
|||
if (!hmfpict) return E_OUTOFMEMORY;
|
||||
mfpict = GlobalLock( hmfpict );
|
||||
|
||||
bits = HeapAlloc( GetProcessHeap(), 0, stat.cbSize.u.LowPart);
|
||||
bits = HeapAlloc( GetProcessHeap(), 0, stat.cbSize.LowPart);
|
||||
if (!bits)
|
||||
{
|
||||
GlobalFree( hmfpict );
|
||||
return E_OUTOFMEMORY;
|
||||
}
|
||||
|
||||
hr = IStream_Read( stm, bits, stat.cbSize.u.LowPart, &read );
|
||||
hr = IStream_Read( stm, bits, stat.cbSize.LowPart, &read );
|
||||
|
||||
if (SUCCEEDED( hr ))
|
||||
{
|
||||
|
@ -642,7 +640,7 @@ static HRESULT load_mf_pict( DataCacheEntry *cache_entry, IStream *stm )
|
|||
mfpict->yExt = ((mf_place.bounding_box[3] - mf_place.bounding_box[1])
|
||||
* 2540) / mf_place.inch;
|
||||
}
|
||||
mfpict->hMF = SetMetaFileBitsEx( stat.cbSize.u.LowPart, bits );
|
||||
mfpict->hMF = SetMetaFileBitsEx( stat.cbSize.LowPart, bits );
|
||||
if (!mfpict->hMF)
|
||||
hr = E_FAIL;
|
||||
}
|
||||
|
@ -651,7 +649,7 @@ static HRESULT load_mf_pict( DataCacheEntry *cache_entry, IStream *stm )
|
|||
if (SUCCEEDED( hr ))
|
||||
{
|
||||
cache_entry->stgmedium.tymed = TYMED_MFPICT;
|
||||
cache_entry->stgmedium.u.hMetaFilePict = hmfpict;
|
||||
cache_entry->stgmedium.hMetaFilePict = hmfpict;
|
||||
}
|
||||
else
|
||||
GlobalFree( hmfpict );
|
||||
|
@ -695,7 +693,7 @@ static HRESULT load_dib( DataCacheEntry *cache_entry, IStream *stm )
|
|||
if (FAILED( hr )) return hr;
|
||||
stat.cbSize.QuadPart -= current_pos.QuadPart;
|
||||
|
||||
hglobal = GlobalAlloc( GMEM_MOVEABLE, stat.cbSize.u.LowPart );
|
||||
hglobal = GlobalAlloc( GMEM_MOVEABLE, stat.cbSize.LowPart );
|
||||
if (!hglobal) return E_OUTOFMEMORY;
|
||||
dib = GlobalLock( hglobal );
|
||||
|
||||
|
@ -730,7 +728,7 @@ static HRESULT load_dib( DataCacheEntry *cache_entry, IStream *stm )
|
|||
stat.cbSize.QuadPart -= skip.QuadPart;
|
||||
}
|
||||
|
||||
hr = IStream_Read( stm, dib + info_size, stat.cbSize.u.LowPart, &read );
|
||||
hr = IStream_Read( stm, dib + info_size, stat.cbSize.LowPart, &read );
|
||||
if (hr != S_OK) goto fail;
|
||||
|
||||
if (bi_size >= sizeof(*info))
|
||||
|
@ -748,7 +746,7 @@ static HRESULT load_dib( DataCacheEntry *cache_entry, IStream *stm )
|
|||
GlobalUnlock( hglobal );
|
||||
|
||||
cache_entry->stgmedium.tymed = TYMED_HGLOBAL;
|
||||
cache_entry->stgmedium.u.hGlobal = hglobal;
|
||||
cache_entry->stgmedium.hGlobal = hglobal;
|
||||
|
||||
return hr;
|
||||
|
||||
|
@ -770,7 +768,7 @@ static HRESULT load_emf( DataCacheEntry *cache_entry, IStream *stm )
|
|||
hr = load_mf_pict( cache_entry, stm );
|
||||
if (SUCCEEDED( hr ))
|
||||
{
|
||||
hr = synthesize_emf( cache_entry->stgmedium.u.hMetaFilePict, &stgmed );
|
||||
hr = synthesize_emf( cache_entry->stgmedium.hMetaFilePict, &stgmed );
|
||||
ReleaseStgMedium( &cache_entry->stgmedium );
|
||||
}
|
||||
if (SUCCEEDED( hr ))
|
||||
|
@ -786,10 +784,10 @@ static HRESULT load_emf( DataCacheEntry *cache_entry, IStream *stm )
|
|||
|
||||
if (SUCCEEDED( hr ))
|
||||
{
|
||||
data = HeapAlloc( GetProcessHeap(), 0, stat.cbSize.u.LowPart );
|
||||
data = HeapAlloc( GetProcessHeap(), 0, stat.cbSize.LowPart );
|
||||
if (!data) return E_OUTOFMEMORY;
|
||||
|
||||
hr = IStream_Read( stm, data, stat.cbSize.u.LowPart, &read );
|
||||
hr = IStream_Read( stm, data, stat.cbSize.LowPart, &read );
|
||||
if (hr != S_OK)
|
||||
{
|
||||
HeapFree( GetProcessHeap(), 0, data );
|
||||
|
@ -802,7 +800,7 @@ static HRESULT load_emf( DataCacheEntry *cache_entry, IStream *stm )
|
|||
return E_FAIL;
|
||||
}
|
||||
size_bits = read - sizeof(DWORD) - sizeof(ENHMETAHEADER);
|
||||
cache_entry->stgmedium.u.hEnhMetaFile = SetEnhMetaFileBits( size_bits, data + (read - size_bits) );
|
||||
cache_entry->stgmedium.hEnhMetaFile = SetEnhMetaFileBits( size_bits, data + (read - size_bits) );
|
||||
cache_entry->stgmedium.tymed = TYMED_ENHMF;
|
||||
cache_entry->stgmedium.pUnkForRelease = NULL;
|
||||
|
||||
|
@ -880,8 +878,8 @@ static HRESULT save_dib(DataCacheEntry *entry, BOOL contents, IStream *stream)
|
|||
|
||||
if (entry->stgmedium.tymed != TYMED_NULL)
|
||||
{
|
||||
data_size = GlobalSize(entry->stgmedium.u.hGlobal);
|
||||
bmi = GlobalLock(entry->stgmedium.u.hGlobal);
|
||||
data_size = GlobalSize(entry->stgmedium.hGlobal);
|
||||
bmi = GlobalLock(entry->stgmedium.hGlobal);
|
||||
}
|
||||
|
||||
if (!contents)
|
||||
|
@ -926,7 +924,7 @@ static HRESULT save_dib(DataCacheEntry *entry, BOOL contents, IStream *stream)
|
|||
}
|
||||
|
||||
end:
|
||||
if (bmi) GlobalUnlock(entry->stgmedium.u.hGlobal);
|
||||
if (bmi) GlobalUnlock(entry->stgmedium.hGlobal);
|
||||
return hr;
|
||||
}
|
||||
|
||||
|
@ -946,7 +944,7 @@ static HRESULT save_mfpict(DataCacheEntry *entry, BOOL contents, IStream *stream
|
|||
if (FAILED(hr)) return hr;
|
||||
if (entry->stgmedium.tymed != TYMED_NULL)
|
||||
{
|
||||
mfpict = GlobalLock(entry->stgmedium.u.hMetaFilePict);
|
||||
mfpict = GlobalLock(entry->stgmedium.hMetaFilePict);
|
||||
if (!mfpict)
|
||||
return DV_E_STGMEDIUM;
|
||||
data_size = GetMetaFileBitsEx(mfpict->hMF, 0, NULL);
|
||||
|
@ -956,11 +954,11 @@ static HRESULT save_mfpict(DataCacheEntry *entry, BOOL contents, IStream *stream
|
|||
data = HeapAlloc(GetProcessHeap(), 0, header.dwSize);
|
||||
if (!data)
|
||||
{
|
||||
GlobalUnlock(entry->stgmedium.u.hMetaFilePict);
|
||||
GlobalUnlock(entry->stgmedium.hMetaFilePict);
|
||||
return E_OUTOFMEMORY;
|
||||
}
|
||||
GetMetaFileBitsEx(mfpict->hMF, header.dwSize, data);
|
||||
GlobalUnlock(entry->stgmedium.u.hMetaFilePict);
|
||||
GlobalUnlock(entry->stgmedium.hMetaFilePict);
|
||||
}
|
||||
hr = IStream_Write(stream, &header, sizeof(PresentationDataHeader), NULL);
|
||||
if (hr == S_OK && data_size)
|
||||
|
@ -972,14 +970,14 @@ static HRESULT save_mfpict(DataCacheEntry *entry, BOOL contents, IStream *stream
|
|||
struct meta_placeable meta_place_rec;
|
||||
WORD *check;
|
||||
|
||||
mfpict = GlobalLock(entry->stgmedium.u.hMetaFilePict);
|
||||
mfpict = GlobalLock(entry->stgmedium.hMetaFilePict);
|
||||
if (!mfpict)
|
||||
return DV_E_STGMEDIUM;
|
||||
data_size = GetMetaFileBitsEx(mfpict->hMF, 0, NULL);
|
||||
data = HeapAlloc(GetProcessHeap(), 0, data_size);
|
||||
if (!data)
|
||||
{
|
||||
GlobalUnlock(entry->stgmedium.u.hMetaFilePict);
|
||||
GlobalUnlock(entry->stgmedium.hMetaFilePict);
|
||||
return E_OUTOFMEMORY;
|
||||
}
|
||||
GetMetaFileBitsEx(mfpict->hMF, data_size, data);
|
||||
|
@ -998,7 +996,7 @@ static HRESULT save_mfpict(DataCacheEntry *entry, BOOL contents, IStream *stream
|
|||
/* These values are rounded down so MulDiv won't do the right thing */
|
||||
meta_place_rec.bounding_box[2] = (LONGLONG)mfpict->xExt * meta_place_rec.inch / 2540;
|
||||
meta_place_rec.bounding_box[3] = (LONGLONG)mfpict->yExt * meta_place_rec.inch / 2540;
|
||||
GlobalUnlock(entry->stgmedium.u.hMetaFilePict);
|
||||
GlobalUnlock(entry->stgmedium.hMetaFilePict);
|
||||
|
||||
for (check = (WORD *)&meta_place_rec; check != &meta_place_rec.checksum; check++)
|
||||
meta_place_rec.checksum ^= *check;
|
||||
|
@ -1030,7 +1028,7 @@ static HRESULT save_emf(DataCacheEntry *entry, BOOL contents, IStream *stream)
|
|||
ReleaseDC(0, hdc);
|
||||
return hr;
|
||||
}
|
||||
data_size = GetWinMetaFileBits(entry->stgmedium.u.hEnhMetaFile, 0, NULL, MM_ANISOTROPIC, hdc);
|
||||
data_size = GetWinMetaFileBits(entry->stgmedium.hEnhMetaFile, 0, NULL, MM_ANISOTROPIC, hdc);
|
||||
header.dwSize = data_size;
|
||||
data = HeapAlloc(GetProcessHeap(), 0, header.dwSize);
|
||||
if (!data)
|
||||
|
@ -1038,7 +1036,7 @@ static HRESULT save_emf(DataCacheEntry *entry, BOOL contents, IStream *stream)
|
|||
ReleaseDC(0, hdc);
|
||||
return E_OUTOFMEMORY;
|
||||
}
|
||||
GetWinMetaFileBits(entry->stgmedium.u.hEnhMetaFile, header.dwSize, data, MM_ANISOTROPIC, hdc);
|
||||
GetWinMetaFileBits(entry->stgmedium.hEnhMetaFile, header.dwSize, data, MM_ANISOTROPIC, hdc);
|
||||
ReleaseDC(0, hdc);
|
||||
mfpict = (METAFILEPICT *)data;
|
||||
header.dwObjectExtentX = mfpict->xExt;
|
||||
|
@ -1050,11 +1048,11 @@ static HRESULT save_emf(DataCacheEntry *entry, BOOL contents, IStream *stream)
|
|||
}
|
||||
else if (entry->stgmedium.tymed != TYMED_NULL)
|
||||
{
|
||||
data_size = GetEnhMetaFileBits(entry->stgmedium.u.hEnhMetaFile, 0, NULL);
|
||||
data_size = GetEnhMetaFileBits(entry->stgmedium.hEnhMetaFile, 0, NULL);
|
||||
data = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD) + sizeof(ENHMETAHEADER) + data_size);
|
||||
if (!data) return E_OUTOFMEMORY;
|
||||
*((DWORD *)data) = sizeof(ENHMETAHEADER);
|
||||
GetEnhMetaFileBits(entry->stgmedium.u.hEnhMetaFile, data_size, data + sizeof(DWORD) + sizeof(ENHMETAHEADER));
|
||||
GetEnhMetaFileBits(entry->stgmedium.hEnhMetaFile, data_size, data + sizeof(DWORD) + sizeof(ENHMETAHEADER));
|
||||
memcpy(data + sizeof(DWORD), data + sizeof(DWORD) + sizeof(ENHMETAHEADER), sizeof(ENHMETAHEADER));
|
||||
data_size += sizeof(DWORD) + sizeof(ENHMETAHEADER);
|
||||
hr = IStream_Write(stream, data, data_size, NULL);
|
||||
|
@ -1139,28 +1137,27 @@ static HRESULT copy_stg_medium(CLIPFORMAT cf, STGMEDIUM *dest_stgm,
|
|||
{
|
||||
if (src_stgm->tymed == TYMED_MFPICT)
|
||||
{
|
||||
const METAFILEPICT *src_mfpict = GlobalLock(src_stgm->u.hMetaFilePict);
|
||||
const METAFILEPICT *src_mfpict = GlobalLock(src_stgm->hMetaFilePict);
|
||||
METAFILEPICT *dest_mfpict;
|
||||
|
||||
if (!src_mfpict)
|
||||
return DV_E_STGMEDIUM;
|
||||
dest_stgm->u.hMetaFilePict = GlobalAlloc(GMEM_MOVEABLE, sizeof(METAFILEPICT));
|
||||
dest_mfpict = GlobalLock(dest_stgm->u.hMetaFilePict);
|
||||
dest_stgm->hMetaFilePict = GlobalAlloc(GMEM_MOVEABLE, sizeof(METAFILEPICT));
|
||||
dest_mfpict = GlobalLock(dest_stgm->hMetaFilePict);
|
||||
if (!dest_mfpict)
|
||||
{
|
||||
GlobalUnlock(src_stgm->u.hMetaFilePict);
|
||||
GlobalUnlock(src_stgm->hMetaFilePict);
|
||||
return E_OUTOFMEMORY;
|
||||
}
|
||||
*dest_mfpict = *src_mfpict;
|
||||
dest_mfpict->hMF = CopyMetaFileW(src_mfpict->hMF, NULL);
|
||||
GlobalUnlock(src_stgm->u.hMetaFilePict);
|
||||
GlobalUnlock(dest_stgm->u.hMetaFilePict);
|
||||
GlobalUnlock(src_stgm->hMetaFilePict);
|
||||
GlobalUnlock(dest_stgm->hMetaFilePict);
|
||||
}
|
||||
else if (src_stgm->tymed != TYMED_NULL)
|
||||
{
|
||||
dest_stgm->u.hGlobal = OleDuplicateData(src_stgm->u.hGlobal, cf,
|
||||
GMEM_MOVEABLE);
|
||||
if (!dest_stgm->u.hGlobal)
|
||||
dest_stgm->hGlobal = OleDuplicateData(src_stgm->hGlobal, cf, GMEM_MOVEABLE);
|
||||
if (!dest_stgm->hGlobal)
|
||||
return E_OUTOFMEMORY;
|
||||
}
|
||||
dest_stgm->tymed = src_stgm->tymed;
|
||||
|
@ -1183,12 +1180,12 @@ static HRESULT synthesize_dib( HBITMAP bm, STGMEDIUM *med )
|
|||
if (!GetDIBits( hdc, bm, 0, 0, NULL, (BITMAPINFO *)&header, DIB_RGB_COLORS )) goto done;
|
||||
|
||||
header_size = bitmap_info_size( (BITMAPINFO *)&header, DIB_RGB_COLORS );
|
||||
if (!(med->u.hGlobal = GlobalAlloc( GMEM_MOVEABLE, header_size + header.biSizeImage ))) goto done;
|
||||
bmi = GlobalLock( med->u.hGlobal );
|
||||
if (!(med->hGlobal = GlobalAlloc( GMEM_MOVEABLE, header_size + header.biSizeImage ))) goto done;
|
||||
bmi = GlobalLock( med->hGlobal );
|
||||
memset( bmi, 0, header_size );
|
||||
memcpy( bmi, &header, header.biSize );
|
||||
GetDIBits( hdc, bm, 0, abs(header.biHeight), (char *)bmi + header_size, bmi, DIB_RGB_COLORS );
|
||||
GlobalUnlock( med->u.hGlobal );
|
||||
GlobalUnlock( med->hGlobal );
|
||||
med->tymed = TYMED_HGLOBAL;
|
||||
med->pUnkForRelease = NULL;
|
||||
hr = S_OK;
|
||||
|
@ -1207,9 +1204,9 @@ static HRESULT synthesize_bitmap( HGLOBAL dib, STGMEDIUM *med )
|
|||
if ((bmi = GlobalLock( dib )))
|
||||
{
|
||||
/* FIXME: validate data size */
|
||||
med->u.hBitmap = CreateDIBitmap( hdc, &bmi->bmiHeader, CBM_INIT,
|
||||
(char *)bmi + bitmap_info_size( bmi, DIB_RGB_COLORS ),
|
||||
bmi, DIB_RGB_COLORS );
|
||||
med->hBitmap = CreateDIBitmap( hdc, &bmi->bmiHeader, CBM_INIT,
|
||||
(char *)bmi + bitmap_info_size( bmi, DIB_RGB_COLORS ),
|
||||
bmi, DIB_RGB_COLORS );
|
||||
GlobalUnlock( dib );
|
||||
med->tymed = TYMED_GDI;
|
||||
med->pUnkForRelease = NULL;
|
||||
|
@ -1240,7 +1237,7 @@ static HRESULT DataCacheEntry_SetData(DataCacheEntry *cache_entry,
|
|||
|
||||
if (formatetc->cfFormat == CF_BITMAP)
|
||||
{
|
||||
hr = synthesize_dib( stgmedium->u.hBitmap, © );
|
||||
hr = synthesize_dib( stgmedium->hBitmap, © );
|
||||
if (FAILED(hr)) return hr;
|
||||
if (fRelease) ReleaseStgMedium(stgmedium);
|
||||
stgmedium = ©
|
||||
|
@ -1248,7 +1245,7 @@ static HRESULT DataCacheEntry_SetData(DataCacheEntry *cache_entry,
|
|||
}
|
||||
else if (formatetc->cfFormat == CF_METAFILEPICT && cache_entry->fmtetc.cfFormat == CF_ENHMETAFILE)
|
||||
{
|
||||
hr = synthesize_emf( stgmedium->u.hMetaFilePict, © );
|
||||
hr = synthesize_emf( stgmedium->hMetaFilePict, © );
|
||||
if (FAILED(hr)) return hr;
|
||||
if (fRelease) ReleaseStgMedium(stgmedium);
|
||||
stgmedium = ©
|
||||
|
@ -1276,7 +1273,7 @@ static HRESULT DataCacheEntry_GetData(DataCacheEntry *cache_entry, IStorage *stg
|
|||
return OLE_E_BLANK;
|
||||
|
||||
if (fmt->cfFormat == CF_BITMAP)
|
||||
return synthesize_bitmap( cache_entry->stgmedium.u.hGlobal, stgmedium );
|
||||
return synthesize_bitmap( cache_entry->stgmedium.hGlobal, stgmedium );
|
||||
|
||||
return copy_stg_medium(cache_entry->fmtetc.cfFormat, stgmedium, &cache_entry->stgmedium);
|
||||
}
|
||||
|
@ -2069,7 +2066,7 @@ static HRESULT WINAPI DataCache_Draw(
|
|||
METAFILEPICT *mfpict;
|
||||
|
||||
if ((cache_entry->stgmedium.tymed != TYMED_MFPICT) ||
|
||||
!((mfpict = GlobalLock(cache_entry->stgmedium.u.hMetaFilePict))))
|
||||
!((mfpict = GlobalLock(cache_entry->stgmedium.hMetaFilePict))))
|
||||
continue;
|
||||
|
||||
prevMapMode = SetMapMode(hdcDraw, mfpict->mm);
|
||||
|
@ -2108,7 +2105,7 @@ static HRESULT WINAPI DataCache_Draw(
|
|||
|
||||
SetMapMode(hdcDraw, prevMapMode);
|
||||
|
||||
GlobalUnlock(cache_entry->stgmedium.u.hMetaFilePict);
|
||||
GlobalUnlock(cache_entry->stgmedium.hMetaFilePict);
|
||||
|
||||
return S_OK;
|
||||
}
|
||||
|
@ -2118,7 +2115,7 @@ static HRESULT WINAPI DataCache_Draw(
|
|||
BYTE *bits;
|
||||
|
||||
if ((cache_entry->stgmedium.tymed != TYMED_HGLOBAL) ||
|
||||
!((info = GlobalLock( cache_entry->stgmedium.u.hGlobal ))))
|
||||
!((info = GlobalLock( cache_entry->stgmedium.hGlobal ))))
|
||||
continue;
|
||||
|
||||
bits = (BYTE *) info + bitmap_info_size( info, DIB_RGB_COLORS );
|
||||
|
@ -2127,7 +2124,7 @@ static HRESULT WINAPI DataCache_Draw(
|
|||
0, 0, info->bmiHeader.biWidth, info->bmiHeader.biHeight,
|
||||
bits, info, DIB_RGB_COLORS, SRCCOPY );
|
||||
|
||||
GlobalUnlock( cache_entry->stgmedium.u.hGlobal );
|
||||
GlobalUnlock( cache_entry->stgmedium.hGlobal );
|
||||
return S_OK;
|
||||
}
|
||||
}
|
||||
|
@ -2319,13 +2316,13 @@ static HRESULT WINAPI DataCache_GetExtent(
|
|||
METAFILEPICT *mfpict;
|
||||
|
||||
if ((cache_entry->stgmedium.tymed != TYMED_MFPICT) ||
|
||||
!((mfpict = GlobalLock(cache_entry->stgmedium.u.hMetaFilePict))))
|
||||
!((mfpict = GlobalLock(cache_entry->stgmedium.hMetaFilePict))))
|
||||
continue;
|
||||
|
||||
lpsizel->cx = mfpict->xExt;
|
||||
lpsizel->cy = mfpict->yExt;
|
||||
|
||||
GlobalUnlock(cache_entry->stgmedium.u.hMetaFilePict);
|
||||
GlobalUnlock(cache_entry->stgmedium.hMetaFilePict);
|
||||
|
||||
return S_OK;
|
||||
}
|
||||
|
@ -2336,7 +2333,7 @@ static HRESULT WINAPI DataCache_GetExtent(
|
|||
|
||||
|
||||
if ((cache_entry->stgmedium.tymed != TYMED_HGLOBAL) ||
|
||||
!((info = GlobalLock( cache_entry->stgmedium.u.hGlobal ))))
|
||||
!((info = GlobalLock( cache_entry->stgmedium.hGlobal ))))
|
||||
continue;
|
||||
|
||||
x_pels_m = info->biXPelsPerMeter;
|
||||
|
@ -2357,7 +2354,7 @@ static HRESULT WINAPI DataCache_GetExtent(
|
|||
ReleaseDC( 0, hdc );
|
||||
}
|
||||
|
||||
GlobalUnlock( cache_entry->stgmedium.u.hGlobal );
|
||||
GlobalUnlock( cache_entry->stgmedium.hGlobal );
|
||||
|
||||
return S_OK;
|
||||
}
|
||||
|
|
|
@ -28,9 +28,6 @@
|
|||
#include <limits.h>
|
||||
|
||||
#define COBJMACROS
|
||||
#define NONAMELESSUNION
|
||||
#define NONAMELESSSTRUCT
|
||||
|
||||
#include "windef.h"
|
||||
#include "winbase.h"
|
||||
#include "winuser.h"
|
||||
|
@ -189,7 +186,7 @@ static HRESULT WINAPI FileLockBytesImpl_ReadAt(
|
|||
LARGE_INTEGER offset;
|
||||
ULONG cbRead;
|
||||
|
||||
TRACE("%p, %ld, %p, %lu, %p.\n", iface, ulOffset.u.LowPart, pv, cb, pcbRead);
|
||||
TRACE("%p, %ld, %p, %lu, %p.\n", iface, ulOffset.LowPart, pv, cb, pcbRead);
|
||||
|
||||
/* verify a sane environment */
|
||||
if (!This) return E_FAIL;
|
||||
|
@ -244,7 +241,7 @@ static HRESULT WINAPI FileLockBytesImpl_WriteAt(
|
|||
LARGE_INTEGER offset;
|
||||
ULONG cbWritten;
|
||||
|
||||
TRACE("%p, %ld, %p, %lu, %p.\n", iface, ulOffset.u.LowPart, pv, cb, pcbWritten);
|
||||
TRACE("%p, %ld, %p, %lu, %p.\n", iface, ulOffset.LowPart, pv, cb, pcbWritten);
|
||||
|
||||
/* verify a sane environment */
|
||||
if (!This) return E_FAIL;
|
||||
|
@ -297,7 +294,7 @@ static HRESULT WINAPI FileLockBytesImpl_SetSize(ILockBytes* iface, ULARGE_INTEGE
|
|||
HRESULT hr = S_OK;
|
||||
LARGE_INTEGER newpos;
|
||||
|
||||
TRACE("new size %lu\n", newSize.u.LowPart);
|
||||
TRACE("new size %lu\n", newSize.LowPart);
|
||||
|
||||
newpos.QuadPart = newSize.QuadPart;
|
||||
if (SetFilePointerEx(This->hfile, newpos, NULL, FILE_BEGIN))
|
||||
|
@ -328,7 +325,7 @@ static HRESULT WINAPI FileLockBytesImpl_LockRegion(ILockBytes* iface,
|
|||
OVERLAPPED ol;
|
||||
DWORD lock_flags = LOCKFILE_FAIL_IMMEDIATELY;
|
||||
|
||||
TRACE("ofs %lu count %lu flags %lx\n", libOffset.u.LowPart, cb.u.LowPart, dwLockType);
|
||||
TRACE("ofs %lu count %lu flags %lx\n", libOffset.LowPart, cb.LowPart, dwLockType);
|
||||
|
||||
if (dwLockType & LOCK_WRITE)
|
||||
return STG_E_INVALIDFUNCTION;
|
||||
|
@ -337,10 +334,10 @@ static HRESULT WINAPI FileLockBytesImpl_LockRegion(ILockBytes* iface,
|
|||
lock_flags |= LOCKFILE_EXCLUSIVE_LOCK;
|
||||
|
||||
ol.hEvent = 0;
|
||||
ol.u.s.Offset = libOffset.u.LowPart;
|
||||
ol.u.s.OffsetHigh = libOffset.u.HighPart;
|
||||
ol.Offset = libOffset.LowPart;
|
||||
ol.OffsetHigh = libOffset.HighPart;
|
||||
|
||||
if (LockFileEx(This->hfile, lock_flags, 0, cb.u.LowPart, cb.u.HighPart, &ol))
|
||||
if (LockFileEx(This->hfile, lock_flags, 0, cb.LowPart, cb.HighPart, &ol))
|
||||
return S_OK;
|
||||
return get_lock_error();
|
||||
}
|
||||
|
@ -351,16 +348,16 @@ static HRESULT WINAPI FileLockBytesImpl_UnlockRegion(ILockBytes* iface,
|
|||
FileLockBytesImpl* This = impl_from_ILockBytes(iface);
|
||||
OVERLAPPED ol;
|
||||
|
||||
TRACE("ofs %lu count %lu flags %lx\n", libOffset.u.LowPart, cb.u.LowPart, dwLockType);
|
||||
TRACE("ofs %lu count %lu flags %lx\n", libOffset.LowPart, cb.LowPart, dwLockType);
|
||||
|
||||
if (dwLockType & LOCK_WRITE)
|
||||
return STG_E_INVALIDFUNCTION;
|
||||
|
||||
ol.hEvent = 0;
|
||||
ol.u.s.Offset = libOffset.u.LowPart;
|
||||
ol.u.s.OffsetHigh = libOffset.u.HighPart;
|
||||
ol.Offset = libOffset.LowPart;
|
||||
ol.OffsetHigh = libOffset.HighPart;
|
||||
|
||||
if (UnlockFileEx(This->hfile, 0, cb.u.LowPart, cb.u.HighPart, &ol))
|
||||
if (UnlockFileEx(This->hfile, 0, cb.LowPart, cb.HighPart, &ol))
|
||||
return S_OK;
|
||||
return get_lock_error();
|
||||
}
|
||||
|
@ -382,7 +379,7 @@ static HRESULT WINAPI FileLockBytesImpl_Stat(ILockBytes* iface,
|
|||
|
||||
pstatstg->type = STGTY_LOCKBYTES;
|
||||
|
||||
pstatstg->cbSize.u.LowPart = GetFileSize(This->hfile, &pstatstg->cbSize.u.HighPart);
|
||||
pstatstg->cbSize.LowPart = GetFileSize(This->hfile, &pstatstg->cbSize.HighPart);
|
||||
/* FIXME: If the implementation is exported, we'll need to set other fields. */
|
||||
|
||||
pstatstg->grfLocksSupported = LOCK_EXCLUSIVE|LOCK_ONLYONCE|WINE_LOCK_READ;
|
||||
|
|
|
@ -24,8 +24,6 @@
|
|||
#include <string.h>
|
||||
|
||||
#define COBJMACROS
|
||||
#define NONAMELESSUNION
|
||||
|
||||
#include "windef.h"
|
||||
#include "winbase.h"
|
||||
#include "winerror.h"
|
||||
|
|
|
@ -23,8 +23,6 @@
|
|||
#include <string.h>
|
||||
|
||||
#define COBJMACROS
|
||||
#define NONAMELESSUNION
|
||||
|
||||
#include "winerror.h"
|
||||
#include "windef.h"
|
||||
#include "winbase.h"
|
||||
|
|
|
@ -24,8 +24,6 @@
|
|||
#include <string.h>
|
||||
|
||||
#define COBJMACROS
|
||||
#define NONAMELESSUNION
|
||||
|
||||
#include "windef.h"
|
||||
#include "winbase.h"
|
||||
#include "winuser.h"
|
||||
|
@ -120,8 +118,8 @@ HRESULT WINAPI CreateILockBytesOnHGlobal(HGLOBAL global, BOOL delete_on_release,
|
|||
/*
|
||||
* Initialize the size of the array to the size of the handle.
|
||||
*/
|
||||
lockbytes->byteArraySize.u.HighPart = 0;
|
||||
lockbytes->byteArraySize.u.LowPart = GlobalSize(lockbytes->supportHandle);
|
||||
lockbytes->byteArraySize.HighPart = 0;
|
||||
lockbytes->byteArraySize.LowPart = GlobalSize(lockbytes->supportHandle);
|
||||
|
||||
*ret = &lockbytes->ILockBytes_iface;
|
||||
|
||||
|
@ -164,18 +162,18 @@ HRESULT WINAPI GetHGlobalFromILockBytes(ILockBytes* iface, HGLOBAL* phglobal)
|
|||
return hres;
|
||||
}
|
||||
TRACE("cbSize is %s\n", wine_dbgstr_longlong(stbuf.cbSize.QuadPart));
|
||||
*phglobal = GlobalAlloc( GMEM_MOVEABLE|GMEM_SHARE, stbuf.cbSize.u.LowPart);
|
||||
*phglobal = GlobalAlloc( GMEM_MOVEABLE|GMEM_SHARE, stbuf.cbSize.LowPart);
|
||||
if (!*phglobal)
|
||||
return E_INVALIDARG;
|
||||
memset(&start,0,sizeof(start));
|
||||
hres = ILockBytes_ReadAt(iface, start, GlobalLock(*phglobal), stbuf.cbSize.u.LowPart, &xread);
|
||||
hres = ILockBytes_ReadAt(iface, start, GlobalLock(*phglobal), stbuf.cbSize.LowPart, &xread);
|
||||
GlobalUnlock(*phglobal);
|
||||
if (hres != S_OK) {
|
||||
FIXME("%p->ReadAt failed with %lx\n",iface,hres);
|
||||
return hres;
|
||||
}
|
||||
if (stbuf.cbSize.u.LowPart != xread) {
|
||||
FIXME("Read size is not requested size %ld vs %ld?\n",stbuf.cbSize.u.LowPart, xread);
|
||||
if (stbuf.cbSize.LowPart != xread) {
|
||||
FIXME("Read size is not requested size %ld vs %ld?\n",stbuf.cbSize.LowPart, xread);
|
||||
}
|
||||
return S_OK;
|
||||
}
|
||||
|
@ -279,15 +277,14 @@ static HRESULT WINAPI HGLOBALLockBytesImpl_ReadAt(
|
|||
/*
|
||||
* Make sure the offset is valid.
|
||||
*/
|
||||
if (ulOffset.u.LowPart > This->byteArraySize.u.LowPart)
|
||||
if (ulOffset.LowPart > This->byteArraySize.LowPart)
|
||||
return E_FAIL;
|
||||
|
||||
/*
|
||||
* Using the known size of the array, calculate the number of bytes
|
||||
* to read.
|
||||
*/
|
||||
bytesToReadFromBuffer = min(This->byteArraySize.u.LowPart -
|
||||
ulOffset.u.LowPart, cb);
|
||||
bytesToReadFromBuffer = min(This->byteArraySize.LowPart - ulOffset.LowPart, cb);
|
||||
|
||||
/*
|
||||
* Lock the buffer in position and copy the data.
|
||||
|
@ -295,7 +292,7 @@ static HRESULT WINAPI HGLOBALLockBytesImpl_ReadAt(
|
|||
supportBuffer = GlobalLock(This->supportHandle);
|
||||
|
||||
memcpy(pv,
|
||||
(char *) supportBuffer + ulOffset.u.LowPart,
|
||||
(char *) supportBuffer + ulOffset.LowPart,
|
||||
bytesToReadFromBuffer);
|
||||
|
||||
/*
|
||||
|
@ -354,14 +351,14 @@ static HRESULT WINAPI HGLOBALLockBytesImpl_WriteAt(
|
|||
}
|
||||
else
|
||||
{
|
||||
newSize.u.HighPart = 0;
|
||||
newSize.u.LowPart = ulOffset.u.LowPart + cb;
|
||||
newSize.HighPart = 0;
|
||||
newSize.LowPart = ulOffset.LowPart + cb;
|
||||
}
|
||||
|
||||
/*
|
||||
* Verify if we need to grow the stream
|
||||
*/
|
||||
if (newSize.u.LowPart > This->byteArraySize.u.LowPart)
|
||||
if (newSize.LowPart > This->byteArraySize.LowPart)
|
||||
{
|
||||
/* grow stream */
|
||||
if (ILockBytes_SetSize(iface, newSize) == STG_E_MEDIUMFULL)
|
||||
|
@ -373,7 +370,7 @@ static HRESULT WINAPI HGLOBALLockBytesImpl_WriteAt(
|
|||
*/
|
||||
supportBuffer = GlobalLock(This->supportHandle);
|
||||
|
||||
memcpy((char *) supportBuffer + ulOffset.u.LowPart, pv, cb);
|
||||
memcpy((char *) supportBuffer + ulOffset.LowPart, pv, cb);
|
||||
|
||||
/*
|
||||
* Return the number of bytes written.
|
||||
|
@ -415,22 +412,22 @@ static HRESULT WINAPI HGLOBALLockBytesImpl_SetSize(
|
|||
/*
|
||||
* As documented.
|
||||
*/
|
||||
if (libNewSize.u.HighPart != 0)
|
||||
if (libNewSize.HighPart != 0)
|
||||
return STG_E_INVALIDFUNCTION;
|
||||
|
||||
if (This->byteArraySize.u.LowPart == libNewSize.u.LowPart)
|
||||
if (This->byteArraySize.LowPart == libNewSize.LowPart)
|
||||
return S_OK;
|
||||
|
||||
/*
|
||||
* Re allocate the HGlobal to fit the new size of the stream.
|
||||
*/
|
||||
supportHandle = GlobalReAlloc(This->supportHandle, libNewSize.u.LowPart, GMEM_MOVEABLE);
|
||||
supportHandle = GlobalReAlloc(This->supportHandle, libNewSize.LowPart, GMEM_MOVEABLE);
|
||||
|
||||
if (supportHandle == 0)
|
||||
return STG_E_MEDIUMFULL;
|
||||
|
||||
This->supportHandle = supportHandle;
|
||||
This->byteArraySize.u.LowPart = libNewSize.u.LowPart;
|
||||
This->byteArraySize.LowPart = libNewSize.LowPart;
|
||||
|
||||
return S_OK;
|
||||
}
|
||||
|
|
|
@ -31,8 +31,6 @@
|
|||
#include <string.h>
|
||||
|
||||
#define COBJMACROS
|
||||
#define NONAMELESSUNION
|
||||
|
||||
#include "windef.h"
|
||||
#include "winbase.h"
|
||||
#include "winerror.h"
|
||||
|
@ -2010,64 +2008,64 @@ void WINAPI ReleaseStgMedium(
|
|||
case TYMED_HGLOBAL:
|
||||
{
|
||||
if ( (pmedium->pUnkForRelease==0) &&
|
||||
(pmedium->u.hGlobal!=0) )
|
||||
GlobalFree(pmedium->u.hGlobal);
|
||||
(pmedium->hGlobal!=0) )
|
||||
GlobalFree(pmedium->hGlobal);
|
||||
break;
|
||||
}
|
||||
case TYMED_FILE:
|
||||
{
|
||||
if (pmedium->u.lpszFileName!=0)
|
||||
if (pmedium->lpszFileName!=0)
|
||||
{
|
||||
if (pmedium->pUnkForRelease==0)
|
||||
{
|
||||
DeleteFileW(pmedium->u.lpszFileName);
|
||||
DeleteFileW(pmedium->lpszFileName);
|
||||
}
|
||||
|
||||
CoTaskMemFree(pmedium->u.lpszFileName);
|
||||
CoTaskMemFree(pmedium->lpszFileName);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case TYMED_ISTREAM:
|
||||
{
|
||||
if (pmedium->u.pstm!=0)
|
||||
if (pmedium->pstm!=0)
|
||||
{
|
||||
IStream_Release(pmedium->u.pstm);
|
||||
IStream_Release(pmedium->pstm);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case TYMED_ISTORAGE:
|
||||
{
|
||||
if (pmedium->u.pstg!=0)
|
||||
if (pmedium->pstg!=0)
|
||||
{
|
||||
IStorage_Release(pmedium->u.pstg);
|
||||
IStorage_Release(pmedium->pstg);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case TYMED_GDI:
|
||||
{
|
||||
if ( (pmedium->pUnkForRelease==0) &&
|
||||
(pmedium->u.hBitmap!=0) )
|
||||
DeleteObject(pmedium->u.hBitmap);
|
||||
(pmedium->hBitmap!=0) )
|
||||
DeleteObject(pmedium->hBitmap);
|
||||
break;
|
||||
}
|
||||
case TYMED_MFPICT:
|
||||
{
|
||||
if ( (pmedium->pUnkForRelease==0) &&
|
||||
(pmedium->u.hMetaFilePict!=0) )
|
||||
(pmedium->hMetaFilePict!=0) )
|
||||
{
|
||||
LPMETAFILEPICT pMP = GlobalLock(pmedium->u.hMetaFilePict);
|
||||
LPMETAFILEPICT pMP = GlobalLock(pmedium->hMetaFilePict);
|
||||
DeleteMetaFile(pMP->hMF);
|
||||
GlobalUnlock(pmedium->u.hMetaFilePict);
|
||||
GlobalFree(pmedium->u.hMetaFilePict);
|
||||
GlobalUnlock(pmedium->hMetaFilePict);
|
||||
GlobalFree(pmedium->hMetaFilePict);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case TYMED_ENHMF:
|
||||
{
|
||||
if ( (pmedium->pUnkForRelease==0) &&
|
||||
(pmedium->u.hEnhMetaFile!=0) )
|
||||
(pmedium->hEnhMetaFile!=0) )
|
||||
{
|
||||
DeleteEnhMetaFile(pmedium->u.hEnhMetaFile);
|
||||
DeleteEnhMetaFile(pmedium->hEnhMetaFile);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
@ -2782,7 +2780,7 @@ static HRESULT get_storage(IDataObject *data, IStorage *stg, UINT *src_cf, BOOL
|
|||
/* CF_EMBEDEDOBJECT */
|
||||
init_fmtetc(&fmt, embedded_object_clipboard_format, TYMED_ISTORAGE);
|
||||
med.tymed = TYMED_ISTORAGE;
|
||||
med.u.pstg = stg;
|
||||
med.pstg = stg;
|
||||
med.pUnkForRelease = NULL;
|
||||
hr = IDataObject_GetDataHere(data, &fmt, &med);
|
||||
if(SUCCEEDED(hr))
|
||||
|
@ -2794,7 +2792,7 @@ static HRESULT get_storage(IDataObject *data, IStorage *stg, UINT *src_cf, BOOL
|
|||
/* CF_EMBEDSOURCE */
|
||||
init_fmtetc(&fmt, embed_source_clipboard_format, TYMED_ISTORAGE);
|
||||
med.tymed = TYMED_ISTORAGE;
|
||||
med.u.pstg = stg;
|
||||
med.pstg = stg;
|
||||
med.pUnkForRelease = NULL;
|
||||
hr = IDataObject_GetDataHere(data, &fmt, &med);
|
||||
if(SUCCEEDED(hr))
|
||||
|
|
|
@ -24,8 +24,6 @@
|
|||
#include <string.h>
|
||||
|
||||
#define COBJMACROS
|
||||
#define NONAMELESSUNION
|
||||
|
||||
#include "windef.h"
|
||||
#include "winbase.h"
|
||||
#include "winuser.h"
|
||||
|
@ -767,7 +765,7 @@ static HRESULT WINAPI DataAdviseHolder_SendOnDataChange(IDataAdviseHolder *iface
|
|||
{
|
||||
STGMEDIUM stg;
|
||||
stg.tymed = TYMED_NULL;
|
||||
stg.u.pstg = NULL;
|
||||
stg.pstg = NULL;
|
||||
stg.pUnkForRelease = NULL;
|
||||
|
||||
if(!(statdata.advf & ADVF_NODATA))
|
||||
|
|
|
@ -23,8 +23,6 @@
|
|||
#include <string.h>
|
||||
|
||||
#define COBJMACROS
|
||||
#define NONAMELESSUNION
|
||||
|
||||
#include "windef.h"
|
||||
#include "winbase.h"
|
||||
#include "winerror.h"
|
||||
|
|
|
@ -44,8 +44,6 @@
|
|||
#include <string.h>
|
||||
|
||||
#define COBJMACROS
|
||||
#define NONAMELESSUNION
|
||||
|
||||
#include "windef.h"
|
||||
#include "winbase.h"
|
||||
#include "winnls.h"
|
||||
|
@ -499,7 +497,7 @@ static HRESULT WINAPI IPropertyStorage_fnReadMultiple(
|
|||
if (rgpspec[i].ulKind == PRSPEC_LPWSTR)
|
||||
{
|
||||
PROPVARIANT *prop = PropertyStorage_FindPropertyByName(This,
|
||||
rgpspec[i].u.lpwstr);
|
||||
rgpspec[i].lpwstr);
|
||||
|
||||
if (prop)
|
||||
PropertyStorage_PropVariantCopy(&rgpropvar[i], prop, GetACP(),
|
||||
|
@ -507,7 +505,7 @@ static HRESULT WINAPI IPropertyStorage_fnReadMultiple(
|
|||
}
|
||||
else
|
||||
{
|
||||
switch (rgpspec[i].u.propid)
|
||||
switch (rgpspec[i].propid)
|
||||
{
|
||||
case PID_CODEPAGE:
|
||||
rgpropvar[i].vt = VT_I2;
|
||||
|
@ -520,7 +518,7 @@ static HRESULT WINAPI IPropertyStorage_fnReadMultiple(
|
|||
default:
|
||||
{
|
||||
PROPVARIANT *prop = PropertyStorage_FindProperty(This,
|
||||
rgpspec[i].u.propid);
|
||||
rgpspec[i].propid);
|
||||
|
||||
if (prop)
|
||||
PropertyStorage_PropVariantCopy(&rgpropvar[i], prop,
|
||||
|
@ -765,7 +763,7 @@ static HRESULT WINAPI IPropertyStorage_fnWriteMultiple(
|
|||
if (rgpspec[i].ulKind == PRSPEC_LPWSTR)
|
||||
{
|
||||
PROPVARIANT *prop = PropertyStorage_FindPropertyByName(This,
|
||||
rgpspec[i].u.lpwstr);
|
||||
rgpspec[i].lpwstr);
|
||||
|
||||
if (prop)
|
||||
PropVariantCopy(prop, &rgpropvar[i]);
|
||||
|
@ -782,7 +780,7 @@ static HRESULT WINAPI IPropertyStorage_fnWriteMultiple(
|
|||
PROPID nextId = max(propidNameFirst, This->highestProp + 1);
|
||||
|
||||
hr = PropertyStorage_StoreNameWithId(This,
|
||||
(LPCSTR)rgpspec[i].u.lpwstr, CP_UNICODE, nextId);
|
||||
(LPCSTR)rgpspec[i].lpwstr, CP_UNICODE, nextId);
|
||||
if (SUCCEEDED(hr))
|
||||
hr = PropertyStorage_StorePropWithId(This, nextId,
|
||||
&rgpropvar[i], GetACP());
|
||||
|
@ -791,7 +789,7 @@ static HRESULT WINAPI IPropertyStorage_fnWriteMultiple(
|
|||
}
|
||||
else
|
||||
{
|
||||
switch (rgpspec[i].u.propid)
|
||||
switch (rgpspec[i].propid)
|
||||
{
|
||||
case PID_DICTIONARY:
|
||||
/* Can't set the dictionary */
|
||||
|
@ -823,11 +821,11 @@ static HRESULT WINAPI IPropertyStorage_fnWriteMultiple(
|
|||
/* silently ignore like MSDN says */
|
||||
break;
|
||||
default:
|
||||
if (rgpspec[i].u.propid >= PID_MIN_READONLY)
|
||||
if (rgpspec[i].propid >= PID_MIN_READONLY)
|
||||
hr = STG_E_INVALIDPARAMETER;
|
||||
else
|
||||
hr = PropertyStorage_StorePropWithId(This,
|
||||
rgpspec[i].u.propid, &rgpropvar[i], GetACP());
|
||||
rgpspec[i].propid, &rgpropvar[i], GetACP());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -864,14 +862,14 @@ static HRESULT WINAPI IPropertyStorage_fnDeleteMultiple(
|
|||
{
|
||||
void *propid;
|
||||
|
||||
if (dictionary_find(This->name_to_propid, rgpspec[i].u.lpwstr, &propid))
|
||||
if (dictionary_find(This->name_to_propid, rgpspec[i].lpwstr, &propid))
|
||||
dictionary_remove(This->propid_to_prop, propid);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (rgpspec[i].u.propid >= PID_FIRST_USABLE &&
|
||||
rgpspec[i].u.propid < PID_MIN_READONLY)
|
||||
dictionary_remove(This->propid_to_prop, UlongToPtr(rgpspec[i].u.propid));
|
||||
if (rgpspec[i].propid >= PID_FIRST_USABLE &&
|
||||
rgpspec[i].propid < PID_MIN_READONLY)
|
||||
dictionary_remove(This->propid_to_prop, UlongToPtr(rgpspec[i].propid));
|
||||
else
|
||||
hr = STG_E_INVALIDPARAMETER;
|
||||
}
|
||||
|
@ -1746,20 +1744,20 @@ static HRESULT PropertyStorage_ReadFromStream(PropertyStorage_impl *This)
|
|||
hr = IStream_Stat(This->stm, &stat, STATFLAG_NONAME);
|
||||
if (FAILED(hr))
|
||||
goto end;
|
||||
if (stat.cbSize.u.HighPart)
|
||||
if (stat.cbSize.HighPart)
|
||||
{
|
||||
WARN("stream too big\n");
|
||||
/* maximum size varies, but it can't be this big */
|
||||
hr = STG_E_INVALIDHEADER;
|
||||
goto end;
|
||||
}
|
||||
if (stat.cbSize.u.LowPart == 0)
|
||||
if (stat.cbSize.LowPart == 0)
|
||||
{
|
||||
/* empty stream is okay */
|
||||
hr = S_OK;
|
||||
goto end;
|
||||
}
|
||||
else if (stat.cbSize.u.LowPart < sizeof(PROPERTYSETHEADER) +
|
||||
else if (stat.cbSize.LowPart < sizeof(PROPERTYSETHEADER) +
|
||||
sizeof(FORMATIDOFFSET))
|
||||
{
|
||||
WARN("stream too small\n");
|
||||
|
@ -1794,9 +1792,9 @@ static HRESULT PropertyStorage_ReadFromStream(PropertyStorage_impl *This)
|
|||
hr = PropertyStorage_ReadFmtIdOffsetFromStream(This->stm, &fmtOffset);
|
||||
if (FAILED(hr))
|
||||
goto end;
|
||||
if (fmtOffset.dwOffset > stat.cbSize.u.LowPart)
|
||||
if (fmtOffset.dwOffset > stat.cbSize.LowPart)
|
||||
{
|
||||
WARN("invalid offset %ld (stream length is %ld)\n", fmtOffset.dwOffset, stat.cbSize.u.LowPart);
|
||||
WARN("invalid offset %ld (stream length is %ld)\n", fmtOffset.dwOffset, stat.cbSize.LowPart);
|
||||
hr = STG_E_INVALIDHEADER;
|
||||
goto end;
|
||||
}
|
||||
|
|
|
@ -29,8 +29,6 @@
|
|||
#include <string.h>
|
||||
|
||||
#define COBJMACROS
|
||||
#define NONAMELESSUNION
|
||||
|
||||
#include "windef.h"
|
||||
#include "winbase.h"
|
||||
#include "winerror.h"
|
||||
|
@ -272,7 +270,7 @@ static HRESULT WINAPI StgStreamImpl_Seek(
|
|||
DirEntry currentEntry;
|
||||
HRESULT hr;
|
||||
|
||||
TRACE("%p, %ld, %ld, %p.\n", iface, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
|
||||
TRACE("%p, %ld, %ld, %p.\n", iface, dlibMove.LowPart, dwOrigin, plibNewPosition);
|
||||
|
||||
/*
|
||||
* fail if the stream has no parent (as does windows)
|
||||
|
@ -342,7 +340,7 @@ static HRESULT WINAPI StgStreamImpl_SetSize(
|
|||
|
||||
HRESULT hr;
|
||||
|
||||
TRACE("%p, %ld.\n", iface, libNewSize.u.LowPart);
|
||||
TRACE("%p, %ld.\n", iface, libNewSize.LowPart);
|
||||
|
||||
if(!This->parentStorage)
|
||||
{
|
||||
|
@ -353,9 +351,9 @@ static HRESULT WINAPI StgStreamImpl_SetSize(
|
|||
/*
|
||||
* As documented.
|
||||
*/
|
||||
if (libNewSize.u.HighPart != 0)
|
||||
if (libNewSize.HighPart != 0)
|
||||
{
|
||||
WARN("invalid value for libNewSize.u.HighPart %ld\n", libNewSize.u.HighPart);
|
||||
WARN("invalid value for libNewSize.HighPart %ld\n", libNewSize.HighPart);
|
||||
return STG_E_INVALIDFUNCTION;
|
||||
}
|
||||
|
||||
|
@ -397,7 +395,7 @@ static HRESULT WINAPI StgStreamImpl_CopyTo(
|
|||
ULARGE_INTEGER totalBytesRead;
|
||||
ULARGE_INTEGER totalBytesWritten;
|
||||
|
||||
TRACE("%p, %p, %ld, %p, %p.\n", iface, pstm, cb.u.LowPart, pcbRead, pcbWritten);
|
||||
TRACE("%p, %p, %ld, %p, %p.\n", iface, pstm, cb.LowPart, pcbRead, pcbWritten);
|
||||
|
||||
/*
|
||||
* Sanity check
|
||||
|
@ -420,7 +418,7 @@ static HRESULT WINAPI StgStreamImpl_CopyTo(
|
|||
if ( cb.QuadPart >= sizeof(tmpBuffer) )
|
||||
copySize = sizeof(tmpBuffer);
|
||||
else
|
||||
copySize = cb.u.LowPart;
|
||||
copySize = cb.LowPart;
|
||||
|
||||
IStream_Read(iface, tmpBuffer, copySize, &bytesRead);
|
||||
|
||||
|
@ -696,8 +694,8 @@ StgStreamImpl* StgStreamImpl_Construct(
|
|||
/*
|
||||
* Start the stream at the beginning.
|
||||
*/
|
||||
newStream->currentPosition.u.HighPart = 0;
|
||||
newStream->currentPosition.u.LowPart = 0;
|
||||
newStream->currentPosition.HighPart = 0;
|
||||
newStream->currentPosition.LowPart = 0;
|
||||
|
||||
/* add us to the storage's list of active streams */
|
||||
StorageBaseImpl_AddStream(parentStorage, newStream);
|
||||
|
|
|
@ -37,8 +37,6 @@
|
|||
#include <string.h>
|
||||
|
||||
#define COBJMACROS
|
||||
#define NONAMELESSUNION
|
||||
|
||||
#include "windef.h"
|
||||
#include "winbase.h"
|
||||
#include "winnls.h"
|
||||
|
@ -1823,7 +1821,7 @@ static HRESULT WINAPI StorageBaseImpl_Stat(
|
|||
end:
|
||||
if (res == S_OK)
|
||||
{
|
||||
TRACE("<-- STATSTG: pwcsName: %s, type: %ld, cbSize.Low/High: %ld/%ld, grfMode: %#lx, grfLocksSupported: %ld, grfStateBits: %#lx\n", debugstr_w(pstatstg->pwcsName), pstatstg->type, pstatstg->cbSize.u.LowPart, pstatstg->cbSize.u.HighPart, pstatstg->grfMode, pstatstg->grfLocksSupported, pstatstg->grfStateBits);
|
||||
TRACE("<-- STATSTG: pwcsName: %s, type: %ld, cbSize.Low/High: %ld/%ld, grfMode: %#lx, grfLocksSupported: %ld, grfStateBits: %#lx\n", debugstr_w(pstatstg->pwcsName), pstatstg->type, pstatstg->cbSize.LowPart, pstatstg->cbSize.HighPart, pstatstg->grfMode, pstatstg->grfLocksSupported, pstatstg->grfStateBits);
|
||||
}
|
||||
TRACE("<-- %#lx\n", res);
|
||||
return res;
|
||||
|
@ -2010,8 +2008,8 @@ static HRESULT WINAPI StorageBaseImpl_CreateStream(
|
|||
|
||||
newStreamEntry.stgType = STGTY_STREAM;
|
||||
newStreamEntry.startingBlock = BLOCK_END_OF_CHAIN;
|
||||
newStreamEntry.size.u.LowPart = 0;
|
||||
newStreamEntry.size.u.HighPart = 0;
|
||||
newStreamEntry.size.LowPart = 0;
|
||||
newStreamEntry.size.HighPart = 0;
|
||||
|
||||
newStreamEntry.leftChild = DIRENTRY_NULL;
|
||||
newStreamEntry.rightChild = DIRENTRY_NULL;
|
||||
|
@ -2205,8 +2203,8 @@ static HRESULT WINAPI StorageBaseImpl_CreateStorage(
|
|||
|
||||
newEntry.stgType = STGTY_STORAGE;
|
||||
newEntry.startingBlock = BLOCK_END_OF_CHAIN;
|
||||
newEntry.size.u.LowPart = 0;
|
||||
newEntry.size.u.HighPart = 0;
|
||||
newEntry.size.LowPart = 0;
|
||||
newEntry.size.HighPart = 0;
|
||||
|
||||
newEntry.leftChild = DIRENTRY_NULL;
|
||||
newEntry.rightChild = DIRENTRY_NULL;
|
||||
|
@ -2521,8 +2519,8 @@ static HRESULT deleteStreamContents(
|
|||
}
|
||||
}
|
||||
|
||||
size.u.HighPart = 0;
|
||||
size.u.LowPart = 0;
|
||||
size.HighPart = 0;
|
||||
size.LowPart = 0;
|
||||
|
||||
hr = IStorage_OpenStream(&parentStorage->IStorage_iface,
|
||||
entryDataToDelete.name, NULL, STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, &pis);
|
||||
|
@ -2893,8 +2891,8 @@ static HRESULT StorageImpl_LoadFileHeader(
|
|||
/*
|
||||
* Get a pointer to the big block of data containing the header.
|
||||
*/
|
||||
offset.u.HighPart = 0;
|
||||
offset.u.LowPart = 0;
|
||||
offset.HighPart = 0;
|
||||
offset.LowPart = 0;
|
||||
hr = StorageImpl_ReadAt(This, offset, headerBigBlock, HEADER_SIZE, &bytes_read);
|
||||
if (SUCCEEDED(hr) && bytes_read != HEADER_SIZE)
|
||||
hr = STG_E_FILENOTFOUND;
|
||||
|
@ -3265,12 +3263,12 @@ static void UpdateRawDirEntry(BYTE *buffer, const DirEntry *newData)
|
|||
StorageUtl_WriteDWord(
|
||||
buffer,
|
||||
OFFSET_PS_SIZE,
|
||||
newData->size.u.LowPart);
|
||||
newData->size.LowPart);
|
||||
|
||||
StorageUtl_WriteDWord(
|
||||
buffer,
|
||||
OFFSET_PS_SIZE_HIGH,
|
||||
newData->size.u.HighPart);
|
||||
newData->size.HighPart);
|
||||
}
|
||||
|
||||
/***************************************************************************
|
||||
|
@ -3464,19 +3462,19 @@ static HRESULT StorageImpl_ReadDirEntry(
|
|||
StorageUtl_ReadDWord(
|
||||
currentEntry,
|
||||
OFFSET_PS_SIZE,
|
||||
&buffer->size.u.LowPart);
|
||||
&buffer->size.LowPart);
|
||||
|
||||
if (This->bigBlockSize < 4096)
|
||||
{
|
||||
/* Version 3 files may have junk in the high part of size. */
|
||||
buffer->size.u.HighPart = 0;
|
||||
buffer->size.HighPart = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
StorageUtl_ReadDWord(
|
||||
currentEntry,
|
||||
OFFSET_PS_SIZE_HIGH,
|
||||
&buffer->size.u.HighPart);
|
||||
&buffer->size.HighPart);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -3623,8 +3621,8 @@ static BlockChainStream* Storage32Impl_SmallBlocksToBigBlocks(
|
|||
* Copy the contents of the small block chain to the big block chain
|
||||
* by small block size increments.
|
||||
*/
|
||||
offset.u.LowPart = 0;
|
||||
offset.u.HighPart = 0;
|
||||
offset.LowPart = 0;
|
||||
offset.HighPart = 0;
|
||||
cbTotalRead.QuadPart = 0;
|
||||
|
||||
buffer = HeapAlloc(GetProcessHeap(),0,DEF_SMALL_BLOCK_SIZE);
|
||||
|
@ -3632,7 +3630,7 @@ static BlockChainStream* Storage32Impl_SmallBlocksToBigBlocks(
|
|||
{
|
||||
resRead = SmallBlockChainStream_ReadAt(*ppsbChain,
|
||||
offset,
|
||||
min(This->smallBlockSize, size.u.LowPart - offset.u.LowPart),
|
||||
min(This->smallBlockSize, size.LowPart - offset.LowPart),
|
||||
buffer,
|
||||
&cbRead);
|
||||
if (FAILED(resRead))
|
||||
|
@ -3651,7 +3649,7 @@ static BlockChainStream* Storage32Impl_SmallBlocksToBigBlocks(
|
|||
if (FAILED(resWrite))
|
||||
break;
|
||||
|
||||
offset.u.LowPart += cbRead;
|
||||
offset.LowPart += cbRead;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -3661,8 +3659,8 @@ static BlockChainStream* Storage32Impl_SmallBlocksToBigBlocks(
|
|||
} while (cbTotalRead.QuadPart < size.QuadPart);
|
||||
HeapFree(GetProcessHeap(),0,buffer);
|
||||
|
||||
size.u.HighPart = 0;
|
||||
size.u.LowPart = 0;
|
||||
size.HighPart = 0;
|
||||
size.LowPart = 0;
|
||||
|
||||
if (FAILED(resRead) || FAILED(resWrite))
|
||||
{
|
||||
|
@ -3733,14 +3731,14 @@ static SmallBlockChainStream* Storage32Impl_BigBlocksToSmallBlocks(
|
|||
size = BlockChainStream_GetSize(*ppbbChain);
|
||||
size.QuadPart = min(size.QuadPart, newSize.QuadPart);
|
||||
|
||||
offset.u.HighPart = 0;
|
||||
offset.u.LowPart = 0;
|
||||
offset.HighPart = 0;
|
||||
offset.LowPart = 0;
|
||||
cbTotalRead.QuadPart = 0;
|
||||
buffer = HeapAlloc(GetProcessHeap(), 0, This->bigBlockSize);
|
||||
while(cbTotalRead.QuadPart < size.QuadPart)
|
||||
{
|
||||
resRead = BlockChainStream_ReadAt(*ppbbChain, offset,
|
||||
min(This->bigBlockSize, size.u.LowPart - offset.u.LowPart),
|
||||
min(This->bigBlockSize, size.LowPart - offset.LowPart),
|
||||
buffer, &cbRead);
|
||||
|
||||
if(FAILED(resRead))
|
||||
|
@ -3756,7 +3754,7 @@ static SmallBlockChainStream* Storage32Impl_BigBlocksToSmallBlocks(
|
|||
if(FAILED(resWrite))
|
||||
break;
|
||||
|
||||
offset.u.LowPart += cbRead;
|
||||
offset.LowPart += cbRead;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -3766,8 +3764,8 @@ static SmallBlockChainStream* Storage32Impl_BigBlocksToSmallBlocks(
|
|||
}
|
||||
HeapFree(GetProcessHeap(), 0, buffer);
|
||||
|
||||
size.u.HighPart = 0;
|
||||
size.u.LowPart = 0;
|
||||
size.HighPart = 0;
|
||||
size.LowPart = 0;
|
||||
|
||||
if(FAILED(resRead) || FAILED(resWrite))
|
||||
{
|
||||
|
@ -4628,8 +4626,8 @@ static HRESULT StorageImpl_Refresh(StorageImpl *This, BOOL new_object, BOOL crea
|
|||
/*
|
||||
* Add one block for the big block depot and one block for the directory table
|
||||
*/
|
||||
size.u.HighPart = 0;
|
||||
size.u.LowPart = This->bigBlockSize * 3;
|
||||
size.HighPart = 0;
|
||||
size.LowPart = This->bigBlockSize * 3;
|
||||
ILockBytes_SetSize(This->lockBytes, size);
|
||||
|
||||
/*
|
||||
|
@ -4737,8 +4735,8 @@ static HRESULT StorageImpl_Refresh(StorageImpl *This, BOOL new_object, BOOL crea
|
|||
rootEntry.rightChild = DIRENTRY_NULL;
|
||||
rootEntry.dirRootEntry = DIRENTRY_NULL;
|
||||
rootEntry.startingBlock = BLOCK_END_OF_CHAIN;
|
||||
rootEntry.size.u.HighPart = 0;
|
||||
rootEntry.size.u.LowPart = 0;
|
||||
rootEntry.size.HighPart = 0;
|
||||
rootEntry.size.LowPart = 0;
|
||||
|
||||
StorageImpl_WriteDirEntry(This, 0, &rootEntry);
|
||||
}
|
||||
|
@ -4811,8 +4809,8 @@ static HRESULT StorageImpl_GetTransactionSig(StorageBaseImpl *base,
|
|||
ULONG bytes_read;
|
||||
BYTE data[4];
|
||||
|
||||
offset.u.HighPart = 0;
|
||||
offset.u.LowPart = OFFSET_TRANSACTIONSIG;
|
||||
offset.HighPart = 0;
|
||||
offset.LowPart = OFFSET_TRANSACTIONSIG;
|
||||
hr = StorageImpl_ReadAt(This, offset, data, 4, &bytes_read);
|
||||
|
||||
if (SUCCEEDED(hr))
|
||||
|
@ -6938,8 +6936,8 @@ void StorageUtl_ReadULargeInteger(const BYTE* buffer, ULONG offset,
|
|||
ULARGE_INTEGER tmp;
|
||||
|
||||
memcpy(&tmp, buffer + offset, sizeof(ULARGE_INTEGER));
|
||||
value->u.LowPart = htole32(tmp.u.HighPart);
|
||||
value->u.HighPart = htole32(tmp.u.LowPart);
|
||||
value->u.LowPart = htole32(tmp.HighPart);
|
||||
value->u.HighPart = htole32(tmp.LowPart);
|
||||
#else
|
||||
memcpy(value, buffer + offset, sizeof(ULARGE_INTEGER));
|
||||
#endif
|
||||
|
@ -6950,8 +6948,8 @@ void StorageUtl_WriteULargeInteger(void *buffer, ULONG offset, const ULARGE_INTE
|
|||
#ifdef WORDS_BIGENDIAN
|
||||
ULARGE_INTEGER tmp;
|
||||
|
||||
tmp.u.LowPart = htole32(value->u.HighPart);
|
||||
tmp.u.HighPart = htole32(value->u.LowPart);
|
||||
tmp.LowPart = htole32(value->u.HighPart);
|
||||
tmp.HighPart = htole32(value->u.LowPart);
|
||||
memcpy((BYTE *)buffer + offset, &tmp, sizeof(ULARGE_INTEGER));
|
||||
#else
|
||||
memcpy((BYTE *)buffer + offset, value, sizeof(ULARGE_INTEGER));
|
||||
|
@ -7579,7 +7577,7 @@ HRESULT BlockChainStream_ReadAt(BlockChainStream* This,
|
|||
HRESULT hr;
|
||||
BlockChainBlock *cachedBlock;
|
||||
|
||||
TRACE("%p, %li, %p, %lu, %p.\n",This, offset.u.LowPart, buffer, size, bytesRead);
|
||||
TRACE("%p, %li, %p, %lu, %p.\n",This, offset.LowPart, buffer, size, bytesRead);
|
||||
|
||||
/*
|
||||
* Find the first block in the stream that contains part of the buffer.
|
||||
|
@ -7904,7 +7902,7 @@ static ULONG SmallBlockChainStream_GetNextFreeBlock(
|
|||
ULONG blocksRequired;
|
||||
ULARGE_INTEGER old_size, size_required;
|
||||
|
||||
offsetOfBlockInDepot.u.HighPart = 0;
|
||||
offsetOfBlockInDepot.HighPart = 0;
|
||||
|
||||
/*
|
||||
* Scan the small block depot for a free block
|
||||
|
@ -8007,9 +8005,9 @@ HRESULT SmallBlockChainStream_ReadAt(
|
|||
HRESULT rc = S_OK;
|
||||
ULARGE_INTEGER offsetInBigBlockFile;
|
||||
ULONG blockNoInSequence =
|
||||
offset.u.LowPart / This->parentStorage->smallBlockSize;
|
||||
offset.LowPart / This->parentStorage->smallBlockSize;
|
||||
|
||||
ULONG offsetInBlock = offset.u.LowPart % This->parentStorage->smallBlockSize;
|
||||
ULONG offsetInBlock = offset.LowPart % This->parentStorage->smallBlockSize;
|
||||
ULONG bytesToReadInBuffer;
|
||||
ULONG blockIndex;
|
||||
ULONG bytesReadFromBigBlockFile;
|
||||
|
@ -8019,7 +8017,7 @@ HRESULT SmallBlockChainStream_ReadAt(
|
|||
/*
|
||||
* This should never happen on a small block file.
|
||||
*/
|
||||
assert(offset.u.HighPart==0);
|
||||
assert(offset.HighPart==0);
|
||||
|
||||
*bytesRead = 0;
|
||||
|
||||
|
@ -8111,9 +8109,9 @@ HRESULT SmallBlockChainStream_WriteAt(
|
|||
{
|
||||
ULARGE_INTEGER offsetInBigBlockFile;
|
||||
ULONG blockNoInSequence =
|
||||
offset.u.LowPart / This->parentStorage->smallBlockSize;
|
||||
offset.LowPart / This->parentStorage->smallBlockSize;
|
||||
|
||||
ULONG offsetInBlock = offset.u.LowPart % This->parentStorage->smallBlockSize;
|
||||
ULONG offsetInBlock = offset.LowPart % This->parentStorage->smallBlockSize;
|
||||
ULONG bytesToWriteInBuffer;
|
||||
ULONG blockIndex;
|
||||
ULONG bytesWrittenToBigBlockFile;
|
||||
|
@ -8123,7 +8121,7 @@ HRESULT SmallBlockChainStream_WriteAt(
|
|||
/*
|
||||
* This should never happen on a small block file.
|
||||
*/
|
||||
assert(offset.u.HighPart==0);
|
||||
assert(offset.HighPart==0);
|
||||
|
||||
/*
|
||||
* Find the first block in the stream that contains part of the buffer.
|
||||
|
@ -8198,9 +8196,9 @@ static BOOL SmallBlockChainStream_Shrink(
|
|||
ULONG numBlocks;
|
||||
ULONG count = 0;
|
||||
|
||||
numBlocks = newSize.u.LowPart / This->parentStorage->smallBlockSize;
|
||||
numBlocks = newSize.LowPart / This->parentStorage->smallBlockSize;
|
||||
|
||||
if ((newSize.u.LowPart % This->parentStorage->smallBlockSize) != 0)
|
||||
if ((newSize.LowPart % This->parentStorage->smallBlockSize) != 0)
|
||||
numBlocks++;
|
||||
|
||||
blockIndex = SmallBlockChainStream_GetHeadOfChain(This);
|
||||
|
@ -8318,9 +8316,9 @@ static BOOL SmallBlockChainStream_Enlarge(
|
|||
/*
|
||||
* Figure out how many blocks are needed to contain this stream
|
||||
*/
|
||||
newNumBlocks = newSize.u.LowPart / This->parentStorage->smallBlockSize;
|
||||
newNumBlocks = newSize.LowPart / This->parentStorage->smallBlockSize;
|
||||
|
||||
if ((newSize.u.LowPart % This->parentStorage->smallBlockSize) != 0)
|
||||
if ((newSize.LowPart % This->parentStorage->smallBlockSize) != 0)
|
||||
newNumBlocks++;
|
||||
|
||||
/*
|
||||
|
@ -8370,10 +8368,10 @@ BOOL SmallBlockChainStream_SetSize(
|
|||
{
|
||||
ULARGE_INTEGER size = SmallBlockChainStream_GetSize(This);
|
||||
|
||||
if (newSize.u.LowPart == size.u.LowPart)
|
||||
if (newSize.LowPart == size.LowPart)
|
||||
return TRUE;
|
||||
|
||||
if (newSize.u.LowPart < size.u.LowPart)
|
||||
if (newSize.LowPart < size.LowPart)
|
||||
{
|
||||
SmallBlockChainStream_Shrink(This, newSize);
|
||||
}
|
||||
|
@ -8423,9 +8421,9 @@ static ULARGE_INTEGER SmallBlockChainStream_GetSize(SmallBlockChainStream* This)
|
|||
if(This->headOfStreamPlaceHolder != NULL)
|
||||
{
|
||||
ULARGE_INTEGER result;
|
||||
result.u.HighPart = 0;
|
||||
result.HighPart = 0;
|
||||
|
||||
result.u.LowPart = SmallBlockChainStream_GetCount(This) *
|
||||
result.LowPart = SmallBlockChainStream_GetCount(This) *
|
||||
This->parentStorage->smallBlockSize;
|
||||
|
||||
return result;
|
||||
|
@ -9017,8 +9015,8 @@ HRESULT WINAPI StgIsStorageILockBytes(ILockBytes *plkbyt)
|
|||
ULARGE_INTEGER offset;
|
||||
ULONG read = 0;
|
||||
|
||||
offset.u.HighPart = 0;
|
||||
offset.u.LowPart = 0;
|
||||
offset.HighPart = 0;
|
||||
offset.LowPart = 0;
|
||||
|
||||
ILockBytes_ReadAt(plkbyt, offset, sig, sizeof(sig), &read);
|
||||
|
||||
|
@ -10213,15 +10211,15 @@ static HRESULT OLECONVERT_GetOLE10ProgID(LPSTORAGE pStorage, char *strProgID, DW
|
|||
{
|
||||
|
||||
/*Get the OleType from the CompObj Stream */
|
||||
iSeekPos.u.LowPart = sizeof(CompObj.byUnknown1) + sizeof(CompObj.clsid);
|
||||
iSeekPos.u.HighPart = 0;
|
||||
iSeekPos.LowPart = sizeof(CompObj.byUnknown1) + sizeof(CompObj.clsid);
|
||||
iSeekPos.HighPart = 0;
|
||||
|
||||
IStream_Seek(pStream, iSeekPos, STREAM_SEEK_SET, NULL);
|
||||
IStream_Read(pStream, &CompObj.dwCLSIDNameLength, sizeof(CompObj.dwCLSIDNameLength), NULL);
|
||||
iSeekPos.u.LowPart = CompObj.dwCLSIDNameLength;
|
||||
iSeekPos.LowPart = CompObj.dwCLSIDNameLength;
|
||||
IStream_Seek(pStream, iSeekPos, STREAM_SEEK_CUR , NULL);
|
||||
IStream_Read(pStream, &CompObj.dwOleTypeNameLength, sizeof(CompObj.dwOleTypeNameLength), NULL);
|
||||
iSeekPos.u.LowPart = CompObj.dwOleTypeNameLength;
|
||||
iSeekPos.LowPart = CompObj.dwOleTypeNameLength;
|
||||
IStream_Seek(pStream, iSeekPos, STREAM_SEEK_CUR , NULL);
|
||||
|
||||
IStream_Read(pStream, dwSize, sizeof(*dwSize), NULL);
|
||||
|
@ -10359,8 +10357,8 @@ static void OLECONVERT_GetOle20PresData(LPSTORAGE pStorage, OLECONVERT_OLESTREAM
|
|||
pOleStreamData[1].dwOleTypeNameLength = strlen(strMetafilePictName) +1;
|
||||
strcpy(pOleStreamData[1].strOleTypeName, strMetafilePictName);
|
||||
|
||||
iSeekPos.u.HighPart = 0;
|
||||
iSeekPos.u.LowPart = sizeof(olePress.byUnknown1);
|
||||
iSeekPos.HighPart = 0;
|
||||
iSeekPos.LowPart = sizeof(olePress.byUnknown1);
|
||||
|
||||
/* Get Presentation Data */
|
||||
IStream_Seek(pStream, iSeekPos, STREAM_SEEK_SET, NULL);
|
||||
|
|
|
@ -23,8 +23,6 @@
|
|||
#include <string.h>
|
||||
|
||||
#define COBJMACROS
|
||||
#define NONAMELESSUNION
|
||||
|
||||
#include "windef.h"
|
||||
#include "winbase.h"
|
||||
#include "wingdi.h"
|
||||
|
@ -736,52 +734,52 @@ ULONG __RPC_USER STGMEDIUM_UserSize(ULONG *pFlags, ULONG StartingSize, STGMEDIUM
|
|||
break;
|
||||
case TYMED_HGLOBAL:
|
||||
TRACE("TYMED_HGLOBAL\n");
|
||||
if (pStgMedium->u.hGlobal)
|
||||
size = HGLOBAL_UserSize(pFlags, size, &pStgMedium->u.hGlobal);
|
||||
if (pStgMedium->hGlobal)
|
||||
size = HGLOBAL_UserSize(pFlags, size, &pStgMedium->hGlobal);
|
||||
break;
|
||||
case TYMED_FILE:
|
||||
TRACE("TYMED_FILE\n");
|
||||
if (pStgMedium->u.lpszFileName)
|
||||
if (pStgMedium->lpszFileName)
|
||||
{
|
||||
TRACE("file name is %s\n", debugstr_w(pStgMedium->u.lpszFileName));
|
||||
TRACE("file name is %s\n", debugstr_w(pStgMedium->lpszFileName));
|
||||
size += 3 * sizeof(DWORD) +
|
||||
(lstrlenW(pStgMedium->u.lpszFileName) + 1) * sizeof(WCHAR);
|
||||
(lstrlenW(pStgMedium->lpszFileName) + 1) * sizeof(WCHAR);
|
||||
}
|
||||
break;
|
||||
case TYMED_ISTREAM:
|
||||
TRACE("TYMED_ISTREAM\n");
|
||||
if (pStgMedium->u.pstm)
|
||||
if (pStgMedium->pstm)
|
||||
{
|
||||
IUnknown *unk;
|
||||
IStream_QueryInterface(pStgMedium->u.pstm, &IID_IUnknown, (void**)&unk);
|
||||
IStream_QueryInterface(pStgMedium->pstm, &IID_IUnknown, (void**)&unk);
|
||||
size = WdtpInterfacePointer_UserSize(pFlags, LOWORD(*pFlags), size, unk, &IID_IStream);
|
||||
IUnknown_Release(unk);
|
||||
}
|
||||
break;
|
||||
case TYMED_ISTORAGE:
|
||||
TRACE("TYMED_ISTORAGE\n");
|
||||
if (pStgMedium->u.pstg)
|
||||
if (pStgMedium->pstg)
|
||||
{
|
||||
IUnknown *unk;
|
||||
IStorage_QueryInterface(pStgMedium->u.pstg, &IID_IUnknown, (void**)&unk);
|
||||
IStorage_QueryInterface(pStgMedium->pstg, &IID_IUnknown, (void**)&unk);
|
||||
size = WdtpInterfacePointer_UserSize(pFlags, LOWORD(*pFlags), size, unk, &IID_IStorage);
|
||||
IUnknown_Release(unk);
|
||||
}
|
||||
break;
|
||||
case TYMED_GDI:
|
||||
TRACE("TYMED_GDI\n");
|
||||
if (pStgMedium->u.hBitmap)
|
||||
size = HBITMAP_UserSize(pFlags, size, &pStgMedium->u.hBitmap);
|
||||
if (pStgMedium->hBitmap)
|
||||
size = HBITMAP_UserSize(pFlags, size, &pStgMedium->hBitmap);
|
||||
break;
|
||||
case TYMED_MFPICT:
|
||||
TRACE("TYMED_MFPICT\n");
|
||||
if (pStgMedium->u.hMetaFilePict)
|
||||
size = HMETAFILEPICT_UserSize(pFlags, size, &pStgMedium->u.hMetaFilePict);
|
||||
if (pStgMedium->hMetaFilePict)
|
||||
size = HMETAFILEPICT_UserSize(pFlags, size, &pStgMedium->hMetaFilePict);
|
||||
break;
|
||||
case TYMED_ENHMF:
|
||||
TRACE("TYMED_ENHMF\n");
|
||||
if (pStgMedium->u.hEnhMetaFile)
|
||||
size = HENHMETAFILE_UserSize(pFlags, size, &pStgMedium->u.hEnhMetaFile);
|
||||
if (pStgMedium->hEnhMetaFile)
|
||||
size = HENHMETAFILE_UserSize(pFlags, size, &pStgMedium->hEnhMetaFile);
|
||||
break;
|
||||
default:
|
||||
RaiseException(DV_E_TYMED, 0, 0, NULL);
|
||||
|
@ -822,7 +820,7 @@ unsigned char * __RPC_USER STGMEDIUM_UserMarshal(ULONG *pFlags, unsigned char *p
|
|||
pBuffer += sizeof(DWORD);
|
||||
if (pStgMedium->tymed != TYMED_NULL)
|
||||
{
|
||||
*(DWORD *)pBuffer = (DWORD)(DWORD_PTR)pStgMedium->u.pstg;
|
||||
*(DWORD *)pBuffer = (DWORD)(DWORD_PTR)pStgMedium->pstg;
|
||||
pBuffer += sizeof(DWORD);
|
||||
}
|
||||
*(DWORD *)pBuffer = (DWORD)(DWORD_PTR)pStgMedium->pUnkForRelease;
|
||||
|
@ -835,15 +833,15 @@ unsigned char * __RPC_USER STGMEDIUM_UserMarshal(ULONG *pFlags, unsigned char *p
|
|||
break;
|
||||
case TYMED_HGLOBAL:
|
||||
TRACE("TYMED_HGLOBAL\n");
|
||||
if (pStgMedium->u.hGlobal)
|
||||
pBuffer = HGLOBAL_UserMarshal(pFlags, pBuffer, &pStgMedium->u.hGlobal);
|
||||
if (pStgMedium->hGlobal)
|
||||
pBuffer = HGLOBAL_UserMarshal(pFlags, pBuffer, &pStgMedium->hGlobal);
|
||||
break;
|
||||
case TYMED_FILE:
|
||||
TRACE("TYMED_FILE\n");
|
||||
if (pStgMedium->u.lpszFileName)
|
||||
if (pStgMedium->lpszFileName)
|
||||
{
|
||||
DWORD len;
|
||||
len = lstrlenW(pStgMedium->u.lpszFileName);
|
||||
len = lstrlenW(pStgMedium->lpszFileName);
|
||||
/* conformance */
|
||||
*(DWORD *)pBuffer = len + 1;
|
||||
pBuffer += sizeof(DWORD);
|
||||
|
@ -854,44 +852,44 @@ unsigned char * __RPC_USER STGMEDIUM_UserMarshal(ULONG *pFlags, unsigned char *p
|
|||
*(DWORD *)pBuffer = len + 1;
|
||||
pBuffer += sizeof(DWORD);
|
||||
|
||||
TRACE("file name is %s\n", debugstr_w(pStgMedium->u.lpszFileName));
|
||||
memcpy(pBuffer, pStgMedium->u.lpszFileName, (len + 1) * sizeof(WCHAR));
|
||||
TRACE("file name is %s\n", debugstr_w(pStgMedium->lpszFileName));
|
||||
memcpy(pBuffer, pStgMedium->lpszFileName, (len + 1) * sizeof(WCHAR));
|
||||
}
|
||||
break;
|
||||
case TYMED_ISTREAM:
|
||||
TRACE("TYMED_ISTREAM\n");
|
||||
if (pStgMedium->u.pstm)
|
||||
if (pStgMedium->pstm)
|
||||
{
|
||||
IUnknown *unk;
|
||||
IStream_QueryInterface(pStgMedium->u.pstm, &IID_IUnknown, (void**)&unk);
|
||||
IStream_QueryInterface(pStgMedium->pstm, &IID_IUnknown, (void**)&unk);
|
||||
pBuffer = WdtpInterfacePointer_UserMarshal(pFlags, LOWORD(*pFlags), pBuffer, unk, &IID_IStream);
|
||||
IUnknown_Release(unk);
|
||||
}
|
||||
break;
|
||||
case TYMED_ISTORAGE:
|
||||
TRACE("TYMED_ISTORAGE\n");
|
||||
if (pStgMedium->u.pstg)
|
||||
if (pStgMedium->pstg)
|
||||
{
|
||||
IUnknown *unk;
|
||||
IStorage_QueryInterface(pStgMedium->u.pstg, &IID_IUnknown, (void**)&unk);
|
||||
IStorage_QueryInterface(pStgMedium->pstg, &IID_IUnknown, (void**)&unk);
|
||||
pBuffer = WdtpInterfacePointer_UserMarshal(pFlags, LOWORD(*pFlags), pBuffer, unk, &IID_IStorage);
|
||||
IUnknown_Release(unk);
|
||||
}
|
||||
break;
|
||||
case TYMED_GDI:
|
||||
TRACE("TYMED_GDI\n");
|
||||
if (pStgMedium->u.hBitmap)
|
||||
pBuffer = HBITMAP_UserMarshal(pFlags, pBuffer, &pStgMedium->u.hBitmap);
|
||||
if (pStgMedium->hBitmap)
|
||||
pBuffer = HBITMAP_UserMarshal(pFlags, pBuffer, &pStgMedium->hBitmap);
|
||||
break;
|
||||
case TYMED_MFPICT:
|
||||
TRACE("TYMED_MFPICT\n");
|
||||
if (pStgMedium->u.hMetaFilePict)
|
||||
pBuffer = HMETAFILEPICT_UserMarshal(pFlags, pBuffer, &pStgMedium->u.hMetaFilePict);
|
||||
if (pStgMedium->hMetaFilePict)
|
||||
pBuffer = HMETAFILEPICT_UserMarshal(pFlags, pBuffer, &pStgMedium->hMetaFilePict);
|
||||
break;
|
||||
case TYMED_ENHMF:
|
||||
TRACE("TYMED_ENHMF\n");
|
||||
if (pStgMedium->u.hEnhMetaFile)
|
||||
pBuffer = HENHMETAFILE_UserMarshal(pFlags, pBuffer, &pStgMedium->u.hEnhMetaFile);
|
||||
if (pStgMedium->hEnhMetaFile)
|
||||
pBuffer = HENHMETAFILE_UserMarshal(pFlags, pBuffer, &pStgMedium->hEnhMetaFile);
|
||||
break;
|
||||
default:
|
||||
RaiseException(DV_E_TYMED, 0, 0, NULL);
|
||||
|
@ -949,7 +947,7 @@ unsigned char * __RPC_USER STGMEDIUM_UserUnmarshal(ULONG *pFlags, unsigned char
|
|||
case TYMED_HGLOBAL:
|
||||
TRACE("TYMED_HGLOBAL\n");
|
||||
if (content)
|
||||
pBuffer = HGLOBAL_UserUnmarshal(pFlags, pBuffer, &pStgMedium->u.hGlobal);
|
||||
pBuffer = HGLOBAL_UserUnmarshal(pFlags, pBuffer, &pStgMedium->hGlobal);
|
||||
break;
|
||||
case TYMED_FILE:
|
||||
TRACE("TYMED_FILE\n");
|
||||
|
@ -980,59 +978,59 @@ unsigned char * __RPC_USER STGMEDIUM_UserUnmarshal(ULONG *pFlags, unsigned char
|
|||
RpcRaiseException(RPC_S_INVALID_BOUND);
|
||||
return NULL;
|
||||
}
|
||||
pStgMedium->u.lpszFileName = CoTaskMemAlloc(conformance * sizeof(WCHAR));
|
||||
if (!pStgMedium->u.lpszFileName) RpcRaiseException(ERROR_OUTOFMEMORY);
|
||||
pStgMedium->lpszFileName = CoTaskMemAlloc(conformance * sizeof(WCHAR));
|
||||
if (!pStgMedium->lpszFileName) RpcRaiseException(ERROR_OUTOFMEMORY);
|
||||
TRACE("unmarshalled file name is %s\n", debugstr_wn((const WCHAR *)pBuffer, variance));
|
||||
memcpy(pStgMedium->u.lpszFileName, pBuffer, variance * sizeof(WCHAR));
|
||||
memcpy(pStgMedium->lpszFileName, pBuffer, variance * sizeof(WCHAR));
|
||||
pBuffer += variance * sizeof(WCHAR);
|
||||
}
|
||||
else
|
||||
pStgMedium->u.lpszFileName = NULL;
|
||||
pStgMedium->lpszFileName = NULL;
|
||||
break;
|
||||
case TYMED_ISTREAM:
|
||||
TRACE("TYMED_ISTREAM\n");
|
||||
if (content)
|
||||
{
|
||||
pBuffer = WdtpInterfacePointer_UserUnmarshal(pFlags, pBuffer, (IUnknown**)&pStgMedium->u.pstm, &IID_IStream);
|
||||
pBuffer = WdtpInterfacePointer_UserUnmarshal(pFlags, pBuffer, (IUnknown**)&pStgMedium->pstm, &IID_IStream);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (pStgMedium->u.pstm) IStream_Release( pStgMedium->u.pstm );
|
||||
pStgMedium->u.pstm = NULL;
|
||||
if (pStgMedium->pstm) IStream_Release( pStgMedium->pstm );
|
||||
pStgMedium->pstm = NULL;
|
||||
}
|
||||
break;
|
||||
case TYMED_ISTORAGE:
|
||||
TRACE("TYMED_ISTORAGE\n");
|
||||
if (content)
|
||||
{
|
||||
pBuffer = WdtpInterfacePointer_UserUnmarshal(pFlags, pBuffer, (IUnknown**)&pStgMedium->u.pstg, &IID_IStorage);
|
||||
pBuffer = WdtpInterfacePointer_UserUnmarshal(pFlags, pBuffer, (IUnknown**)&pStgMedium->pstg, &IID_IStorage);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (pStgMedium->u.pstg) IStorage_Release( pStgMedium->u.pstg );
|
||||
pStgMedium->u.pstg = NULL;
|
||||
if (pStgMedium->pstg) IStorage_Release( pStgMedium->pstg );
|
||||
pStgMedium->pstg = NULL;
|
||||
}
|
||||
break;
|
||||
case TYMED_GDI:
|
||||
TRACE("TYMED_GDI\n");
|
||||
if (content)
|
||||
pBuffer = HBITMAP_UserUnmarshal(pFlags, pBuffer, &pStgMedium->u.hBitmap);
|
||||
pBuffer = HBITMAP_UserUnmarshal(pFlags, pBuffer, &pStgMedium->hBitmap);
|
||||
else
|
||||
pStgMedium->u.hBitmap = NULL;
|
||||
pStgMedium->hBitmap = NULL;
|
||||
break;
|
||||
case TYMED_MFPICT:
|
||||
TRACE("TYMED_MFPICT\n");
|
||||
if (content)
|
||||
pBuffer = HMETAFILEPICT_UserUnmarshal(pFlags, pBuffer, &pStgMedium->u.hMetaFilePict);
|
||||
pBuffer = HMETAFILEPICT_UserUnmarshal(pFlags, pBuffer, &pStgMedium->hMetaFilePict);
|
||||
else
|
||||
pStgMedium->u.hMetaFilePict = NULL;
|
||||
pStgMedium->hMetaFilePict = NULL;
|
||||
break;
|
||||
case TYMED_ENHMF:
|
||||
TRACE("TYMED_ENHMF\n");
|
||||
if (content)
|
||||
pBuffer = HENHMETAFILE_UserUnmarshal(pFlags, pBuffer, &pStgMedium->u.hEnhMetaFile);
|
||||
pBuffer = HENHMETAFILE_UserUnmarshal(pFlags, pBuffer, &pStgMedium->hEnhMetaFile);
|
||||
else
|
||||
pStgMedium->u.hEnhMetaFile = NULL;
|
||||
pStgMedium->hEnhMetaFile = NULL;
|
||||
break;
|
||||
default:
|
||||
RaiseException(DV_E_TYMED, 0, 0, NULL);
|
||||
|
@ -1963,7 +1961,7 @@ HRESULT CALLBACK IDataObject_GetDataHere_Proxy(IDataObject *iface, FORMATETC *fm
|
|||
|
||||
if (med->tymed == TYMED_ISTREAM || med->tymed == TYMED_ISTORAGE)
|
||||
{
|
||||
stg = med->u.pstg; /* This may actually be a stream, but that's ok */
|
||||
stg = med->pstg; /* This may actually be a stream, but that's ok */
|
||||
if (stg) IStorage_AddRef( stg );
|
||||
}
|
||||
|
||||
|
@ -1972,9 +1970,9 @@ HRESULT CALLBACK IDataObject_GetDataHere_Proxy(IDataObject *iface, FORMATETC *fm
|
|||
med->pUnkForRelease = release;
|
||||
if (stg)
|
||||
{
|
||||
if (med->u.pstg)
|
||||
IStorage_Release( med->u.pstg );
|
||||
med->u.pstg = stg;
|
||||
if (med->pstg)
|
||||
IStorage_Release( med->pstg );
|
||||
med->pstg = stg;
|
||||
}
|
||||
|
||||
return hr;
|
||||
|
|
Loading…
Reference in a new issue