rostests/winetests/mshtml/activex.c

   1 /*
   2  * Copyright 2010 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 #define COBJMACROS
  20 #define CONST_VTABLE
  21
  22 #include <wine/test.h>
  23 //#include <stdarg.h>
  24 #include <stdio.h>
  25
  26 //#include "windef.h"
  27 //#include "winbase.h"
  28 //#include "ole2.h"
  29 #include <mshtml.h>
  30 //#include "docobj.h"
  31 #include <hlink.h>
  32 //#include "dispex.h"
  33 #include <mshtmhst.h>
  34 //#include "activscp.h"
  35 //#include "objsafe.h"
  36 #include <mshtmdid.h>
  37 #include "mshtml_test.h"
  38
  39 #include <initguid.h>
  40 #include <test_tlb.h>
  41
  42 #define DEFINE_EXPECT(func) \
  43     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  44
  45 #define SET_EXPECT(func) \
  46     do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)
  47
  48 #define CHECK_EXPECT2(func) \
  49     do { \
  50         ok(expect_ ##func, "unexpected call " #func "\n"); \
  51         called_ ## func = TRUE; \
  52     }while(0)
  53
  54 #define CHECK_EXPECT(func) \
  55     do { \
  56         CHECK_EXPECT2(func); \
  57         expect_ ## func = FALSE; \
  58     }while(0)
  59
  60 #define CHECK_CALLED(func) \
  61     do { \
  62         ok(called_ ## func, "expected " #func "\n"); \
  63         expect_ ## func = called_ ## func = FALSE; \
  64     }while(0)
  65
  66 #define CLEAR_CALLED(func) \
  67     expect_ ## func = called_ ## func = FALSE
  68
  69 #undef GetClassInfo
  70
  71 DEFINE_EXPECT(CreateInstance);
  72 DEFINE_EXPECT(FreezeEvents_TRUE);
  73 DEFINE_EXPECT(FreezeEvents_FALSE);
  74 DEFINE_EXPECT(QuickActivate);
  75 DEFINE_EXPECT(IPersistPropertyBag_InitNew);
  76 DEFINE_EXPECT(IPersistPropertyBag_Load);
  77 DEFINE_EXPECT(Invoke_READYSTATE);
  78 DEFINE_EXPECT(Invoke_ENABLED);
  79 DEFINE_EXPECT(Invoke_VALID);
  80 DEFINE_EXPECT(Invoke_SECURITYCTX);
  81 DEFINE_EXPECT(Invoke_SCRIPTPROP);
  82 DEFINE_EXPECT(Invoke_SCRIPTCALL);
  83 DEFINE_EXPECT(GetIDsOfNames_scriptprop);
  84 DEFINE_EXPECT(DoVerb);
  85 DEFINE_EXPECT(SetExtent);
  86 DEFINE_EXPECT(GetExtent);
  87 DEFINE_EXPECT(SetClientSite);
  88 DEFINE_EXPECT(SetClientSite_NULL);
  89 DEFINE_EXPECT(Close);
  90 DEFINE_EXPECT(InPlaceObject_GetWindow);
  91 DEFINE_EXPECT(SetObjectRects);
  92 DEFINE_EXPECT(InPlaceDeactivate);
  93 DEFINE_EXPECT(UIDeactivate);
  94 DEFINE_EXPECT(QueryService_TestActiveX);
  95 DEFINE_EXPECT(GetMiscStatus);
  96 DEFINE_EXPECT(SetAdvise);
  97 DEFINE_EXPECT(GetViewStatus);
  98 DEFINE_EXPECT(QI_ITestActiveX);
  99 DEFINE_EXPECT(wrapped_AddRef);
 100 DEFINE_EXPECT(wrapped_Release);
 101 DEFINE_EXPECT(wrapped_func);
 102 DEFINE_EXPECT(OnAmbientPropertyChange_UNKNOWN);
 103 DEFINE_EXPECT(GetTypeInfo);
 104 DEFINE_EXPECT(GetClassInfo);
 105 DEFINE_EXPECT(FindConnectionPoint);
 106 DEFINE_EXPECT(Advise);
 107 DEFINE_EXPECT(Unadvise);
 108
 109 #define DISPID_SCRIPTPROP 1000
 110 #define DISPID_SCRIPTCALL 1001
 111
 112 enum {
 113     TEST_FLASH,
 114     TEST_NOQUICKACT,
 115     TEST_DISPONLY
 116 };
 117
 118 static ITypeInfo *actxtest_typeinfo, *class_typeinfo;
 119 static HWND container_hwnd, plugin_hwnd;
 120 static int plugin_behavior;
 121 static BOOL no_quickact;
 122 static LONG activex_refcnt;
 123
 124 #define TESTACTIVEX_CLSID "{178fc163-f585-4e24-9c13-4bb7f6680746}"
 125
 126 static const GUID CLSID_TestActiveX =
 127     {0x178fc163,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xf6,0x68,0x07,0x46}};
 128
 129 static const GUID IID_ITestActiveX =
 130     {0x178fc663,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xf6,0x68,0x07,0x46}};
 131
 132 static const char object_ax_str[] =
 133     "<html><head></head><body>"
 134     "<object classid=\"clsid:" TESTACTIVEX_CLSID "\" width=\"300\" height=\"200\" id=\"objid\">"
 135     "<param name=\"param_name\" value=\"param_value\">"
 136     "<param name=\"num_param\" value=\"3\">"
 137     "</object>"
 138     "<script>"
 139     "objid.scriptCall();"
 140     "</script>"
 141     "</body></html>";
 142
 143 static const char event_binding_str[] =
 144     "<html><head></head><body>"
 145     "<object classid=\"clsid:" TESTACTIVEX_CLSID "\" width=\"300\" height=\"200\" id=\"objid\">"
 146     "<param name=\"param_name\" value=\"param_value\">"
 147     "<param name=\"num_param\" value=\"3\">"
 148     "</object>"
 149     "<script for=\"objid\" event=\"testfunc\">return 6;</script>"
 150     "<script for=\"objid\" event=\"testfunc2(x,y)\">return x+2*y;</script>"
 151     "</body></html>";
 152
 153 static REFIID pluginhost_iids[] = {
 154     &IID_IOleClientSite,
 155     &IID_IAdviseSink,
 156     &IID_IAdviseSinkEx,
 157     &IID_IPropertyNotifySink,
 158     &IID_IDispatch,
 159     &IID_IOleWindow,
 160     &IID_IOleInPlaceSite,
 161     &IID_IOleInPlaceSiteEx,
 162     &IID_IOleControlSite,
 163     &IID_IBindHost,
 164     &IID_IServiceProvider,
 165     NULL
 166 };
 167
 168 static BOOL iface_cmp(IUnknown *iface1, IUnknown *iface2)
 169 {
 170     IUnknown *unk1, *unk2;
 171
 172     if(iface1 == iface2)
 173         return TRUE;
 174
 175     IUnknown_QueryInterface(iface1, &IID_IUnknown, (void**)&unk1);
 176     IUnknown_Release(unk1);
 177     IUnknown_QueryInterface(iface2, &IID_IUnknown, (void**)&unk2);
 178     IUnknown_Release(unk2);
 179
 180     return unk1 == unk2;
 181 }
 182
 183 #define test_ifaces(i,ids) _test_ifaces(__LINE__,i,ids)
 184 static void _test_ifaces(unsigned line, IUnknown *iface, REFIID *iids)
 185 {
 186     const IID * const *piid;
 187     IUnknown *unk;
 188     HRESULT hres;
 189
 190      for(piid = iids; *piid; piid++) {
 191         hres = IUnknown_QueryInterface(iface, *piid, (void**)&unk);
 192         ok_(__FILE__,line) (hres == S_OK, "Could not get %s interface: %08x\n", wine_dbgstr_guid(*piid), hres);
 193         if(SUCCEEDED(hres))
 194             IUnknown_Release(unk);
 195     }
 196 }
 197
 198 static int strcmp_wa(LPCWSTR strw, const char *stra)
 199 {
 200     CHAR buf[512];
 201     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
 202     return lstrcmpA(stra, buf);
 203 }
 204
 205 static BSTR a2bstr(const char *str)
 206 {
 207     BSTR ret;
 208     int len;
 209
 210     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 211     ret = SysAllocStringLen(NULL, len);
 212     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 213
 214     return ret;
 215 }
 216
 217 static IOleClientSite *client_site;
 218 static IDispatch *sink_disp;
 219 static READYSTATE plugin_readystate = READYSTATE_UNINITIALIZED;
 220
 221 static void set_plugin_readystate(READYSTATE state)
 222 {
 223     IPropertyNotifySink *prop_notif;
 224     HRESULT hres;
 225
 226     plugin_readystate = state;
 227
 228     hres = IOleClientSite_QueryInterface(client_site, &IID_IPropertyNotifySink, (void**)&prop_notif);
 229     ok(hres == S_OK, "Could not get IPropertyNotifySink iface: %08x\n", hres);
 230
 231     hres = IPropertyNotifySink_OnChanged(prop_notif, DISPID_READYSTATE);
 232     ok(hres == S_OK, "OnChanged(DISPID_READYSTATE) failed: %08x\n", hres);
 233
 234     IPropertyNotifySink_Release(prop_notif);
 235 }
 236
 237 static void test_mon_displayname(IMoniker *mon, const char *exname, const char *broken_name)
 238 {
 239     LPOLESTR display_name;
 240     DWORD mksys;
 241     HRESULT hres;
 242
 243     hres = IMoniker_GetDisplayName(mon, NULL, NULL, &display_name);
 244     ok(hres == S_OK, "GetDisplayName failed: %08x\n", hres);
 245     ok(!strcmp_wa(display_name, exname) || broken(broken_name && !strcmp_wa(display_name, broken_name)),
 246         "display_name = %s\n", wine_dbgstr_w(display_name));
 247     CoTaskMemFree(display_name);
 248
 249     hres = IMoniker_IsSystemMoniker(mon, &mksys);
 250     ok(hres == S_OK, "IsSystemMoniker failed: %08x\n", hres);
 251     ok(mksys == MKSYS_URLMONIKER, "mksys = %d\n", mksys);
 252 }
 253
 254 static LRESULT WINAPI plugin_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 255 {
 256     switch(msg) {
 257     case WM_PAINT: {
 258         PAINTSTRUCT ps;
 259         HBRUSH brush;
 260         RECT rect;
 261         HDC dc;
 262
 263         GetClientRect(hwnd, &rect);
 264
 265         dc = BeginPaint(hwnd, &ps);
 266         brush = CreateSolidBrush(RGB(255,0,0));
 267         SelectObject(dc, brush);
 268         Rectangle(dc, rect.left, rect.top, rect.right, rect.bottom);
 269         DeleteObject(brush);
 270         EndPaint(hwnd, &ps);
 271         break;
 272     }
 273     }
 274
 275     return DefWindowProcW(hwnd, msg, wParam, lParam);
 276 }
 277
 278 static void create_plugin_window(HWND parent, const RECT *rect)
 279 {
 280     static const WCHAR plugin_testW[] =
 281         {'p','l','u','g','i','n',' ','t','e','s','t',0};
 282     static WNDCLASSEXW wndclass = {
 283         sizeof(WNDCLASSEXW),
 284         0,
 285         plugin_proc,
 286         0, 0, NULL, NULL, NULL, NULL, NULL,
 287         plugin_testW,
 288         NULL
 289     };
 290
 291     RegisterClassExW(&wndclass);
 292     plugin_hwnd = CreateWindowW(plugin_testW, plugin_testW,
 293             WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS|WS_CLIPCHILDREN, rect->left, rect->top,
 294             rect->right-rect->left, rect->bottom-rect->top, parent, NULL, NULL, NULL);
 295 }
 296
 297 static HRESULT WINAPI ConnectionPoint_QueryInterface(IConnectionPoint *iface, REFIID riid, void **ppv)
 298 {
 299     ok(0, "unexpected QI call %s\n", wine_dbgstr_guid(riid));
 300     return E_NOINTERFACE;
 301 }
 302
 303 static ULONG WINAPI ConnectionPoint_AddRef(IConnectionPoint *iface)
 304 {
 305     return 2;
 306 }
 307
 308 static ULONG WINAPI ConnectionPoint_Release(IConnectionPoint *iface)
 309 {
 310     return 1;
 311 }
 312
 313 static HRESULT WINAPI ConnectionPoint_GetConnectionInterface(IConnectionPoint *iface, IID *pIID)
 314 {
 315     ok(0, "unexpected call\n");
 316     return E_NOTIMPL;
 317 }
 318
 319 static HRESULT WINAPI ConnectionPoint_GetConnectionPointContainer(IConnectionPoint *iface,
 320         IConnectionPointContainer **ppCPC)
 321 {
 322     ok(0, "unexpected call\n");
 323     return E_NOTIMPL;
 324 }
 325
 326 static HRESULT WINAPI ConnectionPoint_Advise(IConnectionPoint *iface, IUnknown *pUnkSink, DWORD *pdwCookie)
 327 {
 328     DispActiveXTest *ax_test;
 329     IDispatchEx *dispex;
 330     HRESULT hres;
 331
 332     CHECK_EXPECT(Advise);
 333
 334     hres = IUnknown_QueryInterface(pUnkSink, &IID_IDispatch, (void**)&sink_disp);
 335     ok(hres == S_OK, "Could not get IDispatch iface: %08x\n", hres);
 336
 337     hres = IUnknown_QueryInterface(pUnkSink, &IID_IDispatchEx, (void**)&dispex);
 338     ok(hres == E_NOINTERFACE, "QueryInterface(IID_IDispatchEx) returned: %08x\n", hres);
 339
 340     hres = IUnknown_QueryInterface(pUnkSink, &DIID_DispActiveXTest, (void**)&ax_test);
 341     ok(hres == S_OK, "Could not get DispActiveXTest iface: %08x\n", hres);
 342     DispActiveXTest_Release(ax_test);
 343
 344     *pdwCookie = 0xdeadbeef;
 345     return S_OK;
 346 }
 347
 348 static HRESULT WINAPI ConnectionPoint_Unadvise(IConnectionPoint *iface, DWORD dwCookie)
 349 {
 350     CHECK_EXPECT(Unadvise);
 351
 352     ok(dwCookie == 0xdeadbeef, "dwCookie = %x\n", dwCookie);
 353
 354     if(sink_disp) {
 355         IDispatch_Release(sink_disp);
 356         sink_disp = NULL;
 357     }
 358
 359     return S_OK;
 360 }
 361
 362 static HRESULT WINAPI ConnectionPoint_EnumConnections(IConnectionPoint *iface, IEnumConnections **ppEnum)
 363 {
 364     ok(0, "unexpected call\n");
 365     return E_NOTIMPL;
 366 }
 367
 368 static const IConnectionPointVtbl ConnectionPointVtbl = {
 369     ConnectionPoint_QueryInterface,
 370     ConnectionPoint_AddRef,
 371     ConnectionPoint_Release,
 372     ConnectionPoint_GetConnectionInterface,
 373     ConnectionPoint_GetConnectionPointContainer,
 374     ConnectionPoint_Advise,
 375     ConnectionPoint_Unadvise,
 376     ConnectionPoint_EnumConnections
 377 };
 378
 379 static IConnectionPoint ConnectionPoint = { &ConnectionPointVtbl };
 380
 381 static HRESULT ax_qi(REFIID,void**);
 382
 383 static HRESULT WINAPI OleControl_QueryInterface(IOleControl *iface, REFIID riid, void **ppv)
 384 {
 385     return ax_qi(riid, ppv);
 386 }
 387
 388 static ULONG WINAPI OleControl_AddRef(IOleControl *iface)
 389 {
 390     return ++activex_refcnt;
 391 }
 392
 393 static ULONG WINAPI OleControl_Release(IOleControl *iface)
 394 {
 395     return --activex_refcnt;
 396 }
 397
 398 static HRESULT WINAPI OleControl_GetControlInfo(IOleControl *iface, CONTROLINFO *pCI)
 399 {
 400     ok(0, "unexpected call\n");
 401     return E_NOTIMPL;
 402 }
 403
 404 static HRESULT WINAPI OleControl_OnMnemonic(IOleControl *iface, MSG *mMsg)
 405 {
 406     ok(0, "unexpected call\n");
 407     return E_NOTIMPL;
 408 }
 409
 410 static HRESULT WINAPI OleControl_OnAmbientPropertyChange(IOleControl *iface, DISPID dispID)
 411 {
 412     switch(dispID) {
 413     case DISPID_UNKNOWN:
 414         CHECK_EXPECT2(OnAmbientPropertyChange_UNKNOWN);
 415         break;
 416     default:
 417         ok(0, "unexpected call %d\n", dispID);
 418     }
 419
 420     return S_OK;
 421 }
 422
 423 static HRESULT WINAPI OleControl_FreezeEvents(IOleControl *iface, BOOL bFreeze)
 424 {
 425     if(bFreeze)
 426         CHECK_EXPECT2(FreezeEvents_TRUE);
 427     else
 428         CHECK_EXPECT2(FreezeEvents_FALSE);
 429     return S_OK;
 430 }
 431
 432 static const IOleControlVtbl OleControlVtbl = {
 433     OleControl_QueryInterface,
 434     OleControl_AddRef,
 435     OleControl_Release,
 436     OleControl_GetControlInfo,
 437     OleControl_OnMnemonic,
 438     OleControl_OnAmbientPropertyChange,
 439     OleControl_FreezeEvents
 440 };
 441
 442 static IOleControl OleControl = { &OleControlVtbl };
 443
 444 static HRESULT WINAPI QuickActivate_QueryInterface(IQuickActivate *iface, REFIID riid, void **ppv)
 445 {
 446     return ax_qi(riid, ppv);
 447 }
 448
 449 static ULONG WINAPI QuickActivate_AddRef(IQuickActivate *iface)
 450 {
 451     return ++activex_refcnt;
 452 }
 453
 454 static ULONG WINAPI QuickActivate_Release(IQuickActivate *iface)
 455 {
 456     return --activex_refcnt;
 457 }
 458
 459 static HRESULT WINAPI QuickActivate_QuickActivate(IQuickActivate *iface, QACONTAINER *container, QACONTROL *control)
 460 {
 461     CHECK_EXPECT(QuickActivate);
 462
 463     ok(container != NULL, "container == NULL\n");
 464     ok(container->cbSize == sizeof(*container), "container->cbSize = %d\n", container->cbSize);
 465     ok(container->pClientSite != NULL, "container->pClientSite == NULL\n");
 466     ok(container->pAdviseSink != NULL, "container->pAdviseSink == NULL\n");
 467     ok(container->pPropertyNotifySink != NULL, "container->pPropertyNotifySink == NULL\n");
 468     ok(!container->pUnkEventSink, "container->pUnkEventSink != NULL\n");
 469     ok(container->dwAmbientFlags == (QACONTAINER_SUPPORTSMNEMONICS|QACONTAINER_MESSAGEREFLECT|QACONTAINER_USERMODE),
 470        "container->dwAmbientFlags = %x\n", container->dwAmbientFlags);
 471     ok(!container->colorFore, "container->colorFore == 0\n"); /* FIXME */
 472     todo_wine
 473     ok(container->colorBack, "container->colorBack == 0\n"); /* FIXME */
 474     todo_wine
 475     ok(container->pFont != NULL, "container->pFont == NULL\n");
 476     todo_wine
 477     ok(container->pUndoMgr != NULL, "container->pUndoMgr == NULL\n");
 478     ok(!container->dwAppearance, "container->dwAppearance = %x\n", container->dwAppearance);
 479     ok(!container->lcid, "container->lcid = %x\n", container->lcid);
 480     ok(!container->hpal, "container->hpal = %p\n", container->hpal);
 481     ok(!container->pBindHost, "container->pBindHost != NULL\n");
 482     ok(!container->pOleControlSite, "container->pOleControlSite != NULL\n");
 483     ok(!container->pServiceProvider, "container->pServiceProvider != NULL\n");
 484
 485     ok(control->cbSize == sizeof(*control), "control->cbSize = %d\n", control->cbSize);
 486     ok(!control->dwMiscStatus, "control->dwMiscStatus = %x\n", control->dwMiscStatus);
 487     ok(!control->dwViewStatus, "control->dwViewStatus = %x\n", control->dwViewStatus);
 488     ok(!control->dwEventCookie, "control->dwEventCookie = %x\n", control->dwEventCookie);
 489     ok(!control->dwPropNotifyCookie, "control->dwPropNotifyCookie = %x\n", control->dwPropNotifyCookie);
 490     ok(!control->dwPointerActivationPolicy, "control->dwPointerActivationPolicy = %x\n", control->dwPointerActivationPolicy);
 491
 492     ok(iface_cmp((IUnknown*)container->pClientSite, (IUnknown*)container->pAdviseSink),
 493        "container->pClientSite != container->pAdviseSink\n");
 494     ok(iface_cmp((IUnknown*)container->pClientSite, (IUnknown*)container->pPropertyNotifySink),
 495        "container->pClientSite != container->pPropertyNotifySink\n");
 496     test_ifaces((IUnknown*)container->pClientSite, pluginhost_iids);
 497
 498     IOleClientSite_AddRef(container->pClientSite);
 499     client_site = container->pClientSite;
 500
 501     control->dwMiscStatus = OLEMISC_SETCLIENTSITEFIRST|OLEMISC_ACTIVATEWHENVISIBLE|OLEMISC_INSIDEOUT
 502         |OLEMISC_CANTLINKINSIDE|OLEMISC_RECOMPOSEONRESIZE;
 503     control->dwViewStatus = 0x18;
 504     control->dwPropNotifyCookie = 1;
 505
 506     return S_OK;
 507 }
 508
 509 static HRESULT WINAPI QuickActivate_SetContentExtent(IQuickActivate *iface, LPSIZEL pSizel)
 510 {
 511     ok(0, "unexpected call\n");
 512     return E_NOTIMPL;
 513 }
 514
 515 static HRESULT WINAPI QuickActivate_GetContentExtent(IQuickActivate *iface, LPSIZEL pSizel)
 516 {
 517     ok(0, "unexpected call\n");
 518     return E_NOTIMPL;
 519 }
 520
 521 static const IQuickActivateVtbl QuickActivateVtbl = {
 522     QuickActivate_QueryInterface,
 523     QuickActivate_AddRef,
 524     QuickActivate_Release,
 525     QuickActivate_QuickActivate,
 526     QuickActivate_GetContentExtent,
 527     QuickActivate_SetContentExtent
 528 };
 529
 530 static IQuickActivate QuickActivate = { &QuickActivateVtbl };
 531
 532 static HRESULT WINAPI PersistPropertyBag_QueryInterface(IPersistPropertyBag *iface, REFIID riid, void **ppv)
 533 {
 534     return ax_qi(riid, ppv);
 535 }
 536
 537 static ULONG WINAPI PersistPropertyBag_AddRef(IPersistPropertyBag *iface)
 538 {
 539     return ++activex_refcnt;
 540 }
 541
 542 static ULONG WINAPI PersistPropertyBag_Release(IPersistPropertyBag *iface)
 543 {
 544     return --activex_refcnt;
 545 }
 546
 547 static HRESULT WINAPI PersistPropertyBag_GetClassID(IPersistPropertyBag *face, CLSID *pClassID)
 548 {
 549     ok(0, "unexpected call\n");
 550     return E_NOTIMPL;
 551 }
 552
 553 static HRESULT WINAPI PersistPropertyBag_InitNew(IPersistPropertyBag *face)
 554 {
 555     CHECK_EXPECT(IPersistPropertyBag_InitNew);
 556     return S_OK;
 557 }
 558
 559 static HRESULT WINAPI PersistPropertyBag_Load(IPersistPropertyBag *face, IPropertyBag *pPropBag, IErrorLog *pErrorLog)
 560 {
 561     IBindHost *bind_host, *bind_host2;
 562     IServiceProvider *sp;
 563     IMoniker *mon;
 564     VARIANT v;
 565     HRESULT hres;
 566
 567     static const WCHAR param_nameW[] = {'p','a','r','a','m','_','n','a','m','e',0};
 568     static const WCHAR num_paramW[] = {'n','u','m','_','p','a','r','a','m',0};
 569     static const WCHAR no_paramW[] = {'n','o','_','p','a','r','a','m',0};
 570     static WCHAR test_swfW[] = {'t','e','s','t','.','s','w','f',0};
 571
 572     static const IID *propbag_ifaces[] = {
 573         &IID_IPropertyBag,
 574         &IID_IPropertyBag2,
 575         NULL
 576     };
 577
 578     CHECK_EXPECT(IPersistPropertyBag_Load);
 579
 580     ok(pPropBag != NULL, "pPropBag == NULL\n");
 581     ok(!pErrorLog, "pErrorLog != NULL\n");
 582
 583     test_ifaces((IUnknown*)pPropBag, propbag_ifaces);
 584
 585     V_VT(&v) = VT_BSTR;
 586     hres = IPropertyBag_Read(pPropBag, param_nameW, &v, NULL);
 587     ok(hres == S_OK, "Read failed: %08x\n", hres);
 588     ok(V_VT(&v) == VT_BSTR, "V_VT(&v) = %d\n", V_VT(&v));
 589     ok(!strcmp_wa(V_BSTR(&v), "param_value"), "V_BSTR(v) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
 590
 591     V_VT(&v) = VT_I4;
 592     V_I4(&v) = 0xdeadbeef;
 593     hres = IPropertyBag_Read(pPropBag, param_nameW, &v, NULL);
 594     ok(hres == DISP_E_TYPEMISMATCH, "Read failed: %08x, expected DISP_E_TYPEMISMATCH\n", hres);
 595     ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
 596     ok(V_I4(&v) == 0xdeadbeef, "V_I4(v) = %x\n", V_I4(&v));
 597
 598     V_VT(&v) = VT_BSTR;
 599     hres = IPropertyBag_Read(pPropBag, num_paramW, &v, NULL);
 600     ok(hres == S_OK, "Read failed: %08x\n", hres);
 601     ok(V_VT(&v) == VT_BSTR, "V_VT(&v) = %d\n", V_VT(&v));
 602     ok(!strcmp_wa(V_BSTR(&v), "3"), "V_BSTR(v) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
 603     SysFreeString(V_BSTR(&v));
 604
 605     V_VT(&v) = VT_I4;
 606     V_I4(&v) = 0xdeadbeef;
 607     hres = IPropertyBag_Read(pPropBag, num_paramW, &v, NULL);
 608     ok(hres == S_OK, "Read failed: %08x\n", hres);
 609     ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
 610     ok(V_I4(&v) == 3, "V_I4(v) = %x\n", V_I4(&v));
 611
 612     V_VT(&v) = VT_BSTR;
 613     V_BSTR(&v) = (BSTR)0xdeadbeef;
 614     hres = IPropertyBag_Read(pPropBag, no_paramW, &v, NULL);
 615     ok(hres == E_INVALIDARG, "Read failed: %08x\n", hres);
 616     ok(V_VT(&v) == VT_BSTR, "V_VT(&v) = %d\n", V_VT(&v));
 617     ok(V_BSTR(&v) == (BSTR)0xdeadbeef, "V_BSTR(v) = %p\n", V_BSTR(&v));
 618
 619     set_plugin_readystate(READYSTATE_INTERACTIVE);
 620
 621     hres = IOleClientSite_QueryInterface(client_site, &IID_IBindHost, (void**)&bind_host);
 622     ok(hres == S_OK, "Could not get IBindHost iface: %08x\n", hres);
 623
 624     hres = IOleClientSite_QueryInterface(client_site, &IID_IServiceProvider, (void**)&sp);
 625     ok(hres == S_OK, "Could not get IServiceProvider iface: %08x\n", hres);
 626
 627     hres = IServiceProvider_QueryService(sp, &SID_SBindHost, &IID_IBindHost, (void**)&bind_host2);
 628     ok(hres == S_OK, "QueryService(SID_SBindHost) failed: %08x\n", hres);
 629     IServiceProvider_Release(sp);
 630
 631     ok(iface_cmp((IUnknown*)bind_host, (IUnknown*)bind_host2), "bind_host != bind_host2\n");
 632     IBindHost_Release(bind_host2);
 633
 634     mon = NULL;
 635     hres = IBindHost_CreateMoniker(bind_host, test_swfW, NULL, &mon, 0);
 636     ok(hres == S_OK, "CreateMoniker failed: %08x\n", hres);
 637     ok(mon != NULL, "mon == NULL\n");
 638     test_mon_displayname(mon, "about:test.swf", "about:blanktest.swf");
 639     IMoniker_Release(mon);
 640
 641     IBindHost_Release(bind_host);
 642
 643     mon = NULL;
 644     hres = IOleClientSite_GetMoniker(client_site, OLEGETMONIKER_ONLYIFTHERE, OLEWHICHMK_CONTAINER, &mon);
 645     ok(hres == S_OK, "GetMoniker failed: %08x\n", hres);
 646     ok(mon != NULL, "mon == NULL\n");
 647     test_mon_displayname(mon, "about:blank", NULL);
 648     IMoniker_Release(mon);
 649
 650     set_plugin_readystate(READYSTATE_COMPLETE);
 651
 652     return S_OK;
 653 }
 654
 655 static HRESULT WINAPI PersistPropertyBag_Save(IPersistPropertyBag *face, IPropertyBag *pPropBag, BOOL fClearDisrty, BOOL fSaveAllProperties)
 656 {
 657     ok(0, "unexpected call\n");
 658     return E_NOTIMPL;
 659 }
 660
 661 static const IPersistPropertyBagVtbl PersistPropertyBagVtbl = {
 662     PersistPropertyBag_QueryInterface,
 663     PersistPropertyBag_AddRef,
 664     PersistPropertyBag_Release,
 665     PersistPropertyBag_GetClassID,
 666     PersistPropertyBag_InitNew,
 667     PersistPropertyBag_Load,
 668     PersistPropertyBag_Save
 669
 670 };
 671
 672 static IPersistPropertyBag PersistPropertyBag = { &PersistPropertyBagVtbl };
 673
 674 static HRESULT WINAPI Dispatch_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
 675 {
 676     return ax_qi(riid, ppv);
 677 }
 678
 679 static ULONG WINAPI Dispatch_AddRef(IDispatch *iface)
 680 {
 681     return ++activex_refcnt;
 682 }
 683
 684 static ULONG WINAPI Dispatch_Release(IDispatch *iface)
 685 {
 686     return --activex_refcnt;
 687 }
 688
 689 static HRESULT WINAPI Dispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
 690 {
 691     ok(0, "unexpected call\n");
 692     return E_NOTIMPL;
 693 }
 694
 695 static HRESULT WINAPI Dispatch_GetTypeInfo(IDispatch *iface, UINT iTInfo, LCID lcid,
 696         ITypeInfo **ppTInfo)
 697 {
 698     CHECK_EXPECT(GetTypeInfo);
 699
 700     ITypeInfo_AddRef(actxtest_typeinfo);
 701     *ppTInfo = actxtest_typeinfo;
 702     return S_OK;
 703 }
 704
 705 static HRESULT WINAPI Dispatch_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *rgszNames,
 706         UINT cNames, LCID lcid, DISPID *rgDispId)
 707 {
 708     ok(IsEqualGUID(riid, &IID_NULL), "riid = %s\n", wine_dbgstr_guid(riid));
 709     ok(cNames == 1, "cNames = %d\n", cNames);
 710     ok(rgszNames != NULL, "rgszNames == NULL\n");
 711     ok(rgDispId != NULL, "rgDispId == NULL\n");
 712
 713     if(!strcmp_wa(rgszNames[0], "scriptprop")) {
 714         CHECK_EXPECT(GetIDsOfNames_scriptprop);
 715         *rgDispId = DISPID_SCRIPTPROP;
 716     }else if(!strcmp_wa(rgszNames[0], "scriptCall")) {
 717         *rgDispId = DISPID_SCRIPTCALL;
 718     }else {
 719         ok(0, "rgszNames[0] = %s\n", wine_dbgstr_w(rgszNames[0]));
 720     }
 721
 722     return S_OK;
 723 }
 724
 725 static HRESULT WINAPI Dispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,
 726         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 727         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 728 {
 729     ok(IsEqualGUID(riid, &IID_NULL), "riid = %s\n", wine_dbgstr_guid(riid));
 730     ok(pDispParams != NULL, "pDispParams == NULL\n");
 731     ok(!pDispParams->cNamedArgs, "pDispParams->cNamedArgs = %d\n", pDispParams->cNamedArgs);
 732     ok(!pDispParams->rgdispidNamedArgs, "pDispParams->rgdispidNamedArgs != NULL\n");
 733
 734     switch(dispIdMember) {
 735     case DISPID_READYSTATE:
 736         CHECK_EXPECT2(Invoke_READYSTATE);
 737         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 738         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 739         ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
 740         ok(!pExcepInfo, "pExcepInfo != NULL\n");
 741         ok(puArgErr != NULL, "puArgErr == NULL\n");
 742         ok(pVarResult != NULL, "pVarResult == NULL\n");
 743
 744         V_VT(pVarResult) = VT_I4;
 745         V_I4(pVarResult) = plugin_readystate;
 746         return S_OK;
 747      case DISPID_ENABLED:
 748         CHECK_EXPECT2(Invoke_ENABLED);
 749         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 750         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 751         ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
 752         ok(!pExcepInfo, "pExcepInfo != NULL\n");
 753         ok(puArgErr != NULL, "puArgErr == NULL\n");
 754         ok(pVarResult != NULL, "pVarResult == NULL\n");
 755         return DISP_E_MEMBERNOTFOUND;
 756     case DISPID_VALID:
 757         CHECK_EXPECT(Invoke_VALID);
 758         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 759         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 760         ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
 761         ok(!pExcepInfo, "pExcepInfo != NULL\n");
 762         ok(puArgErr != NULL, "puArgErr == NULL\n");
 763         ok(pVarResult != NULL, "pVarResult == NULL\n");
 764         return DISP_E_MEMBERNOTFOUND;
 765     case DISPID_SECURITYCTX:
 766         CHECK_EXPECT(Invoke_SECURITYCTX);
 767         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 768         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 769         ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
 770         ok(!pExcepInfo, "pExcepInfo != NULL\n");
 771         ok(puArgErr != NULL, "puArgErr == NULL\n");
 772         ok(pVarResult != NULL, "pVarResult == NULL\n");
 773         return DISP_E_MEMBERNOTFOUND;
 774     case DISPID_SCRIPTPROP:
 775         CHECK_EXPECT(Invoke_SCRIPTPROP);
 776         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 777         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 778         ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
 779         ok(pExcepInfo != NULL, "pExcepInfo == NULL\n");
 780         ok(!puArgErr, "puArgErr != NULL\n");
 781         ok(pVarResult != NULL, "pVarResult == NULL\n");
 782
 783         V_VT(pVarResult) = VT_I4;
 784         V_I4(pVarResult) = 4;
 785         return S_OK;
 786     case DISPID_SCRIPTCALL:
 787         CHECK_EXPECT(Invoke_SCRIPTCALL);
 788         ok(wFlags == DISPATCH_METHOD, "wFlags = %x\n", wFlags);
 789         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 790         ok(pExcepInfo != NULL, "pExcepInfo == NULL\n");
 791         ok(!puArgErr, "puArgErr != NULL\n");
 792         ok(!pVarResult, "pVarResult != NULL\n");
 793         /*
 794         V_VT(pVarResult) = VT_I4;
 795         V_I4(pVarResult) = 4;
 796         */
 797         return S_OK;
 798     default:
 799         ok(0, "unexpected call %d\n", dispIdMember);
 800     }
 801
 802     return E_NOTIMPL;
 803 }
 804
 805 static const IDispatchVtbl DispatchVtbl = {
 806     Dispatch_QueryInterface,
 807     Dispatch_AddRef,
 808     Dispatch_Release,
 809     Dispatch_GetTypeInfoCount,
 810     Dispatch_GetTypeInfo,
 811     Dispatch_GetIDsOfNames,
 812     Dispatch_Invoke
 813 };
 814
 815 static IDispatch Dispatch = { &DispatchVtbl };
 816
 817 static HRESULT WINAPI ProvideClassInfo_QueryInterface(IProvideClassInfo *iface, REFIID riid, void **ppv)
 818 {
 819     return ax_qi(riid, ppv);
 820 }
 821
 822 static ULONG WINAPI ProvideClassInfo_AddRef(IProvideClassInfo *iface)
 823 {
 824     return ++activex_refcnt;
 825 }
 826
 827 static ULONG WINAPI ProvideClassInfo_Release(IProvideClassInfo *iface)
 828 {
 829     return --activex_refcnt;
 830 }
 831
 832 static HRESULT WINAPI ProvideClassInfo_GetClassInfo(IProvideClassInfo *iface, ITypeInfo **ppTI)
 833 {
 834     CHECK_EXPECT(GetClassInfo);
 835
 836     ITypeInfo_AddRef(class_typeinfo);
 837     *ppTI = class_typeinfo;
 838     return S_OK;
 839 }
 840
 841 static const IProvideClassInfoVtbl ProvideClassInfoVtbl = {
 842     ProvideClassInfo_QueryInterface,
 843     ProvideClassInfo_AddRef,
 844     ProvideClassInfo_Release,
 845     ProvideClassInfo_GetClassInfo
 846 };
 847
 848 static IProvideClassInfo ProvideClassInfo = { &ProvideClassInfoVtbl };
 849
 850 static HRESULT WINAPI ConnectionPointContainer_QueryInterface(IConnectionPointContainer *iface, REFIID riid, void **ppv)
 851 {
 852     return ax_qi(riid, ppv);
 853 }
 854
 855 static ULONG WINAPI ConnectionPointContainer_AddRef(IConnectionPointContainer *iface)
 856 {
 857     return ++activex_refcnt;
 858 }
 859
 860 static ULONG WINAPI ConnectionPointContainer_Release(IConnectionPointContainer *iface)
 861 {
 862     return --activex_refcnt;
 863 }
 864
 865 static HRESULT WINAPI ConnectionPointContainer_EnumConnectionPoints(IConnectionPointContainer *iface,
 866         IEnumConnectionPoints **ppEnum)
 867 {
 868     ok(0, "unexpected call\n");
 869     return E_NOTIMPL;
 870 }
 871
 872 static HRESULT WINAPI ConnectionPointContainer_FindConnectionPoint(IConnectionPointContainer *iface,
 873         REFIID riid, IConnectionPoint **ppCP)
 874 {
 875     if(IsEqualGUID(riid, &IID_IPropertyNotifySink)) {
 876         /* TODO */
 877         trace("FindConnectionPoint(IID_IPropertyNotifySink)\n");
 878         return CONNECT_E_NOCONNECTION;
 879     }
 880
 881     CHECK_EXPECT(FindConnectionPoint);
 882     ok(IsEqualGUID(riid, &DIID_DispActiveXTest), "riid = %s\n", wine_dbgstr_guid(riid));
 883
 884     IConnectionPoint_AddRef(&ConnectionPoint);
 885     *ppCP = &ConnectionPoint;
 886     return S_OK;
 887 }
 888
 889 static const IConnectionPointContainerVtbl ConnectionPointContainerVtbl = {
 890     ConnectionPointContainer_QueryInterface,
 891     ConnectionPointContainer_AddRef,
 892     ConnectionPointContainer_Release,
 893     ConnectionPointContainer_EnumConnectionPoints,
 894     ConnectionPointContainer_FindConnectionPoint
 895 };
 896
 897 static IConnectionPointContainer ConnectionPointContainer = { &ConnectionPointContainerVtbl };
 898
 899 static HRESULT WINAPI ViewObjectEx_QueryInterface(IViewObjectEx *iface, REFIID riid, void **ppv)
 900 {
 901     return ax_qi(riid, ppv);
 902 }
 903
 904 static ULONG WINAPI ViewObjectEx_AddRef(IViewObjectEx *iface)
 905 {
 906     return ++activex_refcnt;
 907 }
 908
 909 static ULONG WINAPI ViewObjectEx_Release(IViewObjectEx *iface)
 910 {
 911     return --activex_refcnt;
 912 }
 913
 914 static HRESULT WINAPI ViewObjectEx_Draw(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd,
 915         HDC hdcTargetDev, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBoungs, BOOL (WINAPI*pfnContinue)(ULONG_PTR), ULONG_PTR dwContinue)
 916 {
 917     ok(0, "unexpected call\n");
 918     return E_NOTIMPL;
 919 }
 920
 921 static HRESULT WINAPI ViewObjectEx_GetColorSet(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd,
 922         HDC hicTargetDev, LOGPALETTE **ppColorSet)
 923 {
 924     ok(0, "unexpected call\n");
 925     return E_NOTIMPL;
 926 }
 927
 928 static HRESULT WINAPI ViewObjectEx_Freeze(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DWORD *pdwFreeze)
 929 {
 930     ok(0, "unexpected call\n");
 931     return E_NOTIMPL;
 932 }
 933
 934 static HRESULT WINAPI ViewObjectEx_Unfreeze(IViewObjectEx *iface, DWORD dwFreeze)
 935 {
 936     ok(0, "unexpected call\n");
 937     return E_NOTIMPL;
 938 }
 939
 940 static HRESULT WINAPI ViewObjectEx_SetAdvise(IViewObjectEx *iface, DWORD aspects, DWORD advf, IAdviseSink *pAdvSink)
 941 {
 942     CHECK_EXPECT(SetAdvise);
 943
 944     ok(aspects == DVASPECT_CONTENT, "aspects = %x\n", aspects);
 945     ok(!advf, "advf = %x\n", advf);
 946     ok(pAdvSink != NULL, "pAdvSink = NULL\n");
 947
 948     return S_OK;
 949 }
 950
 951 static HRESULT WINAPI ViewObjectEx_GetAdvise(IViewObjectEx *iface, DWORD *pAspects, DWORD *pAdvf, IAdviseSink **ppAdvSink)
 952 {
 953     ok(0, "unexpected call\n");
 954     return E_NOTIMPL;
 955 }
 956
 957 static HRESULT WINAPI ViewObjectEx_GetExtent(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, DVTARGETDEVICE *ptd, LPSIZEL lpsizel)
 958 {
 959     ok(0, "unexpected call\n");
 960     return E_NOTIMPL;
 961 }
 962
 963 static HRESULT WINAPI ViewObjectEx_GetRect(IViewObjectEx *iface, DWORD dwAspect, LPRECTL pRect)
 964 {
 965     ok(0, "unexpected call\n");
 966     return E_NOTIMPL;
 967 }
 968
 969 static HRESULT WINAPI ViewObjectEx_GetViewStatus(IViewObjectEx *iface, DWORD *pdwStatus)
 970 {
 971     CHECK_EXPECT(GetViewStatus);
 972
 973     *pdwStatus = VIEWSTATUS_OPAQUE|VIEWSTATUS_SOLIDBKGND;
 974     return S_OK;
 975 }
 976
 977 static HRESULT WINAPI ViewObjectEx_QueryHitPoint(IViewObjectEx *iface, DWORD dwAspect, LPCRECT pRectBounds, POINT ptlLoc,
 978         LONG lCloseHint, DWORD *pHitResult)
 979 {
 980     trace("QueryHitPoint call ignored\n");
 981     return E_NOTIMPL;
 982 }
 983
 984 static HRESULT WINAPI ViewObjectEx_QueryHitRect(IViewObjectEx *iface, DWORD dwAspect, LPCRECT pRectBounds, LPCRECT pRectLoc,
 985         LONG lCloseHint, DWORD *pHitResult)
 986 {
 987     ok(0, "unexpected call\n");
 988     return E_NOTIMPL;
 989 }
 990
 991 static HRESULT WINAPI ViewObjectEx_GetNaturalExtent(IViewObjectEx *iface, DWORD dwAspect, LONG lindex, DVTARGETDEVICE *ptd,
 992         HDC hicTargetDev, DVEXTENTINFO *pExtentIngo, LPSIZEL pSizel)
 993 {
 994     ok(0, "unexpected call\n");
 995     return E_NOTIMPL;
 996 }
 997
 998 static const IViewObjectExVtbl ViewObjectExVtbl = {
 999     ViewObjectEx_QueryInterface,
1000     ViewObjectEx_AddRef,
1001     ViewObjectEx_Release,
1002     ViewObjectEx_Draw,
1003     ViewObjectEx_GetColorSet,
1004     ViewObjectEx_Freeze,
1005     ViewObjectEx_Unfreeze,
1006     ViewObjectEx_SetAdvise,
1007     ViewObjectEx_GetAdvise,
1008     ViewObjectEx_GetExtent,
1009     ViewObjectEx_GetRect,
1010     ViewObjectEx_GetViewStatus,
1011     ViewObjectEx_QueryHitPoint,
1012     ViewObjectEx_QueryHitRect,
1013     ViewObjectEx_GetNaturalExtent
1014 };
1015
1016 static IViewObjectEx ViewObjectEx = { &ViewObjectExVtbl };
1017
1018 static HRESULT WINAPI OleObject_QueryInterface(IOleObject *iface, REFIID riid, void **ppv)
1019 {
1020     return ax_qi(riid, ppv);
1021 }
1022
1023 static ULONG WINAPI OleObject_AddRef(IOleObject *iface)
1024 {
1025     return ++activex_refcnt;
1026 }
1027
1028 static ULONG WINAPI OleObject_Release(IOleObject *iface)
1029 {
1030     return --activex_refcnt;
1031 }
1032
1033 static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, IOleClientSite *pClientSite)
1034 {
1035     if(!pClientSite) {
1036         CHECK_EXPECT(SetClientSite_NULL);
1037         return S_OK;
1038     }
1039
1040     CHECK_EXPECT(SetClientSite);
1041
1042     IOleClientSite_AddRef(pClientSite);
1043     client_site = pClientSite;
1044     return S_OK;
1045 }
1046
1047 static HRESULT WINAPI OleObject_GetClientSite(IOleObject *iface, IOleClientSite **ppClientSite)
1048 {
1049     ok(0, "unexpected call\n");
1050     return E_NOTIMPL;
1051 }
1052
1053 static HRESULT WINAPI OleObject_SetHostNames(IOleObject *iface, LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
1054 {
1055     ok(0, "unexpected call\n");
1056     return E_NOTIMPL;
1057 }
1058
1059 static HRESULT WINAPI OleObject_Close(IOleObject *iface, DWORD dwSaveOption)
1060 {
1061     CHECK_EXPECT(Close);
1062
1063     ok(dwSaveOption == OLECLOSE_NOSAVE, "dwSaveOption = %d\n", dwSaveOption);
1064     return S_OK;
1065 }
1066
1067 static HRESULT WINAPI OleObject_SetMoniker(IOleObject *iface, DWORD dwWhichMoniker, IMoniker *pmk)
1068 {
1069     ok(0, "unexpected call\n");
1070     return E_NOTIMPL;
1071 }
1072
1073 static HRESULT WINAPI OleObject_GetMoniker(IOleObject *iface, DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk)
1074 {
1075     ok(0, "unexpected call\n");
1076     return E_NOTIMPL;
1077 }
1078
1079 static HRESULT WINAPI OleObject_InitFromData(IOleObject *iface, IDataObject *pDataObject, BOOL fCreation,
1080         DWORD dwReserved)
1081 {
1082     ok(0, "unexpected call\n");
1083     return E_NOTIMPL;
1084 }
1085
1086 static HRESULT WINAPI OleObject_GetClipboardData(IOleObject *iface, DWORD dwReserved, IDataObject **ppDataObject)
1087 {
1088     ok(0, "unexpected call\n");
1089     return E_NOTIMPL;
1090 }
1091
1092 static HRESULT WINAPI OleObject_DoVerb(IOleObject *iface, LONG iVerb, LPMSG lpmsg, IOleClientSite *pActiveSite,
1093         LONG lindex, HWND hwndParent, LPCRECT lprcPosRect)
1094 {
1095     OLEINPLACEFRAMEINFO frame_info = {0xdeadbeef};
1096     IOleInPlaceUIWindow *ip_uiwindow;
1097     IOleInPlaceFrame *ip_frame;
1098     IOleInPlaceSiteEx *ip_site;
1099     RECT pos_rect, clip_rect;
1100     BOOL no_redraw;
1101     HWND hwnd;
1102     HRESULT hres;
1103
1104     CHECK_EXPECT(DoVerb);
1105
1106     ok(iVerb == OLEIVERB_INPLACEACTIVATE, "iVerb = %d\n", iVerb);
1107     ok(!lpmsg, "lpmsg != NULL\n");
1108     ok(pActiveSite != NULL, "pActiveSite == NULL\n");
1109     ok(!lindex, "lindex = %d\n", lindex);
1110     ok(hwndParent != NULL, "hwndParent == NULL\n");
1111     ok(lprcPosRect != NULL, "lprcPosRect == NULL\n");
1112
1113     hres = IOleClientSite_QueryInterface(pActiveSite, &IID_IOleInPlaceSiteEx, (void**)&ip_site);
1114     ok(hres == S_OK, "Could not get IOleInPlaceSiteEx iface: %08x\n", hres);
1115
1116     hres = IOleInPlaceSiteEx_CanInPlaceActivate(ip_site);
1117     ok(hres == S_OK, "CanInPlaceActivate failed: %08x\n", hres);
1118
1119     SET_EXPECT(InPlaceObject_GetWindow);
1120     no_redraw = 0xdeadbeef;
1121     hres = IOleInPlaceSiteEx_OnInPlaceActivateEx(ip_site, &no_redraw, 0);
1122     ok(hres == S_OK, "InPlaceActivateEx failed: %08x\n", hres);
1123     ok(!no_redraw, "no_redraw = %x\n", no_redraw);
1124     CHECK_CALLED(InPlaceObject_GetWindow);
1125
1126     no_redraw = 0xdeadbeef;
1127     hres = IOleInPlaceSiteEx_OnInPlaceActivateEx(ip_site, &no_redraw, 0);
1128     ok(hres == S_OK, "InPlaceActivateEx failed: %08x\n", hres);
1129     ok(no_redraw == 0xdeadbeef, "no_redraw = %x\n", no_redraw);
1130
1131     hwnd = NULL;
1132     hres = IOleInPlaceSiteEx_GetWindow(ip_site, &hwnd);
1133     ok(hres == S_OK, "GetWindow failed: %08x\n", hres);
1134     ok(hwnd != NULL, "hwnd == NULL\n");
1135     ok(hwnd == hwndParent, "hwnd != hwndParent\n");
1136
1137     create_plugin_window(hwnd, lprcPosRect);
1138
1139     ip_frame = NULL;
1140     ip_uiwindow = NULL;
1141     frame_info.cb = sizeof(OLEINPLACEFRAMEINFO);
1142     hres = IOleInPlaceSiteEx_GetWindowContext(ip_site, &ip_frame, &ip_uiwindow, &pos_rect, &clip_rect, &frame_info);
1143     ok(hres == S_OK, "GetWindowContext failed: %08x\n", hres);
1144     ok(ip_frame != NULL, "ip_frame == NULL\n");
1145     ok(ip_uiwindow != NULL, "ip_uiwindow == NULL\n");
1146     ok((IOleInPlaceUIWindow*)ip_frame != ip_uiwindow, "ip_frame == ip_uiwindow\n");
1147     ok(!memcmp(&pos_rect, lprcPosRect, sizeof(RECT)), "pos_rect != lpecPosRect\n");
1148     ok(!memcmp(&clip_rect, lprcPosRect, sizeof(RECT)), "clip_rect != lpecPosRect\n");
1149     ok(frame_info.cb == sizeof(frame_info), "frame_info.cb = %d\n", frame_info.cb);
1150     ok(!frame_info.fMDIApp, "frame_info.fMDIApp = %x\n", frame_info.fMDIApp);
1151     ok(frame_info.hwndFrame != NULL, "frame_info.hwnd == NULL\n");
1152     ok(frame_info.hwndFrame == container_hwnd, "frame_info.hwnd != container_hwnd\n");
1153     ok(!frame_info.haccel, "frame_info.haccel != 0\n");
1154     ok(!frame_info.cAccelEntries, "frame_info.cAccelEntried != 0\n");
1155
1156     IOleInPlaceFrame_Release(ip_frame);
1157     IOleInPlaceUIWindow_Release(ip_uiwindow);
1158
1159
1160     IOleInPlaceSiteEx_Release(ip_site);
1161
1162     hres = IOleClientSite_ShowObject(client_site);
1163     ok(hres == S_OK, "ShowObject failed: %08x\n", hres);
1164
1165     SET_EXPECT(InPlaceObject_GetWindow);
1166     SET_EXPECT(SetObjectRects);
1167
1168     return S_OK;
1169 }
1170
1171 static HRESULT WINAPI OleObject_EnumVerbs(IOleObject *iface, IEnumOLEVERB **ppEnumOleVerb)
1172 {
1173     ok(0, "unexpected call\n");
1174     return E_NOTIMPL;
1175 }
1176
1177 static HRESULT WINAPI OleObject_Update(IOleObject *iface)
1178 {
1179     ok(0, "unexpected call\n");
1180     return E_NOTIMPL;
1181 }
1182
1183 static HRESULT WINAPI OleObject_IsUpToDate(IOleObject *iface)
1184 {
1185     ok(0, "unexpected call\n");
1186     return E_NOTIMPL;
1187 }
1188
1189 static HRESULT WINAPI OleObject_GetUserClassID(IOleObject *iface, CLSID *pClsid)
1190 {
1191     ok(0, "unexpected call\n");
1192     return E_NOTIMPL;
1193 }
1194
1195 static HRESULT WINAPI OleObject_GetUserType(IOleObject *iface, DWORD dwFormOfType, LPOLESTR *pszUserType)
1196 {
1197     ok(0, "unexpected call\n");
1198     return E_NOTIMPL;
1199 }
1200
1201 static HRESULT WINAPI OleObject_SetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
1202 {
1203     CHECK_EXPECT(SetExtent);
1204     return E_NOTIMPL;
1205 }
1206
1207 static HRESULT WINAPI OleObject_GetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
1208 {
1209     CHECK_EXPECT(GetExtent);
1210     return E_NOTIMPL;
1211 }
1212
1213 static HRESULT WINAPI OleObject_Advise(IOleObject *iface, IAdviseSink *pAdvSink, DWORD *pdwConnection)
1214 {
1215     ok(0, "unexpected call\n");
1216     return E_NOTIMPL;
1217 }
1218
1219 static HRESULT WINAPI OleObject_Unadvise(IOleObject *iface, DWORD dwConnection)
1220 {
1221     ok(0, "unexpected call\n");
1222     return E_NOTIMPL;
1223 }
1224
1225 static HRESULT WINAPI OleObject_EnumAdvise(IOleObject *iface, IEnumSTATDATA **ppenumAdvise)
1226 {
1227     ok(0, "unexpected call\n");
1228     return E_NOTIMPL;
1229 }
1230
1231 static HRESULT WINAPI OleObject_GetMiscStatus(IOleObject *iface, DWORD dwAspect, DWORD *pdwStatus)
1232 {
1233     CHECK_EXPECT(GetMiscStatus);
1234     ok(dwAspect == DVASPECT_CONTENT, "dwAspect = %d\n", dwAspect);
1235     ok(pdwStatus != NULL, "pdwStatus == NULL\n");
1236     *pdwStatus = OLEMISC_SETCLIENTSITEFIRST|OLEMISC_ACTIVATEWHENVISIBLE
1237         |OLEMISC_INSIDEOUT|OLEMISC_CANTLINKINSIDE|OLEMISC_RECOMPOSEONRESIZE;
1238     return S_OK;
1239 }
1240
1241 static HRESULT WINAPI OleObject_SetColorScheme(IOleObject *iface, LOGPALETTE *pLogpal)
1242 {
1243     ok(0, "unexpected call\n");
1244     return E_NOTIMPL;
1245 }
1246
1247 static const IOleObjectVtbl OleObjectVtbl = {
1248     OleObject_QueryInterface,
1249     OleObject_AddRef,
1250     OleObject_Release,
1251     OleObject_SetClientSite,
1252     OleObject_GetClientSite,
1253     OleObject_SetHostNames,
1254     OleObject_Close,
1255     OleObject_SetMoniker,
1256     OleObject_GetMoniker,
1257     OleObject_InitFromData,
1258     OleObject_GetClipboardData,
1259     OleObject_DoVerb,
1260     OleObject_EnumVerbs,
1261     OleObject_Update,
1262     OleObject_IsUpToDate,
1263     OleObject_GetUserClassID,
1264     OleObject_GetUserType,
1265     OleObject_SetExtent,
1266     OleObject_GetExtent,
1267     OleObject_Advise,
1268     OleObject_Unadvise,
1269     OleObject_EnumAdvise,
1270     OleObject_GetMiscStatus,
1271     OleObject_SetColorScheme
1272 };
1273
1274 static IOleObject OleObject = { &OleObjectVtbl };
1275
1276 static HRESULT WINAPI OleInPlaceObject_QueryInterface(IOleInPlaceObjectWindowless *iface,
1277         REFIID riid, void **ppv)
1278 {
1279     return ax_qi(riid, ppv);
1280 }
1281
1282 static ULONG WINAPI OleInPlaceObject_AddRef(IOleInPlaceObjectWindowless *iface)
1283 {
1284     return ++activex_refcnt;
1285 }
1286
1287 static ULONG WINAPI OleInPlaceObject_Release(IOleInPlaceObjectWindowless *iface)
1288 {
1289     return --activex_refcnt;
1290 }
1291
1292 static HRESULT WINAPI OleInPlaceObject_GetWindow(IOleInPlaceObjectWindowless *iface,
1293         HWND *phwnd)
1294 {
1295     CHECK_EXPECT2(InPlaceObject_GetWindow);
1296
1297     ok(phwnd != NULL, "phwnd == NULL\n");
1298
1299     *phwnd = plugin_hwnd;
1300     return *phwnd ? S_OK : E_UNEXPECTED;
1301 }
1302
1303 static HRESULT WINAPI OleInPlaceObject_ContextSensitiveHelp(IOleInPlaceObjectWindowless *iface,
1304         BOOL fEnterMode)
1305 {
1306     ok(0, "unexpected call\n");
1307     return E_NOTIMPL;
1308 }
1309
1310 static HRESULT WINAPI OleInPlaceObject_InPlaceDeactivate(IOleInPlaceObjectWindowless *iface)
1311 {
1312     IOleInPlaceSite *ip_site;
1313     HRESULT hres;
1314
1315     CHECK_EXPECT(InPlaceDeactivate);
1316
1317     hres = IOleClientSite_QueryInterface(client_site, &IID_IOleInPlaceSite, (void**)&ip_site);
1318     ok(hres == S_OK, "Could not get IOleInPlaceSite iface: %08x\n", hres);
1319
1320     hres = IOleInPlaceSite_OnInPlaceDeactivate(ip_site);
1321     ok(hres == S_OK, "OnInPlaceDeactivate failed: %08x\n", hres);
1322
1323     IOleInPlaceSite_Release(ip_site);
1324     return S_OK;
1325 }
1326
1327 static HRESULT WINAPI OleInPlaceObject_UIDeactivate(IOleInPlaceObjectWindowless *iface)
1328 {
1329     CHECK_EXPECT2(UIDeactivate);
1330     return S_OK;
1331 }
1332
1333 static HRESULT WINAPI OleInPlaceObject_SetObjectRects(IOleInPlaceObjectWindowless *iface,
1334         LPCRECT lprcPosRect, LPCRECT lprcClipRect)
1335 {
1336     CHECK_EXPECT2(SetObjectRects);
1337     return S_OK;
1338 }
1339
1340 static HRESULT WINAPI OleInPlaceObjectWindowless_ReactivateAndUndo(IOleInPlaceObjectWindowless *iface)
1341 {
1342     ok(0, "unexpected call\n");
1343     return E_NOTIMPL;
1344 }
1345
1346 static HRESULT WINAPI OleInPlaceObjectWindowless_OnWindowMessage(IOleInPlaceObjectWindowless *iface,
1347         UINT msg, WPARAM wParam, LPARAM lParam, LRESULT *lpResult)
1348 {
1349     ok(0, "unexpected call\n");
1350     return E_NOTIMPL;
1351 }
1352
1353 static HRESULT WINAPI OleInPlaceObjectWindowless_GetDropTarget(IOleInPlaceObjectWindowless *iface,
1354         IDropTarget **ppDropTarget)
1355 {
1356     ok(0, "unexpected call\n");
1357     return E_NOTIMPL;
1358 }
1359
1360 static const IOleInPlaceObjectWindowlessVtbl OleInPlaceObjectWindowlessVtbl = {
1361     OleInPlaceObject_QueryInterface,
1362     OleInPlaceObject_AddRef,
1363     OleInPlaceObject_Release,
1364     OleInPlaceObject_GetWindow,
1365     OleInPlaceObject_ContextSensitiveHelp,
1366     OleInPlaceObject_InPlaceDeactivate,
1367     OleInPlaceObject_UIDeactivate,
1368     OleInPlaceObject_SetObjectRects,
1369     OleInPlaceObjectWindowless_ReactivateAndUndo,
1370     OleInPlaceObjectWindowless_OnWindowMessage,
1371     OleInPlaceObjectWindowless_GetDropTarget
1372 };
1373
1374 static IOleInPlaceObjectWindowless OleInPlaceObjectWindowless = { &OleInPlaceObjectWindowlessVtbl };
1375
1376 static void *wrapped_iface_vtbl[100];
1377 static IUnknown wrapped_iface = { (IUnknownVtbl*)wrapped_iface_vtbl };
1378
1379 static HRESULT WINAPI wrapped_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
1380 {
1381     ok(0, "unexpected wrapped_QueryInterface call\n");
1382     *ppv = NULL;
1383     return E_NOINTERFACE;
1384 }
1385
1386 static ULONG WINAPI wrapped_AddRef(IUnknown *iface)
1387 {
1388     CHECK_EXPECT(wrapped_AddRef);
1389     return 2;
1390 }
1391
1392 static ULONG WINAPI wrapped_Release(IUnknown *iface)
1393 {
1394     CHECK_EXPECT(wrapped_Release);
1395     return 1;
1396 }
1397
1398 static HRESULT WINAPI wrapped_func_nocall(IUnknown *iface, int i, double d)
1399 {
1400     ok(0, "unexpected call\n");
1401     return E_FAIL;
1402 }
1403
1404 static HRESULT WINAPI wrapped_func(IUnknown *iface, int i, double d)
1405 {
1406     CHECK_EXPECT(wrapped_func);
1407     ok(iface == &wrapped_iface, "iface != wrapped_iface\n");
1408     ok(i == 10, "i = %d\n", i);
1409     ok(d == 32.0, "d = %lf\n", d);
1410     return S_OK;
1411 }
1412
1413 static void init_wrapped_iface(void)
1414 {
1415     unsigned i;
1416
1417     wrapped_iface_vtbl[0] = wrapped_QueryInterface;
1418     wrapped_iface_vtbl[1] = wrapped_AddRef;
1419     wrapped_iface_vtbl[2] = wrapped_Release;
1420
1421     for(i=3; i<100; i++)
1422         wrapped_iface_vtbl[i] = wrapped_func_nocall;
1423
1424     wrapped_iface_vtbl[63] = wrapped_func;
1425 }
1426
1427 static HRESULT ax_qi(REFIID riid, void **ppv)
1428 {
1429     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IOleControl)) {
1430         *ppv = plugin_behavior == TEST_DISPONLY ? NULL : &OleControl;
1431     }else if(IsEqualGUID(riid, &IID_IQuickActivate)) {
1432         *ppv = no_quickact ? NULL : &QuickActivate;
1433     }else if(IsEqualGUID(riid, &IID_IPersistPropertyBag)) {
1434         *ppv = no_quickact ? NULL : &PersistPropertyBag;
1435     }else if(IsEqualGUID(riid, &IID_IDispatch)) {
1436         *ppv = &Dispatch;
1437     }else if(IsEqualGUID(riid, &IID_IProvideClassInfo)) {
1438         *ppv = &ProvideClassInfo;
1439     }else if(IsEqualGUID(riid, &IID_IConnectionPointContainer)) {
1440         *ppv = plugin_behavior != TEST_DISPONLY ? &ConnectionPointContainer : NULL;
1441     }else if(IsEqualGUID(riid, &IID_IViewObject) || IsEqualGUID(riid, &IID_IViewObject2)
1442             || IsEqualGUID(riid, &IID_IViewObjectEx)) {
1443         *ppv = plugin_behavior == TEST_DISPONLY ? NULL : &ViewObjectEx;
1444     }else if(IsEqualGUID(riid, &IID_IOleObject)) {
1445         *ppv = plugin_behavior == TEST_DISPONLY ? NULL : &OleObject;
1446     }else if(IsEqualGUID(riid, &IID_ITestActiveX)) {
1447         CHECK_EXPECT(QI_ITestActiveX);
1448         *ppv = &wrapped_iface;
1449         return S_OK;
1450     }else  if(IsEqualGUID(riid, &IID_IOleWindow) || IsEqualGUID(riid, &IID_IOleInPlaceObject)
1451        || IsEqualGUID(&IID_IOleInPlaceObjectWindowless, riid)) {
1452         *ppv = plugin_behavior == TEST_DISPONLY ? NULL : &OleInPlaceObjectWindowless;
1453     }else {
1454         trace("QI %s\n", wine_dbgstr_guid(riid));
1455         *ppv = NULL;
1456     }
1457
1458     if(!*ppv)
1459         return E_NOINTERFACE;
1460
1461     IUnknown_AddRef((IUnknown*)*ppv);
1462     return S_OK;
1463 }
1464
1465 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
1466 {
1467     *ppv = NULL;
1468
1469     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
1470         *ppv = iface;
1471         return S_OK;
1472     }
1473
1474     if(IsEqualGUID(&IID_IMarshal, riid))
1475         return E_NOINTERFACE;
1476     if(IsEqualGUID(&CLSID_IdentityUnmarshal, riid))
1477         return E_NOINTERFACE;
1478     if(IsEqualGUID(&IID_IClassFactoryEx, riid))
1479         return E_NOINTERFACE; /* TODO */
1480
1481     ok(0, "unexpected riid %s\n", wine_dbgstr_guid(riid));
1482     return E_NOTIMPL;
1483 }
1484
1485 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
1486 {
1487     return 2;
1488 }
1489
1490 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
1491 {
1492     return 1;
1493 }
1494
1495 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
1496 {
1497     CHECK_EXPECT(CreateInstance);
1498
1499     ok(!outer, "outer = %p\n", outer);
1500     ok(IsEqualGUID(riid, &IID_IUnknown), "riid = %s\n", wine_dbgstr_guid(riid));
1501
1502     activex_refcnt++;
1503     *ppv = &OleControl;
1504     return S_OK;
1505 }
1506
1507 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
1508 {
1509     ok(0, "unexpected call\n");
1510     return S_OK;
1511 }
1512
1513 static const IClassFactoryVtbl ClassFactoryVtbl = {
1514     ClassFactory_QueryInterface,
1515     ClassFactory_AddRef,
1516     ClassFactory_Release,
1517     ClassFactory_CreateInstance,
1518     ClassFactory_LockServer
1519 };
1520
1521 static IClassFactory activex_cf = { &ClassFactoryVtbl };
1522
1523 static void test_elem_dispex(IDispatchEx *dispex)
1524 {
1525     DISPPARAMS dp;
1526     EXCEPINFO ei;
1527     VARIANT v;
1528     DISPID id;
1529     BSTR str;
1530     HRESULT hres;
1531
1532     str = a2bstr("scriptprop");
1533     SET_EXPECT(GetIDsOfNames_scriptprop);
1534     hres = IDispatchEx_GetDispID(dispex, str, 0, &id);
1535     CHECK_CALLED(GetIDsOfNames_scriptprop);
1536     SysFreeString(str);
1537     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
1538     todo_wine
1539     ok(id == DISPID_SCRIPTPROP, "id = %d\n", id);
1540
1541     SET_EXPECT(Invoke_SECURITYCTX);
1542     SET_EXPECT(Invoke_SCRIPTPROP);
1543     memset(&dp, 0, sizeof(dp));
1544     memset(&ei, 0, sizeof(ei));
1545     V_VT(&v) = VT_EMPTY;
1546     hres = IDispatchEx_InvokeEx(dispex, id, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dp, &v, &ei, NULL);
1547     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1548     ok(V_VT(&v) == VT_I4, "V_VT(v) = %d\n", V_VT(&v));
1549     ok(V_I4(&v) == 4, "V_I4(v) = %d\n", V_I4(&v));
1550     CHECK_CALLED(Invoke_SECURITYCTX);
1551     CHECK_CALLED(Invoke_SCRIPTPROP);
1552 }
1553
1554 static void test_iface_wrapping(IHTMLObjectElement *elem)
1555 {
1556     IHTMLObjectElement *elem2;
1557     IUnknown *unk, *unk2;
1558     ULONG ref;
1559     void **vtbl;
1560     HRESULT hres;
1561
1562     SET_EXPECT(QI_ITestActiveX);
1563     SET_EXPECT(wrapped_AddRef);
1564     SET_EXPECT(wrapped_Release);
1565     unk = (void*)0xdeadbeef;
1566     hres = IHTMLObjectElement_QueryInterface(elem, &IID_ITestActiveX, (void**)&unk);
1567     ok(hres == S_OK, "QueryInerface(IID_ITestActiveX failed: %08x\n", hres);
1568     CHECK_CALLED(QI_ITestActiveX);
1569     CHECK_CALLED(wrapped_AddRef);
1570     CHECK_CALLED(wrapped_Release);
1571
1572     /* See dlls/mshtml/ifacewrap.c */
1573     ok(unk != &wrapped_iface, "Unexpected unk %p, expected %p (%p, %p)\n", unk, &ViewObjectEx, unk->lpVtbl, &ViewObjectExVtbl);
1574     ok(unk->lpVtbl != wrapped_iface.lpVtbl, "unk->lpVtbl == wrapped_iface->lpVtbl\n");
1575     ok(unk->lpVtbl->QueryInterface != wrapped_QueryInterface, "QueryInterface not wrapped\n");
1576     ok(unk->lpVtbl->AddRef != wrapped_AddRef, "AddRef not wrapped\n");
1577     ok(unk->lpVtbl->Release != wrapped_Release, "Release not wrapped\n");
1578
1579     vtbl = (void**)unk->lpVtbl;
1580     ok(vtbl[4] != wrapped_func_nocall, "func not wrapped\n");
1581     ok(vtbl[63] != wrapped_func, "func not wrapped\n");
1582
1583     SET_EXPECT(wrapped_func);
1584     hres = ((HRESULT (WINAPI*)(IUnknown*,int,double))vtbl[63])(unk, 10, 32.0);
1585     ok(hres == S_OK, "wrapped_func returned %08x\n", hres);
1586     CHECK_CALLED(wrapped_func);
1587
1588     hres = IUnknown_QueryInterface(unk, &IID_IHTMLObjectElement, (void**)&elem2);
1589     ok(hres == S_OK, "Could not get IHTMLObjectElement from wrapped iface: %08x\n", hres);
1590     ok(iface_cmp((IUnknown*)elem2, (IUnknown*)elem), "elem2 != elem\n");
1591     IHTMLObjectElement_Release(elem2);
1592
1593     SET_EXPECT(wrapped_Release);
1594     ref = IUnknown_Release(unk);
1595     ok(!ref, "ref=%d\n", ref);
1596     CHECK_CALLED(wrapped_Release);
1597
1598     SET_EXPECT(QI_ITestActiveX);
1599     SET_EXPECT(wrapped_AddRef);
1600     SET_EXPECT(wrapped_Release);
1601     unk = (void*)0xdeadbeef;
1602     hres = IHTMLObjectElement_QueryInterface(elem, &IID_ITestActiveX, (void**)&unk2);
1603     ok(hres == S_OK, "QueryInerface(IID_ITestActiveX failed: %08x\n", hres);
1604     CHECK_CALLED(QI_ITestActiveX);
1605     CHECK_CALLED(wrapped_AddRef);
1606     CHECK_CALLED(wrapped_Release);
1607
1608     ok(unk != unk2, "unk == unk2\n");
1609
1610     SET_EXPECT(wrapped_Release);
1611     ref = IUnknown_Release(unk2);
1612     ok(!ref, "ref=%d\n", ref);
1613     CHECK_CALLED(wrapped_Release);
1614 }
1615
1616 static void test_object_elem(IHTMLDocument2 *doc)
1617 {
1618     IHTMLObjectElement *objelem;
1619     IHTMLDocument3 *doc3;
1620     IDispatchEx *dispex;
1621     IHTMLElement *elem;
1622     IDispatch *disp;
1623     VARIANT v;
1624     BSTR str;
1625     HRESULT hres;
1626
1627     hres = IHTMLDocument2_QueryInterface(doc, &IID_IHTMLDocument3, (void**)&doc3);
1628     ok(hres == S_OK, "Could not get IHTMLDocument3 iface: %08x\n", hres);
1629
1630     str = a2bstr("objid");
1631     elem = (void*)0xdeadbeef;
1632     hres = IHTMLDocument3_getElementById(doc3, str, &elem);
1633     IHTMLDocument3_Release(doc3);
1634     SysFreeString(str);
1635     ok(hres == S_OK, "getElementById failed: %08x\n", hres);
1636     ok(elem != NULL, "elem == NULL\n");
1637
1638     hres = IHTMLElement_QueryInterface(elem, &IID_IHTMLObjectElement, (void**)&objelem);
1639     IHTMLElement_Release(elem);
1640     ok(hres == S_OK, "Could not get IHTMLObjectElement iface: %08x\n", hres);
1641
1642     SET_EXPECT(Invoke_SECURITYCTX);
1643     hres = IHTMLObjectElement_get_object(objelem, &disp);
1644     ok(hres == S_OK, "get_object failed: %08x\n", hres);
1645     ok(disp == &Dispatch, "disp != Dispatch\n");
1646     CHECK_CALLED(Invoke_SECURITYCTX);
1647
1648     hres = IHTMLObjectElement_QueryInterface(objelem, &IID_IDispatchEx, (void**)&dispex);
1649     ok(hres == S_OK, "QueryInterface failed: %08x\n", hres);
1650     test_elem_dispex(dispex);
1651     IDispatchEx_Release(dispex);
1652
1653     test_iface_wrapping(objelem);
1654
1655     hres = IHTMLObjectElement_get_width(objelem, &v);
1656     ok(hres == S_OK, "get_width failed: %08x\n", hres);
1657     ok(V_VT(&v) == VT_BSTR, "V_VT(width) = %d\n", V_VT(&v));
1658     ok(!strcmp_wa(V_BSTR(&v), "300"), "V_BSTR(width) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
1659     VariantClear(&v);
1660
1661     hres = IHTMLObjectElement_get_height(objelem, &v);
1662     ok(hres == S_OK, "get_height failed: %08x\n", hres);
1663     ok(V_VT(&v) == VT_BSTR, "V_VT(height) = %d\n", V_VT(&v));
1664     ok(!strcmp_wa(V_BSTR(&v), "200"), "V_BSTR(height) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
1665     VariantClear(&v);
1666
1667     V_VT(&v) = VT_I4;
1668     V_I4(&v) = 400;
1669     SET_EXPECT(OnAmbientPropertyChange_UNKNOWN);
1670     SET_EXPECT(Invoke_ENABLED);
1671     hres = IHTMLObjectElement_put_width(objelem, v);
1672     ok(hres == S_OK, "put_width failed: %08x\n", hres);
1673     CHECK_CALLED(OnAmbientPropertyChange_UNKNOWN);
1674     CLEAR_CALLED(Invoke_ENABLED); /* Not called on IE10 */
1675
1676     hres = IHTMLObjectElement_get_width(objelem, &v);
1677     ok(hres == S_OK, "get_width failed: %08x\n", hres);
1678     ok(V_VT(&v) == VT_BSTR, "V_VT(width) = %d\n", V_VT(&v));
1679     ok(!strcmp_wa(V_BSTR(&v), "400"), "V_BSTR(width) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
1680     VariantClear(&v);
1681
1682     V_VT(&v) = VT_I4;
1683     V_I4(&v) = 250;
1684     SET_EXPECT(OnAmbientPropertyChange_UNKNOWN);
1685     SET_EXPECT(Invoke_ENABLED);
1686     hres = IHTMLObjectElement_put_height(objelem, v);
1687     ok(hres == S_OK, "put_height failed: %08x\n", hres);
1688     CHECK_CALLED(OnAmbientPropertyChange_UNKNOWN);
1689     CLEAR_CALLED(Invoke_ENABLED); /* Not called on IE10 */
1690
1691     hres = IHTMLObjectElement_get_height(objelem, &v);
1692     ok(hres == S_OK, "get_height failed: %08x\n", hres);
1693     ok(V_VT(&v) == VT_BSTR, "V_VT(height) = %d\n", V_VT(&v));
1694     ok(!strcmp_wa(V_BSTR(&v), "250"), "V_BSTR(height) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
1695     VariantClear(&v);
1696
1697     IHTMLObjectElement_Release(objelem);
1698 }
1699
1700 static void test_container(IHTMLDocument2 *doc_obj)
1701 {
1702     IHTMLWindow2 *parent_window, *html_window;
1703     IServiceProvider *serv_prov;
1704     IOleContainer *container;
1705     IHTMLDocument2 *doc;
1706     IUnknown *unk;
1707     HRESULT hres;
1708
1709     container = NULL;
1710     hres = IOleClientSite_GetContainer(client_site, &container);
1711     ok(hres == S_OK, "GetContainer failed: %08x\n", hres);
1712     ok(container != NULL, "container == NULL\n");
1713
1714     hres = IHTMLDocument2_get_parentWindow(doc_obj, &parent_window);
1715     ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
1716     ok(parent_window != NULL, "parentWindow == NULL\n");
1717
1718     hres = IHTMLWindow2_get_document(parent_window, &doc);
1719     ok(hres == S_OK, "get_document failed: %08x\n", hres);
1720     ok(doc != NULL, "doc == NULL\n");
1721     ok(iface_cmp((IUnknown*)doc, (IUnknown*)container), "container != doc\n");
1722     IHTMLDocument2_Release(doc);
1723
1724     hres = IOleClientSite_QueryInterface(client_site, &IID_IServiceProvider, (void**)&serv_prov);
1725     ok(hres == S_OK, "Could not get IServiceProvider iface: %08x\n", hres);
1726
1727     hres = IServiceProvider_QueryService(serv_prov, &IID_IHTMLWindow2, &IID_IHTMLWindow2, (void**)&html_window);
1728     ok(hres == S_OK, "Could not get IHTMLWindow2 service: %08x\n", hres);
1729     todo_wine
1730     ok(!iface_cmp((IUnknown*)html_window, (IUnknown*)parent_window), "html_window != parent_window\n");
1731     IHTMLWindow2_Release(html_window);
1732
1733     SET_EXPECT(QueryService_TestActiveX);
1734     hres = IServiceProvider_QueryService(serv_prov, &CLSID_TestActiveX, &IID_IUnknown, (void**)&unk);
1735     ok(hres == S_OK, "QueryService(CLSID_TestActiveX) failed: %08x\n", hres);
1736     ok(unk == (IUnknown*)&OleObject, "unexpected unk %p\n", unk);
1737     CHECK_CALLED(QueryService_TestActiveX);
1738     IUnknown_Release(unk);
1739
1740     IServiceProvider_Release(serv_prov);
1741
1742     IHTMLWindow2_Release(parent_window);
1743     IOleContainer_Release(container);
1744 }
1745
1746 static void test_ui_activate(void)
1747 {
1748     IOleInPlaceSite *ip_site;
1749     HRESULT hres;
1750
1751     hres = IOleClientSite_QueryInterface(client_site, &IID_IOleInPlaceSite, (void**)&ip_site);
1752     ok(hres == S_OK, "Could not get IOleInPlaceSite iface: %08x\n", hres);
1753
1754     SET_EXPECT(Invoke_ENABLED);
1755     hres = IOleInPlaceSite_OnUIActivate(ip_site);
1756     ok(hres == S_OK, "OnUIActivate failed: %08x\n", hres);
1757     CLEAR_CALLED(Invoke_ENABLED); /* Not called on IE10 */
1758
1759     IOleInPlaceSite_Release(ip_site);
1760 }
1761
1762 static HRESULT cs_qi(REFIID,void **);
1763 static IOleDocumentView *view;
1764
1765 static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
1766 {
1767     static const GUID undocumented_frame_iid = {0xfbece6c9,0x48d7,0x4a37,{0x8f,0xe3,0x6a,0xd4,0x27,0x2f,0xdd,0xac}};
1768
1769     if(!IsEqualGUID(&undocumented_frame_iid, riid))
1770         ok(0, "unexpected riid %s\n", wine_dbgstr_guid(riid));
1771
1772     *ppv = NULL;
1773     return E_NOINTERFACE;
1774 }
1775
1776 static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface)
1777 {
1778     return 2;
1779 }
1780
1781 static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface)
1782 {
1783     return 1;
1784 }
1785
1786 static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
1787 {
1788     return E_NOTIMPL;
1789 }
1790
1791 static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
1792 {
1793     return E_NOTIMPL;
1794 }
1795
1796 static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
1797 {
1798     return E_NOTIMPL;
1799 }
1800
1801 static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface,
1802         LPCBORDERWIDTHS pborderwidths)
1803 {
1804     return E_NOTIMPL;
1805 }
1806
1807 static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface,
1808         LPCBORDERWIDTHS pborderwidths)
1809 {
1810     return S_OK;
1811 }
1812
1813 static HRESULT WINAPI InPlaceUIWindow_SetActiveObject(IOleInPlaceFrame *iface,
1814         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1815 {
1816     return S_OK;
1817 }
1818
1819 static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
1820         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1821 {
1822     return S_OK;
1823 }
1824
1825 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
1826         LPOLEMENUGROUPWIDTHS lpMenuWidths)
1827 {
1828     return E_NOTIMPL;
1829 }
1830
1831 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
1832         HOLEMENU holemenu, HWND hwndActiveObject)
1833 {
1834     ok(0, "unexpected call\n");
1835     return E_NOTIMPL;
1836 }
1837
1838 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
1839 {
1840     ok(0, "unexpected call\n");
1841     return E_NOTIMPL;
1842 }
1843
1844 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
1845 {
1846     return S_OK;
1847 }
1848
1849 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
1850 {
1851     return E_NOTIMPL;
1852 }
1853
1854 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
1855 {
1856     ok(0, "unexpected call\n");
1857     return E_NOTIMPL;
1858 }
1859
1860 static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
1861     InPlaceFrame_QueryInterface,
1862     InPlaceFrame_AddRef,
1863     InPlaceFrame_Release,
1864     InPlaceFrame_GetWindow,
1865     InPlaceFrame_ContextSensitiveHelp,
1866     InPlaceFrame_GetBorder,
1867     InPlaceFrame_RequestBorderSpace,
1868     InPlaceFrame_SetBorderSpace,
1869     InPlaceFrame_SetActiveObject,
1870     InPlaceFrame_InsertMenus,
1871     InPlaceFrame_SetMenu,
1872     InPlaceFrame_RemoveMenus,
1873     InPlaceFrame_SetStatusText,
1874     InPlaceFrame_EnableModeless,
1875     InPlaceFrame_TranslateAccelerator
1876 };
1877
1878 static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
1879
1880 static const IOleInPlaceFrameVtbl InPlaceUIWindowVtbl = {
1881     InPlaceFrame_QueryInterface,
1882     InPlaceFrame_AddRef,
1883     InPlaceFrame_Release,
1884     InPlaceFrame_GetWindow,
1885     InPlaceFrame_ContextSensitiveHelp,
1886     InPlaceFrame_GetBorder,
1887     InPlaceFrame_RequestBorderSpace,
1888     InPlaceFrame_SetBorderSpace,
1889     InPlaceUIWindow_SetActiveObject,
1890 };
1891
1892 static IOleInPlaceFrame InPlaceUIWindow = { &InPlaceUIWindowVtbl };
1893
1894 static HRESULT WINAPI InPlaceSite_QueryInterface(IOleInPlaceSite *iface, REFIID riid, void **ppv)
1895 {
1896     return cs_qi(riid, ppv);
1897 }
1898
1899 static ULONG WINAPI InPlaceSite_AddRef(IOleInPlaceSite *iface)
1900 {
1901     return 2;
1902 }
1903
1904 static ULONG WINAPI InPlaceSite_Release(IOleInPlaceSite *iface)
1905 {
1906     return 1;
1907 }
1908
1909 static HRESULT WINAPI InPlaceSite_GetWindow(IOleInPlaceSite *iface, HWND *phwnd)
1910 {
1911     *phwnd = container_hwnd;
1912     return S_OK;
1913 }
1914
1915 static HRESULT WINAPI InPlaceSite_ContextSensitiveHelp(IOleInPlaceSite *iface, BOOL fEnterMode)
1916 {
1917     ok(0, "unexpected call\n");
1918     return E_NOTIMPL;
1919 }
1920
1921 static HRESULT WINAPI InPlaceSite_CanInPlaceActivate(IOleInPlaceSite *iface)
1922 {
1923     return S_OK;
1924 }
1925
1926 static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSite *iface)
1927 {
1928     return S_OK;
1929 }
1930
1931 static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSite *iface)
1932 {
1933     return S_OK;
1934 }
1935
1936 static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSite *iface,
1937         IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
1938         LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
1939 {
1940     static const RECT rect = {0,0,500,500};
1941
1942     *ppFrame = &InPlaceFrame;
1943     *ppDoc = (IOleInPlaceUIWindow*)&InPlaceUIWindow;
1944     *lprcPosRect = rect;
1945     *lprcClipRect = rect;
1946
1947     lpFrameInfo->fMDIApp = FALSE;
1948     lpFrameInfo->hwndFrame = container_hwnd;
1949     lpFrameInfo->haccel = NULL;
1950     lpFrameInfo->cAccelEntries = 0;
1951
1952     return S_OK;
1953 }
1954
1955 static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSite *iface, SIZE scrollExtant)
1956 {
1957     return E_NOTIMPL;
1958 }
1959
1960 static HRESULT WINAPI InPlaceSite_OnUIDeactivate(IOleInPlaceSite *iface, BOOL fUndoable)
1961 {
1962     return S_OK;
1963 }
1964
1965 static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivate(IOleInPlaceSite *iface)
1966 {
1967     return S_OK;
1968 }
1969
1970 static HRESULT WINAPI InPlaceSite_DiscardUndoState(IOleInPlaceSite *iface)
1971 {
1972     return E_NOTIMPL;
1973 }
1974
1975 static HRESULT WINAPI InPlaceSite_DeactivateAndUndo(IOleInPlaceSite *iface)
1976 {
1977     return E_NOTIMPL;
1978 }
1979
1980 static HRESULT WINAPI InPlaceSite_OnPosRectChange(IOleInPlaceSite *iface, LPCRECT lprcPosRect)
1981 {
1982     return E_NOTIMPL;
1983 }
1984
1985 static const IOleInPlaceSiteVtbl InPlaceSiteVtbl = {
1986     InPlaceSite_QueryInterface,
1987     InPlaceSite_AddRef,
1988     InPlaceSite_Release,
1989     InPlaceSite_GetWindow,
1990     InPlaceSite_ContextSensitiveHelp,
1991     InPlaceSite_CanInPlaceActivate,
1992     InPlaceSite_OnInPlaceActivate,
1993     InPlaceSite_OnUIActivate,
1994     InPlaceSite_GetWindowContext,
1995     InPlaceSite_Scroll,
1996     InPlaceSite_OnUIDeactivate,
1997     InPlaceSite_OnInPlaceDeactivate,
1998     InPlaceSite_DiscardUndoState,
1999     InPlaceSite_DeactivateAndUndo,
2000     InPlaceSite_OnPosRectChange,
2001 };
2002
2003 static IOleInPlaceSite InPlaceSite = { &InPlaceSiteVtbl };
2004
2005 static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
2006 {
2007     return cs_qi(riid, ppv);
2008 }
2009
2010 static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
2011 {
2012     return 2;
2013 }
2014
2015 static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
2016 {
2017     return 1;
2018 }
2019
2020 static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
2021 {
2022     ok(0, "unexpected call\n");
2023     return E_NOTIMPL;
2024 }
2025
2026 static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker,
2027         IMoniker **ppmon)
2028 {
2029     ok(0, "unexpected call\n");
2030     return E_NOTIMPL;
2031 }
2032
2033 static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
2034 {
2035     return E_NOTIMPL;
2036 }
2037
2038 static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
2039 {
2040     ok(0, "unexpected call\n");
2041     return E_NOTIMPL;
2042 }
2043
2044 static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
2045 {
2046     ok(0, "unexpected call\n");
2047     return E_NOTIMPL;
2048 }
2049
2050 static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
2051 {
2052     ok(0, "unexpected call\n");
2053     return E_NOTIMPL;
2054 }
2055
2056 static const IOleClientSiteVtbl ClientSiteVtbl = {
2057     ClientSite_QueryInterface,
2058     ClientSite_AddRef,
2059     ClientSite_Release,
2060     ClientSite_SaveObject,
2061     ClientSite_GetMoniker,
2062     ClientSite_GetContainer,
2063     ClientSite_ShowObject,
2064     ClientSite_OnShowWindow,
2065     ClientSite_RequestNewObjectLayout
2066 };
2067
2068 static IOleClientSite ClientSite = { &ClientSiteVtbl };
2069
2070 static HRESULT WINAPI DocumentSite_QueryInterface(IOleDocumentSite *iface, REFIID riid, void **ppv)
2071 {
2072     return cs_qi(riid, ppv);
2073 }
2074
2075 static ULONG WINAPI DocumentSite_AddRef(IOleDocumentSite *iface)
2076 {
2077     return 2;
2078 }
2079
2080 static ULONG WINAPI DocumentSite_Release(IOleDocumentSite *iface)
2081 {
2082     return 1;
2083 }
2084
2085 static HRESULT WINAPI DocumentSite_ActivateMe(IOleDocumentSite *iface, IOleDocumentView *pViewToActivate)
2086 {
2087     RECT rect = {0,0,400,500};
2088     IOleDocument *document;
2089     HRESULT hres;
2090
2091     hres = IOleDocumentView_QueryInterface(pViewToActivate, &IID_IOleDocument, (void**)&document);
2092     ok(hres == S_OK, "could not get IOleDocument: %08x\n", hres);
2093
2094     hres = IOleDocument_CreateView(document, &InPlaceSite, NULL, 0, &view);
2095     IOleDocument_Release(document);
2096     ok(hres == S_OK, "CreateView failed: %08x\n", hres);
2097
2098     hres = IOleDocumentView_SetInPlaceSite(view, &InPlaceSite);
2099     ok(hres == S_OK, "SetInPlaceSite failed: %08x\n", hres);
2100
2101     hres = IOleDocumentView_UIActivate(view, TRUE);
2102     ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
2103
2104     hres = IOleDocumentView_SetRect(view, &rect);
2105     ok(hres == S_OK, "SetRect failed: %08x\n", hres);
2106
2107     hres = IOleDocumentView_Show(view, TRUE);
2108     ok(hres == S_OK, "Show failed: %08x\n", hres);
2109
2110     return S_OK;
2111 }
2112
2113 static const IOleDocumentSiteVtbl DocumentSiteVtbl = {
2114     DocumentSite_QueryInterface,
2115     DocumentSite_AddRef,
2116     DocumentSite_Release,
2117     DocumentSite_ActivateMe
2118 };
2119
2120 static IOleDocumentSite DocumentSite = { &DocumentSiteVtbl };
2121
2122 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface,
2123                                                      REFIID riid, void **ppv)
2124 {
2125     return cs_qi(riid, ppv);
2126 }
2127
2128 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
2129 {
2130     return 2;
2131 }
2132
2133 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
2134 {
2135     return 1;
2136 }
2137
2138 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService,
2139         REFIID riid, void **ppv)
2140 {
2141     if(IsEqualGUID(&CLSID_TestActiveX, guidService)) {
2142         CHECK_EXPECT(QueryService_TestActiveX);
2143         ok(IsEqualGUID(&IID_IUnknown, riid), "unexpected riid %s\n", wine_dbgstr_guid(riid));
2144         *ppv = &OleObject;
2145         return S_OK;
2146     }
2147
2148     *ppv = NULL;
2149     return E_NOINTERFACE;
2150 }
2151
2152 static const IServiceProviderVtbl ServiceProviderVtbl = {
2153     ServiceProvider_QueryInterface,
2154     ServiceProvider_AddRef,
2155     ServiceProvider_Release,
2156     ServiceProvider_QueryService
2157 };
2158
2159 static IServiceProvider ServiceProvider = { &ServiceProviderVtbl };
2160
2161 static HRESULT cs_qi(REFIID riid, void **ppv)
2162 {
2163     *ppv = NULL;
2164
2165     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IOleClientSite, riid))
2166         *ppv = &ClientSite;
2167     else if(IsEqualGUID(&IID_IOleDocumentSite, riid))
2168         *ppv = &DocumentSite;
2169     else if(IsEqualGUID(&IID_IOleWindow, riid) || IsEqualGUID(&IID_IOleInPlaceSite, riid))
2170         *ppv = &InPlaceSite;
2171     else if(IsEqualGUID(riid, &IID_IServiceProvider))
2172         *ppv = &ServiceProvider;
2173
2174     return *ppv ? S_OK : E_NOINTERFACE;
2175 }
2176
2177 static IHTMLDocument2 *notif_doc;
2178 static BOOL doc_complete;
2179
2180 static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
2181         REFIID riid, void**ppv)
2182 {
2183     if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
2184         *ppv = iface;
2185         return S_OK;
2186     }
2187
2188     ok(0, "unexpected call\n");
2189     return E_NOINTERFACE;
2190 }
2191
2192 static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
2193 {
2194     return 2;
2195 }
2196
2197 static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
2198 {
2199     return 1;
2200 }
2201
2202 static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
2203 {
2204     if(dispID == DISPID_READYSTATE){
2205         BSTR state;
2206         HRESULT hres;
2207
2208         static const WCHAR completeW[] = {'c','o','m','p','l','e','t','e',0};
2209
2210         hres = IHTMLDocument2_get_readyState(notif_doc, &state);
2211         ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
2212
2213         if(!lstrcmpW(state, completeW))
2214             doc_complete = TRUE;
2215
2216         SysFreeString(state);
2217     }
2218
2219     return S_OK;
2220 }
2221
2222 static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
2223 {
2224     ok(0, "unexpected call\n");
2225     return E_NOTIMPL;
2226 }
2227
2228 static IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
2229     PropertyNotifySink_QueryInterface,
2230     PropertyNotifySink_AddRef,
2231     PropertyNotifySink_Release,
2232     PropertyNotifySink_OnChanged,
2233     PropertyNotifySink_OnRequestEdit
2234 };
2235
2236 static IPropertyNotifySink PropertyNotifySink = { &PropertyNotifySinkVtbl };
2237
2238 static void doc_load_string(IHTMLDocument2 *doc, const char *str)
2239 {
2240     IPersistStreamInit *init;
2241     IStream *stream;
2242     HGLOBAL mem;
2243     SIZE_T len;
2244
2245     notif_doc = doc;
2246
2247     doc_complete = FALSE;
2248     len = strlen(str);
2249     mem = GlobalAlloc(0, len);
2250     memcpy(mem, str, len);
2251     CreateStreamOnHGlobal(mem, TRUE, &stream);
2252
2253     IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&init);
2254
2255     IPersistStreamInit_Load(init, stream);
2256     IPersistStreamInit_Release(init);
2257     IStream_Release(stream);
2258 }
2259
2260 static void do_advise(IUnknown *unk, REFIID riid, IUnknown *unk_advise)
2261 {
2262     IConnectionPointContainer *container;
2263     IConnectionPoint *cp;
2264     DWORD cookie;
2265     HRESULT hres;
2266
2267     hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&container);
2268     ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08x\n", hres);
2269
2270     hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
2271     IConnectionPointContainer_Release(container);
2272     ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
2273
2274     hres = IConnectionPoint_Advise(cp, unk_advise, &cookie);
2275     IConnectionPoint_Release(cp);
2276     ok(hres == S_OK, "Advise failed: %08x\n", hres);
2277 }
2278
2279 static void set_client_site(IHTMLDocument2 *doc, BOOL set)
2280 {
2281     IOleObject *oleobj;
2282     HRESULT hres;
2283
2284     if(!set && view) {
2285         IOleDocumentView_Show(view, FALSE);
2286         IOleDocumentView_CloseView(view, 0);
2287         IOleDocumentView_SetInPlaceSite(view, NULL);
2288         IOleDocumentView_Release(view);
2289         view = NULL;
2290     }
2291
2292     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
2293     ok(hres == S_OK, "Could not et IOleObject: %08x\n", hres);
2294
2295     hres = IOleObject_SetClientSite(oleobj, set ? &ClientSite : NULL);
2296     ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
2297
2298     if(set) {
2299         IHlinkTarget *hlink;
2300
2301         hres = IOleObject_QueryInterface(oleobj, &IID_IHlinkTarget, (void**)&hlink);
2302         ok(hres == S_OK, "Could not get IHlinkTarget iface: %08x\n", hres);
2303
2304         hres = IHlinkTarget_Navigate(hlink, 0, NULL);
2305         ok(hres == S_OK, "Navgate failed: %08x\n", hres);
2306
2307         IHlinkTarget_Release(hlink);
2308     }
2309
2310     IOleObject_Release(oleobj);
2311 }
2312 static IHTMLDocument2 *create_document(void)
2313 {
2314     IHTMLDocument2 *doc;
2315     HRESULT hres;
2316
2317     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
2318             &IID_IHTMLDocument2, (void**)&doc);
2319     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
2320
2321     return doc;
2322 }
2323
2324 static IHTMLDocument2 *create_doc(const char *str)
2325 {
2326     IHTMLDocument2 *doc;
2327     MSG msg;
2328
2329     doc = create_document();
2330     set_client_site(doc, TRUE);
2331     doc_load_string(doc, str);
2332     do_advise((IUnknown*)doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
2333
2334     while(!doc_complete && GetMessageW(&msg, NULL, 0, 0)) {
2335         TranslateMessage(&msg);
2336         DispatchMessageW(&msg);
2337     }
2338
2339     return doc;
2340 }
2341
2342 static void release_doc(IHTMLDocument2 *doc)
2343 {
2344     ULONG ref;
2345
2346     set_client_site(doc, FALSE);
2347     ref = IHTMLDocument2_Release(doc);
2348     ok(!ref || broken(ref == 1) /* Vista */, "ref = %d\n", ref);
2349
2350     if(client_site) {
2351         IOleClientSite_Release(client_site);
2352         client_site = NULL;
2353     }
2354
2355     if(plugin_hwnd) {
2356         DestroyWindow(plugin_hwnd);
2357         plugin_hwnd = NULL;
2358     }
2359
2360     ok(!activex_refcnt, "activex_refcnt = %d\n", activex_refcnt);
2361 }
2362
2363 static void init_test(int behavior)
2364 {
2365     plugin_behavior = behavior;
2366
2367     activex_refcnt = 0;
2368     no_quickact = behavior == TEST_NOQUICKACT || behavior == TEST_DISPONLY;
2369 }
2370
2371 static void test_event_call(void)
2372 {
2373     VARIANT res, args[2];
2374     DISPPARAMS dp = {args};
2375     EXCEPINFO ei = {0};
2376     HRESULT hres;
2377
2378     V_VT(&res) = VT_EMPTY;
2379     hres = IDispatch_Invoke(sink_disp, 1, &IID_NULL, 0, DISPATCH_METHOD, &dp, &res, &ei, NULL);
2380     ok(hres == S_OK, "Invoke failed: %08x\n", hres);
2381     ok(V_VT(&res) == VT_I4 && V_I4(&res) == 6, "unexpected result\n");
2382
2383     V_VT(args) = VT_I4;
2384     V_I4(args) = 2;
2385     V_VT(args+1) = VT_I4;
2386     V_I4(args+1) = 3;
2387     dp.cArgs = 2;
2388     V_VT(&res) = VT_EMPTY;
2389     hres = IDispatch_Invoke(sink_disp, 2, &IID_NULL, 0, DISPATCH_METHOD, &dp, &res, &ei, NULL);
2390     ok(hres == S_OK, "Invoke failed: %08x\n", hres);
2391     ok(V_VT(&res) == VT_I4 && V_I4(&res) == 7, "unexpected result: %d\n", V_I4(&res));
2392
2393     V_VT(&res) = VT_ERROR;
2394     hres = IDispatch_Invoke(sink_disp, 10, &IID_NULL, 0, DISPATCH_METHOD, &dp, &res, &ei, NULL);
2395     ok(hres == S_OK, "Invoke failed: %08x\n", hres);
2396     ok(V_VT(&res) == VT_EMPTY, "V_VT(res) = %d\n", V_VT(&res));
2397 }
2398
2399 static void test_flash_ax(void)
2400 {
2401     IHTMLDocument2 *doc;
2402     IOleClientSite *cs;
2403
2404     init_test(TEST_FLASH);
2405
2406     SET_EXPECT(CreateInstance);
2407     SET_EXPECT(FreezeEvents_TRUE);
2408     SET_EXPECT(QuickActivate);
2409     SET_EXPECT(FreezeEvents_FALSE);
2410     SET_EXPECT(IPersistPropertyBag_Load);
2411     SET_EXPECT(Invoke_READYSTATE);
2412     SET_EXPECT(Invoke_SECURITYCTX);
2413     SET_EXPECT(Invoke_SCRIPTCALL);
2414     SET_EXPECT(SetExtent);
2415     SET_EXPECT(GetExtent);
2416     SET_EXPECT(DoVerb);
2417
2418     doc = create_doc(object_ax_str);
2419
2420     CHECK_CALLED(CreateInstance);
2421     todo_wine
2422     CHECK_CALLED(FreezeEvents_TRUE);
2423     CHECK_CALLED(QuickActivate);
2424     todo_wine
2425     CHECK_CALLED(FreezeEvents_FALSE);
2426     CHECK_CALLED(IPersistPropertyBag_Load);
2427     CHECK_CALLED(Invoke_READYSTATE);
2428     CHECK_CALLED(Invoke_SECURITYCTX);
2429     CHECK_CALLED(Invoke_SCRIPTCALL);
2430     todo_wine
2431     CHECK_CALLED(SetExtent);
2432     todo_wine
2433     CHECK_CALLED(GetExtent);
2434     CHECK_CALLED(DoVerb);
2435
2436     /* Set in DoVerb */
2437     CHECK_CALLED(InPlaceObject_GetWindow);
2438     CHECK_CALLED(SetObjectRects);
2439     if (winetest_interactive)
2440     {
2441         test_ui_activate();
2442         test_container(notif_doc);
2443         test_object_elem(notif_doc);
2444     }
2445     else
2446     {
2447         skip("Skipping test_ui_activate(). ROSTESTS-114.\n");
2448         skip("Skipping test_container(notif_doc). ROSTESTS-114.\n");
2449         skip("Skipping test_object_elem(notif_doc). ROSTESTS-114.\n");
2450     }
2451
2452     IOleClientSite_AddRef(client_site);
2453     cs = client_site;
2454
2455     SET_EXPECT(UIDeactivate);
2456     SET_EXPECT(Invoke_ENABLED);
2457     SET_EXPECT(Invoke_VALID);
2458     SET_EXPECT(InPlaceDeactivate);
2459     SET_EXPECT(Close);
2460     SET_EXPECT(SetClientSite_NULL);
2461     release_doc(doc);
2462     CHECK_CALLED(UIDeactivate);
2463     CLEAR_CALLED(Invoke_ENABLED); /* Not called on IE10 */
2464     todo_wine
2465     CHECK_CALLED(Invoke_VALID);
2466     CHECK_CALLED(InPlaceDeactivate);
2467     CHECK_CALLED(Close);
2468     CHECK_CALLED(SetClientSite_NULL);
2469
2470     IOleClientSite_Release(cs);
2471 }
2472
2473 static void test_noquickact_ax(void)
2474 {
2475     IHTMLDocument2 *doc;
2476
2477     init_test(TEST_NOQUICKACT);
2478
2479     SET_EXPECT(CreateInstance);
2480     SET_EXPECT(FreezeEvents_TRUE);
2481     SET_EXPECT(GetMiscStatus);
2482     SET_EXPECT(SetClientSite);
2483     SET_EXPECT(SetAdvise);
2484     SET_EXPECT(GetViewStatus);
2485     SET_EXPECT(FreezeEvents_FALSE);
2486     SET_EXPECT(Invoke_READYSTATE);
2487     SET_EXPECT(Invoke_SECURITYCTX);
2488     SET_EXPECT(Invoke_SCRIPTCALL);
2489     SET_EXPECT(SetExtent);
2490     SET_EXPECT(GetExtent);
2491     SET_EXPECT(DoVerb);
2492
2493     doc = create_doc(object_ax_str);
2494
2495     CHECK_CALLED(CreateInstance);
2496     todo_wine CHECK_CALLED(FreezeEvents_TRUE);
2497     CHECK_CALLED(GetMiscStatus);
2498     CHECK_CALLED(SetClientSite);
2499     CHECK_CALLED(SetAdvise);
2500     CHECK_CALLED(GetViewStatus);
2501     todo_wine CHECK_CALLED(FreezeEvents_FALSE);
2502     CHECK_CALLED(Invoke_READYSTATE);
2503     CHECK_CALLED(Invoke_SECURITYCTX);
2504     CHECK_CALLED(Invoke_SCRIPTCALL);
2505     todo_wine CHECK_CALLED(SetExtent);
2506     todo_wine CHECK_CALLED(GetExtent);
2507     CHECK_CALLED(DoVerb);
2508
2509     /* Set in DoVerb */
2510     CHECK_CALLED(InPlaceObject_GetWindow);
2511     CHECK_CALLED(SetObjectRects);
2512
2513     SET_EXPECT(InPlaceDeactivate);
2514     SET_EXPECT(Close);
2515     SET_EXPECT(SetClientSite_NULL);
2516     release_doc(doc);
2517     CHECK_CALLED(InPlaceDeactivate);
2518     CHECK_CALLED(Close);
2519     CHECK_CALLED(SetClientSite_NULL);
2520 }
2521
2522 static void test_event_binding(void)
2523 {
2524     IHTMLDocument2 *doc;
2525
2526     init_test(TEST_FLASH);
2527
2528     SET_EXPECT(CreateInstance);
2529     SET_EXPECT(FreezeEvents_TRUE);
2530     SET_EXPECT(QuickActivate);
2531     SET_EXPECT(FreezeEvents_FALSE);
2532     SET_EXPECT(IPersistPropertyBag_Load);
2533     SET_EXPECT(Invoke_READYSTATE);
2534     SET_EXPECT(SetExtent);
2535     SET_EXPECT(GetExtent);
2536     SET_EXPECT(DoVerb);
2537
2538     SET_EXPECT(GetClassInfo);
2539     SET_EXPECT(OnAmbientPropertyChange_UNKNOWN);
2540     SET_EXPECT(FindConnectionPoint);
2541     SET_EXPECT(Advise);
2542
2543     doc = create_doc(event_binding_str);
2544
2545     CHECK_CALLED(CreateInstance);
2546     todo_wine
2547     CHECK_CALLED(FreezeEvents_TRUE);
2548     CHECK_CALLED(QuickActivate);
2549     todo_wine
2550     CHECK_CALLED(FreezeEvents_FALSE);
2551     CHECK_CALLED(IPersistPropertyBag_Load);
2552     CHECK_CALLED(Invoke_READYSTATE);
2553     todo_wine
2554     CHECK_CALLED(SetExtent);
2555     todo_wine
2556     CHECK_CALLED(GetExtent);
2557     CHECK_CALLED(DoVerb);
2558
2559     /* Set in DoVerb */
2560     CHECK_CALLED(InPlaceObject_GetWindow);
2561     CHECK_CALLED(SetObjectRects);
2562
2563     CHECK_CALLED(GetClassInfo);
2564     todo_wine
2565     CHECK_CALLED(OnAmbientPropertyChange_UNKNOWN);
2566     CHECK_CALLED(FindConnectionPoint);
2567     CHECK_CALLED(Advise);
2568
2569     if (winetest_interactive)
2570         test_event_call();
2571     else
2572         skip("Skipping test_event_call(). ROSTESTS-114.\n");
2573
2574     SET_EXPECT(InPlaceDeactivate);
2575     SET_EXPECT(Close);
2576     SET_EXPECT(SetClientSite_NULL);
2577     SET_EXPECT(FindConnectionPoint);
2578     SET_EXPECT(Unadvise);
2579     release_doc(doc);
2580     CHECK_CALLED(InPlaceDeactivate);
2581     CHECK_CALLED(Close);
2582     CHECK_CALLED(SetClientSite_NULL);
2583     CHECK_CALLED(FindConnectionPoint);
2584     CHECK_CALLED(Unadvise);
2585 }
2586
2587 static void test_nooleobj_ax(void)
2588 {
2589     IHTMLDocument2 *doc;
2590
2591     init_test(TEST_DISPONLY);
2592
2593     SET_EXPECT(CreateInstance);
2594     SET_EXPECT(Invoke_READYSTATE);
2595     SET_EXPECT(Invoke_SECURITYCTX);
2596     SET_EXPECT(Invoke_SCRIPTCALL);
2597
2598     doc = create_doc(object_ax_str);
2599
2600     CHECK_CALLED(CreateInstance);
2601     CHECK_CALLED(Invoke_READYSTATE);
2602     CHECK_CALLED(Invoke_SECURITYCTX);
2603     CHECK_CALLED(Invoke_SCRIPTCALL);
2604
2605     release_doc(doc);
2606 }
2607
2608 static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
2609 {
2610     return DefWindowProcW(hwnd, msg, wParam, lParam);
2611 }
2612
2613 static HWND create_container_window(void)
2614 {
2615     static const WCHAR html_document_testW[] =
2616         {'H','T','M','L','D','o','c','u','m','e','n','t','T','e','s','t',0};
2617     static WNDCLASSEXW wndclass = {
2618         sizeof(WNDCLASSEXW),
2619         0,
2620         wnd_proc,
2621         0, 0, NULL, NULL, NULL, NULL, NULL,
2622         html_document_testW,
2623         NULL
2624     };
2625
2626     RegisterClassExW(&wndclass);
2627     return CreateWindowW(html_document_testW, html_document_testW,
2628             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
2629             515, 530, NULL, NULL, NULL, NULL);
2630 }
2631
2632 static void load_typelib(void)
2633 {
2634     WCHAR path[MAX_PATH];
2635     ITypeLib *typelib;
2636     HRESULT hres;
2637
2638     GetModuleFileNameW(NULL, path, MAX_PATH);
2639
2640     hres = LoadTypeLib(path, &typelib);
2641     ok(hres == S_OK, "LoadTypeLib failed: %08x\n", hres);
2642
2643     hres = ITypeLib_GetTypeInfoOfGuid(typelib, &DIID_DispActiveXTest, &actxtest_typeinfo);
2644     ok(hres == S_OK, "GetTypeInfoOfGuid(DIID_DispActiveXTest) failed: %08x\n", hres);
2645
2646     hres = ITypeLib_GetTypeInfoOfGuid(typelib, &CLSID_ActiveXTest, &class_typeinfo);
2647     ok(hres == S_OK, "GetTypeInfoOfGuid(CLSID_ActiveXTest) failed: %08x\n", hres);
2648
2649     ITypeLib_Release(typelib);
2650 }
2651
2652 static BOOL init_key(const char *key_name, const char *def_value, BOOL init)
2653 {
2654     HKEY hkey;
2655     DWORD res;
2656
2657     if(!init) {
2658         RegDeleteKeyA(HKEY_CLASSES_ROOT, key_name);
2659         return TRUE;
2660     }
2661
2662     res = RegCreateKeyA(HKEY_CLASSES_ROOT, key_name, &hkey);
2663     if(res != ERROR_SUCCESS)
2664         return FALSE;
2665
2666     if(def_value)
2667         res = RegSetValueA(hkey, NULL, REG_SZ, def_value, strlen(def_value));
2668
2669     RegCloseKey(hkey);
2670
2671     return res == ERROR_SUCCESS;
2672 }
2673
2674 static BOOL init_registry(BOOL init)
2675 {
2676     return init_key("TestActiveX\\CLSID", TESTACTIVEX_CLSID, init)
2677         && init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95801-9882-11cf-9fa9-00aa006c42c4}",
2678                     NULL, init)
2679         && init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95802-9882-11cf-9fa9-00aa006c42c4}",
2680                     NULL, init);
2681 }
2682
2683 static BOOL register_activex(void)
2684 {
2685     DWORD regid;
2686     HRESULT hres;
2687
2688     if(!init_registry(TRUE)) {
2689         init_registry(FALSE);
2690         return FALSE;
2691     }
2692
2693     hres = CoRegisterClassObject(&CLSID_TestActiveX, (IUnknown*)&activex_cf,
2694             CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
2695     ok(hres == S_OK, "Could not register control: %08x\n", hres);
2696
2697     return TRUE;
2698 }
2699
2700 static BOOL check_ie(void)
2701 {
2702     IHTMLDocument5 *doc;
2703     HRESULT hres;
2704
2705     static const WCHAR xW[] = {'x',0};
2706     static const WCHAR yW[] = {'y',0};
2707
2708     if(!lstrcmpW(xW, yW))
2709         return FALSE;
2710
2711     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
2712             &IID_IHTMLDocument5, (void**)&doc);
2713     if(FAILED(hres))
2714         return FALSE;
2715
2716     IHTMLDocument5_Release(doc);
2717     return TRUE;
2718 }
2719
2720 START_TEST(activex)
2721 {
2722     CoInitialize(NULL);
2723
2724     if(!check_ie()) {
2725         CoUninitialize();
2726         win_skip("Too old IE\n");
2727         return;
2728     }
2729
2730     if(is_ie_hardened()) {
2731         CoUninitialize();
2732         win_skip("IE running in Enhanced Security Configuration\n");
2733         return;
2734     }
2735
2736     init_wrapped_iface();
2737     load_typelib();
2738     container_hwnd = create_container_window();
2739     ShowWindow(container_hwnd, SW_SHOW);
2740
2741     if(register_activex()) {
2742         trace("Testing emulated flash embedding...\n");
2743         test_flash_ax();
2744         trace("Testing plugin without IQuickActivate iface...\n");
2745         test_noquickact_ax();
2746         trace("Testing plugin with IDispatch iface only...\n");
2747         test_nooleobj_ax();
2748         trace("Testing event object binding...\n");
2749         test_event_binding();
2750         init_registry(FALSE);
2751     }else {
2752         skip("Could not register ActiveX\n");
2753     }
2754
2755     if(actxtest_typeinfo)
2756         ITypeInfo_Release(actxtest_typeinfo);
2757     if(class_typeinfo)
2758         ITypeInfo_Release(class_typeinfo);
2759     DestroyWindow(container_hwnd);
2760     CoUninitialize();
2761 }