ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Changed ICOM_THIS definition.

This commit is contained in:
Francois Gouget 1999-02-17 15:57:24 +00:00 committed by Alexandre Julliard
parent 4ca9d75542
commit 452db3f18a
10 changed files with 605 additions and 455 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

186
dlls/shell32/dataobject.c
View File

@ -23,7 +23,7 @@ UINT32 cfFileContents=0;
/***********************************************************************
* IEnumFORMATETC implementation
*/
typedef struct _IEnumFORMATETC
typedef struct
{
/* IUnknown fields */
ICOM_VTABLE(IEnumFORMATETC)* lpvtbl;
@ -32,11 +32,11 @@ typedef struct _IEnumFORMATETC
UINT32 posFmt;
UINT32 countFmt;
LPFORMATETC32 pFmt;
} _IEnumFORMATETC;
} IEnumFORMATETCImpl;
static HRESULT WINAPI IEnumFORMATETC_fnQueryInterface(LPUNKNOWN iface, REFIID riid, LPVOID* ppvObj);
static ULONG WINAPI IEnumFORMATETC_fnAddRef(LPUNKNOWN iface);
static ULONG WINAPI IEnumFORMATETC_fnRelease(LPUNKNOWN iface);
static HRESULT WINAPI IEnumFORMATETC_fnQueryInterface(LPENUMFORMATETC iface, REFIID riid, LPVOID* ppvObj);
static ULONG WINAPI IEnumFORMATETC_fnAddRef(LPENUMFORMATETC iface);
static ULONG WINAPI IEnumFORMATETC_fnRelease(LPENUMFORMATETC iface);
static HRESULT WINAPI IEnumFORMATETC_fnNext(LPENUMFORMATETC iface, ULONG celt, FORMATETC32* rgelt, ULONG* pceltFethed);
static HRESULT WINAPI IEnumFORMATETC_fnSkip(LPENUMFORMATETC iface, ULONG celt);
static HRESULT WINAPI IEnumFORMATETC_fnReset(LPENUMFORMATETC iface);
@ -44,11 +44,9 @@ static HRESULT WINAPI IEnumFORMATETC_fnClone(LPENUMFORMATETC iface, LPENUMFORMAT
static struct ICOM_VTABLE(IEnumFORMATETC) efvt =
{
{
IEnumFORMATETC_fnQueryInterface,
IEnumFORMATETC_fnAddRef,
IEnumFORMATETC_fnRelease
},
IEnumFORMATETC_fnRelease,
IEnumFORMATETC_fnNext,
IEnumFORMATETC_fnSkip,
IEnumFORMATETC_fnReset,
@ -57,10 +55,10 @@ static struct ICOM_VTABLE(IEnumFORMATETC) efvt =
LPENUMFORMATETC IEnumFORMATETC_Constructor(UINT32 cfmt, const FORMATETC32 afmt[])
{
_IEnumFORMATETC* ef;
IEnumFORMATETCImpl* ef;
DWORD size=cfmt * sizeof(FORMATETC32);
ef=(_IEnumFORMATETC*)HeapAlloc(GetProcessHeap(),0,sizeof(_IEnumFORMATETC));
ef=(IEnumFORMATETCImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IEnumFORMATETCImpl));
ef->ref=1;
ef->lpvtbl=&efvt;
@ -76,20 +74,20 @@ LPENUMFORMATETC IEnumFORMATETC_Constructor(UINT32 cfmt, const FORMATETC32 afmt[]
shell32_ObjCount++;
return (LPENUMFORMATETC)ef;
}
static HRESULT WINAPI IEnumFORMATETC_fnQueryInterface(LPUNKNOWN iface, REFIID riid, LPVOID* ppvObj)
static HRESULT WINAPI IEnumFORMATETC_fnQueryInterface(LPENUMFORMATETC iface, REFIID riid, LPVOID* ppvObj)
{
ICOM_THIS(IEnumFORMATETC,iface);
ICOM_THIS(IEnumFORMATETCImpl,iface);
char xriid[50];
WINE_StringFromCLSID((LPCLSID)riid,xriid);
TRACE(shell,"(%p)->(\n\tIID:\t%s,%p)\n",this,xriid,ppvObj);
TRACE(shell,"(%p)->(\n\tIID:\t%s,%p)\n",This,xriid,ppvObj);
*ppvObj = NULL;
if(IsEqualIID(riid, &IID_IUnknown))
{ *ppvObj = this;
{ *ppvObj = This;
}
else if(IsEqualIID(riid, &IID_IEnumFORMATETC))
{ *ppvObj = (IDataObject*)this;
{ *ppvObj = (IDataObject*)This;
}
if(*ppvObj)
@ -101,46 +99,46 @@ static HRESULT WINAPI IEnumFORMATETC_fnQueryInterface(LPUNKNOWN iface, REFIID ri
return E_NOINTERFACE;
}
static ULONG WINAPI IEnumFORMATETC_fnAddRef(LPUNKNOWN iface)
static ULONG WINAPI IEnumFORMATETC_fnAddRef(LPENUMFORMATETC iface)
{
ICOM_THIS(IEnumFORMATETC,iface);
TRACE(shell,"(%p)->(count=%lu)\n",this,(this->ref)+1);
ICOM_THIS(IEnumFORMATETCImpl,iface);
TRACE(shell,"(%p)->(count=%lu)\n",This,(This->ref)+1);
shell32_ObjCount++;
return ++(this->ref);
return ++(This->ref);
}
static ULONG WINAPI IEnumFORMATETC_fnRelease(LPUNKNOWN iface)
static ULONG WINAPI IEnumFORMATETC_fnRelease(LPENUMFORMATETC iface)
{
ICOM_THIS(IEnumFORMATETC,iface);
TRACE(shell,"(%p)->()\n",this);
ICOM_THIS(IEnumFORMATETCImpl,iface);
TRACE(shell,"(%p)->()\n",This);
shell32_ObjCount--;
if (!--(this->ref))
{ TRACE(shell," destroying IEnumFORMATETC(%p)\n",this);
if (this->pFmt)
{ SHFree (this->pFmt);
if (!--(This->ref))
{ TRACE(shell," destroying IEnumFORMATETC(%p)\n",This);
if (This->pFmt)
{ SHFree (This->pFmt);
}
HeapFree(GetProcessHeap(),0,this);
HeapFree(GetProcessHeap(),0,This);
return 0;
}
return this->ref;
return This->ref;
}
static HRESULT WINAPI IEnumFORMATETC_fnNext(LPENUMFORMATETC iface, ULONG celt, FORMATETC32 *rgelt, ULONG *pceltFethed)
{
ICOM_THIS(IEnumFORMATETC,iface);
ICOM_THIS(IEnumFORMATETCImpl,iface);
UINT32 cfetch;
HRESULT hres = S_FALSE;
TRACE (shell, "(%p)->()\n", this);
TRACE (shell, "(%p)->()\n", This);
if (this->posFmt < this->countFmt)
{ cfetch = this->countFmt - this->posFmt;
if (This->posFmt < This->countFmt)
{ cfetch = This->countFmt - This->posFmt;
if (cfetch >= celt)
{ cfetch = celt;
hres = S_OK;
}
memcpy(rgelt, &this->pFmt[this->posFmt], cfetch * sizeof(FORMATETC32));
this->posFmt += cfetch;
memcpy(rgelt, &This->pFmt[This->posFmt], cfetch * sizeof(FORMATETC32));
This->posFmt += cfetch;
}
else
{ cfetch = 0;
@ -154,35 +152,35 @@ static HRESULT WINAPI IEnumFORMATETC_fnNext(LPENUMFORMATETC iface, ULONG celt, F
}
static HRESULT WINAPI IEnumFORMATETC_fnSkip(LPENUMFORMATETC iface, ULONG celt)
{
ICOM_THIS(IEnumFORMATETC,iface);
FIXME (shell, "(%p)->(num=%lu)\n", this, celt);
ICOM_THIS(IEnumFORMATETCImpl,iface);
FIXME (shell, "(%p)->(num=%lu)\n", This, celt);
this->posFmt += celt;
if (this->posFmt > this->countFmt)
{ this->posFmt = this->countFmt;
This->posFmt += celt;
if (This->posFmt > This->countFmt)
{ This->posFmt = This->countFmt;
return S_FALSE;
}
return S_OK;
}
static HRESULT WINAPI IEnumFORMATETC_fnReset(LPENUMFORMATETC iface)
{
ICOM_THIS(IEnumFORMATETC,iface);
FIXME (shell, "(%p)->()\n", this);
ICOM_THIS(IEnumFORMATETCImpl,iface);
FIXME (shell, "(%p)->()\n", This);
this->posFmt = 0;
This->posFmt = 0;
return S_OK;
}
static HRESULT WINAPI IEnumFORMATETC_fnClone(LPENUMFORMATETC iface, LPENUMFORMATETC* ppenum)
{
ICOM_THIS(IEnumFORMATETC,iface);
FIXME (shell, "(%p)->(ppenum=%p)\n", this, ppenum);
ICOM_THIS(IEnumFORMATETCImpl,iface);
FIXME (shell, "(%p)->(ppenum=%p)\n", This, ppenum);
return E_NOTIMPL;
}
/***********************************************************************
* IDataObject implementation
*/
typedef struct _IDataObject
typedef struct
{
/* IUnknown fields */
ICOM_VTABLE(IDataObject)* lpvtbl;
@ -191,11 +189,11 @@ typedef struct _IDataObject
LPSHELLFOLDER psf;
LPIDLLIST lpill; /* the data of the dataobject */
LPITEMIDLIST pidl;
} _IDataObject;
} IDataObjectImpl;
static HRESULT WINAPI IDataObject_fnQueryInterface(LPUNKNOWN iface, REFIID riid, LPVOID* ppvObj);
static ULONG WINAPI IDataObject_fnAddRef(LPUNKNOWN iface);
static ULONG WINAPI IDataObject_fnRelease(LPUNKNOWN iface);
static HRESULT WINAPI IDataObject_fnQueryInterface(LPDATAOBJECT iface, REFIID riid, LPVOID* ppvObj);
static ULONG WINAPI IDataObject_fnAddRef(LPDATAOBJECT iface);
static ULONG WINAPI IDataObject_fnRelease(LPDATAOBJECT iface);
static HRESULT WINAPI IDataObject_fnGetData(LPDATAOBJECT iface, LPFORMATETC32 pformatetcIn, STGMEDIUM32* pmedium);
static HRESULT WINAPI IDataObject_fnGetDataHere(LPDATAOBJECT iface, LPFORMATETC32 pformatetc, STGMEDIUM32* pmedium);
static HRESULT WINAPI IDataObject_fnQueryGetData(LPDATAOBJECT iface, LPFORMATETC32 pformatetc);
@ -208,11 +206,9 @@ static HRESULT WINAPI IDataObject_fnEnumDAdvise(LPDATAOBJECT iface, IEnumSTATDAT
static struct ICOM_VTABLE(IDataObject) dtovt =
{
{
IDataObject_fnQueryInterface,
IDataObject_fnAddRef,
IDataObject_fnRelease
},
IDataObject_fnRelease,
IDataObject_fnGetData,
IDataObject_fnGetDataHere,
IDataObject_fnQueryGetData,
@ -229,8 +225,8 @@ static struct ICOM_VTABLE(IDataObject) dtovt =
*/
LPDATAOBJECT IDataObject_Constructor(HWND32 hwndOwner, LPSHELLFOLDER psf, LPITEMIDLIST * apidl, UINT32 cidl)
{
_IDataObject* dto;
if (!(dto = (_IDataObject*)HeapAlloc(GetProcessHeap(),0,sizeof(_IDataObject))))
IDataObjectImpl* dto;
if (!(dto = (IDataObjectImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IDataObjectImpl))))
return NULL;
dto->ref=1;
@ -252,20 +248,20 @@ LPDATAOBJECT IDataObject_Constructor(HWND32 hwndOwner, LPSHELLFOLDER psf, LPITEM
/***************************************************************************
* IDataObject_QueryInterface
*/
static HRESULT WINAPI IDataObject_fnQueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID * ppvObj)
static HRESULT WINAPI IDataObject_fnQueryInterface(LPDATAOBJECT iface, REFIID riid, LPVOID * ppvObj)
{
ICOM_THIS(IDataObject,iface);
ICOM_THIS(IDataObjectImpl,iface);
char xriid[50];
WINE_StringFromCLSID((LPCLSID)riid,xriid);
TRACE(shell,"(%p)->(\n\tIID:\t%s,%p)\n",this,xriid,ppvObj);
TRACE(shell,"(%p)->(\n\tIID:\t%s,%p)\n",This,xriid,ppvObj);
*ppvObj = NULL;
if(IsEqualIID(riid, &IID_IUnknown)) /*IUnknown*/
{ *ppvObj = this;
{ *ppvObj = This;
}
else if(IsEqualIID(riid, &IID_IDataObject)) /*IDataObject*/
{ *ppvObj = (IDataObject*)this;
{ *ppvObj = (IDataObject*)This;
}
if(*ppvObj)
@ -279,32 +275,32 @@ static HRESULT WINAPI IDataObject_fnQueryInterface (LPUNKNOWN iface, REFIID riid
/**************************************************************************
* IDataObject_AddRef
*/
static ULONG WINAPI IDataObject_fnAddRef(LPUNKNOWN iface)
static ULONG WINAPI IDataObject_fnAddRef(LPDATAOBJECT iface)
{
ICOM_THIS(IDataObject,iface);
ICOM_THIS(IDataObjectImpl,iface);
TRACE(shell,"(%p)->(count=%lu)\n",this,(this->ref)+1);
TRACE(shell,"(%p)->(count=%lu)\n",This,(This->ref)+1);
shell32_ObjCount++;
return ++(this->ref);
return ++(This->ref);
}
/**************************************************************************
* IDataObject_Release
*/
static ULONG WINAPI IDataObject_fnRelease(LPUNKNOWN iface)
static ULONG WINAPI IDataObject_fnRelease(LPDATAOBJECT iface)
{
ICOM_THIS(IDataObject,iface);
TRACE(shell,"(%p)->()\n",this);
ICOM_THIS(IDataObjectImpl,iface);
TRACE(shell,"(%p)->()\n",This);
shell32_ObjCount--;
if (!--(this->ref))
{ TRACE(shell," destroying IDataObject(%p)\n",this);
IDLList_Destructor(this->lpill);
HeapFree(GetProcessHeap(),0,this);
if (!--(This->ref))
{ TRACE(shell," destroying IDataObject(%p)\n",This);
IDLList_Destructor(This->lpill);
HeapFree(GetProcessHeap(),0,This);
return 0;
}
return this->ref;
return This->ref;
}
/**************************************************************************
* DATAOBJECT_InitShellIDList (internal)
@ -359,7 +355,7 @@ static BOOL32 DATAOBJECT_InitFileContents(void)
*/
static HRESULT WINAPI IDataObject_fnGetData(LPDATAOBJECT iface, LPFORMATETC32 pformatetcIn, STGMEDIUM32 *pmedium)
{
ICOM_THIS(IDataObject,iface);
ICOM_THIS(IDataObjectImpl,iface);
char temp[256];
UINT32 cItems;
DWORD size, size1, size2;
@ -368,7 +364,7 @@ static HRESULT WINAPI IDataObject_fnGetData(LPDATAOBJECT iface, LPFORMATETC32 pf
HGLOBAL32 hmem;
GetClipboardFormatName32A (pformatetcIn->cfFormat, temp, 256);
WARN (shell, "(%p)->(%p %p format=%s)semi-stub\n", this, pformatetcIn, pmedium, temp);
WARN (shell, "(%p)->(%p %p format=%s)semi-stub\n", This, pformatetcIn, pmedium, temp);
if (!DATAOBJECT_InitShellIDList()) /* is the clipformat registred? */
{ return(E_UNEXPECTED);
@ -379,19 +375,19 @@ static HRESULT WINAPI IDataObject_fnGetData(LPDATAOBJECT iface, LPFORMATETC32 pf
&& (pformatetcIn->dwAspect & DVASPECT_CONTENT)
&& pformatetcIn->lindex==-1
&& (pformatetcIn->tymed&TYMED_HGLOBAL))
{ cItems = this->lpill->lpvtbl->fnGetCount(this->lpill);
{ cItems = This->lpill->lpvtbl->fnGetCount(This->lpill);
if (cItems < 1)
{ return(E_UNEXPECTED);
}
pidl = this->lpill->lpvtbl->fnGetElement(this->lpill, 0);
pidl = This->lpill->lpvtbl->fnGetElement(This->lpill, 0);
pdump(this->pidl);
pdump(This->pidl);
pdump(pidl);
/*hack consider only the first item*/
cItems = 2;
size = sizeof(CIDA) + sizeof (UINT32)*(cItems-1);
size1 = ILGetSize (this->pidl);
size1 = ILGetSize (This->pidl);
size2 = ILGetSize (pidl);
hmem = GlobalAlloc32(GMEM_FIXED, size+size1+size2);
pcida = GlobalLock32 (hmem);
@ -404,10 +400,10 @@ static HRESULT WINAPI IDataObject_fnGetData(LPDATAOBJECT iface, LPFORMATETC32 pf
pcida->aoffset[1] = size+size1;
TRACE(shell,"-- %lu %lu %lu\n",size, size1, size2 );
TRACE(shell,"-- %p %p\n",this->pidl, pidl);
TRACE(shell,"-- %p %p\n",This->pidl, pidl);
TRACE(shell,"-- %p %p %p\n",pcida, (LPBYTE)pcida+size,(LPBYTE)pcida+size+size1);
memcpy ((LPBYTE)pcida+size, this->pidl, size1);
memcpy ((LPBYTE)pcida+size, This->pidl, size1);
memcpy ((LPBYTE)pcida+size+size1, pidl, size2);
TRACE(shell,"-- after copy\n");
@ -425,49 +421,49 @@ static HRESULT WINAPI IDataObject_fnGetData(LPDATAOBJECT iface, LPFORMATETC32 pf
}
static HRESULT WINAPI IDataObject_fnGetDataHere(LPDATAOBJECT iface, LPFORMATETC32 pformatetc, STGMEDIUM32 *pmedium)
{
ICOM_THIS(IDataObject,iface);
FIXME (shell, "(%p)->()\n", this);
ICOM_THIS(IDataObjectImpl,iface);
FIXME (shell, "(%p)->()\n", This);
return E_NOTIMPL;
}
static HRESULT WINAPI IDataObject_fnQueryGetData(LPDATAOBJECT iface, LPFORMATETC32 pformatetc)
{
ICOM_THIS(IDataObject,iface);
FIXME (shell, "(%p)->()\n", this);
ICOM_THIS(IDataObjectImpl,iface);
FIXME (shell, "(%p)->()\n", This);
return E_NOTIMPL;
}
static HRESULT WINAPI IDataObject_fnGetCanonicalFormatEtc(LPDATAOBJECT iface, LPFORMATETC32 pformatectIn, LPFORMATETC32 pformatetcOut)
{
ICOM_THIS(IDataObject,iface);
FIXME (shell, "(%p)->()\n", this);
ICOM_THIS(IDataObjectImpl,iface);
FIXME (shell, "(%p)->()\n", This);
return E_NOTIMPL;
}
static HRESULT WINAPI IDataObject_fnSetData(LPDATAOBJECT iface, LPFORMATETC32 pformatetc, STGMEDIUM32 *pmedium, BOOL32 fRelease)
{
ICOM_THIS(IDataObject,iface);
FIXME (shell, "(%p)->()\n", this);
ICOM_THIS(IDataObjectImpl,iface);
FIXME (shell, "(%p)->()\n", This);
return E_NOTIMPL;
}
static HRESULT WINAPI IDataObject_fnEnumFormatEtc(LPDATAOBJECT iface, DWORD dwDirection, IEnumFORMATETC **ppenumFormatEtc)
{
ICOM_THIS(IDataObject,iface);
FIXME (shell, "(%p)->()\n", this);
ICOM_THIS(IDataObjectImpl,iface);
FIXME (shell, "(%p)->()\n", This);
return E_NOTIMPL;
}
static HRESULT WINAPI IDataObject_fnDAdvise(LPDATAOBJECT iface, LPFORMATETC32 *pformatetc, DWORD advf, IAdviseSink *pAdvSink, DWORD *pdwConnection)
{
ICOM_THIS(IDataObject,iface);
FIXME (shell, "(%p)->()\n", this);
ICOM_THIS(IDataObjectImpl,iface);
FIXME (shell, "(%p)->()\n", This);
return E_NOTIMPL;
}
static HRESULT WINAPI IDataObject_fnDUnadvise(LPDATAOBJECT iface, DWORD dwConnection)
{
ICOM_THIS(IDataObject,iface);
FIXME (shell, "(%p)->()\n", this);
ICOM_THIS(IDataObjectImpl,iface);
FIXME (shell, "(%p)->()\n", This);
return E_NOTIMPL;
}
static HRESULT WINAPI IDataObject_fnEnumDAdvise(LPDATAOBJECT iface, IEnumSTATDATA **ppenumAdvise)
{
ICOM_THIS(IDataObject,iface);
FIXME (shell, "(%p)->()\n", this);
ICOM_THIS(IDataObjectImpl,iface);
FIXME (shell, "(%p)->()\n", This);
return E_NOTIMPL;
}

159
dlls/shell32/shelllink.c
View File

@ -18,11 +18,12 @@
#include "shlguid.h"
/* IPersistFile Implementation */
typedef struct _IPersistFile {
typedef struct
{
/* IUnknown fields */
ICOM_VTABLE(IPersistFile)* lpvtbl;
DWORD ref;
} _IPersistFile;
} IPersistFileImpl;
static struct ICOM_VTABLE(IPersistFile) pfvt;
@ -32,9 +33,9 @@ static struct ICOM_VTABLE(IPersistFile) pfvt;
*/
LPPERSISTFILE IPersistFile_Constructor(void)
{
_IPersistFile* sl;
IPersistFileImpl* sl;
sl = (_IPersistFile*)HeapAlloc(GetProcessHeap(),0,sizeof(_IPersistFile));
sl = (IPersistFileImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IPersistFileImpl));
sl->ref = 1;
sl->lpvtbl = &pfvt;
@ -49,18 +50,18 @@ LPPERSISTFILE IPersistFile_Constructor(void)
static HRESULT WINAPI IPersistFile_fnQueryInterface(
LPUNKNOWN iface, REFIID riid, LPVOID *ppvObj)
{
ICOM_THIS(IPersistFile,iface);
ICOM_THIS(IPersistFileImpl,iface);
char xriid[50];
WINE_StringFromCLSID((LPCLSID)riid,xriid);
TRACE(shell,"(%p)->(\n\tIID:\t%s)\n",this,xriid);
TRACE(shell,"(%p)->(\n\tIID:\t%s)\n",This,xriid);
*ppvObj = NULL;
if(IsEqualIID(riid, &IID_IUnknown)) /*IUnknown*/
{ *ppvObj = this;
{ *ppvObj = This;
}
else if(IsEqualIID(riid, &IID_IPersistFile)) /*IPersistFile*/
{ *ppvObj = (LPPERSISTFILE)this;
{ *ppvObj = (LPPERSISTFILE)This;
}
if(*ppvObj)
@ -76,64 +77,64 @@ static HRESULT WINAPI IPersistFile_fnQueryInterface(
*/
static ULONG WINAPI IPersistFile_fnAddRef(LPUNKNOWN iface)
{
ICOM_THIS(IPersistFile,iface);
TRACE(shell,"(%p)->(count=%lu)\n",this,this->ref);
ICOM_THIS(IPersistFileImpl,iface);
TRACE(shell,"(%p)->(count=%lu)\n",This,This->ref);
shell32_ObjCount++;
return ++(this->ref);
return ++(This->ref);
}
/******************************************************************************
* IPersistFile_Release
*/
static ULONG WINAPI IPersistFile_fnRelease(LPUNKNOWN iface)
{
ICOM_THIS(IPersistFile,iface);
TRACE(shell,"(%p)->(count=%lu)\n",this,this->ref);
ICOM_THIS(IPersistFileImpl,iface);
TRACE(shell,"(%p)->(count=%lu)\n",This,This->ref);
shell32_ObjCount--;
if (!--(this->ref))
{ TRACE(shell,"-- destroying IPersistFile(%p)\n",this);
HeapFree(GetProcessHeap(),0,this);
if (!--(This->ref))
{ TRACE(shell,"-- destroying IPersistFile(%p)\n",This);
HeapFree(GetProcessHeap(),0,This);
return 0;
}
return this->ref;
return This->ref;
}
static HRESULT WINAPI IPersistFile_fnGetClassID(const IPersist* iface, CLSID *pClassID)
{
ICOM_CTHIS(IPersistFile,iface);
FIXME(shell,"(%p)\n",this);
FIXME(shell,"(%p)\n",This);
return NOERROR;
}
static HRESULT WINAPI IPersistFile_fnIsDirty(const IPersistFile* iface)
{
ICOM_CTHIS(IPersistFile,iface);
FIXME(shell,"(%p)\n",this);
FIXME(shell,"(%p)\n",This);
return NOERROR;
}
static HRESULT WINAPI IPersistFile_fnLoad(LPPERSISTFILE iface, LPCOLESTR32 pszFileName, DWORD dwMode)
static HRESULT WINAPI IPersistFile_fnLoad(IPersistFile* iface, LPCOLESTR32 pszFileName, DWORD dwMode)
{
ICOM_THIS(IPersistFile,iface);
FIXME(shell,"(%p)->(%s)\n",this,debugstr_w(pszFileName));
ICOM_THIS(IPersistFileImpl,iface);
FIXME(shell,"(%p)->(%s)\n",This,debugstr_w(pszFileName));
return E_FAIL;
}
static HRESULT WINAPI IPersistFile_fnSave(LPPERSISTFILE iface, LPCOLESTR32 pszFileName, BOOL32 fRemember)
static HRESULT WINAPI IPersistFile_fnSave(IPersistFile* iface, LPCOLESTR32 pszFileName, BOOL32 fRemember)
{
ICOM_THIS(IPersistFile,iface);
FIXME(shell,"(%p)->(%s)\n",this,debugstr_w(pszFileName));
ICOM_THIS(IPersistFileImpl,iface);
FIXME(shell,"(%p)->(%s)\n",This,debugstr_w(pszFileName));
return NOERROR;
}
static HRESULT WINAPI IPersistFile_fnSaveCompleted(LPPERSISTFILE iface, LPCOLESTR32 pszFileName)
static HRESULT WINAPI IPersistFile_fnSaveCompleted(IPersistFile* iface, LPCOLESTR32 pszFileName)
{
ICOM_THIS(IPersistFile,iface);
FIXME(shell,"(%p)->(%s)\n",this,debugstr_w(pszFileName));
ICOM_THIS(IPersistFileImpl,iface);
FIXME(shell,"(%p)->(%s)\n",This,debugstr_w(pszFileName));
return NOERROR;
}
static HRESULT WINAPI IPersistFile_fnGetCurFile(const IPersistFile* iface, LPOLESTR32 *ppszFileName)
{
ICOM_CTHIS(IPersistFile,iface);
FIXME(shell,"(%p)\n",this);
ICOM_CTHIS(IPersistFileImpl,iface);
FIXME(shell,"(%p)\n",This);
return NOERROR;
}
@ -158,6 +159,12 @@ static struct ICOM_VTABLE(IPersistFile) pfvt =
/**************************************************************************
* IShellLink's IClassFactory implementation
*/
typedef struct
{
/* IUnknown fields */
ICOM_VTABLE(IClassFactory)* lpvtbl;
DWORD ref;
} IClassFactoryImpl;
static ICOM_VTABLE(IClassFactory) slcfvt;
@ -167,9 +174,9 @@ static ICOM_VTABLE(IClassFactory) slcfvt;
LPCLASSFACTORY IShellLink_CF_Constructor(void)
{
_IClassFactory* lpclf;
IClassFactoryImpl* lpclf;
lpclf= (_IClassFactory*)HeapAlloc(GetProcessHeap(),0,sizeof(_IClassFactory));
lpclf= (IClassFactoryImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IClassFactoryImpl));
lpclf->ref = 1;
lpclf->lpvtbl = &slcfvt;
TRACE(shell,"(%p)->()\n",lpclf);
@ -180,20 +187,20 @@ LPCLASSFACTORY IShellLink_CF_Constructor(void)
* IShellLink_CF_QueryInterface
*/
static HRESULT WINAPI IShellLink_CF_QueryInterface(
LPCLASSFACTORY iface, REFIID riid, LPVOID *ppvObj)
IClassFactory* iface, REFIID riid, LPVOID *ppvObj)
{
ICOM_THIS(IClassFactory,iface);
ICOM_THIS(IClassFactoryImpl,iface);
char xriid[50];
WINE_StringFromCLSID((LPCLSID)riid,xriid);
TRACE(shell,"(%p)->(\n\tIID:\t%s)\n",this,xriid);
TRACE(shell,"(%p)->(\n\tIID:\t%s)\n",This,xriid);
*ppvObj = NULL;
if(IsEqualIID(riid, &IID_IUnknown)) /*IUnknown*/
{ *ppvObj = (LPUNKNOWN)this;
{ *ppvObj = (LPUNKNOWN)This;
}
else if(IsEqualIID(riid, &IID_IClassFactory)) /*IClassFactory*/
{ *ppvObj = (LPCLASSFACTORY)this;
{ *ppvObj = (LPCLASSFACTORY)This;
}
if(*ppvObj)
@ -207,43 +214,43 @@ static HRESULT WINAPI IShellLink_CF_QueryInterface(
/******************************************************************************
* IShellLink_CF_AddRef
*/
static ULONG WINAPI IShellLink_CF_AddRef(LPCLASSFACTORY iface)
static ULONG WINAPI IShellLink_CF_AddRef(IClassFactory* iface)
{
ICOM_THIS(IClassFactory,iface);
TRACE(shell,"(%p)->(count=%lu)\n",this,this->ref);
ICOM_THIS(IClassFactoryImpl,iface);
TRACE(shell,"(%p)->(count=%lu)\n",This,This->ref);
shell32_ObjCount++;
return ++(this->ref);
return ++(This->ref);
}
/******************************************************************************
* IShellLink_CF_Release
*/
static ULONG WINAPI IShellLink_CF_Release(LPCLASSFACTORY iface)
static ULONG WINAPI IShellLink_CF_Release(IClassFactory* iface)
{
ICOM_THIS(IClassFactory,iface);
TRACE(shell,"(%p)->(count=%lu)\n",this,this->ref);
ICOM_THIS(IClassFactoryImpl,iface);
TRACE(shell,"(%p)->(count=%lu)\n",This,This->ref);
shell32_ObjCount--;
if (!--(this->ref))
{ TRACE(shell,"-- destroying IClassFactory(%p)\n",this);
HeapFree(GetProcessHeap(),0,this);
if (!--(This->ref))
{ TRACE(shell,"-- destroying IClassFactory(%p)\n",This);
HeapFree(GetProcessHeap(),0,This);
return 0;
}
return this->ref;
return This->ref;
}
/******************************************************************************
* IShellLink_CF_CreateInstance
*/
static HRESULT WINAPI IShellLink_CF_CreateInstance(
LPCLASSFACTORY iface, LPUNKNOWN pUnknown, REFIID riid, LPVOID *ppObject)
IClassFactory* iface, LPUNKNOWN pUnknown, REFIID riid, LPVOID *ppObject)
{
ICOM_THIS(IClassFactory,iface);
ICOM_THIS(IClassFactoryImpl,iface);
IUnknown *pObj = NULL;
HRESULT hres;
char xriid[50];
WINE_StringFromCLSID((LPCLSID)riid,xriid);
TRACE(shell,"%p->(%p,\n\tIID:\t%s,%p)\n",this,pUnknown,xriid,ppObject);
TRACE(shell,"%p->(%p,\n\tIID:\t%s,%p)\n",This,pUnknown,xriid,ppObject);
*ppObject = NULL;
@ -265,17 +272,17 @@ static HRESULT WINAPI IShellLink_CF_CreateInstance(
hres = IUnknown_QueryInterface(pObj,riid, ppObject);
IUnknown_Release(pObj);
TRACE(shell,"-- Object created: (%p)->%p\n",this,*ppObject);
TRACE(shell,"-- Object created: (%p)->%p\n",This,*ppObject);
return hres;
}
/******************************************************************************
* IShellLink_CF_LockServer
*/
static HRESULT WINAPI IShellLink_CF_LockServer(LPCLASSFACTORY iface, BOOL32 fLock)
static HRESULT WINAPI IShellLink_CF_LockServer(IClassFactory* iface, BOOL32 fLock)
{
ICOM_THIS(IClassFactory,iface);
TRACE(shell,"%p->(0x%x), not implemented\n",this, fLock);
ICOM_THIS(IClassFactoryImpl,iface);
TRACE(shell,"%p->(0x%x), not implemented\n",This, fLock);
return E_NOTIMPL;
}
static ICOM_VTABLE(IClassFactory) slcfvt =
@ -504,9 +511,9 @@ static ICOM_VTABLE(IClassFactory) slwcfvt;
LPCLASSFACTORY IShellLinkW_CF_Constructor(void)
{
_IClassFactory* lpclf;
IClassFactoryImpl* lpclf;
lpclf= (_IClassFactory*)HeapAlloc(GetProcessHeap(),0,sizeof(_IClassFactory));
lpclf= (IClassFactoryImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IClassFactoryImpl));
lpclf->ref = 1;
lpclf->lpvtbl = &slwcfvt;
TRACE(shell,"(%p)->()\n",lpclf);
@ -519,18 +526,18 @@ LPCLASSFACTORY IShellLinkW_CF_Constructor(void)
static HRESULT WINAPI IShellLinkW_CF_QueryInterface(
LPCLASSFACTORY iface, REFIID riid, LPVOID *ppvObj)
{
ICOM_THIS(IClassFactory,iface);
ICOM_THIS(IClassFactoryImpl,iface);
char xriid[50];
WINE_StringFromCLSID((LPCLSID)riid,xriid);
TRACE(shell,"(%p)->(\n\tIID:\t%s)\n",this,xriid);
TRACE(shell,"(%p)->(\n\tIID:\t%s)\n",This,xriid);
*ppvObj = NULL;
if(IsEqualIID(riid, &IID_IUnknown)) /*IUnknown*/
{ *ppvObj = (LPUNKNOWN)this;
{ *ppvObj = (LPUNKNOWN)This;
}
else if(IsEqualIID(riid, &IID_IClassFactory)) /*IClassFactory*/
{ *ppvObj = (LPCLASSFACTORY)this;
{ *ppvObj = (LPCLASSFACTORY)This;
}
if(*ppvObj) {
@ -546,27 +553,27 @@ static HRESULT WINAPI IShellLinkW_CF_QueryInterface(
*/
static ULONG WINAPI IShellLinkW_CF_AddRef(LPCLASSFACTORY iface)
{
ICOM_THIS(IClassFactory,iface);
TRACE(shell,"(%p)->(count=%lu)\n",this,this->ref);
ICOM_THIS(IClassFactoryImpl,iface);
TRACE(shell,"(%p)->(count=%lu)\n",This,This->ref);
shell32_ObjCount++;
return ++(this->ref);
return ++(This->ref);
}
/******************************************************************************
* IShellLinkW_CF_Release
*/
static ULONG WINAPI IShellLinkW_CF_Release(LPCLASSFACTORY iface)
{
ICOM_THIS(IClassFactory,iface);
TRACE(shell,"(%p)->(count=%lu)\n",this,this->ref);
ICOM_THIS(IClassFactoryImpl,iface);
TRACE(shell,"(%p)->(count=%lu)\n",This,This->ref);
shell32_ObjCount--;
if (!--(this->ref))
{ TRACE(shell,"-- destroying IClassFactory(%p)\n",this);
HeapFree(GetProcessHeap(),0,this);
if (!--(This->ref))
{ TRACE(shell,"-- destroying IClassFactory(%p)\n",This);
HeapFree(GetProcessHeap(),0,This);
return 0;
}
return this->ref;
return This->ref;
}
/******************************************************************************
* IShellLinkW_CF_CreateInstance
@ -574,13 +581,13 @@ static ULONG WINAPI IShellLinkW_CF_Release(LPCLASSFACTORY iface)
static HRESULT WINAPI IShellLinkW_CF_CreateInstance(
LPCLASSFACTORY iface, LPUNKNOWN pUnknown, REFIID riid, LPVOID *ppObject)
{
ICOM_THIS(IClassFactory,iface);
ICOM_THIS(IClassFactoryImpl,iface);
IUnknown *pObj = NULL;
HRESULT hres;
char xriid[50];
WINE_StringFromCLSID((LPCLSID)riid,xriid);
TRACE(shell,"%p->(%p,\n\tIID:\t%s,%p)\n",this,pUnknown,xriid,ppObject);
TRACE(shell,"%p->(%p,\n\tIID:\t%s,%p)\n",This,pUnknown,xriid,ppObject);
*ppObject = NULL;
@ -602,7 +609,7 @@ static HRESULT WINAPI IShellLinkW_CF_CreateInstance(
hres = pObj->lpvtbl->fnQueryInterface(pObj,riid, ppObject);
pObj->lpvtbl->fnRelease(pObj);
TRACE(shell,"-- Object created: (%p)->%p\n",this,*ppObject);
TRACE(shell,"-- Object created: (%p)->%p\n",This,*ppObject);
return hres;
}
@ -612,8 +619,8 @@ static HRESULT WINAPI IShellLinkW_CF_CreateInstance(
static HRESULT WINAPI IShellLinkW_CF_LockServer(LPCLASSFACTORY iface, BOOL32 fLock)
{
ICOM_THIS(IClassFactory,iface);
TRACE(shell,"%p->(0x%x), not implemented\n",this, fLock);
ICOM_THIS(IClassFactoryImpl,iface);
TRACE(shell,"%p->(0x%x), not implemented\n",This, fLock);
return E_NOTIMPL;
}
@ -695,7 +702,7 @@ LPSHELLLINKW IShellLinkW_Constructor(void)
}
/**************************************************************************
* IShellLinkW::QueryInterface
* IShellLinkW_QueryInterface
*/
static HRESULT WINAPI IShellLinkW_QueryInterface(
LPSHELLLINKW this, REFIID riid, LPVOID *ppvObj)

47
dlls/shell32/shellole.c
View File

@ -212,6 +212,13 @@ DWORD WINAPI SHGetMalloc(LPMALLOC32 *lpmal)
* IClassFactory Implementation
*/
typedef struct
{
/* IUnknown fields */
ICOM_VTABLE(IClassFactory)* lpvtbl;
DWORD ref;
} IClassFactoryImpl;
static ICOM_VTABLE(IClassFactory) clfvt;
/**************************************************************************
@ -220,9 +227,9 @@ static ICOM_VTABLE(IClassFactory) clfvt;
LPCLASSFACTORY IClassFactory_Constructor(void)
{
_IClassFactory* lpclf;
IClassFactoryImpl* lpclf;
lpclf= (_IClassFactory*)HeapAlloc(GetProcessHeap(),0,sizeof(_IClassFactory));
lpclf= (IClassFactoryImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IClassFactoryImpl));
lpclf->ref = 1;
lpclf->lpvtbl = &clfvt;
@ -236,18 +243,18 @@ LPCLASSFACTORY IClassFactory_Constructor(void)
static HRESULT WINAPI IClassFactory_fnQueryInterface(
LPCLASSFACTORY iface, REFIID riid, LPVOID *ppvObj)
{
ICOM_THIS(IClassFactory,iface);
ICOM_THIS(IClassFactoryImpl,iface);
char xriid[50];
WINE_StringFromCLSID((LPCLSID)riid,xriid);
TRACE(shell,"(%p)->(\n\tIID:\t%s)\n",this,xriid);
TRACE(shell,"(%p)->(\n\tIID:\t%s)\n",This,xriid);
*ppvObj = NULL;
if(IsEqualIID(riid, &IID_IUnknown)) /*IUnknown*/
{ *ppvObj = this;
{ *ppvObj = This;
}
else if(IsEqualIID(riid, &IID_IClassFactory)) /*IClassFactory*/
{ *ppvObj = (IClassFactory*)this;
{ *ppvObj = (IClassFactory*)This;
}
if(*ppvObj)
@ -263,27 +270,27 @@ static HRESULT WINAPI IClassFactory_fnQueryInterface(
*/
static ULONG WINAPI IClassFactory_fnAddRef(LPCLASSFACTORY iface)
{
ICOM_THIS(IClassFactory,iface);
TRACE(shell,"(%p)->(count=%lu)\n",this,this->ref);
ICOM_THIS(IClassFactoryImpl,iface);
TRACE(shell,"(%p)->(count=%lu)\n",This,This->ref);
shell32_ObjCount++;
return ++(this->ref);
return ++(This->ref);
}
/******************************************************************************
* IClassFactory_Release
*/
static ULONG WINAPI IClassFactory_fnRelease(LPCLASSFACTORY iface)
{
ICOM_THIS(IClassFactory,iface);
TRACE(shell,"(%p)->(count=%lu)\n",this,this->ref);
ICOM_THIS(IClassFactoryImpl,iface);
TRACE(shell,"(%p)->(count=%lu)\n",This,This->ref);
shell32_ObjCount--;
if (!--(this->ref))
{ TRACE(shell,"-- destroying IClassFactory(%p)\n",this);
HeapFree(GetProcessHeap(),0,this);
if (!--(This->ref))
{ TRACE(shell,"-- destroying IClassFactory(%p)\n",This);
HeapFree(GetProcessHeap(),0,This);
return 0;
}
return this->ref;
return This->ref;
}
/******************************************************************************
* IClassFactory_CreateInstance
@ -291,13 +298,13 @@ static ULONG WINAPI IClassFactory_fnRelease(LPCLASSFACTORY iface)
static HRESULT WINAPI IClassFactory_fnCreateInstance(
LPCLASSFACTORY iface, LPUNKNOWN pUnknown, REFIID riid, LPVOID *ppObject)
{
ICOM_THIS(IClassFactory,iface);
ICOM_THIS(IClassFactoryImpl,iface);
IUnknown *pObj = NULL;
HRESULT hres;
char xriid[50];
WINE_StringFromCLSID((LPCLSID)riid,xriid);
TRACE(shell,"%p->(%p,\n\tIID:\t%s,%p)\n",this,pUnknown,xriid,ppObject);
TRACE(shell,"%p->(%p,\n\tIID:\t%s,%p)\n",This,pUnknown,xriid,ppObject);
*ppObject = NULL;
@ -331,7 +338,7 @@ static HRESULT WINAPI IClassFactory_fnCreateInstance(
hres = pObj->lpvtbl->fnQueryInterface(pObj,riid, ppObject);
pObj->lpvtbl->fnRelease(pObj);
TRACE(shell,"-- Object created: (%p)->%p\n",this,*ppObject);
TRACE(shell,"-- Object created: (%p)->%p\n",This,*ppObject);
return hres;
}
@ -340,8 +347,8 @@ static HRESULT WINAPI IClassFactory_fnCreateInstance(
*/
static HRESULT WINAPI IClassFactory_fnLockServer(LPCLASSFACTORY iface, BOOL32 fLock)
{
ICOM_THIS(IClassFactory,iface);
TRACE(shell,"%p->(0x%x), not implemented\n",this, fLock);
ICOM_THIS(IClassFactoryImpl,iface);
TRACE(shell,"%p->(0x%x), not implemented\n",This, fLock);
return E_NOTIMPL;
}

4
include/wine/obj_base.h
View File

@ -652,8 +652,8 @@ BOOL32 WINAPI IsEqualGUID32(REFGUID rguid1,REFGUID rguid2);
#define ICOM_CALL8(xfn, p,a,b,c,d,e,f,g,h) (p)->lpvtbl->fn##xfn(p,a,b,c,d,e,f,g,h)
#define ICOM_THIS(iface,me) struct _##iface* this=(struct _##iface*)me
#define ICOM_CTHIS(iface,me) const _##iface* this=(const _##iface*)me
#define ICOM_THIS(impl,iface) impl* const This=(impl*)iface
#define ICOM_CTHIS(impl,iface) const impl* const This=(const impl*)iface
#endif

172
include/wine/obj_dataobject.h
View File

@ -80,7 +80,8 @@ struct FORMATETC32
* STGMEDIUM structure
*/
typedef enum tagTYMED
{ TYMED_HGLOBAL = 1,
{
TYMED_HGLOBAL = 1,
TYMED_FILE = 2,
TYMED_ISTREAM = 4,
TYMED_ISTORAGE = 8,
@ -110,47 +111,117 @@ struct STGMEDIUM32
/*****************************************************************************
* IAdviseSink interface
*/
/* FIXME: not implemented */
#define ICOM_INTERFACE IAdviseSink
ICOM_BEGIN(IAdviseSink,IUnknown)
ICOM_END(IAdviseSink)
#define IAdviseSink_METHODS \
ICOM_VMETHOD2(OnDataChange, FORMATETC32*,pFormatetc, STGMEDIUM32*,pStgmed) \
ICOM_VMETHOD2(OnViewChange, DWORD,dwAspect, LONG,lindex) \
ICOM_VMETHOD1(OnRename, IMoniker*,pmk) \
ICOM_VMETHOD (OnSave) \
ICOM_VMETHOD (OnClose)
#define IAdviseSink_IMETHODS \
IUnknown_IMETHODS \
IAdviseSink_METHODS
ICOM_DEFINE(IAdviseSink,IUnknown)
#undef ICOM_INTERFACE
#ifdef ICOM_CINTERFACE
/*** IUnknown methods ***/
#define IAdviseSink_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b)
#define IAdviseSink_AddRef(p) ICOM_CALL (AddRef,p)
#define IAdviseSink_Release(p) ICOM_CALL (Release,p)
/*** IAdviseSink methods ***/
#define IAdviseSink_OnDataChange(p,a,b) ICOM_CALL2(OnDataChange,p,a,b)
#define IAdviseSink_OnViewChange(p,a,b) ICOM_CALL2(OnViewChange,p,a,b)
#define IAdviseSink_OnRename(p,a) ICOM_CALL1(OnRename,p,a)
#define IAdviseSink_OnSave(p) ICOM_CALL (OnSave,p)
#define IAdviseSink_OnClose(p) ICOM_CALL (OnClose,p)
#endif
/*****************************************************************************
* IAdviseSink2 interface
*/
/* FIXME: not implemented */
#define ICOM_INTERFACE IAdviseSink2
#define IAdviseSink2_METHODS \
ICOM_VMETHOD1(OnLinkSrcChange, IMoniker*,pmk)
#define IAdviseSink2_IMETHODS \
IAdviseSink_IMETHODS \
IAdviseSink2_METHODS
ICOM_DEFINE(IAdviseSink2,IAdviseSink)
#undef ICOM_INTERFACE
#ifdef ICOM_CINTERFACE
/*** IUnknown methods ***/
#define IAdviseSink2_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b)
#define IAdviseSink2_AddRef(p) ICOM_CALL (AddRef,p)
#define IAdviseSink2_Release(p) ICOM_CALL (Release,p)
/*** IAdviseSink methods ***/
#define IAdviseSink2_OnDataChange(p,a,b) ICOM_CALL2(IAdviseSink,OnDataChange,p,a,b)
#define IAdviseSink2_OnViewChange(p,a,b) ICOM_CALL2(IAdviseSink,OnViewChange,p,a,b)
#define IAdviseSink2_OnRename(p,a) ICOM_CALL1(IAdviseSink,OnRename,p,a)
#define IAdviseSink2_OnSave(p) ICOM_CALL (IAdviseSink,OnSave,p)
#define IAdviseSink2_OnClose(p) ICOM_CALL (IAdviseSink,OnClose,p)
/*** IAdviseSink2 methods ***/
#define IAdviseSink2_OnLinkSrcChange(p,a) ICOM_CALL(OnLinkSrcChange,p,a)
#endif
/*****************************************************************************
* IDataAdviseHolder interface
*/
#define ICOM_INTERFACE IDataAdviseHolder
#define IDataAdviseHolder_METHODS \
ICOM_METHOD5(HRESULT,Advise, IDataObject*,pDataObject, FORMATETC32*,pFetc, DWORD,advf, IAdviseSink*,pAdvise, DWORD*,pdwConnection) \
ICOM_METHOD1(HRESULT,Unadvise, DWORD,dwConnection) \
ICOM_METHOD1(HRESULT,EnumAdvise, IEnumSTATDATA**,ppenumAdvise) \
ICOM_METHOD3(HRESULT,SendOnDataChange, IDataObject*,pDataObject, DWORD,dwReserved, DWORD,advf)
#define IDataAdviseHolder_IMETHODS \
IUnknown_IMETHODS \
IDataAdviseHolder_METHODS
ICOM_DEFINE(IDataAdviseHolder,IUnknown)
#undef ICOM_INTERFACE
#ifdef ICOM_CINTERFACE
/*** IUnknown methods ***/
#define IDataAdviseHolder_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b)
#define IDataAdviseHolder_AddRef(p) ICOM_CALL (AddRef,p)
#define IDataAdviseHolder_Release(p) ICOM_CALL (Release,p)
/*** IDataAdviseHolder methods ***/
#define IDataAdviseHolder_Advise(p,a,b,c,d,e) ICOM_CALL5(Advise,p,a,b,c,d,e)
#define IDataAdviseHolder_Unadvise(p,a) ICOM_CALL1(Unadvise,p,a)
#define IDataAdviseHolder_EnumAdvise(p,a) ICOM_CALL1(EnumAdvise,p,a)
#define IDataAdviseHolder_SendOnDataChange(p,a,b,c) ICOM_CALL3(SendOnDataChange,p,a,b,c)
#endif
/* FIXME: not implemented */
HRESULT WINAPI CreateDataAdviseHolder(LPDATAADVISEHOLDER* ppDAHolder);
/*****************************************************************************
* IDataObject interface
*/
#define ICOM_INTERFACE IDataObject
ICOM_BEGIN(IDataObject,IUnknown)
ICOM_METHOD2(HRESULT,GetData, LPFORMATETC32,pformatetcIn, STGMEDIUM32*,pmedium);
ICOM_METHOD2(HRESULT,GetDataHere, LPFORMATETC32,pformatetc, STGMEDIUM32*,pmedium);
ICOM_METHOD1(HRESULT,QueryGetData, LPFORMATETC32,pformatetc);
ICOM_METHOD2(HRESULT,GetCanonicalFormatEtc, LPFORMATETC32,pformatectIn, LPFORMATETC32,pformatetcOut);
ICOM_METHOD3(HRESULT,SetData, LPFORMATETC32,pformatetc, STGMEDIUM32*,pmedium, BOOL32,fRelease);
ICOM_METHOD2(HRESULT,EnumFormatEtc, DWORD,dwDirection, IEnumFORMATETC**,ppenumFormatEtc);
ICOM_METHOD4(HRESULT,DAdvise, LPFORMATETC32*,pformatetc, DWORD,advf, IAdviseSink*,pAdvSink, DWORD*,pdwConnection);
ICOM_METHOD1(HRESULT,DUnadvise, DWORD,dwConnection);
ICOM_METHOD1(HRESULT,EnumDAdvise, IEnumSTATDATA**,ppenumAdvise);
ICOM_END(IDataObject)
#define IDataObject_METHODS \
ICOM_METHOD2(HRESULT,GetData, LPFORMATETC32,pformatetcIn, STGMEDIUM32*,pmedium) \
ICOM_METHOD2(HRESULT,GetDataHere, LPFORMATETC32,pformatetc, STGMEDIUM32*,pmedium) \
ICOM_METHOD1(HRESULT,QueryGetData, LPFORMATETC32,pformatetc) \
ICOM_METHOD2(HRESULT,GetCanonicalFormatEtc, LPFORMATETC32,pformatectIn, LPFORMATETC32,pformatetcOut) \
ICOM_METHOD3(HRESULT,SetData, LPFORMATETC32,pformatetc, STGMEDIUM32*,pmedium, BOOL32,fRelease) \
ICOM_METHOD2(HRESULT,EnumFormatEtc, DWORD,dwDirection, IEnumFORMATETC**,ppenumFormatEtc) \
ICOM_METHOD4(HRESULT,DAdvise, LPFORMATETC32*,pformatetc, DWORD,advf, IAdviseSink*,pAdvSink, DWORD*,pdwConnection) \
ICOM_METHOD1(HRESULT,DUnadvise, DWORD,dwConnection) \
ICOM_METHOD1(HRESULT,EnumDAdvise, IEnumSTATDATA**,ppenumAdvise)
#define IDataObject_IMETHODS \
IUnknown_IMETHODS \
IDataObject_METHODS
ICOM_DEFINE(IDataObject,IUnknown)
#undef ICOM_INTERFACE
#if !defined(__cplusplus) || defined(CINTERFACE)
#ifdef ICOM_CINTERFACE
/*** IUnknown methods ***/
#define IDataObject_QueryInterface(p,a,b) ICOM_ICALL2(IUnknown,QueryInterface,p,a,b)
#define IDataObject_AddRef(p) ICOM_ICALL (IUnknown,AddRef,p)
#define IDataObject_Release(p) ICOM_ICALL (IUnknown,Release,p)
#define IDataObject_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b)
#define IDataObject_AddRef(p) ICOM_CALL (AddRef,p)
#define IDataObject_Release(p) ICOM_CALL (Release,p)
/*** IDataObject methods ***/
#define IDataObject_GetData(p,a,b) ICOM_CALL2(GetData,p,a,b)
#define IDataObject_GetDataHere(p,a,b) ICOM_CALL2(GetDataHere,p,a,b)
@ -168,19 +239,22 @@ ICOM_END(IDataObject)
* IEnumFORMATETC interface
*/
#define ICOM_INTERFACE IEnumFORMATETC
ICOM_BEGIN(IEnumFORMATETC,IUnknown)
ICOM_METHOD3(HRESULT,Next, ULONG,celt, FORMATETC32*,rgelt, ULONG*,pceltFethed);
ICOM_METHOD1(HRESULT,Skip, ULONG,celt);
ICOM_METHOD (HRESULT,Reset);
ICOM_METHOD1(HRESULT,Clone, IEnumFORMATETC**,ppenum);
ICOM_END(IEnumFORMATETC)
#define IEnumFORMATETC_METHODS \
ICOM_METHOD3(HRESULT,Next, ULONG,celt, FORMATETC32*,rgelt, ULONG*,pceltFethed) \
ICOM_METHOD1(HRESULT,Skip, ULONG,celt) \
ICOM_METHOD (HRESULT,Reset) \
ICOM_METHOD1(HRESULT,Clone, IEnumFORMATETC**,ppenum)
#define IEnumFORMATETC_IMETHODS \
IUnknown_IMETHODS \
IEnumFORMATETC_METHODS
ICOM_DEFINE(IEnumFORMATETC,IUnknown)
#undef ICOM_INTERFACE
#if !defined(__cplusplus) || defined(CINTERFACE)
#ifdef ICOM_CINTERFACE
/*** IUnknown methods ***/
#define IEnumFORMATETC_QueryInterface(p,a,b) ICOM_ICALL2(IUnknown,QueryInterface,p,a,b)
#define IEnumFORMATETC_AddRef(p) ICOM_ICALL (IUnknown,AddRef,p)
#define IEnumFORMATETC_Release(p) ICOM_ICALL (IUnknown,Release,p)
#define IEnumFORMATETC_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b)
#define IEnumFORMATETC_AddRef(p) ICOM_CALL (AddRef,p)
#define IEnumFORMATETC_Release(p) ICOM_CALL (Release,p)
/*** IEnumFORMATETC methods ***/
#define IEnumFORMATETC_Next(p,a,b,c) ICOM_CALL3(Next,p,a,b,c)
#define IEnumFORMATETC_Skip(p,a) ICOM_CALL1(Skip,p,a)
@ -192,7 +266,45 @@ ICOM_END(IEnumFORMATETC)
/*****************************************************************************
* IEnumSTATDATA interface
*/
typedef struct tagSTATDATA
{
FORMATETC32 formatetc;
DWORD advf;
IAdviseSink* pAdvSink;
DWORD dwConnection;
} STATDATA32;
#define ICOM_INTERFACE IEnumSTATDATA
#define IEnumSTATDATA_METHODS \
ICOM_METHOD3(HRESULT,Next, ULONG,celt, STATDATA32*,rgelt, ULONG*,pceltFethed) \
ICOM_METHOD1(HRESULT,Skip, ULONG,celt) \
ICOM_METHOD (HRESULT,Reset) \
ICOM_METHOD1(HRESULT,Clone, IEnumSTATDATA**,ppenum)
#define IEnumSTATDATA_IMETHODS \
IUnknown_IMETHODS \
IEnumSTATDATA_METHODS
ICOM_DEFINE(IEnumSTATDATA,IUnknown)
#undef ICOM_INTERFACE
#ifdef ICOM_CINTERFACE
/*** IUnknown methods ***/
#define IEnumSTATDATA_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b)
#define IEnumSTATDATA_AddRef(p) ICOM_CALL (AddRef,p)
#define IEnumSTATDATA_Release(p) ICOM_CALL (Release,p)
/*** IEnumSTATDATA methods ***/
#define IEnumSTATDATA_Next(p,a,b,c) ICOM_CALL3(Next,p,a,b,c)
#define IEnumSTATDATA_Skip(p,a) ICOM_CALL1(Skip,p,a)
#define IEnumSTATDATA_Reset(p) ICOM_CALL (Reset,p)
#define IEnumSTATDATA_Clone(p,a) ICOM_CALL1(Clone,p,a)
#endif
/*****************************************************************************
* Additional API
*/
/* FIXME: not implemented */
HRESULT WINAPI CreateDataCache(LPUNKNOWN pUnkOuter, REFCLSID rclsid, REFIID iid, LPVOID* ppv);
#endif /* __WINE_WINE_OBJ_DATAOBJECT_H */

33
multimedia/dsound.c
View File

@ -2158,39 +2158,46 @@ HRESULT WINAPI DirectSoundCreate(LPGUID lpGUID,LPDIRECTSOUND *ppDS,IUnknown *pUn
/*******************************************************************************
* DirectSound ClassFactory
*/
typedef struct
{
/* IUnknown fields */
ICOM_VTABLE(IClassFactory)* lpvtbl;
DWORD ref;
} IClassFactoryImpl;
static HRESULT WINAPI
DSCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
ICOM_THIS(IClassFactory,iface);
ICOM_THIS(IClassFactoryImpl,iface);
char buf[80];
if (HIWORD(riid))
WINE_StringFromCLSID(riid,buf);
else
sprintf(buf,"<guid-0x%04x>",LOWORD(riid));
FIXME(dsound,"(%p)->(%s,%p),stub!\n",this,buf,ppobj);
FIXME(dsound,"(%p)->(%s,%p),stub!\n",This,buf,ppobj);
return E_NOINTERFACE;
}
static ULONG WINAPI
DSCF_AddRef(LPCLASSFACTORY iface) {
ICOM_THIS(IClassFactory,iface);
return ++(this->ref);
ICOM_THIS(IClassFactoryImpl,iface);
return ++(This->ref);
}
static ULONG WINAPI DSCF_Release(LPCLASSFACTORY iface) {
ICOM_THIS(IClassFactory,iface);
ICOM_THIS(IClassFactoryImpl,iface);
/* static class, won't be freed */
return --(this->ref);
return --(This->ref);
}
static HRESULT WINAPI DSCF_CreateInstance(
LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj
) {
ICOM_THIS(IClassFactory,iface);
ICOM_THIS(IClassFactoryImpl,iface);
char buf[80];
WINE_StringFromCLSID(riid,buf);
TRACE(dsound,"(%p)->(%p,%s,%p)\n",this,pOuter,buf,ppobj);
TRACE(dsound,"(%p)->(%p,%s,%p)\n",This,pOuter,buf,ppobj);
if (!memcmp(riid,&IID_IDirectSound,sizeof(IID_IDirectSound))) {
/* FIXME: reuse already created dsound if present? */
return DirectSoundCreate(riid,(LPDIRECTSOUND*)ppobj,pOuter);
@ -2199,19 +2206,19 @@ static HRESULT WINAPI DSCF_CreateInstance(
}
static HRESULT WINAPI DSCF_LockServer(LPCLASSFACTORY iface,BOOL32 dolock) {
ICOM_THIS(IClassFactory,iface);
FIXME(dsound,"(%p)->(%d),stub!\n",this,dolock);
ICOM_THIS(IClassFactoryImpl,iface);
FIXME(dsound,"(%p)->(%d),stub!\n",This,dolock);
return S_OK;
}
static ICOM_VTABLE(IClassFactory) DSCF_VTable = {
static ICOM_VTABLE(IClassFactory) DSCF_Vtbl = {
DSCF_QueryInterface,
DSCF_AddRef,
DSCF_Release,
DSCF_CreateInstance,
DSCF_LockServer
};
static _IClassFactory DSOUND_CF = {&DSCF_VTable, 1 };
static IClassFactoryImpl DSOUND_CF = {&DSCF_Vtbl, 1 };
/*******************************************************************************
* DllGetClassObject [DSOUND.4]
@ -2246,7 +2253,7 @@ DWORD WINAPI DSOUND_DllGetClassObject(REFCLSID rclsid,REFIID riid,LPVOID *ppv)
TRACE(dsound, "(%p,%p,%p)\n", xbuf, buf, ppv);
if (!memcmp(riid,&IID_IClassFactory,sizeof(IID_IClassFactory))) {
*ppv = (LPVOID)&DSOUND_CF;
IClassFactory_AddRef(&DSOUND_CF);
IClassFactory_AddRef((IClassFactory*)*ppv);
return S_OK;
}
FIXME(dsound, "(%p,%p,%p): no interface found.\n", xbuf, buf, ppv);

4
ole/compobj.c
View File

@ -45,6 +45,8 @@
#include "objbase.h"
#include "ifs.h"
/****************************************************************************
* COM External Lock structures and methods declaration
*
@ -1283,7 +1285,7 @@ HRESULT WINAPI CoCreateInstance(
hres = CoGetClassObject(rclsid,
dwClsContext,
NULL,
(const REFIID) &IID_IClassFactory,
&IID_IClassFactory,
(LPVOID)&lpclf);
if (FAILED(hres))

147
ole/ifs.c
View File

@ -18,44 +18,51 @@
#include "module.h"
#include "debug.h"
#include "ifs.h"
/* --- IUnknown implementation */
typedef struct
{
/* IUnknown fields */
ICOM_VTABLE(IUnknown)* lpvtbl;
DWORD ref;
} IUnknownImpl;
/******************************************************************************
* IUnknown_AddRef [VTABLE:IUNKNOWN.1]
*/
static ULONG WINAPI IUnknown_fnAddRef(LPUNKNOWN iface) {
ICOM_THIS(IUnknown,iface);
TRACE(relay,"(%p)->AddRef()\n",this);
return ++(this->ref);
ICOM_THIS(IUnknownImpl,iface);
TRACE(relay,"(%p)->AddRef()\n",This);
return ++(This->ref);
}
/******************************************************************************
* IUnknown_Release [VTABLE:IUNKNOWN.2]
*/
static ULONG WINAPI IUnknown_fnRelease(LPUNKNOWN iface) {
ICOM_THIS(IUnknown,iface);
TRACE(relay,"(%p)->Release()\n",this);
if (!--(this->ref)) {
HeapFree(GetProcessHeap(),0,this);
ICOM_THIS(IUnknownImpl,iface);
TRACE(relay,"(%p)->Release()\n",This);
if (!--(This->ref)) {
HeapFree(GetProcessHeap(),0,This);
return 0;
}
return this->ref;
return This->ref;
}
/******************************************************************************
* IUnknown_QueryInterface [VTABLE:IUNKNOWN.0]
*/
static HRESULT WINAPI IUnknown_fnQueryInterface(LPUNKNOWN iface,REFIID refiid,LPVOID *obj) {
ICOM_THIS(IUnknown,iface);
ICOM_THIS(IUnknownImpl,iface);
char xrefiid[50];
WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
TRACE(relay,"(%p)->QueryInterface(%s,%p)\n",this,xrefiid,obj);
TRACE(relay,"(%p)->QueryInterface(%s,%p)\n",This,xrefiid,obj);
if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
*obj = this;
*obj = This;
return 0;
}
return OLE_E_ENUM_NOMORE;
@ -72,9 +79,9 @@ static ICOM_VTABLE(IUnknown) uvt = {
*/
LPUNKNOWN
IUnknown_Constructor() {
_IUnknown* unk;
IUnknownImpl* unk;
unk = (_IUnknown*)HeapAlloc(GetProcessHeap(),0,sizeof(IUnknown));
unk = (IUnknownImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IUnknownImpl));
unk->lpvtbl = &uvt;
unk->ref = 1;
return (LPUNKNOWN)unk;
@ -84,7 +91,8 @@ IUnknown_Constructor() {
/* --- IMalloc16 implementation */
typedef struct _IMalloc16 {
typedef struct
{
/* IUnknown fields */
ICOM_VTABLE(IMalloc16)* lpvtbl;
DWORD ref;
@ -93,21 +101,21 @@ typedef struct _IMalloc16 {
* heaps
*/
HGLOBAL16 heap;
} _IMalloc16;
} IMalloc16Impl;
/******************************************************************************
* IMalloc16_QueryInterface [COMPOBJ.500]
*/
HRESULT WINAPI IMalloc16_fnQueryInterface(IMalloc16* iface,REFIID refiid,LPVOID *obj) {
ICOM_THIS(IMalloc16,iface);
ICOM_THIS(IMalloc16Impl,iface);
char xrefiid[50];
WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
TRACE(relay,"(%p)->QueryInterface(%s,%p)\n",this,xrefiid,obj);
TRACE(relay,"(%p)->QueryInterface(%s,%p)\n",This,xrefiid,obj);
if ( !memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown)) ||
!memcmp(&IID_IMalloc,refiid,sizeof(IID_IMalloc))
) {
*obj = this;
*obj = This;
return 0;
}
return OLE_E_ENUM_NOMORE;
@ -117,8 +125,8 @@ HRESULT WINAPI IMalloc16_fnQueryInterface(IMalloc16* iface,REFIID refiid,LPVOID
* IMalloc16_AddRef [COMPOBJ.501]
*/
ULONG WINAPI IMalloc16_fnAddRef(IMalloc16* iface) {
ICOM_THIS(IMalloc16,iface);
TRACE(relay,"(%p)->AddRef()\n",this);
ICOM_THIS(IMalloc16Impl,iface);
TRACE(relay,"(%p)->AddRef()\n",This);
return 1; /* cannot be freed */
}
@ -126,8 +134,8 @@ ULONG WINAPI IMalloc16_fnAddRef(IMalloc16* iface) {
* IMalloc16_Release [COMPOBJ.502]
*/
ULONG WINAPI IMalloc16_fnRelease(IMalloc16* iface) {
ICOM_THIS(IMalloc16,iface);
TRACE(relay,"(%p)->Release()\n",this);
ICOM_THIS(IMalloc16Impl,iface);
TRACE(relay,"(%p)->Release()\n",This);
return 1; /* cannot be freed */
}
@ -135,36 +143,36 @@ ULONG WINAPI IMalloc16_fnRelease(IMalloc16* iface) {
* IMalloc16_Alloc [COMPOBJ.503]
*/
LPVOID WINAPI IMalloc16_fnAlloc(IMalloc16* iface,DWORD cb) {
ICOM_THIS(IMalloc16,iface);
TRACE(relay,"(%p)->Alloc(%ld)\n",this,cb);
return (LPVOID)PTR_SEG_OFF_TO_SEGPTR(this->heap,LOCAL_Alloc(this->heap,0,cb));
ICOM_THIS(IMalloc16Impl,iface);
TRACE(relay,"(%p)->Alloc(%ld)\n",This,cb);
return (LPVOID)PTR_SEG_OFF_TO_SEGPTR(This->heap,LOCAL_Alloc(This->heap,0,cb));
}
/******************************************************************************
* IMalloc16_Realloc [COMPOBJ.504]
*/
LPVOID WINAPI IMalloc16_fnRealloc(IMalloc16* iface,LPVOID pv,DWORD cb) {
ICOM_THIS(IMalloc16,iface);
TRACE(relay,"(%p)->Realloc(%p,%ld)\n",this,pv,cb);
return (LPVOID)PTR_SEG_OFF_TO_SEGPTR(this->heap,LOCAL_ReAlloc(this->heap,0,LOWORD(pv),cb));
ICOM_THIS(IMalloc16Impl,iface);
TRACE(relay,"(%p)->Realloc(%p,%ld)\n",This,pv,cb);
return (LPVOID)PTR_SEG_OFF_TO_SEGPTR(This->heap,LOCAL_ReAlloc(This->heap,0,LOWORD(pv),cb));
}
/******************************************************************************
* IMalloc16_Free [COMPOBJ.505]
*/
VOID WINAPI IMalloc16_fnFree(IMalloc16* iface,LPVOID pv) {
ICOM_THIS(IMalloc16,iface);
TRACE(relay,"(%p)->Free(%p)\n",this,pv);
LOCAL_Free(this->heap,LOWORD(pv));
ICOM_THIS(IMalloc16Impl,iface);
TRACE(relay,"(%p)->Free(%p)\n",This,pv);
LOCAL_Free(This->heap,LOWORD(pv));
}
/******************************************************************************
* IMalloc16_GetSize [COMPOBJ.506]
*/
DWORD WINAPI IMalloc16_fnGetSize(const IMalloc16* iface,LPVOID pv) {
ICOM_CTHIS(IMalloc16,iface);
TRACE(relay,"(%p)->GetSize(%p)\n",this,pv);
return LOCAL_Size(this->heap,LOWORD(pv));
ICOM_CTHIS(IMalloc16Impl,iface);
TRACE(relay,"(%p)->GetSize(%p)\n",This,pv);
return LOCAL_Size(This->heap,LOWORD(pv));
}
/******************************************************************************
@ -172,7 +180,7 @@ DWORD WINAPI IMalloc16_fnGetSize(const IMalloc16* iface,LPVOID pv) {
*/
INT16 WINAPI IMalloc16_fnDidAlloc(const IMalloc16* iface,LPVOID pv) {
ICOM_CTHIS(IMalloc16,iface);
TRACE(relay,"(%p)->DidAlloc(%p)\n",this,pv);
TRACE(relay,"(%p)->DidAlloc(%p)\n",This,pv);
return (INT16)-1;
}
@ -180,8 +188,8 @@ INT16 WINAPI IMalloc16_fnDidAlloc(const IMalloc16* iface,LPVOID pv) {
* IMalloc16_HeapMinimize [COMPOBJ.508]
*/
LPVOID WINAPI IMalloc16_fnHeapMinimize(IMalloc16* iface) {
ICOM_THIS(IMalloc16,iface);
TRACE(relay,"(%p)->HeapMinimize()\n",this);
ICOM_THIS(IMalloc16Impl,iface);
TRACE(relay,"(%p)->HeapMinimize()\n",This);
return NULL;
}
@ -192,12 +200,12 @@ static ICOM_VTABLE(IMalloc16)* msegvt16 = NULL;
*/
LPMALLOC16
IMalloc16_Constructor() {
_IMalloc16* this;
IMalloc16Impl* This;
HMODULE16 hcomp = GetModuleHandle16("COMPOBJ");
this = (_IMalloc16*)SEGPTR_NEW(_IMalloc16);
This = (IMalloc16Impl*)SEGPTR_NEW(IMalloc16Impl);
if (!msegvt16) {
this->lpvtbl = msegvt16 = SEGPTR_NEW(ICOM_VTABLE(IMalloc16));
This->lpvtbl = msegvt16 = SEGPTR_NEW(ICOM_VTABLE(IMalloc16));
#define VTENT(x) msegvt16->fn##x = (void*)WIN32_GetProcAddress16(hcomp,"IMalloc16_"#x);assert(msegvt16->fn##x)
VTENT(QueryInterface);
@ -212,35 +220,36 @@ IMalloc16_Constructor() {
msegvt16 = (ICOM_VTABLE(IMalloc16)*)SEGPTR_GET(msegvt16);
#undef VTENT
}
this->ref = 1;
This->ref = 1;
/* FIXME: implement multiple heaps */
this->heap = GlobalAlloc16(GMEM_MOVEABLE,64000);
LocalInit(this->heap,0,64000);
return (LPMALLOC16)SEGPTR_GET(this);
This->heap = GlobalAlloc16(GMEM_MOVEABLE,64000);
LocalInit(This->heap,0,64000);
return (LPMALLOC16)SEGPTR_GET(This);
}
/* --- IMalloc32 implementation */
typedef struct _IMalloc32 {
typedef struct
{
/* IUnknown fields */
ICOM_VTABLE(IMalloc32)* lpvtbl;
DWORD ref;
} _IMalloc32;
} IMalloc32Impl;
/******************************************************************************
* IMalloc32_QueryInterface [VTABLE]
*/
static HRESULT WINAPI IMalloc32_fnQueryInterface(LPMALLOC32 iface,REFIID refiid,LPVOID *obj) {
ICOM_THIS(IMalloc32,iface);
ICOM_THIS(IMalloc32Impl,iface);
char xrefiid[50];
WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
TRACE(relay,"(%p)->QueryInterface(%s,%p)\n",this,xrefiid,obj);
TRACE(relay,"(%p)->QueryInterface(%s,%p)\n",This,xrefiid,obj);
if ( !memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown)) ||
!memcmp(&IID_IMalloc,refiid,sizeof(IID_IMalloc))
) {
*obj = this;
*obj = This;
return S_OK;
}
return OLE_E_ENUM_NOMORE;
@ -250,8 +259,8 @@ static HRESULT WINAPI IMalloc32_fnQueryInterface(LPMALLOC32 iface,REFIID refiid,
* IMalloc32_AddRef [VTABLE]
*/
static ULONG WINAPI IMalloc32_fnAddRef(LPMALLOC32 iface) {
ICOM_THIS(IMalloc32,iface);
TRACE(relay,"(%p)->AddRef()\n",this);
ICOM_THIS(IMalloc32Impl,iface);
TRACE(relay,"(%p)->AddRef()\n",This);
return 1; /* cannot be freed */
}
@ -259,8 +268,8 @@ static ULONG WINAPI IMalloc32_fnAddRef(LPMALLOC32 iface) {
* IMalloc32_Release [VTABLE]
*/
static ULONG WINAPI IMalloc32_fnRelease(LPMALLOC32 iface) {
ICOM_THIS(IMalloc32,iface);
TRACE(relay,"(%p)->Release()\n",this);
ICOM_THIS(IMalloc32Impl,iface);
TRACE(relay,"(%p)->Release()\n",This);
return 1; /* cannot be freed */
}
@ -268,8 +277,8 @@ static ULONG WINAPI IMalloc32_fnRelease(LPMALLOC32 iface) {
* IMalloc32_Alloc [VTABLE]
*/
static LPVOID WINAPI IMalloc32_fnAlloc(LPMALLOC32 iface,DWORD cb) {
ICOM_THIS(IMalloc32,iface);
TRACE(relay,"(%p)->Alloc(%ld)\n",this,cb);
ICOM_THIS(IMalloc32Impl,iface);
TRACE(relay,"(%p)->Alloc(%ld)\n",This,cb);
return HeapAlloc(GetProcessHeap(),0,cb);
}
@ -277,8 +286,8 @@ static LPVOID WINAPI IMalloc32_fnAlloc(LPMALLOC32 iface,DWORD cb) {
* IMalloc32_Realloc [VTABLE]
*/
static LPVOID WINAPI IMalloc32_fnRealloc(LPMALLOC32 iface,LPVOID pv,DWORD cb) {
ICOM_THIS(IMalloc32,iface);
TRACE(relay,"(%p)->Realloc(%p,%ld)\n",this,pv,cb);
ICOM_THIS(IMalloc32Impl,iface);
TRACE(relay,"(%p)->Realloc(%p,%ld)\n",This,pv,cb);
return HeapReAlloc(GetProcessHeap(),0,pv,cb);
}
@ -286,8 +295,8 @@ static LPVOID WINAPI IMalloc32_fnRealloc(LPMALLOC32 iface,LPVOID pv,DWORD cb) {
* IMalloc32_Free [VTABLE]
*/
static VOID WINAPI IMalloc32_fnFree(LPMALLOC32 iface,LPVOID pv) {
ICOM_THIS(IMalloc32,iface);
TRACE(relay,"(%p)->Free(%p)\n",this,pv);
ICOM_THIS(IMalloc32Impl,iface);
TRACE(relay,"(%p)->Free(%p)\n",This,pv);
HeapFree(GetProcessHeap(),0,pv);
}
@ -296,7 +305,7 @@ static VOID WINAPI IMalloc32_fnFree(LPMALLOC32 iface,LPVOID pv) {
*/
static DWORD WINAPI IMalloc32_fnGetSize(const IMalloc32* iface,LPVOID pv) {
ICOM_CTHIS(IMalloc32,iface);
TRACE(relay,"(%p)->GetSize(%p)\n",this,pv);
TRACE(relay,"(%p)->GetSize(%p)\n",This,pv);
return HeapSize(GetProcessHeap(),0,pv);
}
@ -304,8 +313,8 @@ static DWORD WINAPI IMalloc32_fnGetSize(const IMalloc32* iface,LPVOID pv) {
* IMalloc32_DidAlloc [VTABLE]
*/
static INT32 WINAPI IMalloc32_fnDidAlloc(const IMalloc32* iface,LPVOID pv) {
ICOM_CTHIS(IMalloc32,iface);
TRACE(relay,"(%p)->DidAlloc(%p)\n",this,pv);
ICOM_CTHIS(IMalloc32Impl,iface);
TRACE(relay,"(%p)->DidAlloc(%p)\n",This,pv);
return -1;
}
@ -313,8 +322,8 @@ static INT32 WINAPI IMalloc32_fnDidAlloc(const IMalloc32* iface,LPVOID pv) {
* IMalloc32_HeapMinimize [VTABLE]
*/
static LPVOID WINAPI IMalloc32_fnHeapMinimize(LPMALLOC32 iface) {
ICOM_THIS(IMalloc32,iface);
TRACE(relay,"(%p)->HeapMinimize()\n",this);
ICOM_THIS(IMalloc32Impl,iface);
TRACE(relay,"(%p)->HeapMinimize()\n",This);
return NULL;
}
@ -335,12 +344,12 @@ static ICOM_VTABLE(IMalloc32) VT_IMalloc32 = {
*/
LPMALLOC32
IMalloc32_Constructor() {
_IMalloc32* this;
IMalloc32Impl* This;
this = (_IMalloc32*)HeapAlloc(GetProcessHeap(),0,sizeof(_IMalloc32));
this->lpvtbl = &VT_IMalloc32;
this->ref = 1;
return (LPMALLOC32)this;
This = (IMalloc32Impl*)HeapAlloc(GetProcessHeap(),0,sizeof(IMalloc32Impl));
This->lpvtbl = &VT_IMalloc32;
This->ref = 1;
return (LPMALLOC32)This;
}
/****************************************************************************

7
ole/ifs.h Normal file
View File

@ -0,0 +1,7 @@
#ifndef __WINE_OLE_IFS_H
#define __WINE_OLE_IFS_H
extern LPMALLOC16 IMalloc16_Constructor();
extern LPMALLOC32 IMalloc32_Constructor();
#endif /* __WINE_OLE_IFS_H */

301
ole/storage.c
View File

@ -664,7 +664,8 @@ STORAGE_get_free_pps_entry(HFILE32 hf) {
/* --- IStream16 implementation */
typedef struct _IStream16 {
typedef struct
{
/* IUnknown fields */
ICOM_VTABLE(IStream16)* lpvtbl;
DWORD ref;
@ -674,7 +675,7 @@ typedef struct _IStream16 {
int ppsent;
HFILE32 hf;
ULARGE_INTEGER offset;
} _IStream16;
} IStream16Impl;
/******************************************************************************
* IStream16_QueryInterface [STORAGE.518]
@ -682,12 +683,12 @@ typedef struct _IStream16 {
HRESULT WINAPI IStream16_fnQueryInterface(
LPUNKNOWN iface,REFIID refiid,LPVOID *obj
) {
ICOM_THIS(IStream16,iface);
ICOM_THIS(IStream16Impl,iface);
char xrefiid[50];
WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
TRACE(relay,"(%p)->(%s,%p)\n",this,xrefiid,obj);
TRACE(relay,"(%p)->(%s,%p)\n",This,xrefiid,obj);
if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
*obj = this;
*obj = This;
return 0;
}
return OLE_E_ENUM_NOMORE;
@ -698,23 +699,23 @@ HRESULT WINAPI IStream16_fnQueryInterface(
* IStream16_AddRef [STORAGE.519]
*/
ULONG WINAPI IStream16_fnAddRef(LPUNKNOWN iface) {
ICOM_THIS(IStream16,iface);
return ++(this->ref);
ICOM_THIS(IStream16Impl,iface);
return ++(This->ref);
}
/******************************************************************************
* IStream16_Release [STORAGE.520]
*/
ULONG WINAPI IStream16_fnRelease(LPUNKNOWN iface) {
ICOM_THIS(IStream16,iface);
FlushFileBuffers(this->hf);
this->ref--;
if (!this->ref) {
CloseHandle(this->hf);
SEGPTR_FREE(this);
ICOM_THIS(IStream16Impl,iface);
FlushFileBuffers(This->hf);
This->ref--;
if (!This->ref) {
CloseHandle(This->hf);
SEGPTR_FREE(This);
return 0;
}
return this->ref;
return This->ref;
}
/******************************************************************************
@ -724,10 +725,10 @@ ULONG WINAPI IStream16_fnRelease(LPUNKNOWN iface) {
* Does not handle 64 bits
*/
HRESULT WINAPI IStream16_fnSeek(
LPSTREAM16 iface,LARGE_INTEGER offset,DWORD whence,ULARGE_INTEGER *newpos
IStream16* iface,LARGE_INTEGER offset,DWORD whence,ULARGE_INTEGER *newpos
) {
ICOM_THIS(IStream16,iface);
TRACE(relay,"(%p)->([%ld.%ld],%ld,%p)\n",this,offset.HighPart,offset.LowPart,whence,newpos);
ICOM_THIS(IStream16Impl,iface);
TRACE(relay,"(%p)->([%ld.%ld],%ld,%p)\n",This,offset.HighPart,offset.LowPart,whence,newpos);
switch (whence) {
/* unix SEEK_xx should be the same as win95 ones */
@ -736,8 +737,8 @@ HRESULT WINAPI IStream16_fnSeek(
* right now.
*/
assert(offset.HighPart==0);
this->offset.HighPart = offset.HighPart;
this->offset.LowPart = offset.LowPart;
This->offset.HighPart = offset.HighPart;
This->offset.LowPart = offset.LowPart;
break;
case SEEK_CUR:
if (offset.HighPart < 0) {
@ -746,21 +747,21 @@ HRESULT WINAPI IStream16_fnSeek(
offset.LowPart = (0xffffffff ^ offset.LowPart)+1;
assert(offset.HighPart==0);
assert(this->offset.LowPart >= offset.LowPart);
this->offset.LowPart -= offset.LowPart;
assert(This->offset.LowPart >= offset.LowPart);
This->offset.LowPart -= offset.LowPart;
} else {
assert(offset.HighPart==0);
this->offset.LowPart+= offset.LowPart;
This->offset.LowPart+= offset.LowPart;
}
break;
case SEEK_END:
assert(offset.HighPart==0);
this->offset.LowPart = this->stde.pps_size-offset.LowPart;
This->offset.LowPart = This->stde.pps_size-offset.LowPart;
break;
}
if (this->offset.LowPart>this->stde.pps_size)
this->offset.LowPart=this->stde.pps_size;
if (newpos) *newpos = this->offset;
if (This->offset.LowPart>This->stde.pps_size)
This->offset.LowPart=This->stde.pps_size;
if (newpos) *newpos = This->offset;
return S_OK;
}
@ -770,56 +771,56 @@ HRESULT WINAPI IStream16_fnSeek(
HRESULT WINAPI IStream16_fnRead(
LPSEQUENTIALSTREAM iface,void *pv,ULONG cb,ULONG *pcbRead
) {
ICOM_THIS(IStream16,iface);
ICOM_THIS(IStream16Impl,iface);
BYTE block[BIGSIZE];
ULONG *bytesread=pcbRead,xxread;
int blocknr;
TRACE(relay,"(%p)->(%p,%ld,%p)\n",this,pv,cb,pcbRead);
TRACE(relay,"(%p)->(%p,%ld,%p)\n",This,pv,cb,pcbRead);
if (!pcbRead) bytesread=&xxread;
*bytesread = 0;
if (cb>this->stde.pps_size-this->offset.LowPart)
cb=this->stde.pps_size-this->offset.LowPart;
if (this->stde.pps_size < 0x1000) {
if (cb>This->stde.pps_size-This->offset.LowPart)
cb=This->stde.pps_size-This->offset.LowPart;
if (This->stde.pps_size < 0x1000) {
/* use small block reader */
blocknr = STORAGE_get_nth_next_small_blocknr(this->hf,this->stde.pps_sb,this->offset.LowPart/SMALLSIZE);
blocknr = STORAGE_get_nth_next_small_blocknr(This->hf,This->stde.pps_sb,This->offset.LowPart/SMALLSIZE);
while (cb) {
int cc;
if (!STORAGE_get_small_block(this->hf,blocknr,block)) {
if (!STORAGE_get_small_block(This->hf,blocknr,block)) {
WARN(ole,"small block read failed!!!\n");
return E_FAIL;
}
cc = cb;
if (cc>SMALLSIZE-(this->offset.LowPart&(SMALLSIZE-1)))
cc=SMALLSIZE-(this->offset.LowPart&(SMALLSIZE-1));
memcpy((LPBYTE)pv,block+(this->offset.LowPart&(SMALLSIZE-1)),cc);
this->offset.LowPart+=cc;
if (cc>SMALLSIZE-(This->offset.LowPart&(SMALLSIZE-1)))
cc=SMALLSIZE-(This->offset.LowPart&(SMALLSIZE-1));
memcpy((LPBYTE)pv,block+(This->offset.LowPart&(SMALLSIZE-1)),cc);
This->offset.LowPart+=cc;
(LPBYTE)pv+=cc;
*bytesread+=cc;
cb-=cc;
blocknr = STORAGE_get_next_small_blocknr(this->hf,blocknr);
blocknr = STORAGE_get_next_small_blocknr(This->hf,blocknr);
}
} else {
/* use big block reader */
blocknr = STORAGE_get_nth_next_big_blocknr(this->hf,this->stde.pps_sb,this->offset.LowPart/BIGSIZE);
blocknr = STORAGE_get_nth_next_big_blocknr(This->hf,This->stde.pps_sb,This->offset.LowPart/BIGSIZE);
while (cb) {
int cc;
if (!STORAGE_get_big_block(this->hf,blocknr,block)) {
if (!STORAGE_get_big_block(This->hf,blocknr,block)) {
WARN(ole,"big block read failed!!!\n");
return E_FAIL;
}
cc = cb;
if (cc>BIGSIZE-(this->offset.LowPart&(BIGSIZE-1)))
cc=BIGSIZE-(this->offset.LowPart&(BIGSIZE-1));
memcpy((LPBYTE)pv,block+(this->offset.LowPart&(BIGSIZE-1)),cc);
this->offset.LowPart+=cc;
if (cc>BIGSIZE-(This->offset.LowPart&(BIGSIZE-1)))
cc=BIGSIZE-(This->offset.LowPart&(BIGSIZE-1));
memcpy((LPBYTE)pv,block+(This->offset.LowPart&(BIGSIZE-1)),cc);
This->offset.LowPart+=cc;
(LPBYTE)pv+=cc;
*bytesread+=cc;
cb-=cc;
blocknr=STORAGE_get_next_big_blocknr(this->hf,blocknr);
blocknr=STORAGE_get_next_big_blocknr(This->hf,blocknr);
}
}
return S_OK;
@ -831,23 +832,23 @@ HRESULT WINAPI IStream16_fnRead(
HRESULT WINAPI IStream16_fnWrite(
LPSEQUENTIALSTREAM iface,const void *pv,ULONG cb,ULONG *pcbWrite
) {
ICOM_THIS(IStream16,iface);
ICOM_THIS(IStream16Impl,iface);
BYTE block[BIGSIZE];
ULONG *byteswritten=pcbWrite,xxwritten;
int oldsize,newsize,i,curoffset=0,lastblocknr,blocknr,cc;
HFILE32 hf = this->hf;
HFILE32 hf = This->hf;
if (!pcbWrite) byteswritten=&xxwritten;
*byteswritten = 0;
TRACE(relay,"(%p)->(%p,%ld,%p)\n",this,pv,cb,pcbWrite);
TRACE(relay,"(%p)->(%p,%ld,%p)\n",This,pv,cb,pcbWrite);
/* do we need to junk some blocks? */
newsize = this->offset.LowPart+cb;
oldsize = this->stde.pps_size;
newsize = This->offset.LowPart+cb;
oldsize = This->stde.pps_size;
if (newsize < oldsize) {
if (oldsize < 0x1000) {
/* only small blocks */
blocknr=STORAGE_get_nth_next_small_blocknr(hf,this->stde.pps_sb,newsize/SMALLSIZE);
blocknr=STORAGE_get_nth_next_small_blocknr(hf,This->stde.pps_sb,newsize/SMALLSIZE);
assert(blocknr>=0);
@ -856,7 +857,7 @@ HRESULT WINAPI IStream16_fnWrite(
return E_FAIL;
} else {
if (newsize >= 0x1000) {
blocknr=STORAGE_get_nth_next_big_blocknr(hf,this->stde.pps_sb,newsize/BIGSIZE);
blocknr=STORAGE_get_nth_next_big_blocknr(hf,This->stde.pps_sb,newsize/BIGSIZE);
assert(blocknr>=0);
/* will set the rest of the chain to 'free' */
@ -868,7 +869,7 @@ HRESULT WINAPI IStream16_fnWrite(
*/
LPBYTE curdata,data = HeapAlloc(GetProcessHeap(),0,newsize+BIGSIZE);
cc = newsize;
blocknr = this->stde.pps_sb;
blocknr = This->stde.pps_sb;
curdata = data;
while (cc>0) {
if (!STORAGE_get_big_block(hf,blocknr,curdata)) {
@ -880,10 +881,10 @@ HRESULT WINAPI IStream16_fnWrite(
blocknr = STORAGE_get_next_big_blocknr(hf,blocknr);
}
/* frees complete chain for this stream */
if (!STORAGE_set_big_chain(hf,this->stde.pps_sb,STORAGE_CHAINENTRY_FREE))
if (!STORAGE_set_big_chain(hf,This->stde.pps_sb,STORAGE_CHAINENTRY_FREE))
return E_FAIL;
curdata = data;
blocknr = this->stde.pps_sb = STORAGE_get_free_small_blocknr(hf);
blocknr = This->stde.pps_sb = STORAGE_get_free_small_blocknr(hf);
if (blocknr<0)
return E_FAIL;
cc = newsize;
@ -908,13 +909,13 @@ HRESULT WINAPI IStream16_fnWrite(
HeapFree(GetProcessHeap(),0,data);
}
}
this->stde.pps_size = newsize;
This->stde.pps_size = newsize;
}
if (newsize > oldsize) {
if (oldsize >= 0x1000) {
/* should return the block right before the 'endofchain' */
blocknr = STORAGE_get_nth_next_big_blocknr(hf,this->stde.pps_sb,this->stde.pps_size/BIGSIZE);
blocknr = STORAGE_get_nth_next_big_blocknr(hf,This->stde.pps_sb,This->stde.pps_size/BIGSIZE);
assert(blocknr>=0);
lastblocknr = blocknr;
for (i=oldsize/BIGSIZE;i<newsize/BIGSIZE;i++) {
@ -931,9 +932,9 @@ HRESULT WINAPI IStream16_fnWrite(
if (newsize < 0x1000) {
/* find startblock */
if (!oldsize)
this->stde.pps_sb = blocknr = STORAGE_get_free_small_blocknr(hf);
This->stde.pps_sb = blocknr = STORAGE_get_free_small_blocknr(hf);
else
blocknr = STORAGE_get_nth_next_small_blocknr(hf,this->stde.pps_sb,this->stde.pps_size/SMALLSIZE);
blocknr = STORAGE_get_nth_next_small_blocknr(hf,This->stde.pps_sb,This->stde.pps_size/SMALLSIZE);
if (blocknr<0)
return E_FAIL;
@ -956,12 +957,12 @@ HRESULT WINAPI IStream16_fnWrite(
blocknr=STORAGE_get_free_big_blocknr(hf);
if (blocknr<0)
return E_FAIL;
this->stde.pps_sb = blocknr;
This->stde.pps_sb = blocknr;
} else {
/* Migrate small blocks to big blocks */
LPBYTE curdata,data = HeapAlloc(GetProcessHeap(),0,oldsize+BIGSIZE);
cc = oldsize;
blocknr = this->stde.pps_sb;
blocknr = This->stde.pps_sb;
curdata = data;
/* slurp in */
while (cc>0) {
@ -974,14 +975,14 @@ HRESULT WINAPI IStream16_fnWrite(
blocknr = STORAGE_get_next_small_blocknr(hf,blocknr);
}
/* free small block chain */
if (!STORAGE_set_small_chain(hf,this->stde.pps_sb,STORAGE_CHAINENTRY_FREE))
if (!STORAGE_set_small_chain(hf,This->stde.pps_sb,STORAGE_CHAINENTRY_FREE))
return E_FAIL;
curdata = data;
blocknr = this->stde.pps_sb = STORAGE_get_free_big_blocknr(hf);
blocknr = This->stde.pps_sb = STORAGE_get_free_big_blocknr(hf);
if (blocknr<0)
return E_FAIL;
/* put the data into the big blocks */
cc = this->stde.pps_size;
cc = This->stde.pps_size;
while (cc>0) {
if (!STORAGE_put_big_block(hf,blocknr,curdata))
return E_FAIL;
@ -1017,18 +1018,18 @@ HRESULT WINAPI IStream16_fnWrite(
return E_FAIL;
}
}
this->stde.pps_size = newsize;
This->stde.pps_size = newsize;
}
/* There are just some cases where we didn't modify it, we write it out
* everytime
*/
if (!STORAGE_put_pps_entry(hf,this->ppsent,&(this->stde)))
if (!STORAGE_put_pps_entry(hf,This->ppsent,&(This->stde)))
return E_FAIL;
/* finally the write pass */
if (this->stde.pps_size < 0x1000) {
blocknr = STORAGE_get_nth_next_small_blocknr(hf,this->stde.pps_sb,this->offset.LowPart/SMALLSIZE);
if (This->stde.pps_size < 0x1000) {
blocknr = STORAGE_get_nth_next_small_blocknr(hf,This->stde.pps_sb,This->offset.LowPart/SMALLSIZE);
assert(blocknr>=0);
while (cb>0) {
/* we ensured that it is allocated above */
@ -1039,10 +1040,10 @@ HRESULT WINAPI IStream16_fnWrite(
if (!STORAGE_get_small_block(hf,blocknr,block))
return E_FAIL;
cc = SMALLSIZE-(this->offset.LowPart&(SMALLSIZE-1));
cc = SMALLSIZE-(This->offset.LowPart&(SMALLSIZE-1));
if (cc>cb)
cc=cb;
memcpy( ((LPBYTE)block)+(this->offset.LowPart&(SMALLSIZE-1)),
memcpy( ((LPBYTE)block)+(This->offset.LowPart&(SMALLSIZE-1)),
(LPBYTE)(pv+curoffset),
cc
);
@ -1051,12 +1052,12 @@ HRESULT WINAPI IStream16_fnWrite(
cb -= cc;
curoffset += cc;
(LPBYTE)pv += cc;
this->offset.LowPart += cc;
This->offset.LowPart += cc;
*byteswritten += cc;
blocknr = STORAGE_get_next_small_blocknr(hf,blocknr);
}
} else {
blocknr = STORAGE_get_nth_next_big_blocknr(hf,this->stde.pps_sb,this->offset.LowPart/BIGSIZE);
blocknr = STORAGE_get_nth_next_big_blocknr(hf,This->stde.pps_sb,This->offset.LowPart/BIGSIZE);
assert(blocknr>=0);
while (cb>0) {
/* we ensured that it is allocated above, so it better is */
@ -1067,10 +1068,10 @@ HRESULT WINAPI IStream16_fnWrite(
if (!STORAGE_get_big_block(hf,blocknr,block))
return E_FAIL;
cc = BIGSIZE-(this->offset.LowPart&(BIGSIZE-1));
cc = BIGSIZE-(This->offset.LowPart&(BIGSIZE-1));
if (cc>cb)
cc=cb;
memcpy( ((LPBYTE)block)+(this->offset.LowPart&(BIGSIZE-1)),
memcpy( ((LPBYTE)block)+(This->offset.LowPart&(BIGSIZE-1)),
(LPBYTE)(pv+curoffset),
cc
);
@ -1079,7 +1080,7 @@ HRESULT WINAPI IStream16_fnWrite(
cb -= cc;
curoffset += cc;
(LPBYTE)pv += cc;
this->offset.LowPart += cc;
This->offset.LowPart += cc;
*byteswritten += cc;
blocknr = STORAGE_get_next_big_blocknr(hf,blocknr);
}
@ -1091,7 +1092,7 @@ HRESULT WINAPI IStream16_fnWrite(
* _create_istream16 [Internal]
*/
static void _create_istream16(LPSTREAM16 *str) {
_IStream16* lpst;
IStream16Impl* lpst;
if (!strvt16.bvt.bvt.fnQueryInterface) {
HMODULE16 wp = GetModuleHandle16("STORAGE");
@ -1146,7 +1147,7 @@ static void _create_istream16(LPSTREAM16 *str) {
segstrvt16 = &strvt16;
}
}
lpst = SEGPTR_NEW(_IStream16);
lpst = SEGPTR_NEW(IStream16Impl);
lpst->lpvtbl = segstrvt16;
lpst->ref = 1;
lpst->thisptr = SEGPTR_GET(lpst);
@ -1156,7 +1157,8 @@ static void _create_istream16(LPSTREAM16 *str) {
/* --- IStream32 implementation */
typedef struct _IStream32 {
typedef struct
{
/* IUnknown fields */
ICOM_VTABLE(IStream32)* lpvtbl;
DWORD ref;
@ -1165,7 +1167,7 @@ typedef struct _IStream32 {
int ppsent;
HFILE32 hf;
ULARGE_INTEGER offset;
} _IStream32;
} IStream32Impl;
/*****************************************************************************
* IStream32_QueryInterface [VTABLE]
@ -1173,13 +1175,13 @@ typedef struct _IStream32 {
HRESULT WINAPI IStream32_fnQueryInterface(
LPUNKNOWN iface,REFIID refiid,LPVOID *obj
) {
ICOM_THIS(IStream32,iface);
ICOM_THIS(IStream32Impl,iface);
char xrefiid[50];
WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
TRACE(relay,"(%p)->(%s,%p)\n",this,xrefiid,obj);
TRACE(relay,"(%p)->(%s,%p)\n",This,xrefiid,obj);
if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
*obj = this;
*obj = This;
return 0;
}
return OLE_E_ENUM_NOMORE;
@ -1190,28 +1192,29 @@ HRESULT WINAPI IStream32_fnQueryInterface(
* IStream32_AddRef [VTABLE]
*/
ULONG WINAPI IStream32_fnAddRef(LPUNKNOWN iface) {
ICOM_THIS(IStream32,iface);
return ++(this->ref);
ICOM_THIS(IStream32Impl,iface);
return ++(This->ref);
}
/******************************************************************************
* IStream32_Release [VTABLE]
*/
ULONG WINAPI IStream32_fnRelease(LPUNKNOWN iface) {
ICOM_THIS(IStream32,iface);
FlushFileBuffers(this->hf);
this->ref--;
if (!this->ref) {
CloseHandle(this->hf);
SEGPTR_FREE(this);
ICOM_THIS(IStream32Impl,iface);
FlushFileBuffers(This->hf);
This->ref--;
if (!This->ref) {
CloseHandle(This->hf);
SEGPTR_FREE(This);
return 0;
}
return this->ref;
return This->ref;
}
/* --- IStorage16 implementation */
typedef struct _IStorage16 {
typedef struct
{
/* IUnknown fields */
ICOM_VTABLE(IStorage16)* lpvtbl;
DWORD ref;
@ -1220,7 +1223,7 @@ typedef struct _IStorage16 {
struct storage_pps_entry stde;
int ppsent;
HFILE32 hf;
} _IStorage16;
} IStorage16Impl;
/******************************************************************************
* IStorage16_QueryInterface [STORAGE.500]
@ -1228,14 +1231,14 @@ typedef struct _IStorage16 {
HRESULT WINAPI IStorage16_fnQueryInterface(
LPUNKNOWN iface,REFIID refiid,LPVOID *obj
) {
ICOM_THIS(IStorage16,iface);
ICOM_THIS(IStorage16Impl,iface);
char xrefiid[50];
WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
TRACE(relay,"(%p)->(%s,%p)\n",this,xrefiid,obj);
TRACE(relay,"(%p)->(%s,%p)\n",This,xrefiid,obj);
if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
*obj = this;
*obj = This;
return 0;
}
return OLE_E_ENUM_NOMORE;
@ -1245,19 +1248,19 @@ HRESULT WINAPI IStorage16_fnQueryInterface(
* IStorage16_AddRef [STORAGE.501]
*/
ULONG WINAPI IStorage16_fnAddRef(LPUNKNOWN iface) {
ICOM_THIS(IStorage16,iface);
return ++(this->ref);
ICOM_THIS(IStorage16Impl,iface);
return ++(This->ref);
}
/******************************************************************************
* IStorage16_Release [STORAGE.502]
*/
ULONG WINAPI IStorage16_fnRelease(LPUNKNOWN iface) {
ICOM_THIS(IStorage16,iface);
this->ref--;
if (this->ref)
return this->ref;
SEGPTR_FREE(this);
ICOM_THIS(IStorage16Impl,iface);
This->ref--;
if (This->ref)
return This->ref;
SEGPTR_FREE(This);
return 0;
}
@ -1267,19 +1270,19 @@ ULONG WINAPI IStorage16_fnRelease(LPUNKNOWN iface) {
HRESULT WINAPI IStorage16_fnStat(
LPSTORAGE16 iface,STATSTG *pstatstg, DWORD grfStatFlag
) {
ICOM_THIS(IStorage16,iface);
ICOM_THIS(IStorage16Impl,iface);
TRACE(ole,"(%p)->(%p,0x%08lx)\n",
this,pstatstg,grfStatFlag
This,pstatstg,grfStatFlag
);
pstatstg->pwcsName=(LPOLESTR16)SEGPTR_GET(SEGPTR_STRDUP_WtoA(this->stde.pps_rawname));
pstatstg->type = this->stde.pps_type;
pstatstg->cbSize.LowPart = this->stde.pps_size;
pstatstg->mtime = this->stde.pps_ft1; /* FIXME */ /* why? */
pstatstg->atime = this->stde.pps_ft2; /* FIXME */
pstatstg->ctime = this->stde.pps_ft2; /* FIXME */
pstatstg->pwcsName=(LPOLESTR16)SEGPTR_GET(SEGPTR_STRDUP_WtoA(This->stde.pps_rawname));
pstatstg->type = This->stde.pps_type;
pstatstg->cbSize.LowPart = This->stde.pps_size;
pstatstg->mtime = This->stde.pps_ft1; /* FIXME */ /* why? */
pstatstg->atime = This->stde.pps_ft2; /* FIXME */
pstatstg->ctime = This->stde.pps_ft2; /* FIXME */
pstatstg->grfMode = 0; /* FIXME */
pstatstg->grfLocksSupported = 0; /* FIXME */
pstatstg->clsid = this->stde.pps_guid;
pstatstg->clsid = This->stde.pps_guid;
pstatstg->grfStateBits = 0; /* FIXME */
pstatstg->reserved = 0;
return S_OK;
@ -1291,9 +1294,9 @@ HRESULT WINAPI IStorage16_fnStat(
HRESULT WINAPI IStorage16_fnCommit(
LPSTORAGE16 iface,DWORD commitflags
) {
ICOM_THIS(IStorage16,iface);
ICOM_THIS(IStorage16Impl,iface);
FIXME(ole,"(%p)->(0x%08lx),STUB!\n",
this,commitflags
This,commitflags
);
return S_OK;
}
@ -1302,7 +1305,7 @@ HRESULT WINAPI IStorage16_fnCommit(
* IStorage16_CopyTo [STORAGE.507]
*/
HRESULT WINAPI IStorage16_fnCopyTo(LPSTORAGE16 iface,DWORD ciidExclude,const IID *rgiidExclude,SNB16 SNB16Exclude,IStorage16 *pstgDest) {
ICOM_THIS(IStorage16,iface);
ICOM_THIS(IStorage16Impl,iface);
char xguid[50];
if (rgiidExclude)
@ -1310,7 +1313,7 @@ HRESULT WINAPI IStorage16_fnCopyTo(LPSTORAGE16 iface,DWORD ciidExclude,const IID
else
strcpy(xguid,"<no guid>");
FIXME(ole,"IStorage16(%p)->(0x%08lx,%s,%p,%p),stub!\n",
this,ciidExclude,xguid,SNB16Exclude,pstgDest
This,ciidExclude,xguid,SNB16Exclude,pstgDest
);
return S_OK;
}
@ -1322,31 +1325,31 @@ HRESULT WINAPI IStorage16_fnCopyTo(LPSTORAGE16 iface,DWORD ciidExclude,const IID
HRESULT WINAPI IStorage16_fnCreateStorage(
LPSTORAGE16 iface,LPCOLESTR16 pwcsName,DWORD grfMode,DWORD dwStgFormat,DWORD reserved2, IStorage16 **ppstg
) {
ICOM_THIS(IStorage16,iface);
_IStorage16* lpstg;
ICOM_THIS(IStorage16Impl,iface);
IStorage16Impl* lpstg;
int ppsent,x;
struct storage_pps_entry stde;
struct storage_header sth;
HFILE32 hf=this->hf;
HFILE32 hf=This->hf;
READ_HEADER;
TRACE(ole,"(%p)->(%s,0x%08lx,0x%08lx,0x%08lx,%p)\n",
this,pwcsName,grfMode,dwStgFormat,reserved2,ppstg
This,pwcsName,grfMode,dwStgFormat,reserved2,ppstg
);
if (grfMode & STGM_TRANSACTED)
FIXME(ole,"We do not support transacted Compound Storage. Using direct mode.\n");
_create_istorage16(ppstg);
lpstg = (_IStorage16*)PTR_SEG_TO_LIN(*ppstg);
lpstg->hf = this->hf;
lpstg = (IStorage16Impl*)PTR_SEG_TO_LIN(*ppstg);
lpstg->hf = This->hf;
ppsent=STORAGE_get_free_pps_entry(lpstg->hf);
if (ppsent<0)
return E_FAIL;
stde=this->stde;
stde=This->stde;
if (stde.pps_dir==-1) {
stde.pps_dir = ppsent;
x = this->ppsent;
x = This->ppsent;
} else {
FIXME(ole," use prev chain too ?\n");
x=stde.pps_dir;
@ -1382,19 +1385,19 @@ HRESULT WINAPI IStorage16_fnCreateStorage(
HRESULT WINAPI IStorage16_fnCreateStream(
LPSTORAGE16 iface,LPCOLESTR16 pwcsName,DWORD grfMode,DWORD reserved1,DWORD reserved2, IStream16 **ppstm
) {
ICOM_THIS(IStorage16,iface);
_IStream16* lpstr;
ICOM_THIS(IStorage16Impl,iface);
IStream16Impl* lpstr;
int ppsent,x;
struct storage_pps_entry stde;
TRACE(ole,"(%p)->(%s,0x%08lx,0x%08lx,0x%08lx,%p)\n",
this,pwcsName,grfMode,reserved1,reserved2,ppstm
This,pwcsName,grfMode,reserved1,reserved2,ppstm
);
if (grfMode & STGM_TRANSACTED)
FIXME(ole,"We do not support transacted Compound Storage. Using direct mode.\n");
_create_istream16(ppstm);
lpstr = (_IStream16*)PTR_SEG_TO_LIN(*ppstm);
DuplicateHandle( GetCurrentProcess(), this->hf, GetCurrentProcess(),
lpstr = (IStream16Impl*)PTR_SEG_TO_LIN(*ppstm);
DuplicateHandle( GetCurrentProcess(), This->hf, GetCurrentProcess(),
&lpstr->hf, 0, TRUE, DUPLICATE_SAME_ACCESS );
lpstr->offset.LowPart = 0;
lpstr->offset.HighPart = 0;
@ -1402,9 +1405,9 @@ HRESULT WINAPI IStorage16_fnCreateStream(
ppsent=STORAGE_get_free_pps_entry(lpstr->hf);
if (ppsent<0)
return E_FAIL;
stde=this->stde;
stde=This->stde;
if (stde.pps_next==-1)
x=this->ppsent;
x=This->ppsent;
else
while (stde.pps_next!=-1) {
x=stde.pps_next;
@ -1435,22 +1438,22 @@ HRESULT WINAPI IStorage16_fnCreateStream(
HRESULT WINAPI IStorage16_fnOpenStorage(
LPSTORAGE16 iface,LPCOLESTR16 pwcsName, IStorage16 *pstgPrio, DWORD grfMode, SNB16 snbExclude, DWORD reserved, IStorage16 **ppstg
) {
ICOM_THIS(IStorage16,iface);
_IStream16* lpstg;
ICOM_THIS(IStorage16Impl,iface);
IStream16Impl* lpstg;
WCHAR name[33];
int newpps;
TRACE(relay,"(%p)->(%s,%p,0x%08lx,%p,0x%08lx,%p)\n",
this,pwcsName,pstgPrio,grfMode,snbExclude,reserved,ppstg
This,pwcsName,pstgPrio,grfMode,snbExclude,reserved,ppstg
);
if (grfMode & STGM_TRANSACTED)
FIXME(ole,"We do not support transacted Compound Storage. Using direct mode.\n");
_create_istorage16(ppstg);
lpstg = (_IStream16*)PTR_SEG_TO_LIN(*ppstg);
DuplicateHandle( GetCurrentProcess(), this->hf, GetCurrentProcess(),
lpstg = (IStream16Impl*)PTR_SEG_TO_LIN(*ppstg);
DuplicateHandle( GetCurrentProcess(), This->hf, GetCurrentProcess(),
&lpstg->hf, 0, TRUE, DUPLICATE_SAME_ACCESS );
lstrcpyAtoW(name,pwcsName);
newpps = STORAGE_look_for_named_pps(lpstg->hf,this->stde.pps_dir,name);
newpps = STORAGE_look_for_named_pps(lpstg->hf,This->stde.pps_dir,name);
if (newpps==-1) {
IStream16_fnRelease((IUnknown*)lpstg);
return E_FAIL;
@ -1470,22 +1473,22 @@ HRESULT WINAPI IStorage16_fnOpenStorage(
HRESULT WINAPI IStorage16_fnOpenStream(
LPSTORAGE16 iface,LPCOLESTR16 pwcsName, void *reserved1, DWORD grfMode, DWORD reserved2, IStream16 **ppstm
) {
ICOM_THIS(IStorage16,iface);
_IStream16* lpstr;
ICOM_THIS(IStorage16Impl,iface);
IStream16Impl* lpstr;
WCHAR name[33];
int newpps;
TRACE(relay,"(%p)->(%s,%p,0x%08lx,0x%08lx,%p)\n",
this,pwcsName,reserved1,grfMode,reserved2,ppstm
This,pwcsName,reserved1,grfMode,reserved2,ppstm
);
if (grfMode & STGM_TRANSACTED)
FIXME(ole,"We do not support transacted Compound Storage. Using direct mode.\n");
_create_istream16(ppstm);
lpstr = (_IStream16*)PTR_SEG_TO_LIN(*ppstm);
DuplicateHandle( GetCurrentProcess(), this->hf, GetCurrentProcess(),
lpstr = (IStream16Impl*)PTR_SEG_TO_LIN(*ppstm);
DuplicateHandle( GetCurrentProcess(), This->hf, GetCurrentProcess(),
&lpstr->hf, 0, TRUE, DUPLICATE_SAME_ACCESS );
lstrcpyAtoW(name,pwcsName);
newpps = STORAGE_look_for_named_pps(lpstr->hf,this->stde.pps_dir,name);
newpps = STORAGE_look_for_named_pps(lpstr->hf,This->stde.pps_dir,name);
if (newpps==-1) {
IStream16_fnRelease((IUnknown*)lpstr);
return E_FAIL;
@ -1505,7 +1508,7 @@ HRESULT WINAPI IStorage16_fnOpenStream(
* _create_istorage16 [INTERNAL]
*/
static void _create_istorage16(LPSTORAGE16 *stg) {
_IStorage16* lpst;
IStorage16Impl* lpst;
if (!stvt16.bvt.fnQueryInterface) {
HMODULE16 wp = GetModuleHandle16("STORAGE");
@ -1563,7 +1566,7 @@ static void _create_istorage16(LPSTORAGE16 *stg) {
segstvt16 = &stvt16;
}
}
lpst = SEGPTR_NEW(_IStorage16);
lpst = SEGPTR_NEW(IStorage16Impl);
lpst->lpvtbl = segstvt16;
lpst->ref = 1;
lpst->thisptr = SEGPTR_GET(lpst);
@ -1582,7 +1585,7 @@ HRESULT WINAPI StgCreateDocFile16(
) {
HFILE32 hf;
int i,ret;
_IStorage16* lpstg;
IStorage16Impl* lpstg;
struct storage_pps_entry stde;
TRACE(ole,"(%s,0x%08lx,0x%08lx,%p)\n",
@ -1594,7 +1597,7 @@ HRESULT WINAPI StgCreateDocFile16(
WARN(ole,"couldn't open file for storage:%ld\n",GetLastError());
return E_FAIL;
}
lpstg = (_IStorage16*)PTR_SEG_TO_LIN(*ppstgOpen);
lpstg = (IStorage16Impl*)PTR_SEG_TO_LIN(*ppstgOpen);
lpstg->hf = hf;
/* FIXME: check for existance before overwriting? */
if (!STORAGE_init_storage(hf)) {
@ -1679,7 +1682,7 @@ HRESULT WINAPI StgOpenStorage16(
) {
HFILE32 hf;
int ret,i;
_IStorage16* lpstg;
IStorage16Impl* lpstg;
struct storage_pps_entry stde;
TRACE(ole,"(%s,%p,0x%08lx,%p,%ld,%p)\n",
@ -1691,7 +1694,7 @@ HRESULT WINAPI StgOpenStorage16(
WARN(ole,"Couldn't open file for storage\n");
return E_FAIL;
}
lpstg = (_IStorage16*)PTR_SEG_TO_LIN(*ppstgOpen);
lpstg = (IStorage16Impl*)PTR_SEG_TO_LIN(*ppstgOpen);
lpstg->hf = hf;
i=0;ret=0;