2 * Copyright 2008-2009 Jacek Caban for CodeWeavers
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
28 #include "wine/debug.h"
30 #include "mshtml_private.h"
32 WINE_DEFAULT_DEBUG_CHANNEL(mshtml
);
34 static const WCHAR objectW
[] = {'[','o','b','j','e','c','t',']',0};
43 struct dispex_data_t
{
46 func_info_t
**name_table
;
59 const IUnknownVtbl
*lpIUnknownVtbl
;
64 #define FUNCUNKNOWN(x) ((IUnknown*) &(x)->lpIUnknownVtbl)
66 struct dispex_dynamic_data_t
{
69 dynamic_prop_t
*props
;
70 func_disp_t
**func_disps
;
73 #define DISPID_DYNPROP_0 0x50000000
74 #define DISPID_DYNPROP_MAX 0x5fffffff
76 static ITypeLib
*typelib
;
77 static ITypeInfo
*typeinfos
[LAST_tid
];
78 static struct list dispex_data_list
= LIST_INIT(dispex_data_list
);
80 static REFIID tid_ids
[] = {
83 &DIID_DispDOMChildrenCollection
,
84 &DIID_DispHTMLAnchorElement
,
86 &DIID_DispHTMLCommentElement
,
87 &DIID_DispHTMLCurrentStyle
,
88 &DIID_DispHTMLDocument
,
89 &DIID_DispHTMLDOMTextNode
,
90 &DIID_DispHTMLElementCollection
,
91 &DIID_DispHTMLGenericElement
,
94 &DIID_DispHTMLInputElement
,
95 &DIID_DispHTMLLocation
,
96 &DIID_DispHTMLNavigator
,
97 &DIID_DispHTMLOptionElement
,
98 &DIID_DispHTMLSelectElement
,
101 &DIID_DispHTMLTableRow
,
102 &DIID_DispHTMLUnknownElement
,
103 &DIID_DispHTMLWindow2
,
104 &IID_IHTMLAnchorElement
,
105 &IID_IHTMLBodyElement
,
106 &IID_IHTMLBodyElement2
,
107 &IID_IHTMLCommentElement
,
108 &IID_IHTMLCurrentStyle
,
109 &IID_IHTMLCurrentStyle2
,
110 &IID_IHTMLCurrentStyle3
,
111 &IID_IHTMLCurrentStyle4
,
116 &IID_IHTMLDOMChildrenCollection
,
119 &IID_IHTMLDOMTextNode
,
124 &IID_IHTMLElementCollection
,
126 &IID_IHTMLFrameBase2
,
127 &IID_IHTMLGenericElement
,
128 &IID_IHTMLImgElement
,
129 &IID_IHTMLInputElement
,
131 &IID_IHTMLOptionElement
,
132 &IID_IHTMLSelectElement
,
139 &IID_IHTMLTextContainer
,
140 &IID_IHTMLUniqueName
,
146 static HRESULT
get_typeinfo(tid_t tid
, ITypeInfo
**typeinfo
)
153 hres
= LoadRegTypeLib(&LIBID_MSHTML
, 4, 0, LOCALE_SYSTEM_DEFAULT
, &tl
);
155 ERR("LoadRegTypeLib failed: %08x\n", hres
);
159 if(InterlockedCompareExchangePointer((void**)&typelib
, tl
, NULL
))
160 ITypeLib_Release(tl
);
163 if(!typeinfos
[tid
]) {
166 hres
= ITypeLib_GetTypeInfoOfGuid(typelib
, tid_ids
[tid
], &typeinfo
);
168 ERR("GetTypeInfoOfGuid(%s) failed: %08x\n", debugstr_guid(tid_ids
[tid
]), hres
);
172 if(InterlockedCompareExchangePointer((void**)(typeinfos
+tid
), typeinfo
, NULL
))
173 ITypeInfo_Release(typeinfo
);
176 *typeinfo
= typeinfos
[tid
];
180 void release_typelib(void)
185 while(!list_empty(&dispex_data_list
)) {
186 iter
= LIST_ENTRY(list_head(&dispex_data_list
), dispex_data_t
, entry
);
187 list_remove(&iter
->entry
);
189 for(i
=0; i
< iter
->func_cnt
; i
++)
190 SysFreeString(iter
->funcs
[i
].name
);
192 heap_free(iter
->funcs
);
193 heap_free(iter
->name_table
);
200 for(i
=0; i
< sizeof(typeinfos
)/sizeof(*typeinfos
); i
++)
202 ITypeInfo_Release(typeinfos
[i
]);
204 ITypeLib_Release(typelib
);
207 static void add_func_info(dispex_data_t
*data
, DWORD
*size
, tid_t tid
, const FUNCDESC
*desc
, ITypeInfo
*dti
)
211 if(data
->func_cnt
&& data
->funcs
[data
->func_cnt
-1].id
== desc
->memid
)
214 if(data
->func_cnt
== *size
)
215 data
->funcs
= heap_realloc(data
->funcs
, (*size
<<= 1)*sizeof(func_info_t
));
217 hres
= ITypeInfo_GetDocumentation(dti
, desc
->memid
, &data
->funcs
[data
->func_cnt
].name
, NULL
, NULL
, NULL
);
221 data
->funcs
[data
->func_cnt
].id
= desc
->memid
;
222 data
->funcs
[data
->func_cnt
].tid
= tid
;
223 data
->funcs
[data
->func_cnt
].func_disp_idx
= desc
->invkind
== INVOKE_FUNC
? data
->func_disp_cnt
++ : -1;
228 static int dispid_cmp(const void *p1
, const void *p2
)
230 return ((func_info_t
*)p1
)->id
- ((func_info_t
*)p2
)->id
;
233 static int func_name_cmp(const void *p1
, const void *p2
)
235 return strcmpiW((*(func_info_t
**)p1
)->name
, (*(func_info_t
**)p2
)->name
);
238 static dispex_data_t
*preprocess_dispex_data(DispatchEx
*This
)
240 const tid_t
*tid
= This
->data
->iface_tids
;
247 TRACE("(%p)\n", This
);
249 if(This
->data
->disp_tid
) {
250 hres
= get_typeinfo(This
->data
->disp_tid
, &dti
);
252 ERR("Could not get disp type info: %08x\n", hres
);
257 data
= heap_alloc(sizeof(dispex_data_t
));
259 data
->func_disp_cnt
= 0;
260 data
->funcs
= heap_alloc(size
*sizeof(func_info_t
));
261 list_add_tail(&dispex_data_list
, &data
->entry
);
264 hres
= get_typeinfo(*tid
, &ti
);
270 hres
= ITypeInfo_GetFuncDesc(ti
, i
++, &funcdesc
);
274 add_func_info(data
, &size
, *tid
, funcdesc
, dti
);
275 ITypeInfo_ReleaseFuncDesc(ti
, funcdesc
);
281 if(!data
->func_cnt
) {
282 heap_free(data
->funcs
);
284 }else if(data
->func_cnt
!= size
) {
285 data
->funcs
= heap_realloc(data
->funcs
, data
->func_cnt
* sizeof(func_info_t
));
288 qsort(data
->funcs
, data
->func_cnt
, sizeof(func_info_t
), dispid_cmp
);
291 data
->name_table
= heap_alloc(data
->func_cnt
* sizeof(func_info_t
*));
292 for(i
=0; i
< data
->func_cnt
; i
++)
293 data
->name_table
[i
] = data
->funcs
+i
;
294 qsort(data
->name_table
, data
->func_cnt
, sizeof(func_info_t
*), func_name_cmp
);
296 data
->name_table
= NULL
;
302 static CRITICAL_SECTION cs_dispex_static_data
;
303 static CRITICAL_SECTION_DEBUG cs_dispex_static_data_dbg
=
305 0, 0, &cs_dispex_static_data
,
306 { &cs_dispex_static_data_dbg
.ProcessLocksList
, &cs_dispex_static_data_dbg
.ProcessLocksList
},
307 0, 0, { (DWORD_PTR
)(__FILE__
": dispex_static_data") }
309 static CRITICAL_SECTION cs_dispex_static_data
= { &cs_dispex_static_data_dbg
, -1, 0, 0, 0, 0 };
312 static dispex_data_t
*get_dispex_data(DispatchEx
*This
)
315 return This
->data
->data
;
317 EnterCriticalSection(&cs_dispex_static_data
);
319 if(!This
->data
->data
)
320 This
->data
->data
= preprocess_dispex_data(This
);
322 LeaveCriticalSection(&cs_dispex_static_data
);
324 return This
->data
->data
;
327 HRESULT
call_disp_func(IDispatch
*disp
, DISPPARAMS
*dp
)
334 hres
= IDispatch_QueryInterface(disp
, &IID_IDispatchEx
, (void**)&dispex
);
336 FIXME("Could not get IDispatchEx interface: %08x\n", hres
);
341 memset(&ei
, 0, sizeof(ei
));
343 hres
= IDispatchEx_InvokeEx(dispex
, 0, GetUserDefaultLCID(), DISPATCH_METHOD
, dp
, &res
, &ei
, NULL
);
345 IDispatchEx_Release(dispex
);
350 static inline BOOL
is_custom_dispid(DISPID id
)
352 return MSHTML_DISPID_CUSTOM_MIN
<= id
&& id
<= MSHTML_DISPID_CUSTOM_MAX
;
355 static inline BOOL
is_dynamic_dispid(DISPID id
)
357 return DISPID_DYNPROP_0
<= id
&& id
<= DISPID_DYNPROP_MAX
;
360 static inline dispex_dynamic_data_t
*get_dynamic_data(DispatchEx
*This
, BOOL alloc
)
362 return !alloc
|| This
->dynamic_data
364 : (This
->dynamic_data
= heap_alloc_zero(sizeof(dispex_dynamic_data_t
)));
367 static HRESULT
get_dynamic_prop(DispatchEx
*This
, const WCHAR
*name
, BOOL alloc
, dynamic_prop_t
**ret
)
369 dispex_dynamic_data_t
*data
= get_dynamic_data(This
, alloc
);
374 return E_OUTOFMEMORY
;
376 TRACE("not found %s\n", debugstr_w(name
));
377 return DISP_E_UNKNOWNNAME
;
380 for(i
=0; i
< data
->prop_cnt
; i
++) {
381 if(!strcmpW(data
->props
[i
].name
, name
)) {
382 *ret
= data
->props
+i
;
387 TRACE("creating dynamic prop %s\n", debugstr_w(name
));
389 if(!data
->buf_size
) {
390 data
->props
= heap_alloc(sizeof(dynamic_prop_t
)*4);
392 return E_OUTOFMEMORY
;
394 }else if(data
->buf_size
== data
->prop_cnt
) {
395 dynamic_prop_t
*new_props
;
397 new_props
= heap_realloc(data
->props
, sizeof(dynamic_prop_t
)*(data
->buf_size
<<1));
399 return E_OUTOFMEMORY
;
401 data
->props
= new_props
;
402 data
->buf_size
<<= 1;
405 data
->props
[data
->prop_cnt
].name
= heap_strdupW(name
);
406 VariantInit(&data
->props
[data
->prop_cnt
].var
);
407 *ret
= data
->props
+ data
->prop_cnt
++;
412 HRESULT
dispex_get_dprop_ref(DispatchEx
*This
, const WCHAR
*name
, BOOL alloc
, VARIANT
**ret
)
414 dynamic_prop_t
*prop
;
417 hres
= get_dynamic_prop(This
, name
, alloc
, &prop
);
425 static HRESULT
dispex_value(DispatchEx
*This
, LCID lcid
, WORD flags
, DISPPARAMS
*params
,
426 VARIANT
*res
, EXCEPINFO
*ei
, IServiceProvider
*caller
)
428 if(This
->data
->vtbl
&& This
->data
->vtbl
->value
)
429 return This
->data
->vtbl
->value(This
->outer
, lcid
, flags
, params
, res
, ei
, caller
);
432 case DISPATCH_PROPERTYGET
:
434 V_BSTR(res
) = SysAllocString(objectW
);
436 return E_OUTOFMEMORY
;
439 FIXME("Unimplemented flags %x\n", flags
);
446 static HRESULT
typeinfo_invoke(DispatchEx
*This
, func_info_t
*func
, WORD flags
, DISPPARAMS
*dp
, VARIANT
*res
,
454 hres
= get_typeinfo(func
->tid
, &ti
);
456 ERR("Could not get type info: %08x\n", hres
);
460 hres
= IUnknown_QueryInterface(This
->outer
, tid_ids
[func
->tid
], (void**)&unk
);
462 ERR("Could not get iface %s: %08x\n", debugstr_guid(tid_ids
[func
->tid
]), hres
);
466 hres
= ITypeInfo_Invoke(ti
, unk
, func
->id
, flags
, dp
, res
, ei
, &argerr
);
468 IUnknown_Release(unk
);
472 #define FUNCTION_THIS(iface) DEFINE_THIS(func_disp_t, IUnknown, iface)
474 static HRESULT WINAPI
Function_QueryInterface(IUnknown
*iface
, REFIID riid
, void **ppv
)
476 func_disp_t
*This
= FUNCTION_THIS(iface
);
478 if(IsEqualGUID(&IID_IUnknown
, riid
)) {
479 TRACE("(%p)->(IID_IUnknown %p)\n", This
, ppv
);
480 *ppv
= FUNCUNKNOWN(This
);
481 }else if(dispex_query_interface(&This
->dispex
, riid
, ppv
)) {
482 return *ppv
? S_OK
: E_NOINTERFACE
;
485 return E_NOINTERFACE
;
488 IUnknown_AddRef((IUnknown
*)*ppv
);
492 static ULONG WINAPI
Function_AddRef(IUnknown
*iface
)
494 func_disp_t
*This
= FUNCTION_THIS(iface
);
496 TRACE("(%p)\n", This
);
498 return IDispatchEx_AddRef(DISPATCHEX(This
->obj
));
501 static ULONG WINAPI
Function_Release(IUnknown
*iface
)
503 func_disp_t
*This
= FUNCTION_THIS(iface
);
505 TRACE("(%p)\n", This
);
507 return IDispatchEx_Release(DISPATCHEX(This
->obj
));
510 static HRESULT
function_value(IUnknown
*iface
, LCID lcid
, WORD flags
, DISPPARAMS
*params
,
511 VARIANT
*res
, EXCEPINFO
*ei
, IServiceProvider
*caller
)
513 func_disp_t
*This
= FUNCTION_THIS(iface
);
517 case DISPATCH_METHOD
:
518 hres
= typeinfo_invoke(This
->obj
, This
->info
, flags
, params
, res
, ei
);
521 FIXME("Unimplemented flags %x\n", flags
);
530 static const IUnknownVtbl FunctionUnkVtbl
= {
531 Function_QueryInterface
,
536 static const dispex_static_data_vtbl_t function_dispex_vtbl
= {
542 static const tid_t function_iface_tids
[] = {0};
544 static dispex_static_data_t function_dispex
= {
545 &function_dispex_vtbl
,
551 static func_disp_t
*create_func_disp(DispatchEx
*obj
, func_info_t
*info
)
555 ret
= heap_alloc_zero(sizeof(func_disp_t
));
559 ret
->lpIUnknownVtbl
= &FunctionUnkVtbl
;
560 init_dispex(&ret
->dispex
, FUNCUNKNOWN(ret
), &function_dispex
);
567 static HRESULT
function_invoke(DispatchEx
*This
, func_info_t
*func
, WORD flags
, DISPPARAMS
*dp
, VARIANT
*res
,
573 case DISPATCH_METHOD
:
574 hres
= typeinfo_invoke(This
, func
, flags
, dp
, res
, ei
);
576 case DISPATCH_PROPERTYGET
: {
577 dispex_dynamic_data_t
*dynamic_data
;
579 if(func
->id
== DISPID_VALUE
) {
582 ret
= SysAllocString(objectW
);
584 return E_OUTOFMEMORY
;
591 dynamic_data
= get_dynamic_data(This
, TRUE
);
593 return E_OUTOFMEMORY
;
595 if(!dynamic_data
->func_disps
) {
596 dynamic_data
->func_disps
= heap_alloc_zero(This
->data
->data
->func_disp_cnt
* sizeof(func_disp_t
*));
597 if(!dynamic_data
->func_disps
)
598 return E_OUTOFMEMORY
;
601 if(!dynamic_data
->func_disps
[func
->func_disp_idx
]) {
602 dynamic_data
->func_disps
[func
->func_disp_idx
] = create_func_disp(This
, func
);
603 if(!dynamic_data
->func_disps
[func
->func_disp_idx
])
604 return E_OUTOFMEMORY
;
607 V_VT(res
) = VT_DISPATCH
;
608 V_DISPATCH(res
) = (IDispatch
*)DISPATCHEX(&dynamic_data
->func_disps
[func
->func_disp_idx
]->dispex
);
609 IDispatch_AddRef(V_DISPATCH(res
));
614 FIXME("Unimplemented flags %x\n", flags
);
615 case DISPATCH_PROPERTYPUT
:
622 static HRESULT
get_builtin_func(dispex_data_t
*data
, DISPID id
, func_info_t
**ret
)
627 max
= data
->func_cnt
-1;
632 if(data
->funcs
[n
].id
== id
) {
633 *ret
= data
->funcs
+n
;
637 if(data
->funcs
[n
].id
< id
)
643 WARN("invalid id %x\n", id
);
644 return DISP_E_UNKNOWNNAME
;
647 #define DISPATCHEX_THIS(iface) DEFINE_THIS(DispatchEx, IDispatchEx, iface)
649 static HRESULT WINAPI
DispatchEx_QueryInterface(IDispatchEx
*iface
, REFIID riid
, void **ppv
)
651 DispatchEx
*This
= DISPATCHEX_THIS(iface
);
653 return IUnknown_QueryInterface(This
->outer
, riid
, ppv
);
656 static ULONG WINAPI
DispatchEx_AddRef(IDispatchEx
*iface
)
658 DispatchEx
*This
= DISPATCHEX_THIS(iface
);
660 return IUnknown_AddRef(This
->outer
);
663 static ULONG WINAPI
DispatchEx_Release(IDispatchEx
*iface
)
665 DispatchEx
*This
= DISPATCHEX_THIS(iface
);
667 return IUnknown_Release(This
->outer
);
670 static HRESULT WINAPI
DispatchEx_GetTypeInfoCount(IDispatchEx
*iface
, UINT
*pctinfo
)
672 DispatchEx
*This
= DISPATCHEX_THIS(iface
);
674 TRACE("(%p)->(%p)\n", This
, pctinfo
);
680 static HRESULT WINAPI
DispatchEx_GetTypeInfo(IDispatchEx
*iface
, UINT iTInfo
,
681 LCID lcid
, ITypeInfo
**ppTInfo
)
683 DispatchEx
*This
= DISPATCHEX_THIS(iface
);
686 TRACE("(%p)->(%u %u %p)\n", This
, iTInfo
, lcid
, ppTInfo
);
688 hres
= get_typeinfo(This
->data
->disp_tid
, ppTInfo
);
692 ITypeInfo_AddRef(*ppTInfo
);
696 static HRESULT WINAPI
DispatchEx_GetIDsOfNames(IDispatchEx
*iface
, REFIID riid
,
697 LPOLESTR
*rgszNames
, UINT cNames
,
698 LCID lcid
, DISPID
*rgDispId
)
700 DispatchEx
*This
= DISPATCHEX_THIS(iface
);
704 TRACE("(%p)->(%s %p %u %u %p)\n", This
, debugstr_guid(riid
), rgszNames
, cNames
,
707 for(i
=0; i
< cNames
; i
++) {
708 hres
= IDispatchEx_GetDispID(DISPATCHEX(This
), rgszNames
[i
], 0, rgDispId
+i
);
716 static HRESULT WINAPI
DispatchEx_Invoke(IDispatchEx
*iface
, DISPID dispIdMember
,
717 REFIID riid
, LCID lcid
, WORD wFlags
, DISPPARAMS
*pDispParams
,
718 VARIANT
*pVarResult
, EXCEPINFO
*pExcepInfo
, UINT
*puArgErr
)
720 DispatchEx
*This
= DISPATCHEX_THIS(iface
);
722 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This
, dispIdMember
, debugstr_guid(riid
),
723 lcid
, wFlags
, pDispParams
, pVarResult
, pExcepInfo
, puArgErr
);
725 return IDispatchEx_InvokeEx(DISPATCHEX(This
), dispIdMember
, lcid
, wFlags
,
726 pDispParams
, pVarResult
, pExcepInfo
, NULL
);
729 static HRESULT WINAPI
DispatchEx_GetDispID(IDispatchEx
*iface
, BSTR bstrName
, DWORD grfdex
, DISPID
*pid
)
731 DispatchEx
*This
= DISPATCHEX_THIS(iface
);
732 dynamic_prop_t
*dprop
;
737 TRACE("(%p)->(%s %x %p)\n", This
, debugstr_w(bstrName
), grfdex
, pid
);
739 if(grfdex
& ~(fdexNameCaseSensitive
|fdexNameEnsure
|fdexNameImplicit
))
740 FIXME("Unsupported grfdex %x\n", grfdex
);
742 data
= get_dispex_data(This
);
747 max
= data
->func_cnt
-1;
752 c
= strcmpiW(data
->name_table
[n
]->name
, bstrName
);
754 if((grfdex
& fdexNameCaseSensitive
) && strcmpW(data
->name_table
[n
]->name
, bstrName
))
757 *pid
= data
->name_table
[n
]->id
;
767 if(This
->data
->vtbl
&& This
->data
->vtbl
->get_dispid
) {
770 hres
= This
->data
->vtbl
->get_dispid(This
->outer
, bstrName
, grfdex
, pid
);
771 if(hres
!= DISP_E_UNKNOWNNAME
)
775 hres
= get_dynamic_prop(This
, bstrName
, grfdex
&fdexNameEnsure
, &dprop
);
779 *pid
= DISPID_DYNPROP_0
+ (dprop
- This
->dynamic_data
->props
);
783 static HRESULT WINAPI
DispatchEx_InvokeEx(IDispatchEx
*iface
, DISPID id
, LCID lcid
, WORD wFlags
, DISPPARAMS
*pdp
,
784 VARIANT
*pvarRes
, EXCEPINFO
*pei
, IServiceProvider
*pspCaller
)
786 DispatchEx
*This
= DISPATCHEX_THIS(iface
);
791 TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This
, id
, lcid
, wFlags
, pdp
, pvarRes
, pei
, pspCaller
);
793 if(is_custom_dispid(id
) && This
->data
->vtbl
&& This
->data
->vtbl
->invoke
)
794 return This
->data
->vtbl
->invoke(This
->outer
, id
, lcid
, wFlags
, pdp
, pvarRes
, pei
, pspCaller
);
796 if(wFlags
== DISPATCH_CONSTRUCT
) {
797 FIXME("DISPATCH_CONSTRUCT not implemented\n");
801 if(is_dynamic_dispid(id
)) {
802 DWORD idx
= id
- DISPID_DYNPROP_0
;
805 if(!This
->dynamic_data
|| This
->dynamic_data
->prop_cnt
<= idx
)
806 return DISP_E_UNKNOWNNAME
;
808 var
= &This
->dynamic_data
->props
[idx
].var
;
812 DISPID named_arg
= DISPID_THIS
;
813 DISPPARAMS dp
= {NULL
, &named_arg
, 0, 1};
816 if(V_VT(var
) != VT_DISPATCH
) {
817 FIXME("invoke vt %d\n", V_VT(var
));
821 if(pdp
->cNamedArgs
) {
822 FIXME("named args not supported\n");
826 dp
.rgvarg
= heap_alloc((pdp
->cArgs
+1)*sizeof(VARIANTARG
));
828 return E_OUTOFMEMORY
;
830 dp
.cArgs
= pdp
->cArgs
+1;
831 memcpy(dp
.rgvarg
+1, pdp
->rgvarg
, pdp
->cArgs
*sizeof(VARIANTARG
));
833 V_VT(dp
.rgvarg
) = VT_DISPATCH
;
834 V_DISPATCH(dp
.rgvarg
) = (IDispatch
*)DISPATCHEX(This
);
836 hres
= IDispatch_QueryInterface(V_DISPATCH(var
), &IID_IDispatchEx
, (void**)&dispex
);
837 TRACE("%s call\n", debugstr_w(This
->dynamic_data
->props
[idx
].name
));
838 if(SUCCEEDED(hres
)) {
839 hres
= IDispatchEx_InvokeEx(dispex
, DISPID_VALUE
, lcid
, wFlags
, &dp
, pvarRes
, pei
, pspCaller
);
840 IDispatchEx_Release(dispex
);
843 hres
= IDispatch_Invoke(V_DISPATCH(var
), DISPID_VALUE
, &IID_NULL
, lcid
, wFlags
, pdp
, pvarRes
, pei
, &err
);
845 TRACE("%s ret %08x\n", debugstr_w(This
->dynamic_data
->props
[idx
].name
), hres
);
847 heap_free(dp
.rgvarg
);
850 case INVOKE_PROPERTYGET
:
851 return VariantCopy(pvarRes
, var
);
852 case INVOKE_PROPERTYPUT
:
854 return VariantCopy(var
, pdp
->rgvarg
);
856 FIXME("unhandled wFlags %x\n", wFlags
);
861 data
= get_dispex_data(This
);
865 hres
= get_builtin_func(data
, id
, &func
);
866 if(id
== DISPID_VALUE
&& hres
== DISP_E_UNKNOWNNAME
)
867 return dispex_value(This
, lcid
, wFlags
, pdp
, pvarRes
, pei
, pspCaller
);
871 if(func
->func_disp_idx
== -1)
872 hres
= typeinfo_invoke(This
, func
, wFlags
, pdp
, pvarRes
, pei
);
874 hres
= function_invoke(This
, func
, wFlags
, pdp
, pvarRes
, pei
);
879 static HRESULT WINAPI
DispatchEx_DeleteMemberByName(IDispatchEx
*iface
, BSTR bstrName
, DWORD grfdex
)
881 DispatchEx
*This
= DISPATCHEX_THIS(iface
);
882 FIXME("(%p)->(%s %x)\n", This
, debugstr_w(bstrName
), grfdex
);
886 static HRESULT WINAPI
DispatchEx_DeleteMemberByDispID(IDispatchEx
*iface
, DISPID id
)
888 DispatchEx
*This
= DISPATCHEX_THIS(iface
);
889 FIXME("(%p)->(%x)\n", This
, id
);
893 static HRESULT WINAPI
DispatchEx_GetMemberProperties(IDispatchEx
*iface
, DISPID id
, DWORD grfdexFetch
, DWORD
*pgrfdex
)
895 DispatchEx
*This
= DISPATCHEX_THIS(iface
);
896 FIXME("(%p)->(%x %x %p)\n", This
, id
, grfdexFetch
, pgrfdex
);
900 static HRESULT WINAPI
DispatchEx_GetMemberName(IDispatchEx
*iface
, DISPID id
, BSTR
*pbstrName
)
902 DispatchEx
*This
= DISPATCHEX_THIS(iface
);
907 TRACE("(%p)->(%x %p)\n", This
, id
, pbstrName
);
909 if(is_dynamic_dispid(id
)) {
910 DWORD idx
= id
- DISPID_DYNPROP_0
;
912 if(!This
->dynamic_data
|| This
->dynamic_data
->prop_cnt
<= idx
)
913 return DISP_E_UNKNOWNNAME
;
915 *pbstrName
= SysAllocString(This
->dynamic_data
->props
[idx
].name
);
917 return E_OUTOFMEMORY
;
922 data
= get_dispex_data(This
);
926 hres
= get_builtin_func(data
, id
, &func
);
930 *pbstrName
= SysAllocString(func
->name
);
932 return E_OUTOFMEMORY
;
936 static HRESULT WINAPI
DispatchEx_GetNextDispID(IDispatchEx
*iface
, DWORD grfdex
, DISPID id
, DISPID
*pid
)
938 DispatchEx
*This
= DISPATCHEX_THIS(iface
);
943 TRACE("(%p)->(%x %x %p)\n", This
, grfdex
, id
, pid
);
945 if(is_dynamic_dispid(id
)) {
946 DWORD idx
= id
- DISPID_DYNPROP_0
;
948 if(!This
->dynamic_data
|| This
->dynamic_data
->prop_cnt
<= idx
)
949 return DISP_E_UNKNOWNNAME
;
951 if(idx
+1 == This
->dynamic_data
->prop_cnt
) {
952 *pid
= DISPID_STARTENUM
;
960 data
= get_dispex_data(This
);
964 if(id
== DISPID_STARTENUM
) {
967 hres
= get_builtin_func(data
, id
, &func
);
973 while(func
< data
->funcs
+data
->func_cnt
) {
974 /* FIXME: Skip hidden properties */
975 if(func
->func_disp_idx
== -1) {
982 if(This
->dynamic_data
&& This
->dynamic_data
->prop_cnt
) {
983 *pid
= DISPID_DYNPROP_0
;
987 *pid
= DISPID_STARTENUM
;
991 static HRESULT WINAPI
DispatchEx_GetNameSpaceParent(IDispatchEx
*iface
, IUnknown
**ppunk
)
993 DispatchEx
*This
= DISPATCHEX_THIS(iface
);
994 FIXME("(%p)->(%p)\n", This
, ppunk
);
998 #undef DISPATCHEX_THIS
1000 static IDispatchExVtbl DispatchExVtbl
= {
1001 DispatchEx_QueryInterface
,
1004 DispatchEx_GetTypeInfoCount
,
1005 DispatchEx_GetTypeInfo
,
1006 DispatchEx_GetIDsOfNames
,
1008 DispatchEx_GetDispID
,
1009 DispatchEx_InvokeEx
,
1010 DispatchEx_DeleteMemberByName
,
1011 DispatchEx_DeleteMemberByDispID
,
1012 DispatchEx_GetMemberProperties
,
1013 DispatchEx_GetMemberName
,
1014 DispatchEx_GetNextDispID
,
1015 DispatchEx_GetNameSpaceParent
1018 BOOL
dispex_query_interface(DispatchEx
*This
, REFIID riid
, void **ppv
)
1020 static const IID IID_UndocumentedScriptIface
=
1021 {0x719c3050,0xf9d3,0x11cf,{0xa4,0x93,0x00,0x40,0x05,0x23,0xa8,0xa0}};
1022 static const IID IID_IDispatchJS
=
1023 {0x719c3050,0xf9d3,0x11cf,{0xa4,0x93,0x00,0x40,0x05,0x23,0xa8,0xa6}};
1025 if(IsEqualGUID(&IID_IDispatch
, riid
)) {
1026 TRACE("(%p)->(IID_IDispatch %p)\n", This
, ppv
);
1027 *ppv
= DISPATCHEX(This
);
1028 }else if(IsEqualGUID(&IID_IDispatchEx
, riid
)) {
1029 TRACE("(%p)->(IID_IDispatchEx %p)\n", This
, ppv
);
1030 *ppv
= DISPATCHEX(This
);
1031 }else if(IsEqualGUID(&IID_IDispatchJS
, riid
)) {
1032 TRACE("(%p)->(IID_IDispatchJS %p) returning NULL\n", This
, ppv
);
1034 }else if(IsEqualGUID(&IID_UndocumentedScriptIface
, riid
)) {
1035 TRACE("(%p)->(IID_UndocumentedScriptIface %p) returning NULL\n", This
, ppv
);
1042 IUnknown_AddRef((IUnknown
*)*ppv
);
1046 void release_dispex(DispatchEx
*This
)
1048 dynamic_prop_t
*prop
;
1050 if(!This
->dynamic_data
)
1053 for(prop
= This
->dynamic_data
->props
; prop
< This
->dynamic_data
->props
+ This
->dynamic_data
->prop_cnt
; prop
++) {
1054 VariantClear(&prop
->var
);
1055 heap_free(prop
->name
);
1058 heap_free(This
->dynamic_data
->props
);
1060 if(This
->dynamic_data
->func_disps
) {
1063 for(i
=0; i
< This
->data
->data
->func_disp_cnt
; i
++) {
1064 if(This
->dynamic_data
->func_disps
[i
]) {
1065 release_dispex(&This
->dynamic_data
->func_disps
[i
]->dispex
);
1066 heap_free(This
->dynamic_data
->func_disps
[i
]);
1070 heap_free(This
->dynamic_data
->func_disps
);
1073 heap_free(This
->dynamic_data
);
1076 void init_dispex(DispatchEx
*dispex
, IUnknown
*outer
, dispex_static_data_t
*data
)
1078 dispex
->lpIDispatchExVtbl
= &DispatchExVtbl
;
1079 dispex
->outer
= outer
;
1080 dispex
->data
= data
;
1081 dispex
->dynamic_data
= NULL
;