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