gdi32: Don't free bitmap bits when changing the owner, we may still have pointers...
[wine] / dlls / oleaut32 / dispatch.c
1 /**
2  * Dispatch API functions
3  *
4  * Copyright 2000  Francois Jacques, Macadamian Technologies Inc.
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  *
20  */
21
22 #include "config.h"
23
24 #include <stdlib.h>
25 #include <string.h>
26 #include <stdarg.h>
27 #include <stdio.h>
28 #include <ctype.h>
29
30 #define COBJMACROS
31
32 #include "windef.h"
33 #include "winbase.h"
34 #include "objbase.h"
35 #include "oleauto.h"
36 #include "winerror.h"
37
38 #include "wine/debug.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(ole);
41
42 static IDispatch * StdDispatch_Construct(IUnknown * punkOuter, void * pvThis, ITypeInfo * pTypeInfo);
43
44 /******************************************************************************
45  *              DispInvoke (OLEAUT32.30)
46  *
47  * Call an object method using the information from its type library.
48  *
49  * RETURNS
50  *  Success: S_OK.
51  *  Failure: Returns DISP_E_EXCEPTION and updates pexcepinfo if an exception occurs.
52  *           DISP_E_BADPARAMCOUNT if the number of parameters is incorrect.
53  *           DISP_E_MEMBERNOTFOUND if the method does not exist.
54  *           puArgErr is updated if a parameter error (see notes) occurs.
55  *           Otherwise, returns the result of calling ITypeInfo_Invoke().
56  *
57  * NOTES
58  *  Parameter errors include the following:
59  *| DISP_E_BADVARTYPE
60  *| E_INVALIDARG            An argument was invalid
61  *| DISP_E_TYPEMISMATCH,
62  *| DISP_E_OVERFLOW         An argument was valid but could not be coerced
63  *| DISP_E_PARAMNOTOPTIONAL A non optional parameter was not passed
64  *| DISP_E_PARAMNOTFOUND    A parameter was passed that was not expected by the method
65  *  This call defers to ITypeInfo_Invoke().
66  */
67 HRESULT WINAPI DispInvoke(
68         VOID       *_this,        /* [in] Object to call method on */
69         ITypeInfo  *ptinfo,       /* [in] Object type info */
70         DISPID      dispidMember, /* [in] DISPID of the member (e.g. from GetIDsOfNames()) */
71         USHORT      wFlags,       /* [in] Kind of method call (DISPATCH_ flags from "oaidl.h") */
72         DISPPARAMS *pparams,      /* [in] Array of method arguments */
73         VARIANT    *pvarResult,   /* [out] Destination for the result of the call */
74         EXCEPINFO  *pexcepinfo,   /* [out] Destination for exception information */
75         UINT       *puArgErr)     /* [out] Destination for bad argument */
76 {
77     TRACE("\n");
78
79     return ITypeInfo_Invoke(ptinfo, _this, dispidMember, wFlags,
80                             pparams, pvarResult, pexcepinfo, puArgErr);
81 }
82
83 /******************************************************************************
84  *              DispGetIDsOfNames (OLEAUT32.29)
85  *
86  * Convert a set of parameter names to DISPIDs for DispInvoke().
87  *
88  * RETURNS
89  *  Success: S_OK.
90  *  Failure: An HRESULT error code.
91  *
92  * NOTES
93  *  This call defers to ITypeInfo_GetIDsOfNames(). The ITypeInfo interface passed
94  *  as ptinfo contains the information to map names to DISPIDs.
95  */
96 HRESULT WINAPI DispGetIDsOfNames(
97         ITypeInfo  *ptinfo,    /* [in] Object's type info */
98         OLECHAR   **rgszNames, /* [in] Array of names to get DISPIDs for */
99         UINT        cNames,    /* [in] Number of names in rgszNames */
100         DISPID     *rgdispid)  /* [out] Destination for converted DISPIDs */
101 {
102     return ITypeInfo_GetIDsOfNames(ptinfo, rgszNames, cNames, rgdispid);
103 }
104
105 /******************************************************************************
106  *              DispGetParam (OLEAUT32.28)
107  *
108  * Retrieve a parameter from a DISPPARAMS structure and coerce it to the
109  * specified variant type.
110  *
111  * NOTES
112  *  Coercion is done using system (0) locale.
113  *
114  * RETURNS
115  *  Success: S_OK.
116  *  Failure: DISP_E_PARAMNOTFOUND, if position is invalid. or
117  *           DISP_E_TYPEMISMATCH, if the coercion failed. puArgErr is
118  *           set to the index of the argument in pdispparams.
119  */
120 HRESULT WINAPI DispGetParam(
121         DISPPARAMS *pdispparams, /* [in] Parameter list */
122         UINT        position,    /* [in] Position of parameter to coerce in pdispparams */
123         VARTYPE     vtTarg,      /* [in] Type of value to coerce to */
124         VARIANT    *pvarResult,  /* [out] Destination for resulting variant */
125         UINT       *puArgErr)    /* [out] Destination for error code */
126 {
127     /* position is counted backwards */
128     UINT pos;
129     HRESULT hr;
130
131     TRACE("position=%d, cArgs=%d, cNamedArgs=%d\n",
132           position, pdispparams->cArgs, pdispparams->cNamedArgs);
133
134     if (position < pdispparams->cArgs)
135     {
136       /* positional arg? */
137       pos = pdispparams->cArgs - position - 1;
138     }
139     else
140     {
141       /* FIXME: is this how to handle named args? */
142       for (pos=0; pos<pdispparams->cNamedArgs; pos++)
143         if (pdispparams->rgdispidNamedArgs[pos] == position) break;
144
145       if (pos==pdispparams->cNamedArgs)
146         return DISP_E_PARAMNOTFOUND;
147     }
148
149     if (pdispparams->cArgs > 0 && !pdispparams->rgvarg)
150     {
151         hr = E_INVALIDARG;
152         goto done;
153     }
154
155     if (!pvarResult)
156     {
157         hr = E_INVALIDARG;
158         goto done;
159     }
160
161     hr = VariantChangeType(pvarResult,
162                            &pdispparams->rgvarg[pos],
163                            0, vtTarg);
164
165 done:
166     if (FAILED(hr))
167         *puArgErr = pos;
168
169     return hr;
170 }
171
172 /******************************************************************************
173  * CreateStdDispatch [OLEAUT32.32]
174  *
175  * Create and return a standard IDispatch object.
176  *
177  * RETURNS
178  *  Success: S_OK. ppunkStdDisp contains the new object.
179  *  Failure: An HRESULT error code.
180  *
181  * NOTES
182  *  Outer unknown appears to be completely ignored.
183  */
184 HRESULT WINAPI CreateStdDispatch(
185         IUnknown* punkOuter,
186         void* pvThis,
187         ITypeInfo* ptinfo,
188         IUnknown** ppunkStdDisp)
189 {
190     TRACE("(%p, %p, %p, %p)\n", punkOuter, pvThis, ptinfo, ppunkStdDisp);
191
192     *ppunkStdDisp = (LPUNKNOWN)StdDispatch_Construct(punkOuter, pvThis, ptinfo);
193     if (!*ppunkStdDisp)
194         return E_OUTOFMEMORY;
195     return S_OK;
196 }
197
198
199 /******************************************************************************
200  * IDispatch {OLEAUT32}
201  *
202  * NOTES
203  *  The IDispatch interface provides a single interface to dispatch method calls,
204  *  regardless of whether the object to be called is in or out of process,
205  *  local or remote (e.g. being called over a network). This interface is late-bound
206  *  (linked at run-time), as opposed to early-bound (linked at compile time).
207  *
208  *  The interface is used by objects that wish to called by scripting
209  *  languages such as VBA, in order to minimise the amount of COM and C/C++
210  *  knowledge required, or by objects that wish to live out of process from code
211  *  that will call their methods.
212  *
213  *  Method, property and parameter names can be localised. The details required to
214  *  map names to methods and parameters are collected in a type library, usually
215  *  output by an IDL compiler using the objects IDL description. This information is
216  *  accessible programmatically through the ITypeLib interface (for a type library),
217  *  and the ITypeInfo interface (for an object within the type library). Type information
218  *  can also be created at run-time using CreateDispTypeInfo().
219  *
220  * WRAPPERS
221  *  Instead of using IDispatch directly, there are several wrapper functions available
222  *  to simplify the process of calling an objects methods through IDispatch.
223  *
224  *  A standard implementation of an IDispatch object is created by calling
225  *  CreateStdDispatch(). Numeric Id values for the parameters and methods (DISPIDs)
226  *  of an object of interest are retrieved by calling DispGetIDsOfNames(). DispGetParam()
227  *  retrieves information about a particular parameter. Finally the DispInvoke()
228  *  function is responsible for actually calling methods on an object.
229  *
230  * METHODS
231  */
232
233 typedef struct
234 {
235     IDispatch IDispatch_iface;
236     void * pvThis;
237     ITypeInfo * pTypeInfo;
238     LONG ref;
239 } StdDispatch;
240
241 static inline StdDispatch *impl_from_IDispatch(IDispatch *iface)
242 {
243     return CONTAINING_RECORD(iface, StdDispatch, IDispatch_iface);
244 }
245
246 /******************************************************************************
247  * IDispatch_QueryInterface {OLEAUT32}
248  *
249  * See IUnknown_QueryInterface.
250  */
251 static HRESULT WINAPI StdDispatch_QueryInterface(
252   LPDISPATCH iface,
253   REFIID riid,
254   void** ppvObject)
255 {
256     StdDispatch *This = impl_from_IDispatch(iface);
257     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppvObject);
258
259     if (IsEqualIID(riid, &IID_IDispatch) ||
260         IsEqualIID(riid, &IID_IUnknown))
261     {
262         *ppvObject = This;
263         IUnknown_AddRef((LPUNKNOWN)*ppvObject);
264         return S_OK;
265     }
266     return E_NOINTERFACE;
267 }
268
269 /******************************************************************************
270  * IDispatch_AddRef {OLEAUT32}
271  *
272  * See IUnknown_AddRef.
273  */
274 static ULONG WINAPI StdDispatch_AddRef(LPDISPATCH iface)
275 {
276     StdDispatch *This = impl_from_IDispatch(iface);
277     ULONG refCount = InterlockedIncrement(&This->ref);
278
279     TRACE("(%p)->(ref before=%u)\n",This, refCount - 1);
280
281     return refCount;
282 }
283
284 /******************************************************************************
285  * IDispatch_Release {OLEAUT32}
286  *
287  * See IUnknown_Release.
288  */
289 static ULONG WINAPI StdDispatch_Release(LPDISPATCH iface)
290 {
291     StdDispatch *This = impl_from_IDispatch(iface);
292     ULONG refCount = InterlockedDecrement(&This->ref);
293
294     TRACE("(%p)->(ref before=%u)\n", This, refCount + 1);
295
296     if (!refCount)
297     {
298         ITypeInfo_Release(This->pTypeInfo);
299         CoTaskMemFree(This);
300     }
301
302     return refCount;
303 }
304
305 /******************************************************************************
306  * IDispatch_GetTypeInfoCount {OLEAUT32}
307  *
308  * Get the count of type information in an IDispatch interface.
309  *
310  * PARAMS
311  *  iface   [I] IDispatch interface
312  *  pctinfo [O] Destination for the count
313  *
314  * RETURNS
315  *  Success: S_OK. pctinfo is updated with the count. This is always 1 if
316  *           the object provides type information, and 0 if it does not.
317  *  Failure: E_NOTIMPL. The object does not provide type information.
318  *
319  * NOTES
320  *  See IDispatch() and IDispatch_GetTypeInfo().
321  */
322 static HRESULT WINAPI StdDispatch_GetTypeInfoCount(LPDISPATCH iface, UINT * pctinfo)
323 {
324     StdDispatch *This = impl_from_IDispatch(iface);
325     TRACE("(%p)\n", pctinfo);
326
327     *pctinfo = This->pTypeInfo ? 1 : 0;
328     return S_OK;
329 }
330
331 /******************************************************************************
332  * IDispatch_GetTypeInfo {OLEAUT32}
333  *
334  * Get type information from an IDispatch interface.
335  *
336  * PARAMS
337  *  iface   [I] IDispatch interface
338  *  iTInfo  [I] Index of type information.
339  *  lcid    [I] Locale of the type information to get
340  *  ppTInfo [O] Destination for the ITypeInfo object
341  *
342  * RETURNS
343  *  Success: S_OK. ppTInfo is updated with the objects type information
344  *  Failure: DISP_E_BADINDEX, if iTInfo is any value other than 0.
345  *
346  * NOTES
347  *  See IDispatch.
348  */
349 static HRESULT WINAPI StdDispatch_GetTypeInfo(LPDISPATCH iface, UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo)
350 {
351     StdDispatch *This = impl_from_IDispatch(iface);
352     TRACE("(%d, %x, %p)\n", iTInfo, lcid, ppTInfo);
353
354     *ppTInfo = NULL;
355     if (iTInfo != 0)
356         return DISP_E_BADINDEX;
357
358     if (This->pTypeInfo)
359     {
360       *ppTInfo = This->pTypeInfo;
361       ITypeInfo_AddRef(*ppTInfo);
362     }
363     return S_OK;
364 }
365
366 /******************************************************************************
367  * IDispatch_GetIDsOfNames {OLEAUT32}
368  *
369  * Convert a methods name and an optional set of parameter names into DISPIDs
370  * for passing to IDispatch_Invoke().
371  *
372  * PARAMS
373  *  iface     [I] IDispatch interface
374  *  riid      [I] Reserved, set to IID_NULL
375  *  rgszNames [I] Name to convert
376  *  cNames    [I] Number of names in rgszNames
377  *  lcid      [I] Locale of the type information to convert from
378  *  rgDispId  [O] Destination for converted DISPIDs.
379  *
380  * RETURNS
381  *  Success: S_OK.
382  *  Failure: DISP_E_UNKNOWNNAME, if any of the names is invalid.
383  *           DISP_E_UNKNOWNLCID if lcid is invalid.
384  *           Otherwise, an HRESULT error code.
385  *
386  * NOTES
387  *  This call defers to ITypeInfo_GetIDsOfNames(), using the ITypeInfo object
388  *  contained within the IDispatch object.
389  *  The first member of the names list must be a method name. The names following
390  *  the method name are the parameters for that method.
391  */
392 static HRESULT WINAPI StdDispatch_GetIDsOfNames(LPDISPATCH iface, REFIID riid, LPOLESTR * rgszNames, UINT cNames, LCID lcid, DISPID * rgDispId)
393 {
394     StdDispatch *This = impl_from_IDispatch(iface);
395     TRACE("(%s, %p, %d, 0x%x, %p)\n", debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
396
397     if (!IsEqualGUID(riid, &IID_NULL))
398     {
399         FIXME(" expected riid == IID_NULL\n");
400         return E_INVALIDARG;
401     }
402     return DispGetIDsOfNames(This->pTypeInfo, rgszNames, cNames, rgDispId);
403 }
404
405 /******************************************************************************
406  * IDispatch_Invoke {OLEAUT32}
407  *
408  * Call an object method.
409  *
410  * PARAMS
411  *  iface        [I] IDispatch interface
412  *  dispIdMember [I] DISPID of the method (from GetIDsOfNames())
413  *  riid         [I] Reserved, set to IID_NULL
414  *  lcid         [I] Locale of the type information to convert parameters with
415  *  wFlags,      [I] Kind of method call (DISPATCH_ flags from "oaidl.h")
416  *  pDispParams  [I] Array of method arguments
417  *  pVarResult   [O] Destination for the result of the call
418  *  pExcepInfo   [O] Destination for exception information
419  *  puArgErr     [O] Destination for bad argument
420  *
421  * RETURNS
422  *  Success: S_OK.
423  *  Failure: See DispInvoke() for failure cases.
424  *
425  * NOTES
426  *  See DispInvoke() and IDispatch().
427  */
428 static HRESULT WINAPI StdDispatch_Invoke(LPDISPATCH iface, DISPID dispIdMember, REFIID riid, LCID lcid,
429                                          WORD wFlags, DISPPARAMS * pDispParams, VARIANT * pVarResult,
430                                          EXCEPINFO * pExcepInfo, UINT * puArgErr)
431 {
432     StdDispatch *This = impl_from_IDispatch(iface);
433     TRACE("(%d, %s, 0x%x, 0x%x, %p, %p, %p, %p)\n", dispIdMember, debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
434
435     if (!IsEqualGUID(riid, &IID_NULL))
436     {
437         FIXME(" expected riid == IID_NULL\n");
438         return E_INVALIDARG;
439     }
440     return DispInvoke(This->pvThis, This->pTypeInfo, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
441 }
442
443 static const IDispatchVtbl StdDispatch_VTable =
444 {
445   StdDispatch_QueryInterface,
446   StdDispatch_AddRef,
447   StdDispatch_Release,
448   StdDispatch_GetTypeInfoCount,
449   StdDispatch_GetTypeInfo,
450   StdDispatch_GetIDsOfNames,
451   StdDispatch_Invoke
452 };
453
454 static IDispatch * StdDispatch_Construct(
455   IUnknown * punkOuter,
456   void * pvThis,
457   ITypeInfo * pTypeInfo)
458 {
459     StdDispatch * pStdDispatch;
460
461     pStdDispatch = CoTaskMemAlloc(sizeof(StdDispatch));
462     if (!pStdDispatch)
463         return &pStdDispatch->IDispatch_iface;
464
465     pStdDispatch->IDispatch_iface.lpVtbl = &StdDispatch_VTable;
466     pStdDispatch->pvThis = pvThis;
467     pStdDispatch->pTypeInfo = pTypeInfo;
468     pStdDispatch->ref = 1;
469
470     /* we keep a reference to the type info so prevent it from
471      * being destroyed until we are done with it */
472     ITypeInfo_AddRef(pTypeInfo);
473
474     return &pStdDispatch->IDispatch_iface;
475 }