git.oblomov.eu Git - wine/blob - dlls/vbscript/vbdisp.c

   1 /*
   2  * Copyright 2011 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 <assert.h>
  20
  21 #include "vbscript.h"
  22
  23 #include "wine/debug.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(vbscript);
  26
  27 static inline BOOL is_func_id(vbdisp_t *This, DISPID id)
  28 {
  29     return id < This->desc->func_cnt;
  30 }
  31
  32 static BOOL get_func_id(vbdisp_t *This, const WCHAR *name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id)
  33 {
  34     unsigned i;
  35
  36     for(i = invoke_type == VBDISP_ANY ? 0 : 1; i < This->desc->func_cnt; i++) {
  37         if(invoke_type == VBDISP_ANY) {
  38             if(!search_private && !This->desc->funcs[i].is_public)
  39                 continue;
  40             if(!i && !This->desc->funcs[0].name) /* default value may not exist */
  41                 continue;
  42         }else {
  43             if(!This->desc->funcs[i].entries[invoke_type]
  44                 || (!search_private && !This->desc->funcs[i].entries[invoke_type]->is_public))
  45                 continue;
  46         }
  47
  48         if(!strcmpiW(This->desc->funcs[i].name, name)) {
  49             *id = i;
  50             return TRUE;
  51         }
  52     }
  53
  54     return FALSE;
  55 }
  56
  57 HRESULT vbdisp_get_id(vbdisp_t *This, BSTR name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id)
  58 {
  59     unsigned i;
  60
  61     if(get_func_id(This, name, invoke_type, search_private, id))
  62         return S_OK;
  63
  64     for(i=0; i < This->desc->prop_cnt; i++) {
  65         if(!search_private && !This->desc->props[i].is_public)
  66             continue;
  67
  68         if(!strcmpiW(This->desc->props[i].name, name)) {
  69             *id = i + This->desc->func_cnt;
  70             return S_OK;
  71         }
  72     }
  73
  74     if(This->desc->typeinfo) {
  75         HRESULT hres;
  76
  77         hres = ITypeInfo_GetIDsOfNames(This->desc->typeinfo, &name, 1, id);
  78         if(SUCCEEDED(hres))
  79             return S_OK;
  80     }
  81
  82     *id = -1;
  83     return DISP_E_UNKNOWNNAME;
  84 }
  85
  86 static VARIANT *get_propput_arg(const DISPPARAMS *dp)
  87 {
  88     unsigned i;
  89
  90     for(i=0; i < dp->cNamedArgs; i++) {
  91         if(dp->rgdispidNamedArgs[i] == DISPID_PROPERTYPUT)
  92             return dp->rgvarg+i;
  93     }
  94
  95     return NULL;
  96 }
  97
  98 static HRESULT invoke_variant_prop(vbdisp_t *This, VARIANT *v, WORD flags, DISPPARAMS *dp, VARIANT *res)
  99 {
 100     HRESULT hres;
 101
 102     switch(flags) {
 103     case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
 104         if(dp->cArgs) {
 105             WARN("called with arguments\n");
 106             return DISP_E_MEMBERNOTFOUND; /* That's what tests show */
 107         }
 108
 109         hres = VariantCopy(res, v);
 110         break;
 111
 112     case DISPATCH_PROPERTYPUT: {
 113         VARIANT *put_val;
 114
 115         put_val = get_propput_arg(dp);
 116         if(!put_val) {
 117             WARN("no value to set\n");
 118             return DISP_E_PARAMNOTOPTIONAL;
 119         }
 120
 121         if(res)
 122             V_VT(res) = VT_EMPTY;
 123
 124         hres = VariantCopy(v, put_val);
 125         break;
 126     }
 127
 128     default:
 129         FIXME("unimplemented flags %x\n", flags);
 130         return E_NOTIMPL;
 131     }
 132
 133     return hres;
 134 }
 135
 136 static HRESULT invoke_builtin(vbdisp_t *This, const builtin_prop_t *prop, WORD flags, DISPPARAMS *dp, VARIANT *res)
 137 {
 138     VARIANT *args, arg_buf[8];
 139     unsigned argn;
 140
 141     switch(flags) {
 142     case DISPATCH_PROPERTYGET:
 143         if(!(prop->flags & (BP_GET|BP_GETPUT))) {
 144             FIXME("property does not support DISPATCH_PROPERTYGET\n");
 145             return E_FAIL;
 146         }
 147         break;
 148     case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
 149         break;
 150     case DISPATCH_METHOD:
 151         if(prop->flags & (BP_GET|BP_GETPUT)) {
 152             FIXME("Call on property\n");
 153             return E_FAIL;
 154         }
 155         break;
 156     case DISPATCH_PROPERTYPUT:
 157         if(!(prop->flags & (BP_GET|BP_GETPUT))) {
 158             FIXME("property does not support DISPATCH_PROPERTYPUT\n");
 159             return E_FAIL;
 160         }
 161
 162         FIXME("call put\n");
 163         return E_NOTIMPL;
 164     default:
 165         FIXME("unsupported flags %x\n", flags);
 166         return E_NOTIMPL;
 167     }
 168
 169     argn = arg_cnt(dp);
 170
 171     if(argn < prop->min_args || argn > (prop->max_args ? prop->max_args : prop->min_args)) {
 172         FIXME("invalid number of arguments\n");
 173         return E_FAIL;
 174     }
 175
 176     args = dp->rgvarg;
 177
 178     if(argn == 1) {
 179         if(V_VT(dp->rgvarg) == (VT_BYREF|VT_VARIANT))
 180             args = V_VARIANTREF(dp->rgvarg);
 181     }else {
 182         unsigned i;
 183
 184         assert(argn < sizeof(arg_buf)/sizeof(*arg_buf));
 185
 186         for(i=0; i < argn; i++) {
 187             if(V_VT(dp->rgvarg+i) == (VT_BYREF|VT_VARIANT)) {
 188                 for(i=0; i < argn; i++) {
 189                     if(V_VT(dp->rgvarg+i) == (VT_BYREF|VT_VARIANT))
 190                         arg_buf[i] = *V_VARIANTREF(dp->rgvarg+i);
 191                     else
 192                         arg_buf[i] = dp->rgvarg[i];
 193                 }
 194                 args = arg_buf;
 195                 break;
 196             }
 197         }
 198     }
 199
 200     return prop->proc(This, args, dp->cArgs, res);
 201 }
 202
 203 static BOOL run_terminator(vbdisp_t *This)
 204 {
 205     DISPPARAMS dp = {0};
 206
 207     if(This->terminator_ran)
 208         return TRUE;
 209     This->terminator_ran = TRUE;
 210
 211     if(!This->desc->class_terminate_id)
 212         return TRUE;
 213
 214     This->ref++;
 215     exec_script(This->desc->ctx, This->desc->funcs[This->desc->class_terminate_id].entries[VBDISP_CALLGET],
 216             (IDispatch*)&This->IDispatchEx_iface, &dp, NULL);
 217     return !--This->ref;
 218 }
 219
 220 static void clean_props(vbdisp_t *This)
 221 {
 222     unsigned i;
 223
 224     if(!This->desc)
 225         return;
 226
 227     for(i=0; i < This->desc->prop_cnt; i++)
 228         VariantClear(This->props+i);
 229 }
 230
 231 static inline vbdisp_t *impl_from_IDispatchEx(IDispatchEx *iface)
 232 {
 233     return CONTAINING_RECORD(iface, vbdisp_t, IDispatchEx_iface);
 234 }
 235
 236 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 237 {
 238     vbdisp_t *This = impl_from_IDispatchEx(iface);
 239
 240     if(IsEqualGUID(&IID_IUnknown, riid)) {
 241         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 242         *ppv = &This->IDispatchEx_iface;
 243     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 244         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 245         *ppv = &This->IDispatchEx_iface;
 246     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
 247         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
 248         *ppv = &This->IDispatchEx_iface;
 249     }else {
 250         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 251         *ppv = NULL;
 252         return E_NOINTERFACE;
 253     }
 254
 255     IUnknown_AddRef((IUnknown*)*ppv);
 256     return S_OK;
 257 }
 258
 259 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 260 {
 261     vbdisp_t *This = impl_from_IDispatchEx(iface);
 262     LONG ref = InterlockedIncrement(&This->ref);
 263
 264     TRACE("(%p) ref=%d\n", This, ref);
 265
 266     return ref;
 267 }
 268
 269 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 270 {
 271     vbdisp_t *This = impl_from_IDispatchEx(iface);
 272     LONG ref = InterlockedDecrement(&This->ref);
 273
 274     TRACE("(%p) ref=%d\n", This, ref);
 275
 276     if(!ref && run_terminator(This)) {
 277         clean_props(This);
 278         list_remove(&This->entry);
 279         heap_free(This);
 280     }
 281
 282     return ref;
 283 }
 284
 285 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 286 {
 287     vbdisp_t *This = impl_from_IDispatchEx(iface);
 288
 289     TRACE("(%p)->(%p)\n", This, pctinfo);
 290
 291     *pctinfo = 1;
 292     return S_OK;
 293 }
 294
 295 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo, LCID lcid,
 296                                               ITypeInfo **ppTInfo)
 297 {
 298     vbdisp_t *This = impl_from_IDispatchEx(iface);
 299     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 300     return E_NOTIMPL;
 301 }
 302
 303 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 304                                                 LPOLESTR *rgszNames, UINT cNames, LCID lcid,
 305                                                 DISPID *rgDispId)
 306 {
 307     vbdisp_t *This = impl_from_IDispatchEx(iface);
 308     FIXME("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 309           lcid, rgDispId);
 310     return E_NOTIMPL;
 311 }
 312
 313 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 314                                         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 315                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 316 {
 317     vbdisp_t *This = impl_from_IDispatchEx(iface);
 318     FIXME("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 319           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 320     return E_NOTIMPL;
 321 }
 322
 323 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 324 {
 325     vbdisp_t *This = impl_from_IDispatchEx(iface);
 326
 327     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
 328
 329     if(!This->desc)
 330         return E_UNEXPECTED;
 331
 332     if(grfdex & ~(fdexNameEnsure|fdexNameCaseInsensitive)) {
 333         FIXME("unsupported flags %x\n", grfdex);
 334         return E_NOTIMPL;
 335     }
 336
 337     return vbdisp_get_id(This, bstrName, VBDISP_ANY, FALSE, pid);
 338 }
 339
 340 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 341         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 342 {
 343     vbdisp_t *This = impl_from_IDispatchEx(iface);
 344
 345     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
 346
 347     if(!This->desc)
 348         return E_UNEXPECTED;
 349
 350     if(pvarRes)
 351         V_VT(pvarRes) = VT_EMPTY;
 352
 353     if(id < 0)
 354         return DISP_E_MEMBERNOTFOUND;
 355
 356     if(is_func_id(This, id)) {
 357         function_t *func;
 358
 359         switch(wFlags) {
 360         case DISPATCH_METHOD:
 361         case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
 362             func = This->desc->funcs[id].entries[VBDISP_CALLGET];
 363             if(!func) {
 364                 FIXME("no invoke/getter\n");
 365                 return DISP_E_MEMBERNOTFOUND;
 366             }
 367
 368             return exec_script(This->desc->ctx, func, (IDispatch*)&This->IDispatchEx_iface, pdp, pvarRes);
 369         case DISPATCH_PROPERTYPUT: {
 370             VARIANT *put_val;
 371             DISPPARAMS dp = {NULL, NULL, 1, 0};
 372
 373             if(arg_cnt(pdp)) {
 374                 FIXME("arguments not implemented\n");
 375                 return E_NOTIMPL;
 376             }
 377
 378             put_val = get_propput_arg(pdp);
 379             if(!put_val) {
 380                 WARN("no value to set\n");
 381                 return DISP_E_PARAMNOTOPTIONAL;
 382             }
 383
 384             dp.rgvarg = put_val;
 385             func = This->desc->funcs[id].entries[V_VT(put_val) == VT_DISPATCH ? VBDISP_SET : VBDISP_LET];
 386             if(!func) {
 387                 FIXME("no letter/setter\n");
 388                 return DISP_E_MEMBERNOTFOUND;
 389             }
 390
 391             return exec_script(This->desc->ctx, func, (IDispatch*)&This->IDispatchEx_iface, &dp, NULL);
 392         }
 393         default:
 394             FIXME("flags %x\n", wFlags);
 395             return DISP_E_MEMBERNOTFOUND;
 396         }
 397     }
 398
 399     if(id < This->desc->prop_cnt + This->desc->func_cnt)
 400         return invoke_variant_prop(This, This->props+(id-This->desc->func_cnt), wFlags, pdp, pvarRes);
 401
 402     if(This->desc->builtin_prop_cnt) {
 403         unsigned min = 0, max = This->desc->builtin_prop_cnt-1, i;
 404
 405         while(min <= max) {
 406             i = (min+max)/2;
 407             if(This->desc->builtin_props[i].id == id)
 408                 return invoke_builtin(This, This->desc->builtin_props+i, wFlags, pdp, pvarRes);
 409             if(This->desc->builtin_props[i].id < id)
 410                 min = i+1;
 411             else
 412                 max = i-1;
 413         }
 414     }
 415
 416     return DISP_E_MEMBERNOTFOUND;
 417 }
 418
 419 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 420 {
 421     vbdisp_t *This = impl_from_IDispatchEx(iface);
 422     FIXME("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
 423     return E_NOTIMPL;
 424 }
 425
 426 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 427 {
 428     vbdisp_t *This = impl_from_IDispatchEx(iface);
 429     FIXME("(%p)->(%x)\n", This, id);
 430     return E_NOTIMPL;
 431 }
 432
 433 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 434 {
 435     vbdisp_t *This = impl_from_IDispatchEx(iface);
 436     FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
 437     return E_NOTIMPL;
 438 }
 439
 440 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 441 {
 442     vbdisp_t *This = impl_from_IDispatchEx(iface);
 443     FIXME("(%p)->(%x %p)\n", This, id, pbstrName);
 444     return E_NOTIMPL;
 445 }
 446
 447 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 448 {
 449     vbdisp_t *This = impl_from_IDispatchEx(iface);
 450     FIXME("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
 451     return E_NOTIMPL;
 452 }
 453
 454 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 455 {
 456     vbdisp_t *This = impl_from_IDispatchEx(iface);
 457     FIXME("(%p)->(%p)\n", This, ppunk);
 458     return E_NOTIMPL;
 459 }
 460
 461 static IDispatchExVtbl DispatchExVtbl = {
 462     DispatchEx_QueryInterface,
 463     DispatchEx_AddRef,
 464     DispatchEx_Release,
 465     DispatchEx_GetTypeInfoCount,
 466     DispatchEx_GetTypeInfo,
 467     DispatchEx_GetIDsOfNames,
 468     DispatchEx_Invoke,
 469     DispatchEx_GetDispID,
 470     DispatchEx_InvokeEx,
 471     DispatchEx_DeleteMemberByName,
 472     DispatchEx_DeleteMemberByDispID,
 473     DispatchEx_GetMemberProperties,
 474     DispatchEx_GetMemberName,
 475     DispatchEx_GetNextDispID,
 476     DispatchEx_GetNameSpaceParent
 477 };
 478
 479 static inline vbdisp_t *unsafe_impl_from_IDispatch(IDispatch *iface)
 480 {
 481     return iface->lpVtbl == (IDispatchVtbl*)&DispatchExVtbl
 482         ? CONTAINING_RECORD(iface, vbdisp_t, IDispatchEx_iface)
 483         : NULL;
 484 }
 485
 486 HRESULT create_vbdisp(const class_desc_t *desc, vbdisp_t **ret)
 487 {
 488     vbdisp_t *vbdisp;
 489
 490     vbdisp = heap_alloc_zero( FIELD_OFFSET( vbdisp_t, props[desc->prop_cnt] ));
 491     if(!vbdisp)
 492         return E_OUTOFMEMORY;
 493
 494     vbdisp->IDispatchEx_iface.lpVtbl = &DispatchExVtbl;
 495     vbdisp->ref = 1;
 496     vbdisp->desc = desc;
 497
 498     if(desc->class_initialize_id) {
 499         DISPPARAMS dp = {0};
 500         HRESULT hres;
 501
 502         hres = exec_script(desc->ctx, desc->funcs[desc->class_initialize_id].entries[VBDISP_CALLGET],
 503                            (IDispatch*)&vbdisp->IDispatchEx_iface, &dp, NULL);
 504         if(FAILED(hres)) {
 505             IDispatchEx_Release(&vbdisp->IDispatchEx_iface);
 506             return hres;
 507         }
 508     }
 509
 510     list_add_tail(&desc->ctx->objects, &vbdisp->entry);
 511     *ret = vbdisp;
 512     return S_OK;
 513 }
 514
 515 void collect_objects(script_ctx_t *ctx)
 516 {
 517     vbdisp_t *iter, *iter2;
 518
 519     LIST_FOR_EACH_ENTRY_SAFE(iter, iter2, &ctx->objects, vbdisp_t, entry)
 520         run_terminator(iter);
 521
 522     while(!list_empty(&ctx->objects)) {
 523         iter = LIST_ENTRY(list_head(&ctx->objects), vbdisp_t, entry);
 524
 525         IDispatchEx_AddRef(&iter->IDispatchEx_iface);
 526         clean_props(iter);
 527         iter->desc = NULL;
 528         list_remove(&iter->entry);
 529         list_init(&iter->entry);
 530         IDispatchEx_Release(&iter->IDispatchEx_iface);
 531     }
 532 }
 533
 534 HRESULT disp_get_id(IDispatch *disp, BSTR name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id)
 535 {
 536     IDispatchEx *dispex;
 537     vbdisp_t *vbdisp;
 538     HRESULT hres;
 539
 540     vbdisp = unsafe_impl_from_IDispatch(disp);
 541     if(vbdisp)
 542         return vbdisp_get_id(vbdisp, name, invoke_type, search_private, id);
 543
 544     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 545     if(FAILED(hres)) {
 546         TRACE("using IDispatch\n");
 547         return IDispatch_GetIDsOfNames(disp, &IID_NULL, &name, 1, 0, id);
 548     }
 549
 550     hres = IDispatchEx_GetDispID(dispex, name, fdexNameCaseInsensitive, id);
 551     IDispatchEx_Release(dispex);
 552     return hres;
 553 }
 554
 555 HRESULT disp_call(script_ctx_t *ctx, IDispatch *disp, DISPID id, DISPPARAMS *dp, VARIANT *retv)
 556 {
 557     const WORD flags = DISPATCH_METHOD|(retv ? DISPATCH_PROPERTYGET : 0);
 558     IDispatchEx *dispex;
 559     EXCEPINFO ei;
 560     HRESULT hres;
 561
 562     memset(&ei, 0, sizeof(ei));
 563     if(retv)
 564         V_VT(retv) = VT_EMPTY;
 565
 566     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 567     if(FAILED(hres)) {
 568         UINT err = 0;
 569
 570         TRACE("using IDispatch\n");
 571         return IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, dp, retv, &ei, &err);
 572     }
 573
 574     hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, dp, retv, &ei, NULL /* CALLER_FIXME */);
 575     IDispatchEx_Release(dispex);
 576     return hres;
 577 }
 578
 579 HRESULT disp_propput(script_ctx_t *ctx, IDispatch *disp, DISPID id, DISPPARAMS *dp)
 580 {
 581     IDispatchEx *dispex;
 582     EXCEPINFO ei = {0};
 583     HRESULT hres;
 584
 585     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 586     if(SUCCEEDED(hres)) {
 587         hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, DISPATCH_PROPERTYPUT, dp, NULL, &ei, NULL /* FIXME! */);
 588         IDispatchEx_Release(dispex);
 589     }else {
 590         ULONG err = 0;
 591
 592         TRACE("using IDispatch\n");
 593         hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, DISPATCH_PROPERTYPUT, dp, NULL, &ei, &err);
 594     }
 595
 596     return hres;
 597 }