Wine-20041201 vendor drop Added: vendor/wine/dlls/oleaut32/ Added: vendor/wine/dlls/oleaut32/current/ Added: vendor/wine/dlls/oleaut32/current/Makefile.in Added: vendor/wine/dlls/oleaut32/current/connpt.c Added: vendor/wine/dlls/oleaut32/current/connpt.h Added: vendor/wine/dlls/oleaut32/current/dispatch.c Added: vendor/wine/dlls/oleaut32/current/hash.c Added: vendor/wine/dlls/oleaut32/current/oaidl_p.c Added: vendor/wine/dlls/oleaut32/current/ole2disp.c Added: vendor/wine/dlls/oleaut32/current/ole2disp.h Added: vendor/wine/dlls/oleaut32/current/ole2disp.spec Added: vendor/wine/dlls/oleaut32/current/oleaut.c Added: vendor/wine/dlls/oleaut32/current/oleaut32.rc Added: vendor/wine/dlls/oleaut32/current/oleaut32.spec Added: vendor/wine/dlls/oleaut32/current/oleaut32_Cz.rc Added: vendor/wine/dlls/oleaut32/current/oleaut32_De.rc Added: vendor/wine/dlls/oleaut32/current/oleaut32_Dk.rc Added: vendor/wine/dlls/oleaut32/current/oleaut32_En.rc Added: vendor/wine/dlls/oleaut32/current/oleaut32_Es.rc Added: vendor/wine/dlls/oleaut32/current/oleaut32_Fr.rc Added: vendor/wine/dlls/oleaut32/current/oleaut32_Hu.rc Added: vendor/wine/dlls/oleaut32/current/oleaut32_It.rc Added: vendor/wine/dlls/oleaut32/current/oleaut32_Nl.rc Added: vendor/wine/dlls/oleaut32/current/oleaut32_No.rc Added: vendor/wine/dlls/oleaut32/current/oleaut32_Pl.rc Added: vendor/wine/dlls/oleaut32/current/oleaut32_Pt.rc Added: vendor/wine/dlls/oleaut32/current/oleaut32_Sv.rc Added: vendor/wine/dlls/oleaut32/current/oleaut32_Th.rc Added: vendor/wine/dlls/oleaut32/current/olefont.c Added: vendor/wine/dlls/oleaut32/current/olepicture.c Added: vendor/wine/dlls/oleaut32/current/regsvr.c Added: vendor/wine/dlls/oleaut32/current/resource.h Added: vendor/wine/dlls/oleaut32/current/safearray.c Added: vendor/wine/dlls/oleaut32/current/stubs.c Added: vendor/wine/dlls/oleaut32/current/tmarshal.c Added: vendor/wine/dlls/oleaut32/current/tmarshal.h Added: vendor/wine/dlls/oleaut32/current/typelib.c Added: vendor/wine/dlls/oleaut32/current/typelib.h Added: vendor/wine/dlls/oleaut32/current/typelib.spec Added: vendor/wine/dlls/oleaut32/current/typelib16.c Added: vendor/wine/dlls/oleaut32/current/typelib2.c Added: vendor/wine/dlls/oleaut32/current/usrmarshal.c Added: vendor/wine/dlls/oleaut32/current/varformat.c Added: vendor/wine/dlls/oleaut32/current/variant.c Added: vendor/wine/dlls/oleaut32/current/variant.h Added: vendor/wine/dlls/oleaut32/current/vartype.c Added: vendor/wine/dlls/oleaut32/current/version.rc _____
Added: vendor/wine/dlls/oleaut32/current/Makefile.in --- vendor/wine/dlls/oleaut32/current/Makefile.in 2004-12-31 15:20:48 UTC (rev 12575) +++ vendor/wine/dlls/oleaut32/current/Makefile.in 2004-12-31 15:25:53 UTC (rev 12576) @@ -0,0 +1,44 @@
+EXTRADEFS = -D_OLEAUT32_ -DCOM_NO_WINDOWS_H +TOPSRCDIR = @top_srcdir@ +TOPOBJDIR = ../.. +SRCDIR = @srcdir@ +VPATH = @srcdir@ +MODULE = oleaut32.dll +IMPORTS = ole32 rpcrt4 user32 gdi32 advapi32 kernel32 ntdll +DELAYIMPORTS = comctl32 +EXTRALIBS = $(LIBUNICODE) -luuid + +C_SRCS = \ + connpt.c \ + dispatch.c \ + hash.c \ + oaidl_p.c \ + oleaut.c \ + olefont.c \ + olepicture.c \ + regsvr.c \ + safearray.c \ + stubs.c \ + tmarshal.c \ + typelib.c \ + typelib2.c \ + usrmarshal.c \ + varformat.c \ + variant.c \ + vartype.c + +C_SRCS16 = \ + ole2disp.c \ + typelib16.c + +SPEC_SRCS16 = \ + ole2disp.spec \ + typelib.spec + +RC_SRCS = oleaut32.rc + +SUBDIRS = tests + +@MAKE_DLL_RULES@ + +### Dependencies: _____
Added: vendor/wine/dlls/oleaut32/current/connpt.c --- vendor/wine/dlls/oleaut32/current/connpt.c 2004-12-31 15:20:48 UTC (rev 12575) +++ vendor/wine/dlls/oleaut32/current/connpt.c 2004-12-31 15:25:53 UTC (rev 12576) @@ -0,0 +1,632 @@
+/* + * Implementation of a generic ConnectionPoint object. + * + * Copyright 2000 Huw D M Davies for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * NOTES: + * See one exported function here is CreateConnectionPoint, see + * comments just above that function for information. + */ + +#include <assert.h> +#include <stdarg.h> +#include <string.h> + +#define COBJMACROS + +#include "winerror.h" +#include "windef.h" +#include "winbase.h" +#include "wingdi.h" +#include "winuser.h" +#include "ole2.h" +#include "olectl.h" +#include "connpt.h" + +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(ole); + +#define MAXSINKS 10 + +/********************************************************************** ** + * Implementation of IConnectionPoint + */ +typedef struct ConnectionPointImpl { + + IConnectionPointVtbl *lpvtbl; + + /* IUnknown of our main object*/ + IUnknown *Obj; + + /* Reference count */ + DWORD ref; + + /* IID of sink interface */ + IID iid; + + /* Array of sink IUnknowns */ + IUnknown **sinks; + DWORD maxSinks; + + DWORD nSinks; +} ConnectionPointImpl; + +static IConnectionPointVtbl ConnectionPointImpl_VTable; + + +/********************************************************************** ** + * Implementation of IEnumConnections + */ +typedef struct EnumConnectionsImpl { + + IEnumConnectionsVtbl *lpvtbl; + + DWORD ref; + + /* IUnknown of ConnectionPoint, used for ref counting */ + IUnknown *pUnk; + + /* Connection Data */ + CONNECTDATA *pCD; + DWORD nConns; + + /* Next connection to enumerate from */ + DWORD nCur; + +} EnumConnectionsImpl; + +static EnumConnectionsImpl *EnumConnectionsImpl_Construct(IUnknown *pUnk, + DWORD nSinks, + CONNECTDATA *pCD); + + +/********************************************************************** ** + * ConnectionPointImpl_Construct + */ +static ConnectionPointImpl *ConnectionPointImpl_Construct(IUnknown *pUnk, + REFIID riid) +{ + ConnectionPointImpl *Obj; + + Obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*Obj)); + Obj->lpvtbl = &ConnectionPointImpl_VTable; + Obj->Obj = pUnk; + Obj->ref = 1; + Obj->iid = *riid; + Obj->maxSinks = MAXSINKS; + Obj->sinks = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, + sizeof(IUnknown*) * MAXSINKS); + Obj->nSinks = 0; + return Obj; +} + +/********************************************************************** ** + * ConnectionPointImpl_Destroy + */ +static void ConnectionPointImpl_Destroy(ConnectionPointImpl *Obj) +{ + DWORD i; + for(i = 0; i < Obj->maxSinks; i++) { + if(Obj->sinks[i]) { + IUnknown_Release(Obj->sinks[i]); + Obj->sinks[i] = NULL; + } + } + HeapFree(GetProcessHeap(), 0, Obj->sinks); + HeapFree(GetProcessHeap(), 0, Obj); + return; +} + +static ULONG WINAPI ConnectionPointImpl_AddRef(IConnectionPoint* iface); +/********************************************************************** ** + * ConnectionPointImpl_QueryInterface (IUnknown) + * + * See Windows documentation for more details on IUnknown methods. + */ +static HRESULT WINAPI ConnectionPointImpl_QueryInterface( + IConnectionPoint* iface, + REFIID riid, + void** ppvObject) +{ + ConnectionPointImpl *This = (ConnectionPointImpl *)iface; + TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObject); + + /* + * Perform a sanity check on the parameters. + */ + if ( (This==0) || (ppvObject==0) ) + return E_INVALIDARG; + + /* + * Initialize the return parameter. + */ + *ppvObject = 0; + + /* + * Compare the riid with the interface IDs implemented by this object. + */ + if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0) + { + *ppvObject = (IConnectionPoint*)This; + } + else if (memcmp(&IID_IConnectionPoint, riid, sizeof(IID_IConnectionPoint)) == 0) + { + *ppvObject = (IConnectionPoint*)This; + } + + /* + * Check that we obtained an interface. + */ + if ((*ppvObject)==0) + { + FIXME("() : asking for un supported interface %s\n",debugstr_guid(riid)); + return E_NOINTERFACE; + } + + /* + * Query Interface always increases the reference count by one when it is + * successful + */ + ConnectionPointImpl_AddRef((IConnectionPoint*)This); + + return S_OK; +} + + +/********************************************************************** ** + * ConnectionPointImpl_AddRef (IUnknown) + * + * See Windows documentation for more details on IUnknown methods. + */ +static ULONG WINAPI ConnectionPointImpl_AddRef(IConnectionPoint* iface) +{ + ConnectionPointImpl *This = (ConnectionPointImpl *)iface; + TRACE("(%p)->(ref=%ld)\n", This, This->ref); + return InterlockedIncrement(&This->ref); +} + +/********************************************************************** ** + * ConnectionPointImpl_Release (IUnknown) + * + * See Windows documentation for more details on IUnknown methods. + */ +static ULONG WINAPI ConnectionPointImpl_Release( + IConnectionPoint* iface) +{ + ConnectionPointImpl *This = (ConnectionPointImpl *)iface; + ULONG ref; + TRACE("(%p)->(ref=%ld)\n", This, This->ref); + + /* + * Decrease the reference count on this object. + */ + ref = InterlockedDecrement(&This->ref); + + /* + * If the reference count goes down to 0, perform suicide. + */ + if (ref == 0) ConnectionPointImpl_Destroy(This); + + return ref; +} + +/********************************************************************** ** + * ConnectionPointImpl_GetConnectionInterface (IConnectionPoint) + * + */ +static HRESULT WINAPI ConnectionPointImpl_GetConnectionInterface( + IConnectionPoint *iface, + IID *piid) +{ + ConnectionPointImpl *This = (ConnectionPointImpl *)iface; + TRACE("(%p)->(%p) returning %s\n", This, piid, debugstr_guid(&(This->iid))); + *piid = This->iid; + return S_OK; +} + +/********************************************************************** ** + * ConnectionPointImpl_GetConnectionPointContainer (IConnectionPoint) + * + */ +static HRESULT WINAPI ConnectionPointImpl_GetConnectionPointContainer( + IConnectionPoint *iface, + IConnectionPointContainer **ppCPC) +{ + ConnectionPointImpl *This = (ConnectionPointImpl *)iface; + TRACE("(%p)->(%p)\n", This, ppCPC); + + return IUnknown_QueryInterface(This->Obj, + &IID_IConnectionPointContainer, + (LPVOID)ppCPC); +} + +/********************************************************************** ** + * ConnectionPointImpl_Advise (IConnectionPoint) + * + */ +static HRESULT WINAPI ConnectionPointImpl_Advise(IConnectionPoint *iface, + IUnknown *lpUnk, + DWORD *pdwCookie) +{ + DWORD i; + ConnectionPointImpl *This = (ConnectionPointImpl *)iface; + IUnknown *lpSink; + TRACE("(%p)->(%p, %p)\n", This, lpUnk, pdwCookie); + + *pdwCookie = 0; + if(FAILED(IUnknown_QueryInterface(lpUnk, &This->iid, (LPVOID)&lpSink))) + return CONNECT_E_CANNOTCONNECT; + + for(i = 0; i < This->maxSinks; i++) { + if(This->sinks[i] == NULL) + break; + } + if(i == This->maxSinks) { + This->maxSinks += MAXSINKS; + This->sinks = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->sinks, + This->maxSinks * sizeof(IUnknown *)); + } + This->sinks[i] = lpSink; + This->nSinks++; + *pdwCookie = i + 1; + return S_OK; +} + + +/********************************************************************** ** + * ConnectionPointImpl_Unadvise (IConnectionPoint) + * + */ +static HRESULT WINAPI ConnectionPointImpl_Unadvise(IConnectionPoint *iface, + DWORD dwCookie) +{ + ConnectionPointImpl *This = (ConnectionPointImpl *)iface; + TRACE("(%p)->(%ld)\n", This, dwCookie); + + if(dwCookie == 0 || dwCookie > This->maxSinks) return E_INVALIDARG; + + if(This->sinks[dwCookie-1] == NULL) return CONNECT_E_NOCONNECTION; + + IUnknown_Release(This->sinks[dwCookie-1]); + This->sinks[dwCookie-1] = NULL; + This->nSinks--; + return S_OK; +} + +/********************************************************************** ** + * ConnectionPointImpl_EnumConnections (IConnectionPoint) + * + */ +static HRESULT WINAPI ConnectionPointImpl_EnumConnections( + IConnectionPoint *iface, + LPENUMCONNECTIONS *ppEnum) +{ + ConnectionPointImpl *This = (ConnectionPointImpl *)iface; + CONNECTDATA *pCD; + DWORD i, nextslot; + EnumConnectionsImpl *EnumObj; + HRESULT hr; + + TRACE("(%p)->(%p)\n", This, ppEnum); + + *ppEnum = NULL; + + if(This->nSinks == 0) return OLE_E_NOCONNECTION; + + pCD = HeapAlloc(GetProcessHeap(), 0, sizeof(CONNECTDATA) * This->nSinks); + + for(i = 0, nextslot = 0; i < This->maxSinks; i++) { + if(This->sinks[i] != NULL) { + pCD[nextslot].pUnk = This->sinks[i]; + pCD[nextslot].dwCookie = i + 1; + nextslot++; + } + } + assert(nextslot == This->nSinks); + + /* Bump the ref count of this object up by one. It gets Released in + IEnumConnections_Release */ + IUnknown_AddRef((IUnknown*)This); + + EnumObj = EnumConnectionsImpl_Construct((IUnknown*)This, This->nSinks, pCD); + hr = IEnumConnections_QueryInterface((IEnumConnections*)EnumObj, + &IID_IEnumConnections, (LPVOID)ppEnum); + IEnumConnections_Release((IEnumConnections*)EnumObj); + + HeapFree(GetProcessHeap(), 0, pCD); + return hr; +} + +static IConnectionPointVtbl ConnectionPointImpl_VTable = +{ + ConnectionPointImpl_QueryInterface, + ConnectionPointImpl_AddRef, + ConnectionPointImpl_Release, + ConnectionPointImpl_GetConnectionInterface, + ConnectionPointImpl_GetConnectionPointContainer, + ConnectionPointImpl_Advise, + ConnectionPointImpl_Unadvise, + ConnectionPointImpl_EnumConnections +}; + + +static IEnumConnectionsVtbl EnumConnectionsImpl_VTable; +static ULONG WINAPI EnumConnectionsImpl_AddRef(IEnumConnections* iface); + +/********************************************************************** ** + * EnumConnectionsImpl_Construct + */ +static EnumConnectionsImpl *EnumConnectionsImpl_Construct(IUnknown *pUnk, + DWORD nSinks, + CONNECTDATA *pCD) +{ + EnumConnectionsImpl *Obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*Obj)); + DWORD i; + + Obj->lpvtbl = &EnumConnectionsImpl_VTable; + Obj->ref = 1; + Obj->pUnk = pUnk; + Obj->pCD = HeapAlloc(GetProcessHeap(), 0, nSinks * sizeof(CONNECTDATA)); + Obj->nConns = nSinks; + Obj->nCur = 0; + + for(i = 0; i < nSinks; i++) { + Obj->pCD[i] = pCD[i]; + IUnknown_AddRef(Obj->pCD[i].pUnk); + } + return Obj; +} + +/********************************************************************** ** + * EnumConnectionsImpl_Destroy + */ +static void EnumConnectionsImpl_Destroy(EnumConnectionsImpl *Obj) +{ + DWORD i; + + for(i = 0; i < Obj->nConns; i++) + IUnknown_Release(Obj->pCD[i].pUnk); + + HeapFree(GetProcessHeap(), 0, Obj->pCD); + HeapFree(GetProcessHeap(), 0, Obj); + return; +} + +/********************************************************************** ** + * EnumConnectionsImpl_QueryInterface (IUnknown) + * + * See Windows documentation for more details on IUnknown methods. + */ +static HRESULT WINAPI EnumConnectionsImpl_QueryInterface( + IEnumConnections* iface, + REFIID riid, + void** ppvObject) +{ + ConnectionPointImpl *This = (ConnectionPointImpl *)iface; + TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObject); + + /* + * Perform a sanity check on the parameters. + */ + if ( (This==0) || (ppvObject==0) ) + return E_INVALIDARG; + + /* + * Initialize the return parameter. + */ + *ppvObject = 0; + + /* + * Compare the riid with the interface IDs implemented by this object. + */ + if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0) + { + *ppvObject = (IEnumConnections*)This; + } + else if (memcmp(&IID_IEnumConnections, riid, sizeof(IID_IEnumConnections)) == 0) + { + *ppvObject = (IEnumConnections*)This; + } + + /* + * Check that we obtained an interface. + */ + if ((*ppvObject)==0) + { + FIXME("() : asking for un supported interface %s\n",debugstr_guid(riid)); + return E_NOINTERFACE; + } + + /* + * Query Interface always increases the reference count by one when it is + * successful + */ + EnumConnectionsImpl_AddRef((IEnumConnections*)This); + + return S_OK; +} + + +/********************************************************************** ** + * EnumConnectionsImpl_AddRef (IUnknown) + * + * See Windows documentation for more details on IUnknown methods. + */ +static ULONG WINAPI EnumConnectionsImpl_AddRef(IEnumConnections* iface) +{ + EnumConnectionsImpl *This = (EnumConnectionsImpl *)iface; + ULONG ref; + TRACE("(%p)->(ref=%ld)\n", This, This->ref); + ref = InterlockedIncrement(&This->ref); + IUnknown_AddRef(This->pUnk); + return ref; +} + +/********************************************************************** ** + * EnumConnectionsImpl_Release (IUnknown) + * + * See Windows documentation for more details on IUnknown methods. + */ +static ULONG WINAPI EnumConnectionsImpl_Release(IEnumConnections* iface) +{ + EnumConnectionsImpl *This = (EnumConnectionsImpl *)iface; + ULONG ref; + TRACE("(%p)->(ref=%ld)\n", This, This->ref); + + IUnknown_Release(This->pUnk); + + /* + * Decrease the reference count on this object. + */ + ref = InterlockedDecrement(&This->ref); + + /* + * If the reference count goes down to 0, perform suicide. + */ + if (ref == 0) EnumConnectionsImpl_Destroy(This); + + return ref; +} + +/********************************************************************** ** + * EnumConnectionsImpl_Next (IEnumConnections) + * + */ +static HRESULT WINAPI EnumConnectionsImpl_Next(IEnumConnections* iface, + ULONG cConn, LPCONNECTDATA pCD, + ULONG *pEnum) +{ + EnumConnectionsImpl *This = (EnumConnectionsImpl *)iface; + DWORD nRet = 0; + TRACE("(%p)->(%ld, %p, %p)\n", This, cConn, pCD, pEnum); + + if(pEnum == NULL) { + if(cConn != 1) + return E_POINTER; + } else + *pEnum = 0; + + if(This->nCur >= This->nConns) + return S_FALSE; + + while(This->nCur < This->nConns && cConn) { + *pCD++ = This->pCD[This->nCur]; + IUnknown_AddRef(This->pCD[This->nCur].pUnk); + This->nCur++; + cConn--; + nRet++; + } + + if(pEnum) + *pEnum = nRet; + + return S_OK; +} + + +/********************************************************************** ** + * EnumConnectionsImpl_Skip (IEnumConnections) + * + */ +static HRESULT WINAPI EnumConnectionsImpl_Skip(IEnumConnections* iface, + ULONG cSkip) +{ + EnumConnectionsImpl *This = (EnumConnectionsImpl *)iface; + TRACE("(%p)->(%ld)\n", This, cSkip); + + if(This->nCur + cSkip >= This->nConns) + return S_FALSE; + + This->nCur += cSkip; + + return S_OK; +} + + +/********************************************************************** ** + * EnumConnectionsImpl_Reset (IEnumConnections) + * + */ +static HRESULT WINAPI EnumConnectionsImpl_Reset(IEnumConnections* iface) +{ + EnumConnectionsImpl *This = (EnumConnectionsImpl *)iface; + TRACE("(%p)\n", This); + + This->nCur = 0; + + return S_OK; +} + + +/********************************************************************** ** + * EnumConnectionsImpl_Clone (IEnumConnections) + * + */ +static HRESULT WINAPI EnumConnectionsImpl_Clone(IEnumConnections* iface, + LPENUMCONNECTIONS *ppEnum) +{ + EnumConnectionsImpl *This = (EnumConnectionsImpl *)iface; + EnumConnectionsImpl *newObj; + TRACE("(%p)->(%p)\n", This, ppEnum); + + newObj = EnumConnectionsImpl_Construct(This->pUnk, This->nConns, This->pCD); + newObj->nCur = This->nCur; + *ppEnum = (LPENUMCONNECTIONS)newObj; + IUnknown_AddRef(This->pUnk); + return S_OK; +} + +static IEnumConnectionsVtbl EnumConnectionsImpl_VTable = +{ + EnumConnectionsImpl_QueryInterface, + EnumConnectionsImpl_AddRef, + EnumConnectionsImpl_Release, + EnumConnectionsImpl_Next, + EnumConnectionsImpl_Skip, + EnumConnectionsImpl_Reset, + EnumConnectionsImpl_Clone +}; + +/********************************************************************** ** + * + * The exported function to create the connection point. + * NB not a windows API + * + * PARAMS + * pUnk [in] IUnknown of object to which the ConnectionPoint is associated. + * Needed to access IConnectionPointContainer. + * + * riid [in] IID of sink interface that this ConnectionPoint manages + * + * pCP [out] returns IConnectionPoint + * + */ +HRESULT CreateConnectionPoint(IUnknown *pUnk, REFIID riid, + IConnectionPoint **pCP) +{ + ConnectionPointImpl *Obj; + HRESULT hr; + + Obj = ConnectionPointImpl_Construct(pUnk, riid); + if(!Obj) return E_OUTOFMEMORY; + + hr = IConnectionPoint_QueryInterface((IConnectionPoint *)Obj, + &IID_IConnectionPoint, (LPVOID)pCP); + IConnectionPoint_Release((IConnectionPoint *)Obj); + return hr; +} _____
Added: vendor/wine/dlls/oleaut32/current/connpt.h --- vendor/wine/dlls/oleaut32/current/connpt.h 2004-12-31 15:20:48 UTC (rev 12575) +++ vendor/wine/dlls/oleaut32/current/connpt.h 2004-12-31 15:25:53 UTC (rev 12576) @@ -0,0 +1,24 @@
+/* + * Copyright 2000 Huw D M Davies for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef _CONNPT_H +#define _CONNPT_H + +HRESULT CreateConnectionPoint(IUnknown *pUnk, REFIID riid, IConnectionPoint **pCP); + +#endif /* _CONNPT_H */ _____
Added: vendor/wine/dlls/oleaut32/current/dispatch.c --- vendor/wine/dlls/oleaut32/current/dispatch.c 2004-12-31 15:20:48 UTC (rev 12575) +++ vendor/wine/dlls/oleaut32/current/dispatch.c 2004-12-31 15:25:53 UTC (rev 12576) @@ -0,0 +1,456 @@
+/** + * Dispatch API functions + * + * Copyright 2000 Francois Jacques, Macadamian Technologies Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * TODO: Type coercion is implemented in variant.c but not called yet. + */ + +#include "config.h" + +#include <stdlib.h> +#include <string.h> +#include <stdarg.h> +#include <stdio.h> +#include <ctype.h> + +#define COBJMACROS + +#include "windef.h" +#include "winbase.h" +#include "objbase.h" +#include "oleauto.h" +#include "winerror.h" +#include "winreg.h" +#include "winnls.h" /* for PRIMARYLANGID */ + +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(ole); +WINE_DECLARE_DEBUG_CHANNEL(typelib); + +static IDispatch * WINAPI StdDispatch_Construct(IUnknown * punkOuter, void * pvThis, ITypeInfo * pTypeInfo); + +/********************************************************************** ******** + * DispInvoke (OLEAUT32.30) + * + * Call an object method using the information from its type library. + * + * RETURNS + * Success: S_OK. + * Failure: Returns DISP_E_EXCEPTION and updates pexcepinfo if an exception occurs. + * DISP_E_BADPARAMCOUNT if the number of parameters is incorrect. + * DISP_E_MEMBERNOTFOUND if the method does not exist. + * puArgErr is updated if a parameter error (see notes) occurs. + * Otherwise, returns the result of calling ITypeInfo_Invoke(). + * + * NOTES + * Parameter errors include the following: + *| DISP_E_BADVARTYPE + *| E_INVALIDARG An argument was invalid + *| DISP_E_TYPEMISMATCH, + *| DISP_E_OVERFLOW An argument was valid but could not be coerced + *| DISP_E_PARAMNOTOPTIONAL A non optional parameter was not passed + *| DISP_E_PARAMNOTFOUND A parameter was passed that was not expected by the method + * This call defers to ITypeInfo_Invoke(). + */ +HRESULT WINAPI DispInvoke( + VOID *_this, /* [in] Object to call method on */ + ITypeInfo *ptinfo, /* [in] Object type info */ + DISPID dispidMember, /* [in] DISPID of the member (e.g. from GetIDsOfNames()) */ + USHORT wFlags, /* [in] Kind of method call (DISPATCH_ flags from "oaidl.h") */ + DISPPARAMS *pparams, /* [in] Array of method arguments */ + VARIANT *pvarResult, /* [out] Destination for the result of the call */ + EXCEPINFO *pexcepinfo, /* [out] Destination for exception information */ + UINT *puArgErr) /* [out] Destination for bad argument */ +{ + /** + * TODO: + * For each param, call DispGetParam to perform type coercion + */ + FIXME("Coercion of arguments not implemented\n"); + + return ITypeInfo_Invoke(ptinfo, _this, dispidMember, wFlags, + pparams, pvarResult, pexcepinfo, puArgErr); +} + +/********************************************************************** ******** + * DispGetIDsOfNames (OLEAUT32.29) + * + * Convert a set of parameter names to DISPID's for DispInvoke(). + * + * RETURNS + * Success: S_OK. + * Failure: An HRESULT error code. + * + * NOTES + * This call defers to ITypeInfo_GetIDsOfNames(). The ITypeInfo interface passed + * as ptinfo contains the information to map names to DISPID's. + */ +HRESULT WINAPI DispGetIDsOfNames( + ITypeInfo *ptinfo, /* [in] Object's type info */ + OLECHAR **rgszNames, /* [in] Array of names to get DISPID's for */ + UINT cNames, /* [in] Number of names in rgszNames */ + DISPID *rgdispid) /* [out] Destination for converted DISPID's */ +{ + return ITypeInfo_GetIDsOfNames(ptinfo, rgszNames, cNames, rgdispid); +} + +/********************************************************************** ******** + * DispGetParam (OLEAUT32.28) + * + * Retrive a parameter from a DISPPARAMS structure and coerce it to the + * specified variant type. + * + * NOTES + * Coercion is done using system (0) locale. + * + * RETURNS + * Success: S_OK. + * Failure: DISP_E_PARAMNOTFOUND, if position is invalid. or + * DISP_E_TYPEMISMATCH, if the coercion failed. puArgErr is + * set to the index of the argument in pdispparams. + */ +HRESULT WINAPI DispGetParam( + DISPPARAMS *pdispparams, /* [in] Parameter list */ + UINT position, /* [in] Position of parameter to coerce in pdispparams */ + VARTYPE vtTarg, /* [in] Type of value to coerce to */ + VARIANT *pvarResult, /* [out] Destination for resulting variant */ + UINT *puArgErr) /* [out] Destination for error code */ +{ + /* position is counted backwards */ + UINT pos; + HRESULT hr; + + TRACE("position=%d, cArgs=%d, cNamedArgs=%d\n", + position, pdispparams->cArgs, pdispparams->cNamedArgs); + if (position < pdispparams->cArgs) { + /* positional arg? */ + pos = pdispparams->cArgs - position - 1; + } else { + /* FIXME: is this how to handle named args? */ + for (pos=0; pos<pdispparams->cNamedArgs; pos++) + if (pdispparams->rgdispidNamedArgs[pos] == position) break; + + if (pos==pdispparams->cNamedArgs) + return DISP_E_PARAMNOTFOUND; + } + hr = VariantChangeType(pvarResult, + &pdispparams->rgvarg[pos], + 0, vtTarg); + if (hr == DISP_E_TYPEMISMATCH) *puArgErr = pos; + return hr; +} + +/********************************************************************** ******** + * CreateStdDispatch [OLEAUT32.32] + * + * Create and return a standard IDispatch object. + * + * RETURNS + * Success: S_OK. ppunkStdDisp contains the new object. + * Failure: An HRESULT error code. + * + * NOTES + * Outer unknown appears to be completely ignored. + */ +HRESULT WINAPI CreateStdDispatch( + IUnknown* punkOuter, + void* pvThis, + ITypeInfo* ptinfo, + IUnknown** ppunkStdDisp) +{ + TRACE("(%p, %p, %p, %p)\n", punkOuter, pvThis, ptinfo, ppunkStdDisp); + + *ppunkStdDisp = (LPUNKNOWN)StdDispatch_Construct(punkOuter, pvThis, ptinfo); + if (!*ppunkStdDisp) + return E_OUTOFMEMORY; + return S_OK; +} + + +/********************************************************************** ******** + * IDispatch {OLEAUT32} + * + * NOTES + * The IDispatch interface provides a single interface to dispatch method calls, + * regardless of whether the object to be called is in or out of process, + * local or remote (e.g. being called over a network). This interface is late-bound + * (linked at run-time), as opposed to early-bound (linked at compile time). + * + * The interface is used by objects that wish to called by scripting + * languages such as VBA, in order to minimise the amount of COM and C/C++ + * knowledge required, or by objects that wish to live out of process from code + * that will call their methods. + * + * Method, property and parameter names can be localised. The details required to + * map names to methods and parameters are collected in a type library, usually + * output by an IDL compiler using the objects IDL description. This information is + * accessible programatically through the ITypeLib interface (for a type library), + * and the ITypeInfo interface (for an object within the type library). Type information + * can also be created at run-time using CreateDispTypeInfo(). + * + * WRAPPERS + * Instead of using IDispatch directly, there are several wrapper functions available + * to simplify the process of calling an objects methods through IDispatch. + * + * A standard implementation of an IDispatch object is created by calling + * CreateStdDispatch(). Numeric Id values for the parameters and methods (DISPID's) + * of an object of interest are retrieved by calling DispGetIDsOfNames(). DispGetParam() + * retrieves information about a particular parameter. Finally the DispInvoke() + * function is responsable for actually calling methods on an object. + * + * METHODS + */ + +typedef struct +{ + IDispatchVtbl *lpVtbl; + void * pvThis; + ITypeInfo * pTypeInfo; + ULONG ref; +} StdDispatch; + +/********************************************************************** ******** + * IDispatch_QueryInterface {OLEAUT32} + * + * See IUnknown_QueryInterface. + */ +static HRESULT WINAPI StdDispatch_QueryInterface( + LPDISPATCH iface, + REFIID riid, + void** ppvObject) +{ + StdDispatch *This = (StdDispatch *)iface; + TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppvObject); + + if (IsEqualIID(riid, &IID_IDispatch) || + IsEqualIID(riid, &IID_IUnknown)) + { + *ppvObject = (LPVOID)This; + IUnknown_AddRef((LPUNKNOWN)*ppvObject); + return S_OK; + } + return E_NOINTERFACE; +} + +/********************************************************************** ******** + * IDispatch_AddRef {OLEAUT32} + * + * See IUnknown_AddRef. + */ +static ULONG WINAPI StdDispatch_AddRef(LPDISPATCH iface) +{ + StdDispatch *This = (StdDispatch *)iface; + TRACE("()\n"); + + return InterlockedIncrement(&This->ref); +} + +/********************************************************************** ******** + * IDispatch_Release {OLEAUT32} + * + * See IUnknown_Release. + */ +static ULONG WINAPI StdDispatch_Release(LPDISPATCH iface) +{ + StdDispatch *This = (StdDispatch *)iface; + ULONG ref; + TRACE("(%p)->()\n", This); + + ref = InterlockedDecrement(&This->ref); + + if (ref == 0) + { + ITypeInfo_Release(This->pTypeInfo); + CoTaskMemFree(This); [truncated at 1000 lines; 50703 more skipped]
-
gvg＠svn.reactos.com