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
;
58 #define DYNPROP_DELETED 0x01
62 IUnknown IUnknown_iface
;
67 struct dispex_dynamic_data_t
{
70 dynamic_prop_t
*props
;
71 func_disp_t
**func_disps
;
74 #define DISPID_DYNPROP_0 0x50000000
75 #define DISPID_DYNPROP_MAX 0x5fffffff
77 #define FDEX_VERSION_MASK 0xf0000000
79 static ITypeLib
*typelib
;
80 static ITypeInfo
*typeinfos
[LAST_tid
];
81 static struct list dispex_data_list
= LIST_INIT(dispex_data_list
);
83 static REFIID tid_ids
[] = {
84 #define XIID(iface) &IID_ ## iface,
85 #define XDIID(iface) &DIID_ ## iface,
91 static HRESULT
load_typelib(void)
96 hres
= LoadRegTypeLib(&LIBID_MSHTML
, 4, 0, LOCALE_SYSTEM_DEFAULT
, &tl
);
98 ERR("LoadRegTypeLib failed: %08x\n", hres
);
102 if(InterlockedCompareExchangePointer((void**)&typelib
, tl
, NULL
))
103 ITypeLib_Release(tl
);
107 static HRESULT
get_typeinfo(tid_t tid
, ITypeInfo
**typeinfo
)
112 hres
= load_typelib();
116 if(!typeinfos
[tid
]) {
119 hres
= ITypeLib_GetTypeInfoOfGuid(typelib
, tid_ids
[tid
], &ti
);
121 ERR("GetTypeInfoOfGuid(%s) failed: %08x\n", debugstr_guid(tid_ids
[tid
]), hres
);
125 if(InterlockedCompareExchangePointer((void**)(typeinfos
+tid
), ti
, NULL
))
126 ITypeInfo_Release(ti
);
129 *typeinfo
= typeinfos
[tid
];
133 void release_typelib(void)
138 while(!list_empty(&dispex_data_list
)) {
139 iter
= LIST_ENTRY(list_head(&dispex_data_list
), dispex_data_t
, entry
);
140 list_remove(&iter
->entry
);
142 for(i
=0; i
< iter
->func_cnt
; i
++)
143 SysFreeString(iter
->funcs
[i
].name
);
145 heap_free(iter
->funcs
);
146 heap_free(iter
->name_table
);
153 for(i
=0; i
< sizeof(typeinfos
)/sizeof(*typeinfos
); i
++)
155 ITypeInfo_Release(typeinfos
[i
]);
157 ITypeLib_Release(typelib
);
160 HRESULT
get_htmldoc_classinfo(ITypeInfo
**typeinfo
)
165 hres
= load_typelib();
169 hres
= ITypeLib_GetTypeInfoOfGuid(typelib
, &CLSID_HTMLDocument
, typeinfo
);
171 ERR("GetTypeInfoOfGuid failed: %08x\n", hres
);
175 static void add_func_info(dispex_data_t
*data
, DWORD
*size
, tid_t tid
, const FUNCDESC
*desc
, ITypeInfo
*dti
)
179 if(data
->func_cnt
&& data
->funcs
[data
->func_cnt
-1].id
== desc
->memid
)
182 if(data
->func_cnt
== *size
)
183 data
->funcs
= heap_realloc(data
->funcs
, (*size
<<= 1)*sizeof(func_info_t
));
185 hres
= ITypeInfo_GetDocumentation(dti
, desc
->memid
, &data
->funcs
[data
->func_cnt
].name
, NULL
, NULL
, NULL
);
189 data
->funcs
[data
->func_cnt
].id
= desc
->memid
;
190 data
->funcs
[data
->func_cnt
].tid
= tid
;
191 data
->funcs
[data
->func_cnt
].func_disp_idx
= (desc
->invkind
& DISPATCH_METHOD
) ? data
->func_disp_cnt
++ : -1;
196 static int dispid_cmp(const void *p1
, const void *p2
)
198 return ((const func_info_t
*)p1
)->id
- ((const func_info_t
*)p2
)->id
;
201 static int func_name_cmp(const void *p1
, const void *p2
)
203 return strcmpiW((*(func_info_t
* const*)p1
)->name
, (*(func_info_t
* const*)p2
)->name
);
206 static dispex_data_t
*preprocess_dispex_data(DispatchEx
*This
)
208 const tid_t
*tid
= This
->data
->iface_tids
;
215 TRACE("(%p)\n", This
);
217 if(This
->data
->disp_tid
) {
218 hres
= get_typeinfo(This
->data
->disp_tid
, &dti
);
220 ERR("Could not get disp type info: %08x\n", hres
);
225 data
= heap_alloc(sizeof(dispex_data_t
));
227 data
->func_disp_cnt
= 0;
228 data
->funcs
= heap_alloc(size
*sizeof(func_info_t
));
229 list_add_tail(&dispex_data_list
, &data
->entry
);
232 hres
= get_typeinfo(*tid
, &ti
);
238 hres
= ITypeInfo_GetFuncDesc(ti
, i
++, &funcdesc
);
242 add_func_info(data
, &size
, *tid
, funcdesc
, dti
);
243 ITypeInfo_ReleaseFuncDesc(ti
, funcdesc
);
249 if(!data
->func_cnt
) {
250 heap_free(data
->funcs
);
251 data
->name_table
= NULL
;
257 data
->funcs
= heap_realloc(data
->funcs
, data
->func_cnt
* sizeof(func_info_t
));
258 qsort(data
->funcs
, data
->func_cnt
, sizeof(func_info_t
), dispid_cmp
);
260 data
->name_table
= heap_alloc(data
->func_cnt
* sizeof(func_info_t
*));
261 for(i
=0; i
< data
->func_cnt
; i
++)
262 data
->name_table
[i
] = data
->funcs
+i
;
263 qsort(data
->name_table
, data
->func_cnt
, sizeof(func_info_t
*), func_name_cmp
);
268 static int id_cmp(const void *p1
, const void *p2
)
270 return *(const DISPID
*)p1
- *(const DISPID
*)p2
;
273 HRESULT
get_dispids(tid_t tid
, DWORD
*ret_size
, DISPID
**ret
)
275 unsigned i
, func_cnt
;
282 hres
= get_typeinfo(tid
, &ti
);
286 hres
= ITypeInfo_GetTypeAttr(ti
, &attr
);
288 ITypeInfo_Release(ti
);
292 func_cnt
= attr
->cFuncs
;
293 ITypeInfo_ReleaseTypeAttr(ti
, attr
);
295 ids
= heap_alloc(func_cnt
*sizeof(DISPID
));
297 ITypeInfo_Release(ti
);
298 return E_OUTOFMEMORY
;
301 for(i
=0; i
< func_cnt
; i
++) {
302 hres
= ITypeInfo_GetFuncDesc(ti
, i
, &funcdesc
);
306 ids
[i
] = funcdesc
->memid
;
307 ITypeInfo_ReleaseFuncDesc(ti
, funcdesc
);
310 ITypeInfo_Release(ti
);
316 qsort(ids
, func_cnt
, sizeof(DISPID
), id_cmp
);
318 *ret_size
= func_cnt
;
323 static CRITICAL_SECTION cs_dispex_static_data
;
324 static CRITICAL_SECTION_DEBUG cs_dispex_static_data_dbg
=
326 0, 0, &cs_dispex_static_data
,
327 { &cs_dispex_static_data_dbg
.ProcessLocksList
, &cs_dispex_static_data_dbg
.ProcessLocksList
},
328 0, 0, { (DWORD_PTR
)(__FILE__
": dispex_static_data") }
330 static CRITICAL_SECTION cs_dispex_static_data
= { &cs_dispex_static_data_dbg
, -1, 0, 0, 0, 0 };
333 static dispex_data_t
*get_dispex_data(DispatchEx
*This
)
336 return This
->data
->data
;
338 EnterCriticalSection(&cs_dispex_static_data
);
340 if(!This
->data
->data
)
341 This
->data
->data
= preprocess_dispex_data(This
);
343 LeaveCriticalSection(&cs_dispex_static_data
);
345 return This
->data
->data
;
348 static inline BOOL
is_custom_dispid(DISPID id
)
350 return MSHTML_DISPID_CUSTOM_MIN
<= id
&& id
<= MSHTML_DISPID_CUSTOM_MAX
;
353 static inline BOOL
is_dynamic_dispid(DISPID id
)
355 return DISPID_DYNPROP_0
<= id
&& id
<= DISPID_DYNPROP_MAX
;
358 static HRESULT
variant_copy(VARIANT
*dest
, VARIANT
*src
)
360 if(V_VT(src
) == VT_BSTR
&& !V_BSTR(src
)) {
361 V_VT(dest
) = VT_BSTR
;
366 return VariantCopy(dest
, src
);
369 static inline dispex_dynamic_data_t
*get_dynamic_data(DispatchEx
*This
, BOOL alloc
)
371 return !alloc
|| This
->dynamic_data
373 : (This
->dynamic_data
= heap_alloc_zero(sizeof(dispex_dynamic_data_t
)));
376 static HRESULT
get_dynamic_prop(DispatchEx
*This
, const WCHAR
*name
, DWORD flags
, dynamic_prop_t
**ret
)
378 const BOOL alloc
= flags
& fdexNameEnsure
;
379 dispex_dynamic_data_t
*data
;
380 dynamic_prop_t
*prop
;
382 data
= get_dynamic_data(This
, alloc
);
385 return E_OUTOFMEMORY
;
387 TRACE("not found %s\n", debugstr_w(name
));
388 return DISP_E_UNKNOWNNAME
;
391 for(prop
= data
->props
; prop
< data
->props
+data
->prop_cnt
; prop
++) {
392 if(flags
& fdexNameCaseInsensitive
? !strcmpiW(prop
->name
, name
) : !strcmpW(prop
->name
, name
)) {
393 if(prop
->flags
& DYNPROP_DELETED
) {
395 return DISP_E_UNKNOWNNAME
;
396 prop
->flags
&= ~DYNPROP_DELETED
;
404 return DISP_E_UNKNOWNNAME
;
406 TRACE("creating dynamic prop %s\n", debugstr_w(name
));
408 if(!data
->buf_size
) {
409 data
->props
= heap_alloc(sizeof(dynamic_prop_t
)*4);
411 return E_OUTOFMEMORY
;
413 }else if(data
->buf_size
== data
->prop_cnt
) {
414 dynamic_prop_t
*new_props
;
416 new_props
= heap_realloc(data
->props
, sizeof(dynamic_prop_t
)*(data
->buf_size
<<1));
418 return E_OUTOFMEMORY
;
420 data
->props
= new_props
;
421 data
->buf_size
<<= 1;
424 prop
= data
->props
+ data
->prop_cnt
;
426 prop
->name
= heap_strdupW(name
);
428 return E_OUTOFMEMORY
;
430 VariantInit(&prop
->var
);
437 HRESULT
dispex_get_dprop_ref(DispatchEx
*This
, const WCHAR
*name
, BOOL alloc
, VARIANT
**ret
)
439 dynamic_prop_t
*prop
;
442 hres
= get_dynamic_prop(This
, name
, alloc
? fdexNameEnsure
: 0, &prop
);
450 static HRESULT
dispex_value(DispatchEx
*This
, LCID lcid
, WORD flags
, DISPPARAMS
*params
,
451 VARIANT
*res
, EXCEPINFO
*ei
, IServiceProvider
*caller
)
453 if(This
->data
->vtbl
&& This
->data
->vtbl
->value
)
454 return This
->data
->vtbl
->value(This
, lcid
, flags
, params
, res
, ei
, caller
);
457 case DISPATCH_PROPERTYGET
:
459 V_BSTR(res
) = SysAllocString(objectW
);
461 return E_OUTOFMEMORY
;
464 FIXME("Unimplemented flags %x\n", flags
);
471 static HRESULT
typeinfo_invoke(DispatchEx
*This
, func_info_t
*func
, WORD flags
, DISPPARAMS
*dp
, VARIANT
*res
,
479 hres
= get_typeinfo(func
->tid
, &ti
);
481 ERR("Could not get type info: %08x\n", hres
);
485 hres
= IUnknown_QueryInterface(This
->outer
, tid_ids
[func
->tid
], (void**)&unk
);
487 ERR("Could not get iface %s: %08x\n", debugstr_guid(tid_ids
[func
->tid
]), hres
);
491 hres
= ITypeInfo_Invoke(ti
, unk
, func
->id
, flags
, dp
, res
, ei
, &argerr
);
493 IUnknown_Release(unk
);
497 static inline func_disp_t
*impl_from_IUnknown(IUnknown
*iface
)
499 return CONTAINING_RECORD(iface
, func_disp_t
, IUnknown_iface
);
502 static HRESULT WINAPI
Function_QueryInterface(IUnknown
*iface
, REFIID riid
, void **ppv
)
504 func_disp_t
*This
= impl_from_IUnknown(iface
);
506 if(IsEqualGUID(&IID_IUnknown
, riid
)) {
507 TRACE("(%p)->(IID_IUnknown %p)\n", This
, ppv
);
508 *ppv
= &This
->IUnknown_iface
;
509 }else if(dispex_query_interface(&This
->dispex
, riid
, ppv
)) {
510 return *ppv
? S_OK
: E_NOINTERFACE
;
513 return E_NOINTERFACE
;
516 IUnknown_AddRef((IUnknown
*)*ppv
);
520 static ULONG WINAPI
Function_AddRef(IUnknown
*iface
)
522 func_disp_t
*This
= impl_from_IUnknown(iface
);
524 TRACE("(%p)\n", This
);
526 return IDispatchEx_AddRef(&This
->obj
->IDispatchEx_iface
);
529 static ULONG WINAPI
Function_Release(IUnknown
*iface
)
531 func_disp_t
*This
= impl_from_IUnknown(iface
);
533 TRACE("(%p)\n", This
);
535 return IDispatchEx_Release(&This
->obj
->IDispatchEx_iface
);
538 static const IUnknownVtbl FunctionUnkVtbl
= {
539 Function_QueryInterface
,
544 static inline func_disp_t
*impl_from_DispatchEx(DispatchEx
*iface
)
546 return CONTAINING_RECORD(iface
, func_disp_t
, dispex
);
549 static HRESULT
function_value(DispatchEx
*dispex
, LCID lcid
, WORD flags
, DISPPARAMS
*params
,
550 VARIANT
*res
, EXCEPINFO
*ei
, IServiceProvider
*caller
)
552 func_disp_t
*This
= impl_from_DispatchEx(dispex
);
556 case DISPATCH_METHOD
|DISPATCH_PROPERTYGET
:
559 case DISPATCH_METHOD
:
560 hres
= typeinfo_invoke(This
->obj
, This
->info
, flags
, params
, res
, ei
);
563 FIXME("Unimplemented flags %x\n", flags
);
570 static const dispex_static_data_vtbl_t function_dispex_vtbl
= {
576 static const tid_t function_iface_tids
[] = {0};
578 static dispex_static_data_t function_dispex
= {
579 &function_dispex_vtbl
,
585 static func_disp_t
*create_func_disp(DispatchEx
*obj
, func_info_t
*info
)
589 ret
= heap_alloc_zero(sizeof(func_disp_t
));
593 ret
->IUnknown_iface
.lpVtbl
= &FunctionUnkVtbl
;
594 init_dispex(&ret
->dispex
, &ret
->IUnknown_iface
, &function_dispex
);
601 static HRESULT
function_invoke(DispatchEx
*This
, func_info_t
*func
, WORD flags
, DISPPARAMS
*dp
, VARIANT
*res
,
607 case DISPATCH_METHOD
|DISPATCH_PROPERTYGET
:
610 case DISPATCH_METHOD
:
611 hres
= typeinfo_invoke(This
, func
, flags
, dp
, res
, ei
);
613 case DISPATCH_PROPERTYGET
: {
614 dispex_dynamic_data_t
*dynamic_data
;
616 if(func
->id
== DISPID_VALUE
) {
619 ret
= SysAllocString(objectW
);
621 return E_OUTOFMEMORY
;
628 dynamic_data
= get_dynamic_data(This
, TRUE
);
630 return E_OUTOFMEMORY
;
632 if(!dynamic_data
->func_disps
) {
633 dynamic_data
->func_disps
= heap_alloc_zero(This
->data
->data
->func_disp_cnt
* sizeof(func_disp_t
*));
634 if(!dynamic_data
->func_disps
)
635 return E_OUTOFMEMORY
;
638 if(!dynamic_data
->func_disps
[func
->func_disp_idx
]) {
639 dynamic_data
->func_disps
[func
->func_disp_idx
] = create_func_disp(This
, func
);
640 if(!dynamic_data
->func_disps
[func
->func_disp_idx
])
641 return E_OUTOFMEMORY
;
644 V_VT(res
) = VT_DISPATCH
;
645 V_DISPATCH(res
) = (IDispatch
*)&dynamic_data
->func_disps
[func
->func_disp_idx
]->dispex
.IDispatchEx_iface
;
646 IDispatch_AddRef(V_DISPATCH(res
));
651 FIXME("Unimplemented flags %x\n", flags
);
652 case DISPATCH_PROPERTYPUT
:
659 static HRESULT
get_builtin_func(dispex_data_t
*data
, DISPID id
, func_info_t
**ret
)
664 max
= data
->func_cnt
-1;
669 if(data
->funcs
[n
].id
== id
) {
670 *ret
= data
->funcs
+n
;
674 if(data
->funcs
[n
].id
< id
)
680 WARN("invalid id %x\n", id
);
681 return DISP_E_UNKNOWNNAME
;
684 static HRESULT
get_builtin_id(DispatchEx
*This
, BSTR name
, DWORD grfdex
, DISPID
*ret
)
689 data
= get_dispex_data(This
);
694 max
= data
->func_cnt
-1;
699 c
= strcmpiW(data
->name_table
[n
]->name
, name
);
701 if((grfdex
& fdexNameCaseSensitive
) && strcmpW(data
->name_table
[n
]->name
, name
))
704 *ret
= data
->name_table
[n
]->id
;
714 if(This
->data
->vtbl
&& This
->data
->vtbl
->get_dispid
) {
717 hres
= This
->data
->vtbl
->get_dispid(This
, name
, grfdex
, ret
);
718 if(hres
!= DISP_E_UNKNOWNNAME
)
722 return DISP_E_UNKNOWNNAME
;
725 static HRESULT
invoke_builtin_prop(DispatchEx
*This
, DISPID id
, LCID lcid
, WORD flags
, DISPPARAMS
*dp
,
726 VARIANT
*res
, EXCEPINFO
*ei
, IServiceProvider
*caller
)
732 data
= get_dispex_data(This
);
736 hres
= get_builtin_func(data
, id
, &func
);
737 if(id
== DISPID_VALUE
&& hres
== DISP_E_UNKNOWNNAME
)
738 return dispex_value(This
, lcid
, flags
, dp
, res
, ei
, caller
);
742 if(func
->func_disp_idx
== -1)
743 hres
= typeinfo_invoke(This
, func
, flags
, dp
, res
, ei
);
745 hres
= function_invoke(This
, func
, flags
, dp
, res
, ei
);
750 HRESULT
remove_prop(DispatchEx
*This
, BSTR name
, VARIANT_BOOL
*success
)
752 dynamic_prop_t
*prop
;
756 hres
= get_builtin_id(This
, name
, 0, &id
);
758 DISPID named_id
= DISPID_PROPERTYPUT
;
760 DISPPARAMS dp
= {&var
,&named_id
,1,1};
763 V_VT(&var
) = VT_EMPTY
;
764 memset(&ei
, 0, sizeof(ei
));
765 hres
= invoke_builtin_prop(This
, id
, 0, DISPATCH_PROPERTYPUT
, &dp
, NULL
, &ei
, NULL
);
769 *success
= VARIANT_TRUE
;
773 hres
= get_dynamic_prop(This
, name
, 0, &prop
);
775 if(hres
!= DISP_E_UNKNOWNNAME
)
777 *success
= VARIANT_FALSE
;
781 VariantClear(&prop
->var
);
782 prop
->flags
|= DYNPROP_DELETED
;
783 *success
= VARIANT_TRUE
;
787 static inline DispatchEx
*impl_from_IDispatchEx(IDispatchEx
*iface
)
789 return CONTAINING_RECORD(iface
, DispatchEx
, IDispatchEx_iface
);
792 static HRESULT WINAPI
DispatchEx_QueryInterface(IDispatchEx
*iface
, REFIID riid
, void **ppv
)
794 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
796 return IUnknown_QueryInterface(This
->outer
, riid
, ppv
);
799 static ULONG WINAPI
DispatchEx_AddRef(IDispatchEx
*iface
)
801 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
803 return IUnknown_AddRef(This
->outer
);
806 static ULONG WINAPI
DispatchEx_Release(IDispatchEx
*iface
)
808 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
810 return IUnknown_Release(This
->outer
);
813 static HRESULT WINAPI
DispatchEx_GetTypeInfoCount(IDispatchEx
*iface
, UINT
*pctinfo
)
815 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
817 TRACE("(%p)->(%p)\n", This
, pctinfo
);
823 static HRESULT WINAPI
DispatchEx_GetTypeInfo(IDispatchEx
*iface
, UINT iTInfo
,
824 LCID lcid
, ITypeInfo
**ppTInfo
)
826 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
829 TRACE("(%p)->(%u %u %p)\n", This
, iTInfo
, lcid
, ppTInfo
);
831 hres
= get_typeinfo(This
->data
->disp_tid
, ppTInfo
);
835 ITypeInfo_AddRef(*ppTInfo
);
839 static HRESULT WINAPI
DispatchEx_GetIDsOfNames(IDispatchEx
*iface
, REFIID riid
,
840 LPOLESTR
*rgszNames
, UINT cNames
,
841 LCID lcid
, DISPID
*rgDispId
)
843 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
847 TRACE("(%p)->(%s %p %u %u %p)\n", This
, debugstr_guid(riid
), rgszNames
, cNames
,
850 for(i
=0; i
< cNames
; i
++) {
851 hres
= IDispatchEx_GetDispID(&This
->IDispatchEx_iface
, rgszNames
[i
], 0, rgDispId
+i
);
859 static HRESULT WINAPI
DispatchEx_Invoke(IDispatchEx
*iface
, DISPID dispIdMember
,
860 REFIID riid
, LCID lcid
, WORD wFlags
, DISPPARAMS
*pDispParams
,
861 VARIANT
*pVarResult
, EXCEPINFO
*pExcepInfo
, UINT
*puArgErr
)
863 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
865 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This
, dispIdMember
, debugstr_guid(riid
),
866 lcid
, wFlags
, pDispParams
, pVarResult
, pExcepInfo
, puArgErr
);
868 return IDispatchEx_InvokeEx(&This
->IDispatchEx_iface
, dispIdMember
, lcid
, wFlags
, pDispParams
,
869 pVarResult
, pExcepInfo
, NULL
);
872 static HRESULT WINAPI
DispatchEx_GetDispID(IDispatchEx
*iface
, BSTR bstrName
, DWORD grfdex
, DISPID
*pid
)
874 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
875 dynamic_prop_t
*dprop
;
878 TRACE("(%p)->(%s %x %p)\n", This
, debugstr_w(bstrName
), grfdex
, pid
);
880 if(grfdex
& ~(fdexNameCaseSensitive
|fdexNameCaseInsensitive
|fdexNameEnsure
|fdexNameImplicit
|FDEX_VERSION_MASK
))
881 FIXME("Unsupported grfdex %x\n", grfdex
);
883 hres
= get_builtin_id(This
, bstrName
, grfdex
, pid
);
884 if(hres
!= DISP_E_UNKNOWNNAME
)
887 hres
= get_dynamic_prop(This
, bstrName
, grfdex
, &dprop
);
891 *pid
= DISPID_DYNPROP_0
+ (dprop
- This
->dynamic_data
->props
);
895 static HRESULT WINAPI
DispatchEx_InvokeEx(IDispatchEx
*iface
, DISPID id
, LCID lcid
, WORD wFlags
, DISPPARAMS
*pdp
,
896 VARIANT
*pvarRes
, EXCEPINFO
*pei
, IServiceProvider
*pspCaller
)
898 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
901 TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This
, id
, lcid
, wFlags
, pdp
, pvarRes
, pei
, pspCaller
);
903 if(is_custom_dispid(id
) && This
->data
->vtbl
&& This
->data
->vtbl
->invoke
)
904 return This
->data
->vtbl
->invoke(This
, id
, lcid
, wFlags
, pdp
, pvarRes
, pei
, pspCaller
);
906 if(wFlags
== DISPATCH_CONSTRUCT
) {
907 if(id
== DISPID_VALUE
) {
908 if(This
->data
->vtbl
&& This
->data
->vtbl
->value
) {
909 return This
->data
->vtbl
->value(This
, lcid
, wFlags
, pdp
, pvarRes
, pei
, pspCaller
);
911 FIXME("DISPATCH_CONSTRUCT flag but missing value function\n");
914 FIXME("DISPATCH_CONSTRUCT flag without DISPID_VALUE\n");
918 if(is_dynamic_dispid(id
)) {
919 DWORD idx
= id
- DISPID_DYNPROP_0
;
920 dynamic_prop_t
*prop
;
922 if(!This
->dynamic_data
|| This
->dynamic_data
->prop_cnt
<= idx
)
923 return DISP_E_UNKNOWNNAME
;
925 prop
= This
->dynamic_data
->props
+idx
;
928 case DISPATCH_METHOD
|DISPATCH_PROPERTYGET
:
931 case DISPATCH_METHOD
: {
932 DISPID named_arg
= DISPID_THIS
;
933 DISPPARAMS dp
= {NULL
, &named_arg
, 0, 1};
936 if(V_VT(&prop
->var
) != VT_DISPATCH
) {
937 FIXME("invoke %s\n", debugstr_variant(&prop
->var
));
941 if(pdp
->cNamedArgs
) {
942 FIXME("named args not supported\n");
946 dp
.rgvarg
= heap_alloc((pdp
->cArgs
+1)*sizeof(VARIANTARG
));
948 return E_OUTOFMEMORY
;
950 dp
.cArgs
= pdp
->cArgs
+1;
951 memcpy(dp
.rgvarg
+1, pdp
->rgvarg
, pdp
->cArgs
*sizeof(VARIANTARG
));
953 V_VT(dp
.rgvarg
) = VT_DISPATCH
;
954 V_DISPATCH(dp
.rgvarg
) = (IDispatch
*)&This
->IDispatchEx_iface
;
956 hres
= IDispatch_QueryInterface(V_DISPATCH(&prop
->var
), &IID_IDispatchEx
, (void**)&dispex
);
957 TRACE("%s call\n", debugstr_w(This
->dynamic_data
->props
[idx
].name
));
958 if(SUCCEEDED(hres
)) {
959 hres
= IDispatchEx_InvokeEx(dispex
, DISPID_VALUE
, lcid
, wFlags
, &dp
, pvarRes
, pei
, pspCaller
);
960 IDispatchEx_Release(dispex
);
963 hres
= IDispatch_Invoke(V_DISPATCH(&prop
->var
), DISPID_VALUE
, &IID_NULL
, lcid
, wFlags
, pdp
, pvarRes
, pei
, &err
);
965 TRACE("%s ret %08x\n", debugstr_w(This
->dynamic_data
->props
[idx
].name
), hres
);
967 heap_free(dp
.rgvarg
);
970 case DISPATCH_PROPERTYGET
:
971 if(prop
->flags
& DYNPROP_DELETED
)
972 return DISP_E_UNKNOWNNAME
;
973 return variant_copy(pvarRes
, &prop
->var
);
974 case DISPATCH_PROPERTYPUT
|DISPATCH_PROPERTYPUTREF
:
975 case DISPATCH_PROPERTYPUT
:
976 if(pdp
->cArgs
!= 1 || (pdp
->cNamedArgs
== 1 && *pdp
->rgdispidNamedArgs
!= DISPID_PROPERTYPUT
)
977 || pdp
->cNamedArgs
> 1) {
978 FIXME("invalid args\n");
982 TRACE("put %s\n", debugstr_variant(pdp
->rgvarg
));
983 VariantClear(&prop
->var
);
984 hres
= variant_copy(&prop
->var
, pdp
->rgvarg
);
988 prop
->flags
&= ~DYNPROP_DELETED
;
991 FIXME("unhandled wFlags %x\n", wFlags
);
996 return invoke_builtin_prop(This
, id
, lcid
, wFlags
, pdp
, pvarRes
, pei
, pspCaller
);
999 static HRESULT WINAPI
DispatchEx_DeleteMemberByName(IDispatchEx
*iface
, BSTR bstrName
, DWORD grfdex
)
1001 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
1003 TRACE("(%p)->(%s %x)\n", This
, debugstr_w(bstrName
), grfdex
);
1005 /* Not implemented by IE */
1009 static HRESULT WINAPI
DispatchEx_DeleteMemberByDispID(IDispatchEx
*iface
, DISPID id
)
1011 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
1012 FIXME("(%p)->(%x)\n", This
, id
);
1016 static HRESULT WINAPI
DispatchEx_GetMemberProperties(IDispatchEx
*iface
, DISPID id
, DWORD grfdexFetch
, DWORD
*pgrfdex
)
1018 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
1019 FIXME("(%p)->(%x %x %p)\n", This
, id
, grfdexFetch
, pgrfdex
);
1023 static HRESULT WINAPI
DispatchEx_GetMemberName(IDispatchEx
*iface
, DISPID id
, BSTR
*pbstrName
)
1025 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
1026 dispex_data_t
*data
;
1030 TRACE("(%p)->(%x %p)\n", This
, id
, pbstrName
);
1032 if(is_dynamic_dispid(id
)) {
1033 DWORD idx
= id
- DISPID_DYNPROP_0
;
1035 if(!This
->dynamic_data
|| This
->dynamic_data
->prop_cnt
<= idx
)
1036 return DISP_E_UNKNOWNNAME
;
1038 *pbstrName
= SysAllocString(This
->dynamic_data
->props
[idx
].name
);
1040 return E_OUTOFMEMORY
;
1045 data
= get_dispex_data(This
);
1049 hres
= get_builtin_func(data
, id
, &func
);
1053 *pbstrName
= SysAllocString(func
->name
);
1055 return E_OUTOFMEMORY
;
1059 static HRESULT WINAPI
DispatchEx_GetNextDispID(IDispatchEx
*iface
, DWORD grfdex
, DISPID id
, DISPID
*pid
)
1061 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
1062 dispex_data_t
*data
;
1066 TRACE("(%p)->(%x %x %p)\n", This
, grfdex
, id
, pid
);
1068 if(is_dynamic_dispid(id
)) {
1069 DWORD idx
= id
- DISPID_DYNPROP_0
;
1071 if(!This
->dynamic_data
|| This
->dynamic_data
->prop_cnt
<= idx
)
1072 return DISP_E_UNKNOWNNAME
;
1074 while(++idx
< This
->dynamic_data
->prop_cnt
&& This
->dynamic_data
->props
[idx
].flags
& DYNPROP_DELETED
);
1076 if(idx
== This
->dynamic_data
->prop_cnt
) {
1077 *pid
= DISPID_STARTENUM
;
1081 *pid
= DISPID_DYNPROP_0
+idx
;
1085 data
= get_dispex_data(This
);
1089 if(id
== DISPID_STARTENUM
) {
1092 hres
= get_builtin_func(data
, id
, &func
);
1098 while(func
< data
->funcs
+data
->func_cnt
) {
1099 /* FIXME: Skip hidden properties */
1100 if(func
->func_disp_idx
== -1) {
1107 if(This
->dynamic_data
&& This
->dynamic_data
->prop_cnt
) {
1108 *pid
= DISPID_DYNPROP_0
;
1112 *pid
= DISPID_STARTENUM
;
1116 static HRESULT WINAPI
DispatchEx_GetNameSpaceParent(IDispatchEx
*iface
, IUnknown
**ppunk
)
1118 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
1119 FIXME("(%p)->(%p)\n", This
, ppunk
);
1123 static IDispatchExVtbl DispatchExVtbl
= {
1124 DispatchEx_QueryInterface
,
1127 DispatchEx_GetTypeInfoCount
,
1128 DispatchEx_GetTypeInfo
,
1129 DispatchEx_GetIDsOfNames
,
1131 DispatchEx_GetDispID
,
1132 DispatchEx_InvokeEx
,
1133 DispatchEx_DeleteMemberByName
,
1134 DispatchEx_DeleteMemberByDispID
,
1135 DispatchEx_GetMemberProperties
,
1136 DispatchEx_GetMemberName
,
1137 DispatchEx_GetNextDispID
,
1138 DispatchEx_GetNameSpaceParent
1141 BOOL
dispex_query_interface(DispatchEx
*This
, REFIID riid
, void **ppv
)
1143 static const IID IID_UndocumentedScriptIface
=
1144 {0x719c3050,0xf9d3,0x11cf,{0xa4,0x93,0x00,0x40,0x05,0x23,0xa8,0xa0}};
1145 static const IID IID_IDispatchJS
=
1146 {0x719c3050,0xf9d3,0x11cf,{0xa4,0x93,0x00,0x40,0x05,0x23,0xa8,0xa6}};
1148 if(IsEqualGUID(&IID_IDispatch
, riid
)) {
1149 TRACE("(%p)->(IID_IDispatch %p)\n", This
, ppv
);
1150 *ppv
= &This
->IDispatchEx_iface
;
1151 }else if(IsEqualGUID(&IID_IDispatchEx
, riid
)) {
1152 TRACE("(%p)->(IID_IDispatchEx %p)\n", This
, ppv
);
1153 *ppv
= &This
->IDispatchEx_iface
;
1154 }else if(IsEqualGUID(&IID_IDispatchJS
, riid
)) {
1155 TRACE("(%p)->(IID_IDispatchJS %p) returning NULL\n", This
, ppv
);
1157 }else if(IsEqualGUID(&IID_UndocumentedScriptIface
, riid
)) {
1158 TRACE("(%p)->(IID_UndocumentedScriptIface %p) returning NULL\n", This
, ppv
);
1165 IUnknown_AddRef((IUnknown
*)*ppv
);
1169 void release_dispex(DispatchEx
*This
)
1171 dynamic_prop_t
*prop
;
1173 if(!This
->dynamic_data
)
1176 for(prop
= This
->dynamic_data
->props
; prop
< This
->dynamic_data
->props
+ This
->dynamic_data
->prop_cnt
; prop
++) {
1177 VariantClear(&prop
->var
);
1178 heap_free(prop
->name
);
1181 heap_free(This
->dynamic_data
->props
);
1183 if(This
->dynamic_data
->func_disps
) {
1186 for(i
=0; i
< This
->data
->data
->func_disp_cnt
; i
++) {
1187 if(This
->dynamic_data
->func_disps
[i
]) {
1188 release_dispex(&This
->dynamic_data
->func_disps
[i
]->dispex
);
1189 heap_free(This
->dynamic_data
->func_disps
[i
]);
1193 heap_free(This
->dynamic_data
->func_disps
);
1196 heap_free(This
->dynamic_data
);
1199 void init_dispex(DispatchEx
*dispex
, IUnknown
*outer
, dispex_static_data_t
*data
)
1201 dispex
->IDispatchEx_iface
.lpVtbl
= &DispatchExVtbl
;
1202 dispex
->outer
= outer
;
1203 dispex
->data
= data
;
1204 dispex
->dynamic_data
= NULL
;