git.oblomov.eu Git - wine/blob - dlls/mshtml/dispex.c

   1 /*
   2  * Copyright 2008 Jacek Caban for CodeWeavers
   3  *
   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.
   8  *
   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.
  13  *
  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
  17  */
  18
  19 #include <stdarg.h>
  20
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "ole2.h"
  27
  28 #include "wine/debug.h"
  29
  30 #include "mshtml_private.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  33
  34 typedef struct {
  35     DISPID id;
  36     BSTR name;
  37     tid_t tid;
  38 } func_info_t;
  39
  40 struct dispex_data_t {
  41     DWORD func_cnt;
  42     func_info_t *funcs;
  43     func_info_t **name_table;
  44
  45     struct list entry;
  46 };
  47
  48 typedef struct {
  49     VARIANT var;
  50     LPWSTR name;
  51 } dynamic_prop_t;
  52
  53 struct dispex_dynamic_data_t {
  54     DWORD buf_size;
  55     DWORD prop_cnt;
  56     dynamic_prop_t *props;
  57 };
  58
  59 #define DISPID_DYNPROP_0    0x50000000
  60 #define DISPID_DYNPROP_MAX  0x5fffffff
  61
  62 static ITypeLib *typelib;
  63 static ITypeInfo *typeinfos[LAST_tid];
  64 static struct list dispex_data_list = LIST_INIT(dispex_data_list);
  65
  66 static REFIID tid_ids[] = {
  67     &IID_NULL,
  68     &DIID_DispDOMChildrenCollection,
  69     &DIID_DispHTMLBody,
  70     &DIID_DispHTMLCommentElement,
  71     &DIID_DispHTMLDocument,
  72     &DIID_DispHTMLDOMTextNode,
  73     &DIID_DispHTMLElementCollection,
  74     &DIID_DispHTMLGenericElement,
  75     &DIID_DispHTMLImg,
  76     &DIID_DispHTMLInputElement,
  77     &DIID_DispHTMLOptionElement,
  78     &DIID_DispHTMLSelectElement,
  79     &DIID_DispHTMLStyle,
  80     &DIID_DispHTMLUnknownElement,
  81     &DIID_DispHTMLWindow2,
  82     &IID_IHTMLBodyElement,
  83     &IID_IHTMLBodyElement2,
  84     &IID_IHTMLCommentElement,
  85     &IID_IHTMLControlElement,
  86     &IID_IHTMLDocument2,
  87     &IID_IHTMLDocument3,
  88     &IID_IHTMLDocument4,
  89     &IID_IHTMLDocument5,
  90     &IID_IHTMLDOMChildrenCollection,
  91     &IID_IHTMLDOMNode,
  92     &IID_IHTMLDOMNode2,
  93     &IID_IHTMLDOMTextNode,
  94     &IID_IHTMLElement,
  95     &IID_IHTMLElement2,
  96     &IID_IHTMLElement3,
  97     &IID_IHTMLElement4,
  98     &IID_IHTMLElementCollection,
  99     &IID_IHTMLGenericElement,
 100     &IID_IHTMLImgElement,
 101     &IID_IHTMLInputElement,
 102     &IID_IHTMLOptionElement,
 103     &IID_IHTMLSelectElement,
 104     &IID_IHTMLStyle,
 105     &IID_IHTMLTextContainer,
 106     &IID_IHTMLUniqueName,
 107     &IID_IHTMLWindow2,
 108     &IID_IHTMLWindow3,
 109     &IID_IOmNavigator
 110 };
 111
 112 HRESULT get_typeinfo(tid_t tid, ITypeInfo **typeinfo)
 113 {
 114     HRESULT hres;
 115
 116     if(!typelib) {
 117         ITypeLib *tl;
 118
 119         hres = LoadRegTypeLib(&LIBID_MSHTML, 4, 0, LOCALE_SYSTEM_DEFAULT, &tl);
 120         if(FAILED(hres)) {
 121             ERR("LoadRegTypeLib failed: %08x\n", hres);
 122             return hres;
 123         }
 124
 125         if(InterlockedCompareExchangePointer((void**)&typelib, tl, NULL))
 126             ITypeLib_Release(tl);
 127     }
 128
 129     if(!typeinfos[tid]) {
 130         ITypeInfo *typeinfo;
 131
 132         hres = ITypeLib_GetTypeInfoOfGuid(typelib, tid_ids[tid], &typeinfo);
 133         if(FAILED(hres)) {
 134             ERR("GetTypeInfoOfGuid(%s) failed: %08x\n", debugstr_guid(tid_ids[tid]), hres);
 135             return hres;
 136         }
 137
 138         if(InterlockedCompareExchangePointer((void**)(typeinfos+tid), typeinfo, NULL))
 139             ITypeInfo_Release(typeinfo);
 140     }
 141
 142     *typeinfo = typeinfos[tid];
 143     return S_OK;
 144 }
 145
 146 void release_typelib(void)
 147 {
 148     dispex_data_t *iter;
 149     unsigned i;
 150
 151     while(!list_empty(&dispex_data_list)) {
 152         iter = LIST_ENTRY(list_head(&dispex_data_list), dispex_data_t, entry);
 153         list_remove(&iter->entry);
 154
 155         for(i=0; i < iter->func_cnt; i++)
 156             SysFreeString(iter->funcs[i].name);
 157
 158         heap_free(iter->funcs);
 159         heap_free(iter->name_table);
 160         heap_free(iter);
 161     }
 162
 163     if(!typelib)
 164         return;
 165
 166     for(i=0; i < sizeof(typeinfos)/sizeof(*typeinfos); i++)
 167         if(typeinfos[i])
 168             ITypeInfo_Release(typeinfos[i]);
 169
 170     ITypeLib_Release(typelib);
 171 }
 172
 173 static void add_func_info(dispex_data_t *data, DWORD *size, tid_t tid, DISPID id, ITypeInfo *dti)
 174 {
 175     HRESULT hres;
 176
 177     if(data->func_cnt && data->funcs[data->func_cnt-1].id == id)
 178         return;
 179
 180     if(data->func_cnt == *size)
 181         data->funcs = heap_realloc(data->funcs, (*size <<= 1)*sizeof(func_info_t));
 182
 183     hres = ITypeInfo_GetDocumentation(dti, id, &data->funcs[data->func_cnt].name, NULL, NULL, NULL);
 184     if(FAILED(hres))
 185         return;
 186
 187     data->funcs[data->func_cnt].id = id;
 188     data->funcs[data->func_cnt].tid = tid;
 189
 190     data->func_cnt++;
 191 }
 192
 193 static int dispid_cmp(const void *p1, const void *p2)
 194 {
 195     return ((func_info_t*)p1)->id - ((func_info_t*)p2)->id;
 196 }
 197
 198 static int func_name_cmp(const void *p1, const void *p2)
 199 {
 200     return strcmpiW((*(func_info_t**)p1)->name, (*(func_info_t**)p2)->name);
 201 }
 202
 203 static dispex_data_t *preprocess_dispex_data(DispatchEx *This)
 204 {
 205     const tid_t *tid = This->data->iface_tids;
 206     FUNCDESC *funcdesc;
 207     dispex_data_t *data;
 208     DWORD size = 16, i;
 209     ITypeInfo *ti, *dti;
 210     HRESULT hres;
 211
 212     TRACE("(%p)\n", This);
 213
 214     hres = get_typeinfo(This->data->disp_tid, &dti);
 215     if(FAILED(hres)) {
 216         ERR("Could not get disp type info: %08x\n", hres);
 217         return NULL;
 218     }
 219
 220     data = heap_alloc(sizeof(dispex_data_t));
 221     data->func_cnt = 0;
 222     data->funcs = heap_alloc(size*sizeof(func_info_t));
 223     list_add_tail(&dispex_data_list, &data->entry);
 224
 225     while(*tid) {
 226         hres = get_typeinfo(*tid, &ti);
 227         if(FAILED(hres))
 228             break;
 229
 230         i=7;
 231         while(1) {
 232             hres = ITypeInfo_GetFuncDesc(ti, i++, &funcdesc);
 233             if(FAILED(hres))
 234                 break;
 235
 236             add_func_info(data, &size, *tid, funcdesc->memid, dti);
 237             ITypeInfo_ReleaseFuncDesc(ti, funcdesc);
 238         }
 239
 240         tid++;
 241     }
 242
 243     if(!data->func_cnt) {
 244         heap_free(data->funcs);
 245         data->funcs = NULL;
 246     }else if(data->func_cnt != size) {
 247         data->funcs = heap_realloc(data->funcs, data->func_cnt * sizeof(func_info_t));
 248     }
 249
 250     qsort(data->funcs, data->func_cnt, sizeof(func_info_t), dispid_cmp);
 251
 252     if(data->funcs) {
 253         data->name_table = heap_alloc(data->func_cnt * sizeof(func_info_t*));
 254         for(i=0; i < data->func_cnt; i++)
 255             data->name_table[i] = data->funcs+i;
 256         qsort(data->name_table, data->func_cnt, sizeof(func_info_t*), func_name_cmp);
 257     }else {
 258         data->name_table = NULL;
 259     }
 260
 261     return data;
 262 }
 263
 264 static CRITICAL_SECTION cs_dispex_static_data;
 265 static CRITICAL_SECTION_DEBUG cs_dispex_static_data_dbg =
 266 {
 267     0, 0, &cs_dispex_static_data,
 268     { &cs_dispex_static_data_dbg.ProcessLocksList, &cs_dispex_static_data_dbg.ProcessLocksList },
 269       0, 0, { (DWORD_PTR)(__FILE__ ": dispex_static_data") }
 270 };
 271 static CRITICAL_SECTION cs_dispex_static_data = { &cs_dispex_static_data_dbg, -1, 0, 0, 0, 0 };
 272
 273
 274 static dispex_data_t *get_dispex_data(DispatchEx *This)
 275 {
 276     if(This->data->data)
 277         return This->data->data;
 278
 279     EnterCriticalSection(&cs_dispex_static_data);
 280
 281     if(!This->data->data)
 282         This->data->data = preprocess_dispex_data(This);
 283
 284     LeaveCriticalSection(&cs_dispex_static_data);
 285
 286     return This->data->data;
 287 }
 288
 289 void call_disp_func(HTMLDocument *doc, IDispatch *disp)
 290 {
 291     DISPID named_arg = DISPID_THIS;
 292     VARIANTARG arg;
 293     DISPPARAMS params = {&arg, &named_arg, 1, 1};
 294     EXCEPINFO ei;
 295     IDispatchEx *dispex;
 296     VARIANT res;
 297     HRESULT hres;
 298
 299     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 300     if(FAILED(hres)) {
 301         FIXME("Could not get IDispatchEx interface: %08x\n", hres);
 302         return;
 303     }
 304
 305     V_VT(&arg) = VT_DISPATCH;
 306     V_DISPATCH(&arg) = (IDispatch*)HTMLWINDOW2(doc->window);
 307     VariantInit(&res);
 308     memset(&ei, 0, sizeof(ei));
 309
 310     hres = IDispatchEx_InvokeEx(dispex, 0, GetUserDefaultLCID(), DISPATCH_METHOD, &params, &res, &ei, NULL);
 311     IDispatchEx_Release(dispex);
 312
 313     TRACE("%p returned %08x\n", disp, hres);
 314
 315     VariantClear(&res);
 316 }
 317
 318 static inline BOOL is_custom_dispid(DISPID id)
 319 {
 320     return MSHTML_DISPID_CUSTOM_MIN <= id && id <= MSHTML_DISPID_CUSTOM_MAX;
 321 }
 322
 323 static inline BOOL is_dynamic_dispid(DISPID id)
 324 {
 325     return DISPID_DYNPROP_0 <= id && id <= DISPID_DYNPROP_MAX;
 326 }
 327
 328 #define DISPATCHEX_THIS(iface) DEFINE_THIS(DispatchEx, IDispatchEx, iface)
 329
 330 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 331 {
 332     DispatchEx *This = DISPATCHEX_THIS(iface);
 333
 334     return IUnknown_QueryInterface(This->outer, riid, ppv);
 335 }
 336
 337 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 338 {
 339     DispatchEx *This = DISPATCHEX_THIS(iface);
 340
 341     return IUnknown_AddRef(This->outer);
 342 }
 343
 344 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 345 {
 346     DispatchEx *This = DISPATCHEX_THIS(iface);
 347
 348     return IUnknown_Release(This->outer);
 349 }
 350
 351 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 352 {
 353     DispatchEx *This = DISPATCHEX_THIS(iface);
 354
 355     TRACE("(%p)->(%p)\n", This, pctinfo);
 356
 357     *pctinfo = 1;
 358     return S_OK;
 359 }
 360
 361 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
 362                                               LCID lcid, ITypeInfo **ppTInfo)
 363 {
 364     DispatchEx *This = DISPATCHEX_THIS(iface);
 365     HRESULT hres;
 366
 367     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 368
 369     hres = get_typeinfo(This->data->disp_tid, ppTInfo);
 370     if(FAILED(hres))
 371         return hres;
 372
 373     ITypeInfo_AddRef(*ppTInfo);
 374     return S_OK;
 375 }
 376
 377 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 378                                                 LPOLESTR *rgszNames, UINT cNames,
 379                                                 LCID lcid, DISPID *rgDispId)
 380 {
 381     DispatchEx *This = DISPATCHEX_THIS(iface);
 382     UINT i;
 383     HRESULT hres;
 384
 385     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 386           lcid, rgDispId);
 387
 388     for(i=0; i < cNames; i++) {
 389         hres = IDispatchEx_GetDispID(DISPATCHEX(This), rgszNames[i], 0, rgDispId+i);
 390         if(FAILED(hres))
 391             return hres;
 392     }
 393
 394     return S_OK;
 395 }
 396
 397 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 398                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 399                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 400 {
 401     DispatchEx *This = DISPATCHEX_THIS(iface);
 402
 403     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 404           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 405
 406     return IDispatchEx_InvokeEx(DISPATCHEX(This), dispIdMember, lcid, wFlags,
 407                                 pDispParams, pVarResult, pExcepInfo, NULL);
 408 }
 409
 410 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 411 {
 412     DispatchEx *This = DISPATCHEX_THIS(iface);
 413     dispex_data_t *data;
 414     int min, max, n, c;
 415
 416     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
 417
 418     if(grfdex & ~(fdexNameCaseSensitive|fdexNameEnsure|fdexNameImplicit))
 419         FIXME("Unsupported grfdex %x\n", grfdex);
 420
 421     data = get_dispex_data(This);
 422     if(!data)
 423         return E_FAIL;
 424
 425     min = 0;
 426     max = data->func_cnt-1;
 427
 428     while(min <= max) {
 429         n = (min+max)/2;
 430
 431         c = strcmpiW(data->name_table[n]->name, bstrName);
 432         if(!c) {
 433             if((grfdex & fdexNameCaseSensitive) && strcmpW(data->name_table[n]->name, bstrName))
 434                 break;
 435
 436             *pid = data->name_table[n]->id;
 437             return S_OK;
 438         }
 439
 440         if(c > 0)
 441             max = n-1;
 442         else
 443             min = n+1;
 444     }
 445
 446     if(This->dynamic_data) {
 447         unsigned i;
 448
 449         for(i=0; i < This->dynamic_data->prop_cnt; i++) {
 450             if(!strcmpW(This->dynamic_data->props[i].name, bstrName)) {
 451                 *pid = DISPID_DYNPROP_0 + i;
 452                 return S_OK;
 453             }
 454         }
 455     }
 456
 457     if(This->data->vtbl && This->data->vtbl->get_dispid) {
 458         HRESULT hres;
 459
 460         hres = This->data->vtbl->get_dispid(This->outer, bstrName, grfdex, pid);
 461         if(hres != DISP_E_UNKNOWNNAME)
 462             return hres;
 463     }
 464
 465     if(grfdex & fdexNameEnsure) {
 466         dispex_dynamic_data_t *dynamic_data;
 467
 468         TRACE("creating dynamic prop %s\n", debugstr_w(bstrName));
 469
 470         if(This->dynamic_data) {
 471             dynamic_data = This->dynamic_data;
 472         }else {
 473             dynamic_data = This->dynamic_data = heap_alloc_zero(sizeof(dispex_dynamic_data_t));
 474             if(!dynamic_data)
 475                 return E_OUTOFMEMORY;
 476         }
 477
 478         if(!dynamic_data->buf_size) {
 479             dynamic_data->props = heap_alloc(sizeof(dynamic_prop_t)*4);
 480             if(!dynamic_data->props)
 481                 return E_OUTOFMEMORY;
 482             dynamic_data->buf_size = 4;
 483         }else if(dynamic_data->buf_size == dynamic_data->prop_cnt) {
 484             dynamic_prop_t *new_props;
 485
 486             new_props = heap_realloc(dynamic_data->props, sizeof(dynamic_prop_t)*(dynamic_data->buf_size<<1));
 487             if(!new_props)
 488                 return E_OUTOFMEMORY;
 489
 490             dynamic_data->props = new_props;
 491             dynamic_data->buf_size <<= 1;
 492         }
 493
 494         dynamic_data->props[dynamic_data->prop_cnt].name = heap_strdupW(bstrName);
 495         VariantInit(&dynamic_data->props[dynamic_data->prop_cnt].var);
 496         *pid = DISPID_DYNPROP_0 + dynamic_data->prop_cnt++;
 497
 498         return S_OK;
 499     }
 500
 501     TRACE("not found %s\n", debugstr_w(bstrName));
 502     return DISP_E_UNKNOWNNAME;
 503 }
 504
 505 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 506         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 507 {
 508     DispatchEx *This = DISPATCHEX_THIS(iface);
 509     IUnknown *unk;
 510     ITypeInfo *ti;
 511     dispex_data_t *data;
 512     UINT argerr=0;
 513     int min, max, n;
 514     HRESULT hres;
 515
 516     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
 517
 518     if(is_custom_dispid(id) && This->data->vtbl && This->data->vtbl->invoke)
 519         return This->data->vtbl->invoke(This->outer, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
 520
 521     if(wFlags == DISPATCH_CONSTRUCT) {
 522         FIXME("DISPATCH_CONSTRUCT not implemented\n");
 523         return E_NOTIMPL;
 524     }
 525
 526     if(is_dynamic_dispid(id)) {
 527         DWORD idx = id - DISPID_DYNPROP_0;
 528         VARIANT *var;
 529
 530         if(!This->dynamic_data || This->dynamic_data->prop_cnt <= idx)
 531             return DISP_E_UNKNOWNNAME;
 532
 533         var = &This->dynamic_data->props[idx].var;
 534
 535         switch(wFlags) {
 536         case INVOKE_PROPERTYGET:
 537             return VariantCopy(pvarRes, var);
 538         case INVOKE_PROPERTYPUT:
 539             VariantClear(var);
 540             return VariantCopy(var, pdp->rgvarg);
 541         default:
 542             FIXME("unhandled wFlags %x\n", wFlags);
 543             return E_NOTIMPL;
 544         }
 545     }
 546
 547     data = get_dispex_data(This);
 548     if(!data)
 549         return E_FAIL;
 550
 551     min = 0;
 552     max = data->func_cnt-1;
 553
 554     while(min <= max) {
 555         n = (min+max)/2;
 556
 557         if(data->funcs[n].id == id)
 558             break;
 559
 560         if(data->funcs[n].id < id)
 561             min = n+1;
 562         else
 563             max = n-1;
 564     }
 565
 566     if(min > max) {
 567         WARN("invalid id %x\n", id);
 568         return DISP_E_UNKNOWNNAME;
 569     }
 570
 571     hres = get_typeinfo(data->funcs[n].tid, &ti);
 572     if(FAILED(hres)) {
 573         ERR("Could not get type info: %08x\n", hres);
 574         return hres;
 575     }
 576
 577     hres = IUnknown_QueryInterface(This->outer, tid_ids[data->funcs[n].tid], (void**)&unk);
 578     if(FAILED(hres)) {
 579         ERR("Could not get iface: %08x\n", hres);
 580         return E_FAIL;
 581     }
 582
 583     hres = ITypeInfo_Invoke(ti, unk, id, wFlags, pdp, pvarRes, pei, &argerr);
 584
 585     IUnknown_Release(unk);
 586     return hres;
 587 }
 588
 589 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 590 {
 591     DispatchEx *This = DISPATCHEX_THIS(iface);
 592     FIXME("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
 593     return E_NOTIMPL;
 594 }
 595
 596 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 597 {
 598     DispatchEx *This = DISPATCHEX_THIS(iface);
 599     FIXME("(%p)->(%x)\n", This, id);
 600     return E_NOTIMPL;
 601 }
 602
 603 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 604 {
 605     DispatchEx *This = DISPATCHEX_THIS(iface);
 606     FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
 607     return E_NOTIMPL;
 608 }
 609
 610 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 611 {
 612     DispatchEx *This = DISPATCHEX_THIS(iface);
 613     FIXME("(%p)->(%x %p)\n", This, id, pbstrName);
 614     return E_NOTIMPL;
 615 }
 616
 617 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 618 {
 619     DispatchEx *This = DISPATCHEX_THIS(iface);
 620     FIXME("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
 621     return E_NOTIMPL;
 622 }
 623
 624 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 625 {
 626     DispatchEx *This = DISPATCHEX_THIS(iface);
 627     FIXME("(%p)->(%p)\n", This, ppunk);
 628     return E_NOTIMPL;
 629 }
 630
 631 #undef DISPATCHEX_THIS
 632
 633 static IDispatchExVtbl DispatchExVtbl = {
 634     DispatchEx_QueryInterface,
 635     DispatchEx_AddRef,
 636     DispatchEx_Release,
 637     DispatchEx_GetTypeInfoCount,
 638     DispatchEx_GetTypeInfo,
 639     DispatchEx_GetIDsOfNames,
 640     DispatchEx_Invoke,
 641     DispatchEx_GetDispID,
 642     DispatchEx_InvokeEx,
 643     DispatchEx_DeleteMemberByName,
 644     DispatchEx_DeleteMemberByDispID,
 645     DispatchEx_GetMemberProperties,
 646     DispatchEx_GetMemberName,
 647     DispatchEx_GetNextDispID,
 648     DispatchEx_GetNameSpaceParent
 649 };
 650
 651 BOOL dispex_query_interface(DispatchEx *This, REFIID riid, void **ppv)
 652 {
 653     static const IID IID_UndocumentedScriptIface =
 654         {0x719c3050,0xf9d3,0x11cf,{0xa4,0x93,0x00,0x40,0x05,0x23,0xa8,0xa0}};
 655
 656     if(IsEqualGUID(&IID_IDispatch, riid)) {
 657         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 658         *ppv = DISPATCHEX(This);
 659     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
 660         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
 661         *ppv = DISPATCHEX(This);
 662     }else if(IsEqualGUID(&IID_UndocumentedScriptIface, riid)) {
 663         TRACE("(%p)->(IID_UndocumentedScriptIface %p) returning NULL\n", This, ppv);
 664         *ppv = NULL;
 665     }else {
 666         return FALSE;
 667     }
 668
 669     if(*ppv)
 670         IUnknown_AddRef((IUnknown*)*ppv);
 671     return TRUE;
 672 }
 673
 674 void init_dispex(DispatchEx *dispex, IUnknown *outer, dispex_static_data_t *data)
 675 {
 676     dispex->lpIDispatchExVtbl = &DispatchExVtbl;
 677     dispex->outer = outer;
 678     dispex->data = data;
 679 }