git.oblomov.eu Git - wine/blob - dlls/mshtml/tests/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 #define DEFINE_EXPECT(func) \
  40     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  41
  42 #define SET_EXPECT(func) \
  43     do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)
  44
  45 #define CHECK_EXPECT2(func) \
  46     do { \
  47         ok(expect_ ##func, "unexpected call " #func "\n"); \
  48         called_ ## func = TRUE; \
  49     }while(0)
  50
  51 #define CHECK_EXPECT(func) \
  52     do { \
  53         CHECK_EXPECT2(func); \
  54         expect_ ## func = FALSE; \
  55     }while(0)
  56
  57 #define CHECK_CALLED(func) \
  58     do { \
  59         ok(called_ ## func, "expected " #func "\n"); \
  60         expect_ ## func = called_ ## func = FALSE; \
  61     }while(0)
  62
  63 DEFINE_EXPECT(CreateInstance);
  64 DEFINE_EXPECT(FreezeEvents_TRUE);
  65 DEFINE_EXPECT(FreezeEvents_FALSE);
  66 DEFINE_EXPECT(QuickActivate);
  67 DEFINE_EXPECT(IPersistPropertyBag_InitNew);
  68 DEFINE_EXPECT(IPersistPropertyBag_Load);
  69 DEFINE_EXPECT(Invoke_READYSTATE);
  70 DEFINE_EXPECT(Invoke_ENABLED);
  71 DEFINE_EXPECT(Invoke_VALID);
  72 DEFINE_EXPECT(Invoke_SECURITYCTX);
  73 DEFINE_EXPECT(Invoke_SCRIPTPROP);
  74 DEFINE_EXPECT(GetIDsOfNames_scriptprop);
  75 DEFINE_EXPECT(DoVerb);
  76 DEFINE_EXPECT(SetExtent);
  77 DEFINE_EXPECT(GetExtent);
  78 DEFINE_EXPECT(SetClientSite);
  79 DEFINE_EXPECT(SetClientSite_NULL);
  80 DEFINE_EXPECT(Close);
  81 DEFINE_EXPECT(InPlaceObject_GetWindow);
  82 DEFINE_EXPECT(SetObjectRects);
  83 DEFINE_EXPECT(InPlaceDeactivate);
  84 DEFINE_EXPECT(UIDeactivate);
  85 DEFINE_EXPECT(QueryService_TestActiveX);
  86
  87 #define DISPID_SCRIPTPROP 1000
  88
  89 static HWND container_hwnd, plugin_hwnd;
  90
  91 #define TESTACTIVEX_CLSID "{178fc163-f585-4e24-9c13-4bb7f6680746}"
  92
  93 static const GUID CLSID_TestActiveX =
  94     {0x178fc163,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xf6,0x68,0x07,0x46}};
  95
  96 static const char object_ax_str[] =
  97     "<html><head></head><body>"
  98     "<object classid=\"clsid:" TESTACTIVEX_CLSID "\" width=\"300\" height=\"200\" id=\"objid\">"
  99     "<param name=\"param_name\" value=\"param_value\">"
 100     "<param name=\"num_param\" value=\"3\">"
 101     "</object>"
 102     "</body></html>";
 103
 104 static const REFIID pluginhost_iids[] = {
 105     &IID_IOleClientSite,
 106     &IID_IAdviseSink,
 107     &IID_IAdviseSinkEx,
 108     &IID_IPropertyNotifySink,
 109     &IID_IDispatch,
 110     &IID_IOleWindow,
 111     &IID_IOleInPlaceSite,
 112     &IID_IOleInPlaceSiteEx,
 113     &IID_IOleControlSite,
 114     &IID_IBindHost,
 115     &IID_IServiceProvider,
 116     NULL
 117 };
 118
 119 static const char *debugstr_guid(REFIID riid)
 120 {
 121     static char buf[50];
 122
 123     sprintf(buf, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
 124             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
 125             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
 126             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
 127
 128     return buf;
 129 }
 130
 131 static BOOL iface_cmp(IUnknown *iface1, IUnknown *iface2)
 132 {
 133     IUnknown *unk1, *unk2;
 134
 135     if(iface1 == iface2)
 136         return TRUE;
 137
 138     IUnknown_QueryInterface(iface1, &IID_IUnknown, (void**)&unk1);
 139     IUnknown_Release(unk1);
 140     IUnknown_QueryInterface(iface2, &IID_IUnknown, (void**)&unk2);
 141     IUnknown_Release(unk2);
 142
 143     return unk1 == unk2;
 144 }
 145
 146 #define test_ifaces(i,ids) _test_ifaces(__LINE__,i,ids)
 147 static void _test_ifaces(unsigned line, IUnknown *iface, REFIID *iids)
 148 {
 149     const IID * const *piid;
 150     IUnknown *unk;
 151     HRESULT hres;
 152
 153      for(piid = iids; *piid; piid++) {
 154         hres = IDispatch_QueryInterface(iface, *piid, (void**)&unk);
 155         ok_(__FILE__,line) (hres == S_OK, "Could not get %s interface: %08x\n", debugstr_guid(*piid), hres);
 156         if(SUCCEEDED(hres))
 157             IUnknown_Release(unk);
 158     }
 159 }
 160
 161 static int strcmp_wa(LPCWSTR strw, const char *stra)
 162 {
 163     CHAR buf[512];
 164     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
 165     return lstrcmpA(stra, buf);
 166 }
 167
 168 static BSTR a2bstr(const char *str)
 169 {
 170     BSTR ret;
 171     int len;
 172
 173     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 174     ret = SysAllocStringLen(NULL, len);
 175     MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
 176
 177     return ret;
 178 }
 179
 180 static IOleClientSite *client_site;
 181 static READYSTATE plugin_readystate = READYSTATE_UNINITIALIZED;
 182
 183 static void set_plugin_readystate(READYSTATE state)
 184 {
 185     IPropertyNotifySink *prop_notif;
 186     HRESULT hres;
 187
 188     plugin_readystate = state;
 189
 190     hres = IOleClientSite_QueryInterface(client_site, &IID_IPropertyNotifySink, (void**)&prop_notif);
 191     ok(hres == S_OK, "Could not get IPropertyNotifySink iface: %08x\n", hres);
 192
 193     hres = IPropertyNotifySink_OnChanged(prop_notif, DISPID_READYSTATE);
 194     ok(hres == S_OK, "OnChanged(DISPID_READYSTATE) failed: %08x\n", hres);
 195
 196     IPropertyNotifySink_Release(prop_notif);
 197 }
 198
 199 static void test_mon_displayname(IMoniker *mon, const char *exname, const char *broken_name)
 200 {
 201     LPOLESTR display_name;
 202     DWORD mksys;
 203     HRESULT hres;
 204
 205     hres = IMoniker_GetDisplayName(mon, NULL, NULL, &display_name);
 206     ok(hres == S_OK, "GetDisplayName failed: %08x\n", hres);
 207     ok(!strcmp_wa(display_name, exname) || broken(broken_name && !strcmp_wa(display_name, broken_name)),
 208         "display_name = %s\n", wine_dbgstr_w(display_name));
 209     CoTaskMemFree(display_name);
 210
 211     hres = IMoniker_IsSystemMoniker(mon, &mksys);
 212     ok(hres == S_OK, "IsSystemMoniker failed: %08x\n", hres);
 213     ok(mksys == MKSYS_URLMONIKER, "mksys = %d\n", mksys);
 214 }
 215
 216 static LRESULT WINAPI plugin_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 217 {
 218     switch(msg) {
 219     case WM_PAINT: {
 220         PAINTSTRUCT ps;
 221         HBRUSH brush;
 222         RECT rect;
 223         HDC dc;
 224
 225         GetClientRect(hwnd, &rect);
 226
 227         dc = BeginPaint(hwnd, &ps);
 228         brush = CreateSolidBrush(RGB(255,0,0));
 229         SelectObject(dc, brush);
 230         Rectangle(dc, rect.left, rect.top, rect.right, rect.bottom);
 231         DeleteObject(brush);
 232         EndPaint(hwnd, &ps);
 233         break;
 234     }
 235     }
 236
 237     return DefWindowProc(hwnd, msg, wParam, lParam);
 238 }
 239
 240 static void create_plugin_window(HWND parent, const RECT *rect)
 241 {
 242     static const WCHAR plugin_testW[] =
 243         {'p','l','u','g','i','n',' ','t','e','s','t',0};
 244     static WNDCLASSEXW wndclass = {
 245         sizeof(WNDCLASSEXW),
 246         0,
 247         plugin_proc,
 248         0, 0, NULL, NULL, NULL, NULL, NULL,
 249         plugin_testW,
 250         NULL
 251     };
 252
 253     RegisterClassExW(&wndclass);
 254     plugin_hwnd = CreateWindowW(plugin_testW, plugin_testW,
 255             WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS|WS_CLIPCHILDREN, rect->left, rect->top,
 256             rect->right-rect->left, rect->bottom-rect->top, parent, NULL, NULL, NULL);
 257 }
 258
 259 static HRESULT ax_qi(REFIID,void**);
 260
 261 static HRESULT WINAPI OleControl_QueryInterface(IOleControl *iface, REFIID riid, void **ppv)
 262 {
 263     return ax_qi(riid, ppv);
 264 }
 265
 266 static ULONG WINAPI OleControl_AddRef(IOleControl *iface)
 267 {
 268     return 2;
 269 }
 270
 271 static ULONG WINAPI OleControl_Release(IOleControl *iface)
 272 {
 273     return 1;
 274 }
 275
 276 static HRESULT WINAPI OleControl_GetControlInfo(IOleControl *iface, CONTROLINFO *pCI)
 277 {
 278     ok(0, "unexpected call\n");
 279     return E_NOTIMPL;
 280 }
 281
 282 static HRESULT WINAPI OleControl_OnMnemonic(IOleControl *iface, MSG *mMsg)
 283 {
 284     ok(0, "unexpected call\n");
 285     return E_NOTIMPL;
 286 }
 287
 288 static HRESULT WINAPI OleControl_OnAmbientPropertyChange(IOleControl *iface, DISPID dispID)
 289 {
 290     ok(0, "unexpected call\n");
 291     return E_NOTIMPL;
 292 }
 293
 294 static HRESULT WINAPI OleControl_FreezeEvents(IOleControl *iface, BOOL bFreeze)
 295 {
 296     if(bFreeze)
 297         CHECK_EXPECT2(FreezeEvents_TRUE);
 298     else
 299         CHECK_EXPECT2(FreezeEvents_FALSE);
 300     return S_OK;
 301 }
 302
 303 static const IOleControlVtbl OleControlVtbl = {
 304     OleControl_QueryInterface,
 305     OleControl_AddRef,
 306     OleControl_Release,
 307     OleControl_GetControlInfo,
 308     OleControl_OnMnemonic,
 309     OleControl_OnAmbientPropertyChange,
 310     OleControl_FreezeEvents
 311 };
 312
 313 static IOleControl OleControl = { &OleControlVtbl };
 314
 315 static HRESULT WINAPI QuickActivate_QueryInterface(IQuickActivate *iface, REFIID riid, void **ppv)
 316 {
 317     return ax_qi(riid, ppv);
 318 }
 319
 320 static ULONG WINAPI QuickActivate_AddRef(IQuickActivate *iface)
 321 {
 322     return 2;
 323 }
 324
 325 static ULONG WINAPI QuickActivate_Release(IQuickActivate *iface)
 326 {
 327     return 1;
 328 }
 329
 330 static HRESULT WINAPI QuickActivate_QuickActivate(IQuickActivate *iface, QACONTAINER *container, QACONTROL *control)
 331 {
 332     CHECK_EXPECT(QuickActivate);
 333
 334     ok(container != NULL, "container == NULL\n");
 335     ok(container->cbSize == sizeof(*container), "container->cbSize = %d\n", container->cbSize);
 336     ok(container->pClientSite != NULL, "container->pClientSite == NULL\n");
 337     ok(container->pAdviseSink != NULL, "container->pAdviseSink == NULL\n");
 338     ok(container->pPropertyNotifySink != NULL, "container->pPropertyNotifySink == NULL\n");
 339     ok(!container->pUnkEventSink, "container->pUnkEventSink != NULL\n");
 340     ok(container->dwAmbientFlags == (QACONTAINER_SUPPORTSMNEMONICS|QACONTAINER_MESSAGEREFLECT|QACONTAINER_USERMODE),
 341        "container->dwAmbientFlags = %x\n", container->dwAmbientFlags);
 342     ok(!container->colorFore, "container->colorFore == 0\n"); /* FIXME */
 343     todo_wine
 344     ok(container->colorBack, "container->colorBack == 0\n"); /* FIXME */
 345     todo_wine
 346     ok(container->pFont != NULL, "container->pFont == NULL\n");
 347     todo_wine
 348     ok(container->pUndoMgr != NULL, "container->pUndoMgr == NULL\n");
 349     ok(!container->dwAppearance, "container->dwAppearance = %x\n", container->dwAppearance);
 350     ok(!container->lcid, "container->lcid = %x\n", container->lcid);
 351     ok(!container->hpal, "container->hpal = %p\n", container->hpal);
 352     ok(!container->pBindHost, "container->pBindHost != NULL\n");
 353     ok(!container->pOleControlSite, "container->pOleControlSite != NULL\n");
 354     ok(!container->pServiceProvider, "container->pServiceProvider != NULL\n");
 355
 356     ok(control->cbSize == sizeof(*control), "control->cbSize = %d\n", control->cbSize);
 357     ok(!control->dwMiscStatus, "control->dwMiscStatus = %x\n", control->dwMiscStatus);
 358     ok(!control->dwViewStatus, "control->dwViewStatus = %x\n", control->dwViewStatus);
 359     ok(!control->dwEventCookie, "control->dwEventCookie = %x\n", control->dwEventCookie);
 360     ok(!control->dwPropNotifyCookie, "control->dwPropNotifyCookie = %x\n", control->dwPropNotifyCookie);
 361     ok(!control->dwPointerActivationPolicy, "control->dwPointerActivationPolicy = %x\n", control->dwPointerActivationPolicy);
 362
 363     ok(iface_cmp((IUnknown*)container->pClientSite, (IUnknown*)container->pAdviseSink),
 364        "container->pClientSite != container->pAdviseSink\n");
 365     ok(iface_cmp((IUnknown*)container->pClientSite, (IUnknown*)container->pPropertyNotifySink),
 366        "container->pClientSite != container->pPropertyNotifySink\n");
 367     test_ifaces((IUnknown*)container->pClientSite, pluginhost_iids);
 368
 369     IOleClientSite_AddRef(container->pClientSite);
 370     client_site = container->pClientSite;
 371
 372     control->dwMiscStatus = OLEMISC_SETCLIENTSITEFIRST|OLEMISC_ACTIVATEWHENVISIBLE|OLEMISC_INSIDEOUT
 373         |OLEMISC_CANTLINKINSIDE|OLEMISC_RECOMPOSEONRESIZE;
 374     control->dwViewStatus = 0x18;
 375     control->dwPropNotifyCookie = 1;
 376
 377     return S_OK;
 378 }
 379
 380 static HRESULT WINAPI QuickActivate_SetContentExtent(IQuickActivate *iface, LPSIZEL pSizel)
 381 {
 382     ok(0, "unexpected call\n");
 383     return E_NOTIMPL;
 384 }
 385
 386 static HRESULT WINAPI QuickActivate_GetContentExtent(IQuickActivate *iface, LPSIZEL pSizel)
 387 {
 388     ok(0, "unexpected call\n");
 389     return E_NOTIMPL;
 390 }
 391
 392 static const IQuickActivateVtbl QuickActivateVtbl = {
 393     QuickActivate_QueryInterface,
 394     QuickActivate_AddRef,
 395     QuickActivate_Release,
 396     QuickActivate_QuickActivate,
 397     QuickActivate_GetContentExtent,
 398     QuickActivate_SetContentExtent
 399 };
 400
 401 static IQuickActivate QuickActivate = { &QuickActivateVtbl };
 402
 403 static HRESULT WINAPI PersistPropertyBag_QueryInterface(IPersistPropertyBag *iface, REFIID riid, void **ppv)
 404 {
 405     return ax_qi(riid, ppv);
 406 }
 407
 408 static ULONG WINAPI PersistPropertyBag_AddRef(IPersistPropertyBag *iface)
 409 {
 410     return 2;
 411 }
 412
 413 static ULONG WINAPI PersistPropertyBag_Release(IPersistPropertyBag *iface)
 414 {
 415     return 1;
 416 }
 417
 418 static HRESULT WINAPI PersistPropertyBag_GetClassID(IPersistPropertyBag *face, CLSID *pClassID)
 419 {
 420     ok(0, "unexpected call\n");
 421     return E_NOTIMPL;
 422 }
 423
 424 static HRESULT WINAPI PersistPropertyBag_InitNew(IPersistPropertyBag *face)
 425 {
 426     CHECK_EXPECT(IPersistPropertyBag_InitNew);
 427     return S_OK;
 428 }
 429
 430 static HRESULT WINAPI PersistPropertyBag_Load(IPersistPropertyBag *face, IPropertyBag *pPropBag, IErrorLog *pErrorLog)
 431 {
 432     IBindHost *bind_host, *bind_host2;
 433     IServiceProvider *sp;
 434     IMoniker *mon;
 435     VARIANT v;
 436     HRESULT hres;
 437
 438     static const WCHAR param_nameW[] = {'p','a','r','a','m','_','n','a','m','e',0};
 439     static const WCHAR num_paramW[] = {'n','u','m','_','p','a','r','a','m',0};
 440     static const WCHAR no_paramW[] = {'n','o','_','p','a','r','a','m',0};
 441     static WCHAR test_swfW[] = {'t','e','s','t','.','s','w','f',0};
 442
 443     static const IID *propbag_ifaces[] = {
 444         &IID_IPropertyBag,
 445         &IID_IPropertyBag2,
 446         NULL
 447     };
 448
 449     CHECK_EXPECT(IPersistPropertyBag_Load);
 450
 451     ok(pPropBag != NULL, "pPropBag == NULL\n");
 452     ok(!pErrorLog, "pErrorLog != NULL\n");
 453
 454     test_ifaces((IUnknown*)pPropBag, propbag_ifaces);
 455
 456     V_VT(&v) = VT_BSTR;
 457     hres = IPropertyBag_Read(pPropBag, param_nameW, &v, NULL);
 458     ok(hres == S_OK, "Read failed: %08x\n", hres);
 459     ok(V_VT(&v) == VT_BSTR, "V_VT(&v) = %d\n", V_VT(&v));
 460     ok(!strcmp_wa(V_BSTR(&v), "param_value"), "V_BSTR(v) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
 461
 462     V_VT(&v) = VT_I4;
 463     V_I4(&v) = 0xdeadbeef;
 464     hres = IPropertyBag_Read(pPropBag, param_nameW, &v, NULL);
 465     ok(hres == DISP_E_TYPEMISMATCH, "Read failed: %08x, expected DISP_E_TYPEMISMATCH\n", hres);
 466     ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
 467     ok(V_I4(&v) == 0xdeadbeef, "V_I4(v) = %x\n", V_I4(&v));
 468
 469     V_VT(&v) = VT_BSTR;
 470     hres = IPropertyBag_Read(pPropBag, num_paramW, &v, NULL);
 471     ok(hres == S_OK, "Read failed: %08x\n", hres);
 472     ok(V_VT(&v) == VT_BSTR, "V_VT(&v) = %d\n", V_VT(&v));
 473     ok(!strcmp_wa(V_BSTR(&v), "3"), "V_BSTR(v) = %s\n", wine_dbgstr_w(V_BSTR(&v)));
 474     SysFreeString(V_BSTR(&v));
 475
 476     V_VT(&v) = VT_I4;
 477     V_I4(&v) = 0xdeadbeef;
 478     hres = IPropertyBag_Read(pPropBag, num_paramW, &v, NULL);
 479     ok(hres == S_OK, "Read failed: %08x\n", hres);
 480     ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
 481     ok(V_I4(&v) == 3, "V_I4(v) = %x\n", V_I4(&v));
 482
 483     V_VT(&v) = VT_BSTR;
 484     V_BSTR(&v) = (BSTR)0xdeadbeef;
 485     hres = IPropertyBag_Read(pPropBag, no_paramW, &v, NULL);
 486     ok(hres == E_INVALIDARG, "Read failed: %08x\n", hres);
 487     ok(V_VT(&v) == VT_BSTR, "V_VT(&v) = %d\n", V_VT(&v));
 488     ok(V_BSTR(&v) == (BSTR)0xdeadbeef, "V_BSTR(v) = %p\n", V_BSTR(&v));
 489
 490     set_plugin_readystate(READYSTATE_INTERACTIVE);
 491
 492     hres = IOleClientSite_QueryInterface(client_site, &IID_IBindHost, (void**)&bind_host);
 493     ok(hres == S_OK, "Could not get IBindHost iface: %08x\n", hres);
 494
 495     hres = IOleClientSite_QueryInterface(client_site, &IID_IServiceProvider, (void**)&sp);
 496     ok(hres == S_OK, "Could not get IServiceProvider iface: %08x\n", hres);
 497
 498     hres = IServiceProvider_QueryService(sp, &SID_SBindHost, &IID_IBindHost, (void**)&bind_host2);
 499     ok(hres == S_OK, "QueryService(SID_SBindHost) failed: %08x\n", hres);
 500     IServiceProvider_Release(sp);
 501
 502     ok(iface_cmp((IUnknown*)bind_host, (IUnknown*)bind_host2), "bind_host != bind_host2\n");
 503     IBindHost_Release(bind_host2);
 504
 505     mon = NULL;
 506     hres = IBindHost_CreateMoniker(bind_host, test_swfW, NULL, &mon, 0);
 507     ok(hres == S_OK, "CreateMoniker failed: %08x\n", hres);
 508     ok(mon != NULL, "mon == NULL\n");
 509     test_mon_displayname(mon, "about:test.swf", "about:blanktest.swf");
 510     IMoniker_Release(mon);
 511
 512     IBindHost_Release(bind_host);
 513
 514     mon = NULL;
 515     hres = IOleClientSite_GetMoniker(client_site, OLEGETMONIKER_ONLYIFTHERE, OLEWHICHMK_CONTAINER, &mon);
 516     ok(hres == S_OK, "GetMoniker failed: %08x\n", hres);
 517     ok(mon != NULL, "mon == NULL\n");
 518     test_mon_displayname(mon, "about:blank", NULL);
 519     IMoniker_Release(mon);
 520
 521     set_plugin_readystate(READYSTATE_COMPLETE);
 522
 523     return S_OK;
 524 }
 525
 526 static HRESULT WINAPI PersistPropertyBag_Save(IPersistPropertyBag *face, IPropertyBag *pPropBag, BOOL fClearDisrty, BOOL fSaveAllProperties)
 527 {
 528     ok(0, "unexpected call\n");
 529     return E_NOTIMPL;
 530 }
 531
 532 static const IPersistPropertyBagVtbl PersistPropertyBagVtbl = {
 533     PersistPropertyBag_QueryInterface,
 534     PersistPropertyBag_AddRef,
 535     PersistPropertyBag_Release,
 536     PersistPropertyBag_GetClassID,
 537     PersistPropertyBag_InitNew,
 538     PersistPropertyBag_Load,
 539     PersistPropertyBag_Save
 540
 541 };
 542
 543 static IPersistPropertyBag PersistPropertyBag = { &PersistPropertyBagVtbl };
 544
 545 static HRESULT WINAPI Dispatch_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
 546 {
 547     return ax_qi(riid, ppv);
 548 }
 549
 550 static ULONG WINAPI Dispatch_AddRef(IDispatch *iface)
 551 {
 552     return 2;
 553 }
 554
 555 static ULONG WINAPI Dispatch_Release(IDispatch *iface)
 556 {
 557     return 1;
 558 }
 559
 560 static HRESULT WINAPI Dispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
 561 {
 562     ok(0, "unexpected call\n");
 563     return E_NOTIMPL;
 564 }
 565
 566 static HRESULT WINAPI Dispatch_GetTypeInfo(IDispatch *iface, UINT iTInfo, LCID lcid,
 567         ITypeInfo **ppTInfo)
 568 {
 569     ok(0, "unexpected call\n");
 570     return E_NOTIMPL;
 571 }
 572
 573 static HRESULT WINAPI Dispatch_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *rgszNames,
 574         UINT cNames, LCID lcid, DISPID *rgDispId)
 575 {
 576     CHECK_EXPECT(GetIDsOfNames_scriptprop);
 577     ok(IsEqualGUID(riid, &IID_NULL), "riid = %s\n", debugstr_guid(riid));
 578     ok(cNames == 1, "cNames = %d\n", cNames);
 579     ok(rgszNames != NULL, "rgszNames == NULL\n");
 580     ok(!strcmp_wa(rgszNames[0], "scriptprop"), "rgszNames[0] = %s\n", wine_dbgstr_w(rgszNames[0]));
 581     ok(rgDispId != NULL, "rgDispId == NULL\n");
 582
 583     *rgDispId = DISPID_SCRIPTPROP;
 584     return S_OK;
 585 }
 586
 587 static HRESULT WINAPI Dispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,
 588         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 589         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 590 {
 591     ok(IsEqualGUID(riid, &IID_NULL), "riid = %s\n", debugstr_guid(riid));
 592     ok(pDispParams != NULL, "pDispParams == NULL\n");
 593     ok(!pDispParams->cNamedArgs, "pDispParams->cNamedArgs = %d\n", pDispParams->cNamedArgs);
 594     ok(!pDispParams->rgdispidNamedArgs, "pDispParams->rgdispidNamedArgs != NULL\n");
 595     ok(pVarResult != NULL, "pVarResult == NULL\n");
 596
 597     switch(dispIdMember) {
 598     case DISPID_READYSTATE:
 599         CHECK_EXPECT2(Invoke_READYSTATE);
 600         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 601         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 602         ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
 603         ok(!pExcepInfo, "pExcepInfo != NULL\n");
 604         ok(puArgErr != NULL, "puArgErr == NULL\n");
 605
 606         V_VT(pVarResult) = VT_I4;
 607         V_I4(pVarResult) = plugin_readystate;
 608         return S_OK;
 609      case DISPID_ENABLED:
 610         CHECK_EXPECT2(Invoke_ENABLED);
 611         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 612         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 613         ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
 614         ok(!pExcepInfo, "pExcepInfo != NULL\n");
 615         ok(puArgErr != NULL, "puArgErr == NULL\n");
 616         return DISP_E_MEMBERNOTFOUND;
 617     case DISPID_VALID:
 618         CHECK_EXPECT(Invoke_VALID);
 619         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 620         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 621         ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
 622         ok(!pExcepInfo, "pExcepInfo != NULL\n");
 623         ok(puArgErr != NULL, "puArgErr == NULL\n");
 624         return DISP_E_MEMBERNOTFOUND;
 625     case DISPID_SECURITYCTX:
 626         CHECK_EXPECT(Invoke_SECURITYCTX);
 627         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 628         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 629         ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
 630         ok(!pExcepInfo, "pExcepInfo != NULL\n");
 631         ok(puArgErr != NULL, "puArgErr == NULL\n");
 632         return DISP_E_MEMBERNOTFOUND;
 633     case DISPID_SCRIPTPROP:
 634         CHECK_EXPECT(Invoke_SCRIPTPROP);
 635         ok(wFlags == DISPATCH_PROPERTYGET, "wFlags = %x\n", wFlags);
 636         ok(!pDispParams->cArgs, "pDispParams->cArgs = %d\n", pDispParams->cArgs);
 637         ok(!pDispParams->rgvarg, "pDispParams->rgvarg != NULL\n");
 638         ok(pExcepInfo != NULL, "pExcepInfo == NULL\n");
 639         ok(!puArgErr, "puArgErr != NULL\n");
 640
 641         V_VT(pVarResult) = VT_I4;
 642         V_I4(pVarResult) = 4;
 643         return S_OK;
 644     default:
 645         ok(0, "unexpected call %d\n", dispIdMember);
 646     }
 647
 648     return E_NOTIMPL;
 649 }
 650
 651 static const IDispatchVtbl DispatchVtbl = {
 652     Dispatch_QueryInterface,
 653     Dispatch_AddRef,
 654     Dispatch_Release,
 655     Dispatch_GetTypeInfoCount,
 656     Dispatch_GetTypeInfo,
 657     Dispatch_GetIDsOfNames,
 658     Dispatch_Invoke
 659 };
 660
 661 static IDispatch Dispatch = { &DispatchVtbl };
 662
 663 static HRESULT WINAPI ViewObjectEx_QueryInterface(IViewObjectEx *iface, REFIID riid, void **ppv)
 664 {
 665     return ax_qi(riid, ppv);
 666 }
 667
 668 static ULONG WINAPI ViewObjectEx_AddRef(IViewObjectEx *iface)
 669 {
 670     return 2;
 671 }
 672
 673 static ULONG WINAPI ViewObjectEx_Release(IViewObjectEx *iface)
 674 {
 675     return 1;
 676 }
 677
 678 static HRESULT WINAPI ViewObjectEx_Draw(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd,
 679         HDC hdcTargetDev, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBoungs, BOOL (WINAPI*pfnContinue)(ULONG_PTR), ULONG_PTR dwContinue)
 680 {
 681     ok(0, "unexpected call\n");
 682     return E_NOTIMPL;
 683 }
 684
 685 static HRESULT WINAPI ViewObjectEx_GetColorSet(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd,
 686         HDC hicTargetDev, LOGPALETTE **ppColorSet)
 687 {
 688     ok(0, "unexpected call\n");
 689     return E_NOTIMPL;
 690 }
 691
 692 static HRESULT WINAPI ViewObjectEx_Freeze(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DWORD *pdwFreeze)
 693 {
 694     ok(0, "unexpected call\n");
 695     return E_NOTIMPL;
 696 }
 697
 698 static HRESULT WINAPI ViewObjectEx_Unfreeze(IViewObjectEx *iface, DWORD dwFreeze)
 699 {
 700     ok(0, "unexpected call\n");
 701     return E_NOTIMPL;
 702 }
 703
 704 static HRESULT WINAPI ViewObjectEx_SetAdvise(IViewObjectEx *iface, DWORD aspects, DWORD advf, IAdviseSink *pAdvSink)
 705 {
 706     ok(0, "unexpected call\n");
 707     return E_NOTIMPL;
 708 }
 709
 710 static HRESULT WINAPI ViewObjectEx_GetAdvise(IViewObjectEx *iface, DWORD *pAspects, DWORD *pAdvf, IAdviseSink **ppAdvSink)
 711 {
 712     ok(0, "unexpected call\n");
 713     return E_NOTIMPL;
 714 }
 715
 716 static HRESULT WINAPI ViewObjectEx_GetExtent(IViewObjectEx *iface, DWORD dwDrawAspect, LONG lindex, DVTARGETDEVICE *ptd, LPSIZEL lpsizel)
 717 {
 718     ok(0, "unexpected call\n");
 719     return E_NOTIMPL;
 720 }
 721
 722 static HRESULT WINAPI ViewObjectEx_GetRect(IViewObjectEx *iface, DWORD dwAspect, LPRECTL pRect)
 723 {
 724     ok(0, "unexpected call\n");
 725     return E_NOTIMPL;
 726 }
 727
 728 static HRESULT WINAPI ViewObjectEx_GetViewStatus(IViewObjectEx *iface, DWORD *pdwStatus)
 729 {
 730     ok(0, "unexpected call\n");
 731     return E_NOTIMPL;
 732 }
 733
 734 static HRESULT WINAPI ViewObjectEx_QueryHitPoint(IViewObjectEx *iface, DWORD dwAspect, LPCRECT pRectBounds, POINT ptlLoc,
 735         LONG lCloseHint, DWORD *pHitResult)
 736 {
 737     ok(0, "unexpected call\n");
 738     return E_NOTIMPL;
 739 }
 740
 741 static HRESULT WINAPI ViewObjectEx_QueryHitRect(IViewObjectEx *iface, DWORD dwAspect, LPCRECT pRectBounds, LPCRECT pRectLoc,
 742         LONG lCloseHint, DWORD *pHitResult)
 743 {
 744     ok(0, "unexpected call\n");
 745     return E_NOTIMPL;
 746 }
 747
 748 static HRESULT WINAPI ViewObjectEx_GetNaturalExtent(IViewObjectEx *iface, DWORD dwAspect, LONG lindex, DVTARGETDEVICE *ptd,
 749         HDC hicTargetDev, DVEXTENTINFO *pExtentIngo, LPSIZEL pSizel)
 750 {
 751     ok(0, "unexpected call\n");
 752     return E_NOTIMPL;
 753 }
 754
 755 static const IViewObjectExVtbl ViewObjectExVtbl = {
 756     ViewObjectEx_QueryInterface,
 757     ViewObjectEx_AddRef,
 758     ViewObjectEx_Release,
 759     ViewObjectEx_Draw,
 760     ViewObjectEx_GetColorSet,
 761     ViewObjectEx_Freeze,
 762     ViewObjectEx_Unfreeze,
 763     ViewObjectEx_SetAdvise,
 764     ViewObjectEx_GetAdvise,
 765     ViewObjectEx_GetExtent,
 766     ViewObjectEx_GetRect,
 767     ViewObjectEx_GetViewStatus,
 768     ViewObjectEx_QueryHitPoint,
 769     ViewObjectEx_QueryHitRect,
 770     ViewObjectEx_GetNaturalExtent
 771 };
 772
 773 static IViewObjectEx ViewObjectEx = { &ViewObjectExVtbl };
 774
 775 static HRESULT WINAPI OleObject_QueryInterface(IOleObject *iface, REFIID riid, void **ppv)
 776 {
 777     return ax_qi(riid, ppv);
 778 }
 779
 780 static ULONG WINAPI OleObject_AddRef(IOleObject *iface)
 781 {
 782     return 2;
 783 }
 784
 785 static ULONG WINAPI OleObject_Release(IOleObject *iface)
 786 {
 787     return 1;
 788 }
 789
 790 static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, IOleClientSite *pClientSite)
 791 {
 792     if(!pClientSite) {
 793         CHECK_EXPECT(SetClientSite_NULL);
 794         return S_OK;
 795     }
 796
 797     CHECK_EXPECT(SetClientSite);
 798     return E_NOTIMPL;
 799 }
 800
 801 static HRESULT WINAPI OleObject_GetClientSite(IOleObject *iface, IOleClientSite **ppClientSite)
 802 {
 803     ok(0, "unexpected call\n");
 804     return E_NOTIMPL;
 805 }
 806
 807 static HRESULT WINAPI OleObject_SetHostNames(IOleObject *iface, LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
 808 {
 809     ok(0, "unexpected call\n");
 810     return E_NOTIMPL;
 811 }
 812
 813 static HRESULT WINAPI OleObject_Close(IOleObject *iface, DWORD dwSaveOption)
 814 {
 815     CHECK_EXPECT(Close);
 816
 817     ok(dwSaveOption == OLECLOSE_NOSAVE, "dwSaveOption = %d\n", dwSaveOption);
 818     return S_OK;
 819 }
 820
 821 static HRESULT WINAPI OleObject_SetMoniker(IOleObject *iface, DWORD dwWhichMoniker, IMoniker *pmk)
 822 {
 823     ok(0, "unexpected call\n");
 824     return E_NOTIMPL;
 825 }
 826
 827 static HRESULT WINAPI OleObject_GetMoniker(IOleObject *iface, DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk)
 828 {
 829     ok(0, "unexpected call\n");
 830     return E_NOTIMPL;
 831 }
 832
 833 static HRESULT WINAPI OleObject_InitFromData(IOleObject *iface, IDataObject *pDataObject, BOOL fCreation,
 834         DWORD dwReserved)
 835 {
 836     ok(0, "unexpected call\n");
 837     return E_NOTIMPL;
 838 }
 839
 840 static HRESULT WINAPI OleObject_GetClipboardData(IOleObject *iface, DWORD dwReserved, IDataObject **ppDataObject)
 841 {
 842     ok(0, "unexpected call\n");
 843     return E_NOTIMPL;
 844 }
 845
 846 static HRESULT WINAPI OleObject_DoVerb(IOleObject *iface, LONG iVerb, LPMSG lpmsg, IOleClientSite *pActiveSite,
 847         LONG lindex, HWND hwndParent, LPCRECT lprcPosRect)
 848 {
 849     OLEINPLACEFRAMEINFO frame_info = {0xdeadbeef};
 850     IOleInPlaceUIWindow *ip_uiwindow;
 851     IOleInPlaceFrame *ip_frame;
 852     IOleInPlaceSiteEx *ip_site;
 853     RECT pos_rect, clip_rect;
 854     BOOL no_redraw;
 855     HWND hwnd;
 856     HRESULT hres;
 857
 858     CHECK_EXPECT(DoVerb);
 859
 860     ok(iVerb == OLEIVERB_INPLACEACTIVATE, "iVerb = %d\n", iVerb);
 861     ok(!lpmsg, "lpmsg != NULL\n");
 862     ok(pActiveSite != NULL, "pActiveSite == NULL\n");
 863     ok(!lindex, "lindex = %d\n", lindex);
 864     ok(hwndParent != NULL, "hwndParent == NULL\n");
 865     ok(lprcPosRect != NULL, "lprcPosRect == NULL\n");
 866
 867     hres = IOleClientSite_QueryInterface(pActiveSite, &IID_IOleInPlaceSiteEx, (void**)&ip_site);
 868     ok(hres == S_OK, "Could not get IOleInPlaceSiteEx iface: %08x\n", hres);
 869
 870     SET_EXPECT(InPlaceObject_GetWindow);
 871     no_redraw = 0xdeadbeef;
 872     hres = IOleInPlaceSiteEx_OnInPlaceActivateEx(ip_site, &no_redraw, 0);
 873     ok(hres == S_OK, "InPlaceActivateEx failed: %08x\n", hres);
 874     ok(!no_redraw, "no_redraw = %x\n", no_redraw);
 875     CHECK_CALLED(InPlaceObject_GetWindow);
 876
 877     no_redraw = 0xdeadbeef;
 878     hres = IOleInPlaceSiteEx_OnInPlaceActivateEx(ip_site, &no_redraw, 0);
 879     ok(hres == S_OK, "InPlaceActivateEx failed: %08x\n", hres);
 880     ok(no_redraw == 0xdeadbeef, "no_redraw = %x\n", no_redraw);
 881
 882     hwnd = NULL;
 883     hres = IOleInPlaceSiteEx_GetWindow(ip_site, &hwnd);
 884     ok(hres == S_OK, "GetWindow failed: %08x\n", hres);
 885     ok(hwnd != NULL, "hwnd == NULL\n");
 886     ok(hwnd == hwndParent, "hwnd != hwndParent\n");
 887
 888     create_plugin_window(hwnd, lprcPosRect);
 889
 890     ip_frame = NULL;
 891     ip_uiwindow = NULL;
 892     hres = IOleInPlaceSiteEx_GetWindowContext(ip_site, &ip_frame, &ip_uiwindow, &pos_rect, &clip_rect, &frame_info);
 893     ok(hres == S_OK, "GetWindowContext failed: %08x\n", hres);
 894     ok(ip_frame != NULL, "ip_frame == NULL\n");
 895     ok(ip_uiwindow != NULL, "ip_uiwindow == NULL\n");
 896     ok((IOleInPlaceUIWindow*)ip_frame != ip_uiwindow, "ip_frame == ip_uiwindow\n");
 897     ok(!memcmp(&pos_rect, lprcPosRect, sizeof(RECT)), "pos_rect != lpecPosRect\n");
 898     ok(!memcmp(&clip_rect, lprcPosRect, sizeof(RECT)), "clip_rect != lpecPosRect\n");
 899     ok(frame_info.cb == sizeof(frame_info), "frame_info.cb = %d\n", frame_info.cb);
 900     ok(!frame_info.fMDIApp, "frame_info.fMDIApp = %x\n", frame_info.fMDIApp);
 901     ok(frame_info.hwndFrame != NULL, "frame_info.hwnd == NULL\n");
 902     ok(frame_info.hwndFrame == container_hwnd, "frame_info.hwnd != container_hwnd\n");
 903     ok(!frame_info.haccel, "frame_info.haccel != 0\n");
 904     ok(!frame_info.cAccelEntries, "frame_info.cAccelEntried != 0\n");
 905
 906     IOleInPlaceFrame_Release(ip_frame);
 907     IOleInPlaceUIWindow_Release(ip_uiwindow);
 908
 909
 910     IOleInPlaceSiteEx_Release(ip_site);
 911
 912     hres = IOleClientSite_ShowObject(client_site);
 913     ok(hres == S_OK, "ShowObject failed: %08x\n", hres);
 914
 915     SET_EXPECT(InPlaceObject_GetWindow);
 916     SET_EXPECT(SetObjectRects);
 917
 918     return S_OK;
 919 }
 920
 921 static HRESULT WINAPI OleObject_EnumVerbs(IOleObject *iface, IEnumOLEVERB **ppEnumOleVerb)
 922 {
 923     ok(0, "unexpected call\n");
 924     return E_NOTIMPL;
 925 }
 926
 927 static HRESULT WINAPI OleObject_Update(IOleObject *iface)
 928 {
 929     ok(0, "unexpected call\n");
 930     return E_NOTIMPL;
 931 }
 932
 933 static HRESULT WINAPI OleObject_IsUpToDate(IOleObject *iface)
 934 {
 935     ok(0, "unexpected call\n");
 936     return E_NOTIMPL;
 937 }
 938
 939 static HRESULT WINAPI OleObject_GetUserClassID(IOleObject *iface, CLSID *pClsid)
 940 {
 941     ok(0, "unexpected call\n");
 942     return E_NOTIMPL;
 943 }
 944
 945 static HRESULT WINAPI OleObject_GetUserType(IOleObject *iface, DWORD dwFormOfType, LPOLESTR *pszUserType)
 946 {
 947     ok(0, "unexpected call\n");
 948     return E_NOTIMPL;
 949 }
 950
 951 static HRESULT WINAPI OleObject_SetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
 952 {
 953     CHECK_EXPECT(SetExtent);
 954     return E_NOTIMPL;
 955 }
 956
 957 static HRESULT WINAPI OleObject_GetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
 958 {
 959     CHECK_EXPECT(GetExtent);
 960     return E_NOTIMPL;
 961 }
 962
 963 static HRESULT WINAPI OleObject_Advise(IOleObject *iface, IAdviseSink *pAdvSink, DWORD *pdwConnection)
 964 {
 965     ok(0, "unexpected call\n");
 966     return E_NOTIMPL;
 967 }
 968
 969 static HRESULT WINAPI OleObject_Unadvise(IOleObject *iface, DWORD dwConnection)
 970 {
 971     ok(0, "unexpected call\n");
 972     return E_NOTIMPL;
 973 }
 974
 975 static HRESULT WINAPI OleObject_EnumAdvise(IOleObject *iface, IEnumSTATDATA **ppenumAdvise)
 976 {
 977     ok(0, "unexpected call\n");
 978     return E_NOTIMPL;
 979 }
 980
 981 static HRESULT WINAPI OleObject_GetMiscStatus(IOleObject *iface, DWORD dwAspect, DWORD *pdwStatus)
 982 {
 983     ok(0, "unexpected call\n");
 984     return E_NOTIMPL;
 985 }
 986
 987 static HRESULT WINAPI OleObject_SetColorScheme(IOleObject *iface, LOGPALETTE *pLogpal)
 988 {
 989     ok(0, "unexpected call\n");
 990     return E_NOTIMPL;
 991 }
 992
 993 static const IOleObjectVtbl OleObjectVtbl = {
 994     OleObject_QueryInterface,
 995     OleObject_AddRef,
 996     OleObject_Release,
 997     OleObject_SetClientSite,
 998     OleObject_GetClientSite,
 999     OleObject_SetHostNames,
1000     OleObject_Close,
1001     OleObject_SetMoniker,
1002     OleObject_GetMoniker,
1003     OleObject_InitFromData,
1004     OleObject_GetClipboardData,
1005     OleObject_DoVerb,
1006     OleObject_EnumVerbs,
1007     OleObject_Update,
1008     OleObject_IsUpToDate,
1009     OleObject_GetUserClassID,
1010     OleObject_GetUserType,
1011     OleObject_SetExtent,
1012     OleObject_GetExtent,
1013     OleObject_Advise,
1014     OleObject_Unadvise,
1015     OleObject_EnumAdvise,
1016     OleObject_GetMiscStatus,
1017     OleObject_SetColorScheme
1018 };
1019
1020 static IOleObject OleObject = { &OleObjectVtbl };
1021
1022 static HRESULT WINAPI OleInPlaceObject_QueryInterface(IOleInPlaceObjectWindowless *iface,
1023         REFIID riid, void **ppv)
1024 {
1025     return ax_qi(riid, ppv);
1026 }
1027
1028 static ULONG WINAPI OleInPlaceObject_AddRef(IOleInPlaceObjectWindowless *iface)
1029 {
1030     return 2;
1031 }
1032
1033 static ULONG WINAPI OleInPlaceObject_Release(IOleInPlaceObjectWindowless *iface)
1034 {
1035     return 1;
1036 }
1037
1038 static HRESULT WINAPI OleInPlaceObject_GetWindow(IOleInPlaceObjectWindowless *iface,
1039         HWND *phwnd)
1040 {
1041     CHECK_EXPECT2(InPlaceObject_GetWindow);
1042
1043     ok(phwnd != NULL, "phwnd == NULL\n");
1044
1045     *phwnd = plugin_hwnd;
1046     return *phwnd ? S_OK : E_UNEXPECTED;
1047 }
1048
1049 static HRESULT WINAPI OleInPlaceObject_ContextSensitiveHelp(IOleInPlaceObjectWindowless *iface,
1050         BOOL fEnterMode)
1051 {
1052     ok(0, "unexpected call\n");
1053     return E_NOTIMPL;
1054 }
1055
1056 static HRESULT WINAPI OleInPlaceObject_InPlaceDeactivate(IOleInPlaceObjectWindowless *iface)
1057 {
1058     IOleInPlaceSite *ip_site;
1059     HRESULT hres;
1060
1061     CHECK_EXPECT(InPlaceDeactivate);
1062
1063     hres = IOleClientSite_QueryInterface(client_site, &IID_IOleInPlaceSite, (void**)&ip_site);
1064     ok(hres == S_OK, "Could not get IOleInPlaceSite iface: %08x\n", hres);
1065
1066     hres = IOleInPlaceSite_OnInPlaceDeactivate(ip_site);
1067     ok(hres == S_OK, "OnInPlaceDeactivate failed: %08x\n", hres);
1068
1069     IOleInPlaceSite_Release(ip_site);
1070     return S_OK;
1071 }
1072
1073 static HRESULT WINAPI OleInPlaceObject_UIDeactivate(IOleInPlaceObjectWindowless *iface)
1074 {
1075     CHECK_EXPECT2(UIDeactivate);
1076     return S_OK;
1077 }
1078
1079 static HRESULT WINAPI OleInPlaceObject_SetObjectRects(IOleInPlaceObjectWindowless *iface,
1080         LPCRECT lprcPosRect, LPCRECT lprcClipRect)
1081 {
1082     CHECK_EXPECT(SetObjectRects);
1083     return S_OK;
1084 }
1085
1086 static HRESULT WINAPI OleInPlaceObjectWindowless_ReactivateAndUndo(IOleInPlaceObjectWindowless *iface)
1087 {
1088     ok(0, "unexpected call\n");
1089     return E_NOTIMPL;
1090 }
1091
1092 static HRESULT WINAPI OleInPlaceObjectWindowless_OnWindowMessage(IOleInPlaceObjectWindowless *iface,
1093         UINT msg, WPARAM wParam, LPARAM lParam, LRESULT *lpResult)
1094 {
1095     ok(0, "unexpected call\n");
1096     return E_NOTIMPL;
1097 }
1098
1099 static HRESULT WINAPI OleInPlaceObjectWindowless_GetDropTarget(IOleInPlaceObjectWindowless *iface,
1100         IDropTarget **ppDropTarget)
1101 {
1102     ok(0, "unexpected call\n");
1103     return E_NOTIMPL;
1104 }
1105
1106 static const IOleInPlaceObjectWindowlessVtbl OleInPlaceObjectWindowlessVtbl = {
1107     OleInPlaceObject_QueryInterface,
1108     OleInPlaceObject_AddRef,
1109     OleInPlaceObject_Release,
1110     OleInPlaceObject_GetWindow,
1111     OleInPlaceObject_ContextSensitiveHelp,
1112     OleInPlaceObject_InPlaceDeactivate,
1113     OleInPlaceObject_UIDeactivate,
1114     OleInPlaceObject_SetObjectRects,
1115     OleInPlaceObjectWindowless_ReactivateAndUndo,
1116     OleInPlaceObjectWindowless_OnWindowMessage,
1117     OleInPlaceObjectWindowless_GetDropTarget
1118 };
1119
1120 static IOleInPlaceObjectWindowless OleInPlaceObjectWindowless = { &OleInPlaceObjectWindowlessVtbl };
1121
1122 static HRESULT ax_qi(REFIID riid, void **ppv)
1123 {
1124     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IOleControl)) {
1125         *ppv = &OleControl;
1126         return S_OK;
1127     }
1128
1129     if(IsEqualGUID(riid, &IID_IQuickActivate)) {
1130         *ppv = &QuickActivate;
1131         return S_OK;
1132     }
1133
1134     if(IsEqualGUID(riid, &IID_IPersistPropertyBag)) {
1135         *ppv = &PersistPropertyBag;
1136         return S_OK;
1137     }
1138
1139     if(IsEqualGUID(riid, &IID_IDispatch)) {
1140         *ppv = &Dispatch;
1141         return S_OK;
1142     }
1143
1144     if(IsEqualGUID(riid, &IID_IViewObject) || IsEqualGUID(riid, &IID_IViewObject2) || IsEqualGUID(riid, &IID_IViewObjectEx)) {
1145         *ppv = &ViewObjectEx;
1146         return S_OK;
1147     }
1148
1149     if(IsEqualGUID(riid, &IID_IOleObject)) {
1150         *ppv = &OleObject;
1151         return S_OK;
1152     }
1153
1154     if(IsEqualGUID(riid, &IID_IOleWindow) || IsEqualGUID(riid, &IID_IOleInPlaceObject)
1155        || IsEqualGUID(&IID_IOleInPlaceObjectWindowless, riid)) {
1156         *ppv = &OleInPlaceObjectWindowless;
1157         return S_OK;
1158     }
1159
1160     *ppv = NULL;
1161     return E_NOINTERFACE;
1162 }
1163
1164 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
1165 {
1166     *ppv = NULL;
1167
1168     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
1169         *ppv = iface;
1170         return S_OK;
1171     }
1172
1173     if(IsEqualGUID(&IID_IMarshal, riid))
1174         return E_NOINTERFACE;
1175     if(IsEqualGUID(&CLSID_IdentityUnmarshal, riid))
1176         return E_NOINTERFACE;
1177     if(IsEqualGUID(&IID_IClassFactoryEx, riid))
1178         return E_NOINTERFACE; /* TODO */
1179
1180     ok(0, "unexpected riid %s\n", debugstr_guid(riid));
1181     return E_NOTIMPL;
1182 }
1183
1184 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
1185 {
1186     return 2;
1187 }
1188
1189 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
1190 {
1191     return 1;
1192 }
1193
1194 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
1195 {
1196     CHECK_EXPECT(CreateInstance);
1197
1198     ok(!outer, "outer = %p\n", outer);
1199     ok(IsEqualGUID(riid, &IID_IUnknown), "riid = %s\n", debugstr_guid(riid));
1200
1201     *ppv = &OleControl;
1202     return S_OK;
1203 }
1204
1205 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
1206 {
1207     ok(0, "unexpected call\n");
1208     return S_OK;
1209 }
1210
1211 static const IClassFactoryVtbl ClassFactoryVtbl = {
1212     ClassFactory_QueryInterface,
1213     ClassFactory_AddRef,
1214     ClassFactory_Release,
1215     ClassFactory_CreateInstance,
1216     ClassFactory_LockServer
1217 };
1218
1219 static IClassFactory activex_cf = { &ClassFactoryVtbl };
1220
1221 static void test_elem_dispex(IDispatchEx *dispex)
1222 {
1223     DISPPARAMS dp;
1224     EXCEPINFO ei;
1225     VARIANT v;
1226     DISPID id;
1227     BSTR str;
1228     HRESULT hres;
1229
1230     str = a2bstr("scriptprop");
1231     SET_EXPECT(GetIDsOfNames_scriptprop);
1232     hres = IDispatchEx_GetDispID(dispex, str, 0, &id);
1233     CHECK_CALLED(GetIDsOfNames_scriptprop);
1234     SysFreeString(str);
1235     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
1236     todo_wine
1237     ok(id == DISPID_SCRIPTPROP, "id = %d\n", id);
1238
1239     SET_EXPECT(Invoke_SECURITYCTX);
1240     SET_EXPECT(Invoke_SCRIPTPROP);
1241     memset(&dp, 0, sizeof(dp));
1242     memset(&ei, 0, sizeof(ei));
1243     V_VT(&v) = VT_EMPTY;
1244     hres = IDispatchEx_InvokeEx(dispex, id, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dp, &v, &ei, NULL);
1245     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1246     ok(V_VT(&v) == VT_I4, "V_VT(v) = %d\n", V_VT(&v));
1247     ok(V_I4(&v) == 4, "V_I4(v) = %d\n", V_I4(&v));
1248     CHECK_CALLED(Invoke_SECURITYCTX);
1249     CHECK_CALLED(Invoke_SCRIPTPROP);
1250 }
1251
1252 static void test_object_elem(IHTMLDocument2 *doc)
1253 {
1254     IHTMLObjectElement *objelem;
1255     IHTMLDocument3 *doc3;
1256     IDispatchEx *dispex;
1257     IHTMLElement *elem;
1258     IDispatch *disp;
1259     BSTR str;
1260     HRESULT hres;
1261
1262     hres = IHTMLDocument2_QueryInterface(doc, &IID_IHTMLDocument3, (void**)&doc3);
1263     ok(hres == S_OK, "Could not get IHTMLDocument3 iface: %08x\n", hres);
1264
1265     str = a2bstr("objid");
1266     elem = (void*)0xdeadbeef;
1267     hres = IHTMLDocument3_getElementById(doc3, str, &elem);
1268     IHTMLDocument3_Release(doc3);
1269     SysFreeString(str);
1270     ok(hres == S_OK, "getElementById failed: %08x\n", hres);
1271     ok(elem != NULL, "elem == NULL\n");
1272
1273     hres = IHTMLElement_QueryInterface(elem, &IID_IHTMLObjectElement, (void**)&objelem);
1274     IHTMLElement_Release(elem);
1275     ok(hres == S_OK, "Could not get IHTMLObjectElement iface: %08x\n", hres);
1276
1277     SET_EXPECT(Invoke_SECURITYCTX);
1278     hres = IHTMLObjectElement_get_object(objelem, &disp);
1279     ok(hres == S_OK, "get_object failed: %08x\n", hres);
1280     ok(disp == &Dispatch, "disp != Dispatch\n");
1281     CHECK_CALLED(Invoke_SECURITYCTX);
1282
1283     hres = IHTMLObjectElement_QueryInterface(objelem, &IID_IDispatchEx, (void**)&dispex);
1284     test_elem_dispex(dispex);
1285     IDispatchEx_Release(dispex);
1286
1287     IHTMLObjectElement_Release(objelem);
1288 }
1289
1290 static void test_container(IHTMLDocument2 *doc_obj)
1291 {
1292     IHTMLWindow2 *parent_window, *html_window;
1293     IServiceProvider *serv_prov;
1294     IOleContainer *container;
1295     IHTMLDocument2 *doc;
1296     IUnknown *unk;
1297     HRESULT hres;
1298
1299     container = NULL;
1300     hres = IOleClientSite_GetContainer(client_site, &container);
1301     ok(hres == S_OK, "GetContainer failed: %08x\n", hres);
1302     ok(container != NULL, "container == NULL\n");
1303
1304     hres = IHTMLDocument2_get_parentWindow(doc_obj, &parent_window);
1305     ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
1306     ok(parent_window != NULL, "parentWindow == NULL\n");
1307
1308     hres = IHTMLWindow2_get_document(parent_window, &doc);
1309     ok(hres == S_OK, "get_document failed: %08x\n", hres);
1310     ok(doc != NULL, "doc == NULL\n");
1311     ok(iface_cmp((IUnknown*)doc, (IUnknown*)container), "container != doc\n");
1312     IHTMLDocument2_Release(doc);
1313
1314     hres = IOleClientSite_QueryInterface(client_site, &IID_IServiceProvider, (void**)&serv_prov);
1315     ok(hres == S_OK, "Could not get IServiceProvider iface: %08x\n", hres);
1316
1317     hres = IServiceProvider_QueryService(serv_prov, &IID_IHTMLWindow2, &IID_IHTMLWindow2, (void**)&html_window);
1318     ok(hres == S_OK, "Could not get IHTMLWindow2 service: %08x\n", hres);
1319     todo_wine
1320     ok(!iface_cmp((IUnknown*)html_window, (IUnknown*)parent_window), "html_window != parent_window\n");
1321     IHTMLWindow2_Release(html_window);
1322
1323     SET_EXPECT(QueryService_TestActiveX);
1324     hres = IServiceProvider_QueryService(serv_prov, &CLSID_TestActiveX, &IID_IUnknown, (void**)&unk);
1325     ok(hres == S_OK, "QueryService(CLSID_TestActiveX) failed: %08x\n", hres);
1326     ok(unk == (IUnknown*)&OleObject, "unexpected unk %p\n", unk);
1327     CHECK_CALLED(QueryService_TestActiveX);
1328
1329     IServiceProvider_Release(serv_prov);
1330
1331     IHTMLWindow2_Release(parent_window);
1332     IOleContainer_Release(container);
1333 }
1334
1335 static void test_ui_activate(void)
1336 {
1337     IOleInPlaceSite *ip_site;
1338     HRESULT hres;
1339
1340     hres = IOleClientSite_QueryInterface(client_site, &IID_IOleInPlaceSite, (void**)&ip_site);
1341     ok(hres == S_OK, "Could not get IOleInPlaceSite iface: %08x\n", hres);
1342
1343     SET_EXPECT(Invoke_ENABLED);
1344     hres = IOleInPlaceSite_OnUIActivate(ip_site);
1345     ok(hres == S_OK, "OnUIActivate failed: %08x\n", hres);
1346     CHECK_CALLED(Invoke_ENABLED);
1347
1348     IOleInPlaceSite_Release(ip_site);
1349 }
1350
1351 static HRESULT cs_qi(REFIID,void **);
1352 static IOleDocumentView *view;
1353
1354 static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
1355 {
1356     static const GUID undocumented_frame_iid = {0xfbece6c9,0x48d7,0x4a37,{0x8f,0xe3,0x6a,0xd4,0x27,0x2f,0xdd,0xac}};
1357
1358     if(!IsEqualGUID(&undocumented_frame_iid, riid))
1359         ok(0, "unexpected riid %s\n", debugstr_guid(riid));
1360
1361     *ppv = NULL;
1362     return E_NOINTERFACE;
1363 }
1364
1365 static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface)
1366 {
1367     return 2;
1368 }
1369
1370 static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface)
1371 {
1372     return 1;
1373 }
1374
1375 static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
1376 {
1377     return E_NOTIMPL;
1378 }
1379
1380 static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
1381 {
1382     return E_NOTIMPL;
1383 }
1384
1385 static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
1386 {
1387     return E_NOTIMPL;
1388 }
1389
1390 static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface,
1391         LPCBORDERWIDTHS pborderwidths)
1392 {
1393     return E_NOTIMPL;
1394 }
1395
1396 static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface,
1397         LPCBORDERWIDTHS pborderwidths)
1398 {
1399     return S_OK;
1400 }
1401
1402 static HRESULT WINAPI InPlaceUIWindow_SetActiveObject(IOleInPlaceFrame *iface,
1403         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1404 {
1405     return S_OK;
1406 }
1407
1408 static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
1409         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1410 {
1411     return S_OK;
1412 }
1413
1414 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
1415         LPOLEMENUGROUPWIDTHS lpMenuWidths)
1416 {
1417     return E_NOTIMPL;
1418 }
1419
1420 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
1421         HOLEMENU holemenu, HWND hwndActiveObject)
1422 {
1423     ok(0, "unexpected call\n");
1424     return E_NOTIMPL;
1425 }
1426
1427 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
1428 {
1429     ok(0, "unexpected call\n");
1430     return E_NOTIMPL;
1431 }
1432
1433 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
1434 {
1435     return S_OK;
1436 }
1437
1438 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
1439 {
1440     return E_NOTIMPL;
1441 }
1442
1443 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
1444 {
1445     ok(0, "unexpected call\n");
1446     return E_NOTIMPL;
1447 }
1448
1449 static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
1450     InPlaceFrame_QueryInterface,
1451     InPlaceFrame_AddRef,
1452     InPlaceFrame_Release,
1453     InPlaceFrame_GetWindow,
1454     InPlaceFrame_ContextSensitiveHelp,
1455     InPlaceFrame_GetBorder,
1456     InPlaceFrame_RequestBorderSpace,
1457     InPlaceFrame_SetBorderSpace,
1458     InPlaceFrame_SetActiveObject,
1459     InPlaceFrame_InsertMenus,
1460     InPlaceFrame_SetMenu,
1461     InPlaceFrame_RemoveMenus,
1462     InPlaceFrame_SetStatusText,
1463     InPlaceFrame_EnableModeless,
1464     InPlaceFrame_TranslateAccelerator
1465 };
1466
1467 static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
1468
1469 static const IOleInPlaceFrameVtbl InPlaceUIWindowVtbl = {
1470     InPlaceFrame_QueryInterface,
1471     InPlaceFrame_AddRef,
1472     InPlaceFrame_Release,
1473     InPlaceFrame_GetWindow,
1474     InPlaceFrame_ContextSensitiveHelp,
1475     InPlaceFrame_GetBorder,
1476     InPlaceFrame_RequestBorderSpace,
1477     InPlaceFrame_SetBorderSpace,
1478     InPlaceUIWindow_SetActiveObject,
1479 };
1480
1481 static IOleInPlaceFrame InPlaceUIWindow = { &InPlaceUIWindowVtbl };
1482
1483 static HRESULT WINAPI InPlaceSite_QueryInterface(IOleInPlaceSite *iface, REFIID riid, void **ppv)
1484 {
1485     return cs_qi(riid, ppv);
1486 }
1487
1488 static ULONG WINAPI InPlaceSite_AddRef(IOleInPlaceSite *iface)
1489 {
1490     return 2;
1491 }
1492
1493 static ULONG WINAPI InPlaceSite_Release(IOleInPlaceSite *iface)
1494 {
1495     return 1;
1496 }
1497
1498 static HRESULT WINAPI InPlaceSite_GetWindow(IOleInPlaceSite *iface, HWND *phwnd)
1499 {
1500     *phwnd = container_hwnd;
1501     return S_OK;
1502 }
1503
1504 static HRESULT WINAPI InPlaceSite_ContextSensitiveHelp(IOleInPlaceSite *iface, BOOL fEnterMode)
1505 {
1506     ok(0, "unexpected call\n");
1507     return E_NOTIMPL;
1508 }
1509
1510 static HRESULT WINAPI InPlaceSite_CanInPlaceActivate(IOleInPlaceSite *iface)
1511 {
1512     return S_OK;
1513 }
1514
1515 static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSite *iface)
1516 {
1517     return S_OK;
1518 }
1519
1520 static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSite *iface)
1521 {
1522     return S_OK;
1523 }
1524
1525 static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSite *iface,
1526         IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
1527         LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
1528 {
1529     static const RECT rect = {0,0,500,500};
1530
1531     *ppFrame = &InPlaceFrame;
1532     *ppDoc = (IOleInPlaceUIWindow*)&InPlaceUIWindow;
1533     *lprcPosRect = rect;
1534     *lprcClipRect = rect;
1535
1536     lpFrameInfo->cb = sizeof(*lpFrameInfo);
1537     lpFrameInfo->fMDIApp = FALSE;
1538     lpFrameInfo->hwndFrame = container_hwnd;
1539     lpFrameInfo->haccel = NULL;
1540     lpFrameInfo->cAccelEntries = 0;
1541
1542     return S_OK;
1543 }
1544
1545 static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSite *iface, SIZE scrollExtant)
1546 {
1547     return E_NOTIMPL;
1548 }
1549
1550 static HRESULT WINAPI InPlaceSite_OnUIDeactivate(IOleInPlaceSite *iface, BOOL fUndoable)
1551 {
1552     return S_OK;
1553 }
1554
1555 static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivate(IOleInPlaceSite *iface)
1556 {
1557     return S_OK;
1558 }
1559
1560 static HRESULT WINAPI InPlaceSite_DiscardUndoState(IOleInPlaceSite *iface)
1561 {
1562     return E_NOTIMPL;
1563 }
1564
1565 static HRESULT WINAPI InPlaceSite_DeactivateAndUndo(IOleInPlaceSite *iface)
1566 {
1567     return E_NOTIMPL;
1568 }
1569
1570 static HRESULT WINAPI InPlaceSite_OnPosRectChange(IOleInPlaceSite *iface, LPCRECT lprcPosRect)
1571 {
1572     return E_NOTIMPL;
1573 }
1574
1575 static const IOleInPlaceSiteVtbl InPlaceSiteVtbl = {
1576     InPlaceSite_QueryInterface,
1577     InPlaceSite_AddRef,
1578     InPlaceSite_Release,
1579     InPlaceSite_GetWindow,
1580     InPlaceSite_ContextSensitiveHelp,
1581     InPlaceSite_CanInPlaceActivate,
1582     InPlaceSite_OnInPlaceActivate,
1583     InPlaceSite_OnUIActivate,
1584     InPlaceSite_GetWindowContext,
1585     InPlaceSite_Scroll,
1586     InPlaceSite_OnUIDeactivate,
1587     InPlaceSite_OnInPlaceDeactivate,
1588     InPlaceSite_DiscardUndoState,
1589     InPlaceSite_DeactivateAndUndo,
1590     InPlaceSite_OnPosRectChange,
1591 };
1592
1593 static IOleInPlaceSite InPlaceSite = { &InPlaceSiteVtbl };
1594
1595 static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
1596 {
1597     return cs_qi(riid, ppv);
1598 }
1599
1600 static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
1601 {
1602     return 2;
1603 }
1604
1605 static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
1606 {
1607     return 1;
1608 }
1609
1610 static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
1611 {
1612     ok(0, "unexpected call\n");
1613     return E_NOTIMPL;
1614 }
1615
1616 static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker,
1617         IMoniker **ppmon)
1618 {
1619     ok(0, "unexpected call\n");
1620     return E_NOTIMPL;
1621 }
1622
1623 static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
1624 {
1625     return E_NOTIMPL;
1626 }
1627
1628 static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
1629 {
1630     ok(0, "unexpected call\n");
1631     return E_NOTIMPL;
1632 }
1633
1634 static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
1635 {
1636     ok(0, "unexpected call\n");
1637     return E_NOTIMPL;
1638 }
1639
1640 static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
1641 {
1642     ok(0, "unexpected call\n");
1643     return E_NOTIMPL;
1644 }
1645
1646 static const IOleClientSiteVtbl ClientSiteVtbl = {
1647     ClientSite_QueryInterface,
1648     ClientSite_AddRef,
1649     ClientSite_Release,
1650     ClientSite_SaveObject,
1651     ClientSite_GetMoniker,
1652     ClientSite_GetContainer,
1653     ClientSite_ShowObject,
1654     ClientSite_OnShowWindow,
1655     ClientSite_RequestNewObjectLayout
1656 };
1657
1658 static IOleClientSite ClientSite = { &ClientSiteVtbl };
1659
1660 static HRESULT WINAPI DocumentSite_QueryInterface(IOleDocumentSite *iface, REFIID riid, void **ppv)
1661 {
1662     return cs_qi(riid, ppv);
1663 }
1664
1665 static ULONG WINAPI DocumentSite_AddRef(IOleDocumentSite *iface)
1666 {
1667     return 2;
1668 }
1669
1670 static ULONG WINAPI DocumentSite_Release(IOleDocumentSite *iface)
1671 {
1672     return 1;
1673 }
1674
1675 static HRESULT WINAPI DocumentSite_ActivateMe(IOleDocumentSite *iface, IOleDocumentView *pViewToActivate)
1676 {
1677     RECT rect = {0,0,400,500};
1678     IOleDocument *document;
1679     HRESULT hres;
1680
1681     hres = IOleDocumentView_QueryInterface(pViewToActivate, &IID_IOleDocument, (void**)&document);
1682     ok(hres == S_OK, "could not get IOleDocument: %08x\n", hres);
1683
1684     hres = IOleDocument_CreateView(document, &InPlaceSite, NULL, 0, &view);
1685     IOleDocument_Release(document);
1686     ok(hres == S_OK, "CreateView failed: %08x\n", hres);
1687
1688     hres = IOleDocumentView_SetInPlaceSite(view, &InPlaceSite);
1689     ok(hres == S_OK, "SetInPlaceSite failed: %08x\n", hres);
1690
1691     hres = IOleDocumentView_UIActivate(view, TRUE);
1692     ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
1693
1694     hres = IOleDocumentView_SetRect(view, &rect);
1695     ok(hres == S_OK, "SetRect failed: %08x\n", hres);
1696
1697     hres = IOleDocumentView_Show(view, TRUE);
1698     ok(hres == S_OK, "Show failed: %08x\n", hres);
1699
1700     return S_OK;
1701 }
1702
1703 static const IOleDocumentSiteVtbl DocumentSiteVtbl = {
1704     DocumentSite_QueryInterface,
1705     DocumentSite_AddRef,
1706     DocumentSite_Release,
1707     DocumentSite_ActivateMe
1708 };
1709
1710 static IOleDocumentSite DocumentSite = { &DocumentSiteVtbl };
1711
1712 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface,
1713                                                      REFIID riid, void **ppv)
1714 {
1715     return cs_qi(riid, ppv);
1716 }
1717
1718 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
1719 {
1720     return 2;
1721 }
1722
1723 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
1724 {
1725     return 1;
1726 }
1727
1728 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService,
1729         REFIID riid, void **ppv)
1730 {
1731     if(IsEqualGUID(&CLSID_TestActiveX, guidService)) {
1732         CHECK_EXPECT(QueryService_TestActiveX);
1733         ok(IsEqualGUID(&IID_IUnknown, riid), "unexpected riid %s\n", debugstr_guid(riid));
1734         *ppv = &OleObject;
1735         return S_OK;
1736     }
1737
1738     *ppv = NULL;
1739     return E_NOINTERFACE;
1740 }
1741
1742 static const IServiceProviderVtbl ServiceProviderVtbl = {
1743     ServiceProvider_QueryInterface,
1744     ServiceProvider_AddRef,
1745     ServiceProvider_Release,
1746     ServiceProvider_QueryService
1747 };
1748
1749 static IServiceProvider ServiceProvider = { &ServiceProviderVtbl };
1750
1751 static HRESULT cs_qi(REFIID riid, void **ppv)
1752 {
1753     *ppv = NULL;
1754
1755     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IOleClientSite, riid))
1756         *ppv = &ClientSite;
1757     else if(IsEqualGUID(&IID_IOleDocumentSite, riid))
1758         *ppv = &DocumentSite;
1759     else if(IsEqualGUID(&IID_IOleWindow, riid) || IsEqualGUID(&IID_IOleInPlaceSite, riid))
1760         *ppv = &InPlaceSite;
1761     else if(IsEqualGUID(riid, &IID_IServiceProvider))
1762         *ppv = &ServiceProvider;
1763
1764     return *ppv ? S_OK : E_NOINTERFACE;
1765 }
1766
1767 static IHTMLDocument2 *notif_doc;
1768 static BOOL doc_complete;
1769
1770 static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
1771         REFIID riid, void**ppv)
1772 {
1773     if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
1774         *ppv = iface;
1775         return S_OK;
1776     }
1777
1778     ok(0, "unexpected call\n");
1779     return E_NOINTERFACE;
1780 }
1781
1782 static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
1783 {
1784     return 2;
1785 }
1786
1787 static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
1788 {
1789     return 1;
1790 }
1791
1792 static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
1793 {
1794     if(dispID == DISPID_READYSTATE){
1795         BSTR state;
1796         HRESULT hres;
1797
1798         static const WCHAR completeW[] = {'c','o','m','p','l','e','t','e',0};
1799
1800         hres = IHTMLDocument2_get_readyState(notif_doc, &state);
1801         ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
1802
1803         if(!lstrcmpW(state, completeW))
1804             doc_complete = TRUE;
1805
1806         SysFreeString(state);
1807     }
1808
1809     return S_OK;
1810 }
1811
1812 static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
1813 {
1814     ok(0, "unexpected call\n");
1815     return E_NOTIMPL;
1816 }
1817
1818 static IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
1819     PropertyNotifySink_QueryInterface,
1820     PropertyNotifySink_AddRef,
1821     PropertyNotifySink_Release,
1822     PropertyNotifySink_OnChanged,
1823     PropertyNotifySink_OnRequestEdit
1824 };
1825
1826 static IPropertyNotifySink PropertyNotifySink = { &PropertyNotifySinkVtbl };
1827
1828 static void doc_load_string(IHTMLDocument2 *doc, const char *str)
1829 {
1830     IPersistStreamInit *init;
1831     IStream *stream;
1832     HGLOBAL mem;
1833     SIZE_T len;
1834
1835     notif_doc = doc;
1836
1837     doc_complete = FALSE;
1838     len = strlen(str);
1839     mem = GlobalAlloc(0, len);
1840     memcpy(mem, str, len);
1841     CreateStreamOnHGlobal(mem, TRUE, &stream);
1842
1843     IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&init);
1844
1845     IPersistStreamInit_Load(init, stream);
1846     IPersistStreamInit_Release(init);
1847     IStream_Release(stream);
1848 }
1849
1850 static void do_advise(IUnknown *unk, REFIID riid, IUnknown *unk_advise)
1851 {
1852     IConnectionPointContainer *container;
1853     IConnectionPoint *cp;
1854     DWORD cookie;
1855     HRESULT hres;
1856
1857     hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&container);
1858     ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08x\n", hres);
1859
1860     hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
1861     IConnectionPointContainer_Release(container);
1862     ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
1863
1864     hres = IConnectionPoint_Advise(cp, unk_advise, &cookie);
1865     IConnectionPoint_Release(cp);
1866     ok(hres == S_OK, "Advise failed: %08x\n", hres);
1867 }
1868
1869 static void set_client_site(IHTMLDocument2 *doc, BOOL set)
1870 {
1871     IOleObject *oleobj;
1872     HRESULT hres;
1873
1874     if(!set && view) {
1875         IOleDocumentView_Show(view, FALSE);
1876         IOleDocumentView_CloseView(view, 0);
1877         IOleDocumentView_SetInPlaceSite(view, NULL);
1878         IOleDocumentView_Release(view);
1879         view = NULL;
1880     }
1881
1882     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
1883     ok(hres == S_OK, "Could not et IOleObject: %08x\n", hres);
1884
1885     hres = IOleObject_SetClientSite(oleobj, set ? &ClientSite : NULL);
1886     ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
1887
1888     if(set) {
1889         IHlinkTarget *hlink;
1890
1891         hres = IOleObject_QueryInterface(oleobj, &IID_IHlinkTarget, (void**)&hlink);
1892         ok(hres == S_OK, "Could not get IHlinkTarget iface: %08x\n", hres);
1893
1894         hres = IHlinkTarget_Navigate(hlink, 0, NULL);
1895         ok(hres == S_OK, "Navgate failed: %08x\n", hres);
1896
1897         IHlinkTarget_Release(hlink);
1898     }
1899
1900     IOleObject_Release(oleobj);
1901 }
1902 static IHTMLDocument2 *create_document(void)
1903 {
1904     IHTMLDocument2 *doc;
1905     HRESULT hres;
1906
1907     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
1908             &IID_IHTMLDocument2, (void**)&doc);
1909     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
1910
1911     return doc;
1912 }
1913
1914 static IHTMLDocument2 *create_doc(const char *str, BOOL *b)
1915 {
1916     IHTMLDocument2 *doc;
1917     MSG msg;
1918
1919     doc = create_document();
1920     set_client_site(doc, TRUE);
1921     doc_load_string(doc, str);
1922     do_advise((IUnknown*)doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
1923
1924     while((!doc_complete || (b && !*b)) && GetMessage(&msg, NULL, 0, 0)) {
1925         TranslateMessage(&msg);
1926         DispatchMessage(&msg);
1927     }
1928
1929     return doc;
1930 }
1931
1932 static void release_doc(IHTMLDocument2 *doc)
1933 {
1934     ULONG ref;
1935
1936     set_client_site(doc, FALSE);
1937     ref = IHTMLDocument2_Release(doc);
1938     ok(!ref, "ref = %d\n", ref);
1939
1940     if(client_site) {
1941         IOleClientSite_Release(client_site);
1942         client_site = NULL;
1943     }
1944
1945     if(plugin_hwnd) {
1946         DestroyWindow(plugin_hwnd);
1947         plugin_hwnd = NULL;
1948     }
1949 }
1950
1951 static void test_object_ax(void)
1952 {
1953     IHTMLDocument2 *doc;
1954
1955     /*
1956      * We pump messages until both document is loaded and plugin instance is created.
1957      * Pumping until document is loaded should be enough, but Gecko loads plugins
1958      * asynchronously and until we'll work around it, we need this hack.
1959      */
1960     SET_EXPECT(CreateInstance);
1961     SET_EXPECT(FreezeEvents_TRUE);
1962     SET_EXPECT(QuickActivate);
1963     SET_EXPECT(FreezeEvents_FALSE);
1964     SET_EXPECT(IPersistPropertyBag_Load);
1965     SET_EXPECT(Invoke_READYSTATE);
1966     SET_EXPECT(SetExtent);
1967     SET_EXPECT(GetExtent);
1968     SET_EXPECT(DoVerb);
1969
1970     doc = create_doc(object_ax_str, &called_CreateInstance);
1971
1972     CHECK_CALLED(CreateInstance);
1973     todo_wine
1974     CHECK_CALLED(FreezeEvents_TRUE);
1975     CHECK_CALLED(QuickActivate);
1976     todo_wine
1977     CHECK_CALLED(FreezeEvents_FALSE);
1978     CHECK_CALLED(IPersistPropertyBag_Load);
1979     CHECK_CALLED(Invoke_READYSTATE);
1980     todo_wine
1981     CHECK_CALLED(SetExtent);
1982     todo_wine
1983     CHECK_CALLED(GetExtent);
1984     CHECK_CALLED(DoVerb);
1985
1986     /* Set in DoVerb */
1987     CHECK_CALLED(InPlaceObject_GetWindow);
1988     CHECK_CALLED(SetObjectRects);
1989
1990     test_ui_activate();
1991     test_container(notif_doc);
1992     test_object_elem(notif_doc);
1993
1994     SET_EXPECT(UIDeactivate);
1995     SET_EXPECT(Invoke_ENABLED);
1996     SET_EXPECT(Invoke_VALID);
1997     SET_EXPECT(InPlaceDeactivate);
1998     SET_EXPECT(Close);
1999     SET_EXPECT(SetClientSite_NULL);
2000     release_doc(doc);
2001     CHECK_CALLED(UIDeactivate);
2002     todo_wine
2003     CHECK_CALLED(Invoke_ENABLED);
2004     todo_wine
2005     CHECK_CALLED(Invoke_VALID);
2006     CHECK_CALLED(InPlaceDeactivate);
2007     CHECK_CALLED(Close);
2008     CHECK_CALLED(SetClientSite_NULL);
2009 }
2010
2011 static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
2012 {
2013     return DefWindowProc(hwnd, msg, wParam, lParam);
2014 }
2015
2016 static HWND create_container_window(void)
2017 {
2018     static const WCHAR html_document_testW[] =
2019         {'H','T','M','L','D','o','c','u','m','e','n','t','T','e','s','t',0};
2020     static WNDCLASSEXW wndclass = {
2021         sizeof(WNDCLASSEXW),
2022         0,
2023         wnd_proc,
2024         0, 0, NULL, NULL, NULL, NULL, NULL,
2025         html_document_testW,
2026         NULL
2027     };
2028
2029     RegisterClassExW(&wndclass);
2030     return CreateWindowW(html_document_testW, html_document_testW,
2031             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
2032             515, 530, NULL, NULL, NULL, NULL);
2033 }
2034
2035 static BOOL init_key(const char *key_name, const char *def_value, BOOL init)
2036 {
2037     HKEY hkey;
2038     DWORD res;
2039
2040     if(!init) {
2041         RegDeleteKey(HKEY_CLASSES_ROOT, key_name);
2042         return TRUE;
2043     }
2044
2045     res = RegCreateKeyA(HKEY_CLASSES_ROOT, key_name, &hkey);
2046     if(res != ERROR_SUCCESS)
2047         return FALSE;
2048
2049     if(def_value)
2050         res = RegSetValueA(hkey, NULL, REG_SZ, def_value, strlen(def_value));
2051
2052     RegCloseKey(hkey);
2053
2054     return res == ERROR_SUCCESS;
2055 }
2056
2057 static BOOL init_registry(BOOL init)
2058 {
2059     return init_key("TestActiveX\\CLSID", TESTACTIVEX_CLSID, init)
2060         && init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95801-9882-11cf-9fa9-00aa006c42c4}",
2061                     NULL, init)
2062         && init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95802-9882-11cf-9fa9-00aa006c42c4}",
2063                     NULL, init);
2064 }
2065
2066 static BOOL register_activex(void)
2067 {
2068     DWORD regid;
2069     HRESULT hres;
2070
2071     if(!init_registry(TRUE)) {
2072         init_registry(FALSE);
2073         return FALSE;
2074     }
2075
2076     hres = CoRegisterClassObject(&CLSID_TestActiveX, (IUnknown*)&activex_cf,
2077             CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
2078     ok(hres == S_OK, "Could not register control: %08x\n", hres);
2079
2080     return TRUE;
2081 }
2082
2083 static BOOL check_ie(void)
2084 {
2085     IHTMLDocument5 *doc;
2086     HRESULT hres;
2087
2088     static const WCHAR xW[] = {'x',0};
2089     static const WCHAR yW[] = {'y',0};
2090
2091     if(!lstrcmpW(xW, yW))
2092         return FALSE;
2093
2094     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
2095             &IID_IHTMLDocument5, (void**)&doc);
2096     if(FAILED(hres))
2097         return FALSE;
2098
2099     IHTMLDocument5_Release(doc);
2100     return TRUE;
2101 }
2102
2103 START_TEST(activex)
2104 {
2105     CoInitialize(NULL);
2106
2107     if(!check_ie()) {
2108         CoUninitialize();
2109         win_skip("Too old IE\n");
2110         return;
2111     }
2112
2113     if(is_ie_hardened()) {
2114         CoUninitialize();
2115         win_skip("IE running in Enhanced Security Configuration\n");
2116         return;
2117     }
2118
2119     container_hwnd = create_container_window();
2120     ShowWindow(container_hwnd, SW_SHOW);
2121
2122     if(register_activex()) {
2123         test_object_ax();
2124         init_registry(FALSE);
2125     }else {
2126         skip("Could not register ActiveX\n");
2127     }
2128
2129     DestroyWindow(container_hwnd);
2130     CoUninitialize();
2131 }