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 static ITypeLib *typelib;
  49 static ITypeInfo *typeinfos[LAST_tid];
  50 static struct list dispex_data_list = LIST_INIT(dispex_data_list);
  51
  52 static REFIID tid_ids[] = {
  53     &IID_NULL,
  54     &DIID_DispHTMLDocument,
  55     &DIID_DispHTMLDOMTextNode,
  56     &DIID_DispHTMLElementCollection,
  57     &DIID_DispHTMLInputElement,
  58     &DIID_DispHTMLOptionElement,
  59     &DIID_DispHTMLUnknownElement,
  60     &DIID_DispHTMLWindow2,
  61     &IID_IHTMLDocument2,
  62     &IID_IHTMLDocument3,
  63     &IID_IHTMLDocument4,
  64     &IID_IHTMLDocument5,
  65     &IID_IHTMLDOMNode,
  66     &IID_IHTMLDOMNode2,
  67     &IID_IHTMLDOMTextNode,
  68     &IID_IHTMLElement,
  69     &IID_IHTMLElement2,
  70     &IID_IHTMLElementCollection,
  71     &IID_IHTMLInputElement,
  72     &IID_IHTMLOptionElement,
  73     &IID_IHTMLWindow2,
  74     &IID_IHTMLWindow3,
  75     &IID_IOmNavigator
  76 };
  77
  78 HRESULT get_typeinfo(tid_t tid, ITypeInfo **typeinfo)
  79 {
  80     HRESULT hres;
  81
  82     if(!typelib) {
  83         ITypeLib *tl;
  84
  85         hres = LoadRegTypeLib(&LIBID_MSHTML, 4, 0, LOCALE_SYSTEM_DEFAULT, &tl);
  86         if(FAILED(hres)) {
  87             ERR("LoadRegTypeLib failed: %08x\n", hres);
  88             return hres;
  89         }
  90
  91         if(InterlockedCompareExchangePointer((void**)&typelib, tl, NULL))
  92             ITypeLib_Release(tl);
  93     }
  94
  95     if(!typeinfos[tid]) {
  96         ITypeInfo *typeinfo;
  97
  98         hres = ITypeLib_GetTypeInfoOfGuid(typelib, tid_ids[tid], &typeinfo);
  99         if(FAILED(hres)) {
 100             ERR("GetTypeInfoOfGuid(%s) failed: %08x\n", debugstr_guid(tid_ids[tid]), hres);
 101             return hres;
 102         }
 103
 104         if(InterlockedCompareExchangePointer((void**)(typeinfos+tid), typeinfo, NULL))
 105             ITypeInfo_Release(typeinfo);
 106     }
 107
 108     *typeinfo = typeinfos[tid];
 109     return S_OK;
 110 }
 111
 112 void release_typelib(void)
 113 {
 114     dispex_data_t *iter;
 115     unsigned i;
 116
 117     while(!list_empty(&dispex_data_list)) {
 118         iter = LIST_ENTRY(list_head(&dispex_data_list), dispex_data_t, entry);
 119         list_remove(&iter->entry);
 120
 121         for(i=0; i < iter->func_cnt; i++)
 122             SysFreeString(iter->funcs[i].name);
 123
 124         heap_free(iter->funcs);
 125         heap_free(iter->name_table);
 126         heap_free(iter);
 127     }
 128
 129     if(!typelib)
 130         return;
 131
 132     for(i=0; i < sizeof(typeinfos)/sizeof(*typeinfos); i++)
 133         if(typeinfos[i])
 134             ITypeInfo_Release(typeinfos[i]);
 135
 136     ITypeLib_Release(typelib);
 137 }
 138
 139 static void add_func_info(dispex_data_t *data, DWORD *size, tid_t tid, DISPID id, ITypeInfo *dti)
 140 {
 141     HRESULT hres;
 142
 143     if(data->func_cnt && data->funcs[data->func_cnt-1].id == id)
 144         return;
 145
 146     if(data->func_cnt == *size)
 147         data->funcs = heap_realloc(data->funcs, (*size <<= 1)*sizeof(func_info_t));
 148
 149     hres = ITypeInfo_GetDocumentation(dti, id, &data->funcs[data->func_cnt].name, NULL, NULL, NULL);
 150     if(FAILED(hres))
 151         return;
 152
 153     data->funcs[data->func_cnt].id = id;
 154     data->funcs[data->func_cnt].tid = tid;
 155
 156     data->func_cnt++;
 157 }
 158
 159 static int dispid_cmp(const void *p1, const void *p2)
 160 {
 161     return ((func_info_t*)p1)->id - ((func_info_t*)p2)->id;
 162 }
 163
 164 static int func_name_cmp(const void *p1, const void *p2)
 165 {
 166     return strcmpiW((*(func_info_t**)p1)->name, (*(func_info_t**)p2)->name);
 167 }
 168
 169 static dispex_data_t *preprocess_dispex_data(DispatchEx *This)
 170 {
 171     const tid_t *tid = This->data->iface_tids;
 172     FUNCDESC *funcdesc;
 173     dispex_data_t *data;
 174     DWORD size = 16, i;
 175     ITypeInfo *ti, *dti;
 176     HRESULT hres;
 177
 178     TRACE("(%p)\n", This);
 179
 180     hres = get_typeinfo(This->data->disp_tid, &dti);
 181     if(FAILED(hres)) {
 182         ERR("Could not get disp type info: %08x\n", hres);
 183         return NULL;
 184     }
 185
 186     data = heap_alloc(sizeof(dispex_data_t));
 187     data->func_cnt = 0;
 188     data->funcs = heap_alloc(size*sizeof(func_info_t));
 189     list_add_tail(&dispex_data_list, &data->entry);
 190
 191     while(*tid) {
 192         hres = get_typeinfo(*tid, &ti);
 193         if(FAILED(hres))
 194             break;
 195
 196         i=7;
 197         while(1) {
 198             hres = ITypeInfo_GetFuncDesc(ti, i++, &funcdesc);
 199             if(FAILED(hres))
 200                 break;
 201
 202             add_func_info(data, &size, *tid, funcdesc->memid, dti);
 203             ITypeInfo_ReleaseFuncDesc(ti, funcdesc);
 204         }
 205
 206         tid++;
 207     }
 208
 209     if(!data->func_cnt) {
 210         heap_free(data->funcs);
 211         data->funcs = NULL;
 212     }else if(data->func_cnt != size) {
 213         data->funcs = heap_realloc(data->funcs, data->func_cnt * sizeof(func_info_t));
 214     }
 215
 216     qsort(data->funcs, data->func_cnt, sizeof(func_info_t), dispid_cmp);
 217
 218     if(data->funcs) {
 219         data->name_table = heap_alloc(data->func_cnt * sizeof(func_info_t*));
 220         for(i=0; i < data->func_cnt; i++)
 221             data->name_table[i] = data->funcs+i;
 222         qsort(data->name_table, data->func_cnt, sizeof(func_info_t*), func_name_cmp);
 223     }else {
 224         data->name_table = NULL;
 225     }
 226
 227     return data;
 228 }
 229
 230 static CRITICAL_SECTION cs_dispex_static_data;
 231 static CRITICAL_SECTION_DEBUG cs_dispex_static_data_dbg =
 232 {
 233     0, 0, &cs_dispex_static_data,
 234     { &cs_dispex_static_data_dbg.ProcessLocksList, &cs_dispex_static_data_dbg.ProcessLocksList },
 235       0, 0, { (DWORD_PTR)(__FILE__ ": dispex_static_data") }
 236 };
 237 static CRITICAL_SECTION cs_dispex_static_data = { &cs_dispex_static_data_dbg, -1, 0, 0, 0, 0 };
 238
 239
 240 static dispex_data_t *get_dispex_data(DispatchEx *This)
 241 {
 242     if(This->data->data)
 243         return This->data->data;
 244
 245     EnterCriticalSection(&cs_dispex_static_data);
 246
 247     if(!This->data->data)
 248         This->data->data = preprocess_dispex_data(This);
 249
 250     LeaveCriticalSection(&cs_dispex_static_data);
 251
 252     return This->data->data;
 253 }
 254
 255 void call_disp_func(HTMLDocument *doc, IDispatch *disp)
 256 {
 257     DISPID named_arg = DISPID_THIS;
 258     VARIANTARG arg;
 259     DISPPARAMS params = {&arg, &named_arg, 1, 1};
 260     EXCEPINFO ei;
 261     IDispatchEx *dispex;
 262     VARIANT res;
 263     HRESULT hres;
 264
 265     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 266     if(FAILED(hres)) {
 267         FIXME("Could not get IDispatchEx interface: %08x\n", hres);
 268         return;
 269     }
 270
 271     V_VT(&arg) = VT_DISPATCH;
 272     V_DISPATCH(&arg) = (IDispatch*)HTMLWINDOW2(doc->window);
 273     VariantInit(&res);
 274     memset(&ei, 0, sizeof(ei));
 275
 276     hres = IDispatchEx_InvokeEx(dispex, 0, GetUserDefaultLCID(), DISPATCH_METHOD, &params, &res, &ei, NULL);
 277     IDispatchEx_Release(dispex);
 278
 279     TRACE("%p returned %08x\n", disp, hres);
 280
 281     VariantClear(&res);
 282 }
 283
 284 static inline BOOL is_custom_dispid(DISPID id)
 285 {
 286     return MSHTML_DISPID_CUSTOM_MIN <= id && id <= MSHTML_DISPID_CUSTOM_MAX;
 287 }
 288
 289 #define DISPATCHEX_THIS(iface) DEFINE_THIS(DispatchEx, IDispatchEx, iface)
 290
 291 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 292 {
 293     DispatchEx *This = DISPATCHEX_THIS(iface);
 294
 295     return IUnknown_QueryInterface(This->outer, riid, ppv);
 296 }
 297
 298 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 299 {
 300     DispatchEx *This = DISPATCHEX_THIS(iface);
 301
 302     return IUnknown_AddRef(This->outer);
 303 }
 304
 305 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 306 {
 307     DispatchEx *This = DISPATCHEX_THIS(iface);
 308
 309     return IUnknown_Release(This->outer);
 310 }
 311
 312 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 313 {
 314     DispatchEx *This = DISPATCHEX_THIS(iface);
 315
 316     TRACE("(%p)->(%p)\n", This, pctinfo);
 317
 318     *pctinfo = 1;
 319     return S_OK;
 320 }
 321
 322 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
 323                                               LCID lcid, ITypeInfo **ppTInfo)
 324 {
 325     DispatchEx *This = DISPATCHEX_THIS(iface);
 326     HRESULT hres;
 327
 328     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 329
 330     hres = get_typeinfo(This->data->disp_tid, ppTInfo);
 331     if(FAILED(hres))
 332         return hres;
 333
 334     ITypeInfo_AddRef(*ppTInfo);
 335     return S_OK;
 336 }
 337
 338 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 339                                                 LPOLESTR *rgszNames, UINT cNames,
 340                                                 LCID lcid, DISPID *rgDispId)
 341 {
 342     DispatchEx *This = DISPATCHEX_THIS(iface);
 343     UINT i;
 344     HRESULT hres;
 345
 346     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 347           lcid, rgDispId);
 348
 349     for(i=0; i < cNames; i++) {
 350         hres = IDispatchEx_GetDispID(DISPATCHEX(This), rgszNames[i], 0, rgDispId+i);
 351         if(FAILED(hres))
 352             return hres;
 353     }
 354
 355     return S_OK;
 356 }
 357
 358 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 359                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 360                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 361 {
 362     DispatchEx *This = DISPATCHEX_THIS(iface);
 363
 364     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 365           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 366
 367     return IDispatchEx_InvokeEx(DISPATCHEX(This), dispIdMember, lcid, wFlags,
 368                                 pDispParams, pVarResult, pExcepInfo, NULL);
 369 }
 370
 371 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 372 {
 373     DispatchEx *This = DISPATCHEX_THIS(iface);
 374     dispex_data_t *data;
 375     int min, max, n, c;
 376
 377     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
 378
 379     if(grfdex & (~fdexNameCaseSensitive))
 380         FIXME("Unsupported grfdex %x\n", grfdex);
 381
 382     data = get_dispex_data(This);
 383     if(!data)
 384         return E_FAIL;
 385
 386     min = 0;
 387     max = data->func_cnt-1;
 388
 389     while(min <= max) {
 390         n = (min+max)/2;
 391
 392         c = strcmpiW(data->name_table[n]->name, bstrName);
 393         if(!c) {
 394             if((grfdex & fdexNameCaseSensitive) && strcmpW(data->name_table[n]->name, bstrName))
 395                 break;
 396
 397             *pid = data->name_table[n]->id;
 398             return S_OK;
 399         }
 400
 401         if(c > 0)
 402             max = n-1;
 403         else
 404             min = n+1;
 405     }
 406
 407     if(This->data->vtbl && This->data->vtbl->get_dispid) {
 408         HRESULT hres;
 409
 410         hres = This->data->vtbl->get_dispid(This->outer, bstrName, grfdex, pid);
 411         if(hres != DISP_E_UNKNOWNNAME)
 412             return hres;
 413     }
 414
 415     TRACE("not found %s\n", debugstr_w(bstrName));
 416     return DISP_E_UNKNOWNNAME;
 417 }
 418
 419 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 420         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 421 {
 422     DispatchEx *This = DISPATCHEX_THIS(iface);
 423     IUnknown *unk;
 424     ITypeInfo *ti;
 425     dispex_data_t *data;
 426     UINT argerr=0;
 427     int min, max, n;
 428     HRESULT hres;
 429
 430     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
 431
 432     if(is_custom_dispid(id) && This->data->vtbl && This->data->vtbl->invoke)
 433         return This->data->vtbl->invoke(This->outer, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
 434
 435     if(wFlags == DISPATCH_CONSTRUCT) {
 436         FIXME("DISPATCH_CONSTRUCT not implemented\n");
 437         return E_NOTIMPL;
 438     }
 439
 440     data = get_dispex_data(This);
 441     if(!data)
 442         return E_FAIL;
 443
 444     min = 0;
 445     max = data->func_cnt-1;
 446
 447     while(min <= max) {
 448         n = (min+max)/2;
 449
 450         if(data->funcs[n].id == id)
 451             break;
 452
 453         if(data->funcs[n].id < id)
 454             min = n+1;
 455         else
 456             max = n-1;
 457     }
 458
 459     if(min > max) {
 460         WARN("invalid id %x\n", id);
 461         return DISP_E_UNKNOWNNAME;
 462     }
 463
 464     hres = get_typeinfo(data->funcs[n].tid, &ti);
 465     if(FAILED(hres)) {
 466         ERR("Could not get type info: %08x\n", hres);
 467         return hres;
 468     }
 469
 470     hres = IUnknown_QueryInterface(This->outer, tid_ids[data->funcs[n].tid], (void**)&unk);
 471     if(FAILED(hres)) {
 472         ERR("Could not get iface: %08x\n", hres);
 473         return E_FAIL;
 474     }
 475
 476     hres = ITypeInfo_Invoke(ti, unk, id, wFlags, pdp, pvarRes, pei, &argerr);
 477
 478     IUnknown_Release(unk);
 479     return hres;
 480 }
 481
 482 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 483 {
 484     DispatchEx *This = DISPATCHEX_THIS(iface);
 485     FIXME("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
 486     return E_NOTIMPL;
 487 }
 488
 489 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 490 {
 491     DispatchEx *This = DISPATCHEX_THIS(iface);
 492     FIXME("(%p)->(%x)\n", This, id);
 493     return E_NOTIMPL;
 494 }
 495
 496 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 497 {
 498     DispatchEx *This = DISPATCHEX_THIS(iface);
 499     FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
 500     return E_NOTIMPL;
 501 }
 502
 503 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 504 {
 505     DispatchEx *This = DISPATCHEX_THIS(iface);
 506     FIXME("(%p)->(%x %p)\n", This, id, pbstrName);
 507     return E_NOTIMPL;
 508 }
 509
 510 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 511 {
 512     DispatchEx *This = DISPATCHEX_THIS(iface);
 513     FIXME("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
 514     return E_NOTIMPL;
 515 }
 516
 517 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 518 {
 519     DispatchEx *This = DISPATCHEX_THIS(iface);
 520     FIXME("(%p)->(%p)\n", This, ppunk);
 521     return E_NOTIMPL;
 522 }
 523
 524 #undef DISPATCHEX_THIS
 525
 526 static IDispatchExVtbl DispatchExVtbl = {
 527     DispatchEx_QueryInterface,
 528     DispatchEx_AddRef,
 529     DispatchEx_Release,
 530     DispatchEx_GetTypeInfoCount,
 531     DispatchEx_GetTypeInfo,
 532     DispatchEx_GetIDsOfNames,
 533     DispatchEx_Invoke,
 534     DispatchEx_GetDispID,
 535     DispatchEx_InvokeEx,
 536     DispatchEx_DeleteMemberByName,
 537     DispatchEx_DeleteMemberByDispID,
 538     DispatchEx_GetMemberProperties,
 539     DispatchEx_GetMemberName,
 540     DispatchEx_GetNextDispID,
 541     DispatchEx_GetNameSpaceParent
 542 };
 543
 544 void init_dispex(DispatchEx *dispex, IUnknown *outer, dispex_static_data_t *data)
 545 {
 546     dispex->lpIDispatchExVtbl = &DispatchExVtbl;
 547     dispex->outer = outer;
 548     dispex->data = data;
 549 }