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 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     frame_info.cb = sizeof(OLEINPLACEFRAMEINFO);
 893     hres = IOleInPlaceSiteEx_GetWindowContext(ip_site, &ip_frame, &ip_uiwindow, &pos_rect, &clip_rect, &frame_info);
 894     ok(hres == S_OK, "GetWindowContext failed: %08x\n", hres);
 895     ok(ip_frame != NULL, "ip_frame == NULL\n");
 896     ok(ip_uiwindow != NULL, "ip_uiwindow == NULL\n");
 897     ok((IOleInPlaceUIWindow*)ip_frame != ip_uiwindow, "ip_frame == ip_uiwindow\n");
 898     ok(!memcmp(&pos_rect, lprcPosRect, sizeof(RECT)), "pos_rect != lpecPosRect\n");
 899     ok(!memcmp(&clip_rect, lprcPosRect, sizeof(RECT)), "clip_rect != lpecPosRect\n");
 900     ok(frame_info.cb == sizeof(frame_info), "frame_info.cb = %d\n", frame_info.cb);
 901     ok(!frame_info.fMDIApp, "frame_info.fMDIApp = %x\n", frame_info.fMDIApp);
 902     ok(frame_info.hwndFrame != NULL, "frame_info.hwnd == NULL\n");
 903     ok(frame_info.hwndFrame == container_hwnd, "frame_info.hwnd != container_hwnd\n");
 904     ok(!frame_info.haccel, "frame_info.haccel != 0\n");
 905     ok(!frame_info.cAccelEntries, "frame_info.cAccelEntried != 0\n");
 906
 907     IOleInPlaceFrame_Release(ip_frame);
 908     IOleInPlaceUIWindow_Release(ip_uiwindow);
 909
 910
 911     IOleInPlaceSiteEx_Release(ip_site);
 912
 913     hres = IOleClientSite_ShowObject(client_site);
 914     ok(hres == S_OK, "ShowObject failed: %08x\n", hres);
 915
 916     SET_EXPECT(InPlaceObject_GetWindow);
 917     SET_EXPECT(SetObjectRects);
 918
 919     return S_OK;
 920 }
 921
 922 static HRESULT WINAPI OleObject_EnumVerbs(IOleObject *iface, IEnumOLEVERB **ppEnumOleVerb)
 923 {
 924     ok(0, "unexpected call\n");
 925     return E_NOTIMPL;
 926 }
 927
 928 static HRESULT WINAPI OleObject_Update(IOleObject *iface)
 929 {
 930     ok(0, "unexpected call\n");
 931     return E_NOTIMPL;
 932 }
 933
 934 static HRESULT WINAPI OleObject_IsUpToDate(IOleObject *iface)
 935 {
 936     ok(0, "unexpected call\n");
 937     return E_NOTIMPL;
 938 }
 939
 940 static HRESULT WINAPI OleObject_GetUserClassID(IOleObject *iface, CLSID *pClsid)
 941 {
 942     ok(0, "unexpected call\n");
 943     return E_NOTIMPL;
 944 }
 945
 946 static HRESULT WINAPI OleObject_GetUserType(IOleObject *iface, DWORD dwFormOfType, LPOLESTR *pszUserType)
 947 {
 948     ok(0, "unexpected call\n");
 949     return E_NOTIMPL;
 950 }
 951
 952 static HRESULT WINAPI OleObject_SetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
 953 {
 954     CHECK_EXPECT(SetExtent);
 955     return E_NOTIMPL;
 956 }
 957
 958 static HRESULT WINAPI OleObject_GetExtent(IOleObject *iface, DWORD dwDrawAspect, SIZEL *psizel)
 959 {
 960     CHECK_EXPECT(GetExtent);
 961     return E_NOTIMPL;
 962 }
 963
 964 static HRESULT WINAPI OleObject_Advise(IOleObject *iface, IAdviseSink *pAdvSink, DWORD *pdwConnection)
 965 {
 966     ok(0, "unexpected call\n");
 967     return E_NOTIMPL;
 968 }
 969
 970 static HRESULT WINAPI OleObject_Unadvise(IOleObject *iface, DWORD dwConnection)
 971 {
 972     ok(0, "unexpected call\n");
 973     return E_NOTIMPL;
 974 }
 975
 976 static HRESULT WINAPI OleObject_EnumAdvise(IOleObject *iface, IEnumSTATDATA **ppenumAdvise)
 977 {
 978     ok(0, "unexpected call\n");
 979     return E_NOTIMPL;
 980 }
 981
 982 static HRESULT WINAPI OleObject_GetMiscStatus(IOleObject *iface, DWORD dwAspect, DWORD *pdwStatus)
 983 {
 984     ok(0, "unexpected call\n");
 985     return E_NOTIMPL;
 986 }
 987
 988 static HRESULT WINAPI OleObject_SetColorScheme(IOleObject *iface, LOGPALETTE *pLogpal)
 989 {
 990     ok(0, "unexpected call\n");
 991     return E_NOTIMPL;
 992 }
 993
 994 static const IOleObjectVtbl OleObjectVtbl = {
 995     OleObject_QueryInterface,
 996     OleObject_AddRef,
 997     OleObject_Release,
 998     OleObject_SetClientSite,
 999     OleObject_GetClientSite,
1000     OleObject_SetHostNames,
1001     OleObject_Close,
1002     OleObject_SetMoniker,
1003     OleObject_GetMoniker,
1004     OleObject_InitFromData,
1005     OleObject_GetClipboardData,
1006     OleObject_DoVerb,
1007     OleObject_EnumVerbs,
1008     OleObject_Update,
1009     OleObject_IsUpToDate,
1010     OleObject_GetUserClassID,
1011     OleObject_GetUserType,
1012     OleObject_SetExtent,
1013     OleObject_GetExtent,
1014     OleObject_Advise,
1015     OleObject_Unadvise,
1016     OleObject_EnumAdvise,
1017     OleObject_GetMiscStatus,
1018     OleObject_SetColorScheme
1019 };
1020
1021 static IOleObject OleObject = { &OleObjectVtbl };
1022
1023 static HRESULT WINAPI OleInPlaceObject_QueryInterface(IOleInPlaceObjectWindowless *iface,
1024         REFIID riid, void **ppv)
1025 {
1026     return ax_qi(riid, ppv);
1027 }
1028
1029 static ULONG WINAPI OleInPlaceObject_AddRef(IOleInPlaceObjectWindowless *iface)
1030 {
1031     return 2;
1032 }
1033
1034 static ULONG WINAPI OleInPlaceObject_Release(IOleInPlaceObjectWindowless *iface)
1035 {
1036     return 1;
1037 }
1038
1039 static HRESULT WINAPI OleInPlaceObject_GetWindow(IOleInPlaceObjectWindowless *iface,
1040         HWND *phwnd)
1041 {
1042     CHECK_EXPECT2(InPlaceObject_GetWindow);
1043
1044     ok(phwnd != NULL, "phwnd == NULL\n");
1045
1046     *phwnd = plugin_hwnd;
1047     return *phwnd ? S_OK : E_UNEXPECTED;
1048 }
1049
1050 static HRESULT WINAPI OleInPlaceObject_ContextSensitiveHelp(IOleInPlaceObjectWindowless *iface,
1051         BOOL fEnterMode)
1052 {
1053     ok(0, "unexpected call\n");
1054     return E_NOTIMPL;
1055 }
1056
1057 static HRESULT WINAPI OleInPlaceObject_InPlaceDeactivate(IOleInPlaceObjectWindowless *iface)
1058 {
1059     IOleInPlaceSite *ip_site;
1060     HRESULT hres;
1061
1062     CHECK_EXPECT(InPlaceDeactivate);
1063
1064     hres = IOleClientSite_QueryInterface(client_site, &IID_IOleInPlaceSite, (void**)&ip_site);
1065     ok(hres == S_OK, "Could not get IOleInPlaceSite iface: %08x\n", hres);
1066
1067     hres = IOleInPlaceSite_OnInPlaceDeactivate(ip_site);
1068     ok(hres == S_OK, "OnInPlaceDeactivate failed: %08x\n", hres);
1069
1070     IOleInPlaceSite_Release(ip_site);
1071     return S_OK;
1072 }
1073
1074 static HRESULT WINAPI OleInPlaceObject_UIDeactivate(IOleInPlaceObjectWindowless *iface)
1075 {
1076     CHECK_EXPECT2(UIDeactivate);
1077     return S_OK;
1078 }
1079
1080 static HRESULT WINAPI OleInPlaceObject_SetObjectRects(IOleInPlaceObjectWindowless *iface,
1081         LPCRECT lprcPosRect, LPCRECT lprcClipRect)
1082 {
1083     CHECK_EXPECT(SetObjectRects);
1084     return S_OK;
1085 }
1086
1087 static HRESULT WINAPI OleInPlaceObjectWindowless_ReactivateAndUndo(IOleInPlaceObjectWindowless *iface)
1088 {
1089     ok(0, "unexpected call\n");
1090     return E_NOTIMPL;
1091 }
1092
1093 static HRESULT WINAPI OleInPlaceObjectWindowless_OnWindowMessage(IOleInPlaceObjectWindowless *iface,
1094         UINT msg, WPARAM wParam, LPARAM lParam, LRESULT *lpResult)
1095 {
1096     ok(0, "unexpected call\n");
1097     return E_NOTIMPL;
1098 }
1099
1100 static HRESULT WINAPI OleInPlaceObjectWindowless_GetDropTarget(IOleInPlaceObjectWindowless *iface,
1101         IDropTarget **ppDropTarget)
1102 {
1103     ok(0, "unexpected call\n");
1104     return E_NOTIMPL;
1105 }
1106
1107 static const IOleInPlaceObjectWindowlessVtbl OleInPlaceObjectWindowlessVtbl = {
1108     OleInPlaceObject_QueryInterface,
1109     OleInPlaceObject_AddRef,
1110     OleInPlaceObject_Release,
1111     OleInPlaceObject_GetWindow,
1112     OleInPlaceObject_ContextSensitiveHelp,
1113     OleInPlaceObject_InPlaceDeactivate,
1114     OleInPlaceObject_UIDeactivate,
1115     OleInPlaceObject_SetObjectRects,
1116     OleInPlaceObjectWindowless_ReactivateAndUndo,
1117     OleInPlaceObjectWindowless_OnWindowMessage,
1118     OleInPlaceObjectWindowless_GetDropTarget
1119 };
1120
1121 static IOleInPlaceObjectWindowless OleInPlaceObjectWindowless = { &OleInPlaceObjectWindowlessVtbl };
1122
1123 static HRESULT ax_qi(REFIID riid, void **ppv)
1124 {
1125     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IOleControl)) {
1126         *ppv = &OleControl;
1127         return S_OK;
1128     }
1129
1130     if(IsEqualGUID(riid, &IID_IQuickActivate)) {
1131         *ppv = &QuickActivate;
1132         return S_OK;
1133     }
1134
1135     if(IsEqualGUID(riid, &IID_IPersistPropertyBag)) {
1136         *ppv = &PersistPropertyBag;
1137         return S_OK;
1138     }
1139
1140     if(IsEqualGUID(riid, &IID_IDispatch)) {
1141         *ppv = &Dispatch;
1142         return S_OK;
1143     }
1144
1145     if(IsEqualGUID(riid, &IID_IViewObject) || IsEqualGUID(riid, &IID_IViewObject2) || IsEqualGUID(riid, &IID_IViewObjectEx)) {
1146         *ppv = &ViewObjectEx;
1147         return S_OK;
1148     }
1149
1150     if(IsEqualGUID(riid, &IID_IOleObject)) {
1151         *ppv = &OleObject;
1152         return S_OK;
1153     }
1154
1155     if(IsEqualGUID(riid, &IID_IOleWindow) || IsEqualGUID(riid, &IID_IOleInPlaceObject)
1156        || IsEqualGUID(&IID_IOleInPlaceObjectWindowless, riid)) {
1157         *ppv = &OleInPlaceObjectWindowless;
1158         return S_OK;
1159     }
1160
1161     *ppv = NULL;
1162     return E_NOINTERFACE;
1163 }
1164
1165 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
1166 {
1167     *ppv = NULL;
1168
1169     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
1170         *ppv = iface;
1171         return S_OK;
1172     }
1173
1174     if(IsEqualGUID(&IID_IMarshal, riid))
1175         return E_NOINTERFACE;
1176     if(IsEqualGUID(&CLSID_IdentityUnmarshal, riid))
1177         return E_NOINTERFACE;
1178     if(IsEqualGUID(&IID_IClassFactoryEx, riid))
1179         return E_NOINTERFACE; /* TODO */
1180
1181     ok(0, "unexpected riid %s\n", debugstr_guid(riid));
1182     return E_NOTIMPL;
1183 }
1184
1185 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
1186 {
1187     return 2;
1188 }
1189
1190 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
1191 {
1192     return 1;
1193 }
1194
1195 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
1196 {
1197     CHECK_EXPECT(CreateInstance);
1198
1199     ok(!outer, "outer = %p\n", outer);
1200     ok(IsEqualGUID(riid, &IID_IUnknown), "riid = %s\n", debugstr_guid(riid));
1201
1202     *ppv = &OleControl;
1203     return S_OK;
1204 }
1205
1206 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
1207 {
1208     ok(0, "unexpected call\n");
1209     return S_OK;
1210 }
1211
1212 static const IClassFactoryVtbl ClassFactoryVtbl = {
1213     ClassFactory_QueryInterface,
1214     ClassFactory_AddRef,
1215     ClassFactory_Release,
1216     ClassFactory_CreateInstance,
1217     ClassFactory_LockServer
1218 };
1219
1220 static IClassFactory activex_cf = { &ClassFactoryVtbl };
1221
1222 static void test_elem_dispex(IDispatchEx *dispex)
1223 {
1224     DISPPARAMS dp;
1225     EXCEPINFO ei;
1226     VARIANT v;
1227     DISPID id;
1228     BSTR str;
1229     HRESULT hres;
1230
1231     str = a2bstr("scriptprop");
1232     SET_EXPECT(GetIDsOfNames_scriptprop);
1233     hres = IDispatchEx_GetDispID(dispex, str, 0, &id);
1234     CHECK_CALLED(GetIDsOfNames_scriptprop);
1235     SysFreeString(str);
1236     ok(hres == S_OK, "GetDispID failed: %08x\n", hres);
1237     todo_wine
1238     ok(id == DISPID_SCRIPTPROP, "id = %d\n", id);
1239
1240     SET_EXPECT(Invoke_SECURITYCTX);
1241     SET_EXPECT(Invoke_SCRIPTPROP);
1242     memset(&dp, 0, sizeof(dp));
1243     memset(&ei, 0, sizeof(ei));
1244     V_VT(&v) = VT_EMPTY;
1245     hres = IDispatchEx_InvokeEx(dispex, id, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &dp, &v, &ei, NULL);
1246     ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
1247     ok(V_VT(&v) == VT_I4, "V_VT(v) = %d\n", V_VT(&v));
1248     ok(V_I4(&v) == 4, "V_I4(v) = %d\n", V_I4(&v));
1249     CHECK_CALLED(Invoke_SECURITYCTX);
1250     CHECK_CALLED(Invoke_SCRIPTPROP);
1251 }
1252
1253 static void test_object_elem(IHTMLDocument2 *doc)
1254 {
1255     IHTMLObjectElement *objelem;
1256     IHTMLDocument3 *doc3;
1257     IDispatchEx *dispex;
1258     IHTMLElement *elem;
1259     IDispatch *disp;
1260     BSTR str;
1261     HRESULT hres;
1262
1263     hres = IHTMLDocument2_QueryInterface(doc, &IID_IHTMLDocument3, (void**)&doc3);
1264     ok(hres == S_OK, "Could not get IHTMLDocument3 iface: %08x\n", hres);
1265
1266     str = a2bstr("objid");
1267     elem = (void*)0xdeadbeef;
1268     hres = IHTMLDocument3_getElementById(doc3, str, &elem);
1269     IHTMLDocument3_Release(doc3);
1270     SysFreeString(str);
1271     ok(hres == S_OK, "getElementById failed: %08x\n", hres);
1272     ok(elem != NULL, "elem == NULL\n");
1273
1274     hres = IHTMLElement_QueryInterface(elem, &IID_IHTMLObjectElement, (void**)&objelem);
1275     IHTMLElement_Release(elem);
1276     ok(hres == S_OK, "Could not get IHTMLObjectElement iface: %08x\n", hres);
1277
1278     SET_EXPECT(Invoke_SECURITYCTX);
1279     hres = IHTMLObjectElement_get_object(objelem, &disp);
1280     ok(hres == S_OK, "get_object failed: %08x\n", hres);
1281     ok(disp == &Dispatch, "disp != Dispatch\n");
1282     CHECK_CALLED(Invoke_SECURITYCTX);
1283
1284     hres = IHTMLObjectElement_QueryInterface(objelem, &IID_IDispatchEx, (void**)&dispex);
1285     ok(hres == S_OK, "QueryInterface failed: %08x\n", hres);
1286     test_elem_dispex(dispex);
1287     IDispatchEx_Release(dispex);
1288
1289     IHTMLObjectElement_Release(objelem);
1290 }
1291
1292 static void test_container(IHTMLDocument2 *doc_obj)
1293 {
1294     IHTMLWindow2 *parent_window, *html_window;
1295     IServiceProvider *serv_prov;
1296     IOleContainer *container;
1297     IHTMLDocument2 *doc;
1298     IUnknown *unk;
1299     HRESULT hres;
1300
1301     container = NULL;
1302     hres = IOleClientSite_GetContainer(client_site, &container);
1303     ok(hres == S_OK, "GetContainer failed: %08x\n", hres);
1304     ok(container != NULL, "container == NULL\n");
1305
1306     hres = IHTMLDocument2_get_parentWindow(doc_obj, &parent_window);
1307     ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
1308     ok(parent_window != NULL, "parentWindow == NULL\n");
1309
1310     hres = IHTMLWindow2_get_document(parent_window, &doc);
1311     ok(hres == S_OK, "get_document failed: %08x\n", hres);
1312     ok(doc != NULL, "doc == NULL\n");
1313     ok(iface_cmp((IUnknown*)doc, (IUnknown*)container), "container != doc\n");
1314     IHTMLDocument2_Release(doc);
1315
1316     hres = IOleClientSite_QueryInterface(client_site, &IID_IServiceProvider, (void**)&serv_prov);
1317     ok(hres == S_OK, "Could not get IServiceProvider iface: %08x\n", hres);
1318
1319     hres = IServiceProvider_QueryService(serv_prov, &IID_IHTMLWindow2, &IID_IHTMLWindow2, (void**)&html_window);
1320     ok(hres == S_OK, "Could not get IHTMLWindow2 service: %08x\n", hres);
1321     todo_wine
1322     ok(!iface_cmp((IUnknown*)html_window, (IUnknown*)parent_window), "html_window != parent_window\n");
1323     IHTMLWindow2_Release(html_window);
1324
1325     SET_EXPECT(QueryService_TestActiveX);
1326     hres = IServiceProvider_QueryService(serv_prov, &CLSID_TestActiveX, &IID_IUnknown, (void**)&unk);
1327     ok(hres == S_OK, "QueryService(CLSID_TestActiveX) failed: %08x\n", hres);
1328     ok(unk == (IUnknown*)&OleObject, "unexpected unk %p\n", unk);
1329     CHECK_CALLED(QueryService_TestActiveX);
1330
1331     IServiceProvider_Release(serv_prov);
1332
1333     IHTMLWindow2_Release(parent_window);
1334     IOleContainer_Release(container);
1335 }
1336
1337 static void test_ui_activate(void)
1338 {
1339     IOleInPlaceSite *ip_site;
1340     HRESULT hres;
1341
1342     hres = IOleClientSite_QueryInterface(client_site, &IID_IOleInPlaceSite, (void**)&ip_site);
1343     ok(hres == S_OK, "Could not get IOleInPlaceSite iface: %08x\n", hres);
1344
1345     SET_EXPECT(Invoke_ENABLED);
1346     hres = IOleInPlaceSite_OnUIActivate(ip_site);
1347     ok(hres == S_OK, "OnUIActivate failed: %08x\n", hres);
1348     CHECK_CALLED(Invoke_ENABLED);
1349
1350     IOleInPlaceSite_Release(ip_site);
1351 }
1352
1353 static HRESULT cs_qi(REFIID,void **);
1354 static IOleDocumentView *view;
1355
1356 static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
1357 {
1358     static const GUID undocumented_frame_iid = {0xfbece6c9,0x48d7,0x4a37,{0x8f,0xe3,0x6a,0xd4,0x27,0x2f,0xdd,0xac}};
1359
1360     if(!IsEqualGUID(&undocumented_frame_iid, riid))
1361         ok(0, "unexpected riid %s\n", debugstr_guid(riid));
1362
1363     *ppv = NULL;
1364     return E_NOINTERFACE;
1365 }
1366
1367 static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface)
1368 {
1369     return 2;
1370 }
1371
1372 static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface)
1373 {
1374     return 1;
1375 }
1376
1377 static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
1378 {
1379     return E_NOTIMPL;
1380 }
1381
1382 static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
1383 {
1384     return E_NOTIMPL;
1385 }
1386
1387 static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
1388 {
1389     return E_NOTIMPL;
1390 }
1391
1392 static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface,
1393         LPCBORDERWIDTHS pborderwidths)
1394 {
1395     return E_NOTIMPL;
1396 }
1397
1398 static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface,
1399         LPCBORDERWIDTHS pborderwidths)
1400 {
1401     return S_OK;
1402 }
1403
1404 static HRESULT WINAPI InPlaceUIWindow_SetActiveObject(IOleInPlaceFrame *iface,
1405         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1406 {
1407     return S_OK;
1408 }
1409
1410 static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
1411         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
1412 {
1413     return S_OK;
1414 }
1415
1416 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
1417         LPOLEMENUGROUPWIDTHS lpMenuWidths)
1418 {
1419     return E_NOTIMPL;
1420 }
1421
1422 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
1423         HOLEMENU holemenu, HWND hwndActiveObject)
1424 {
1425     ok(0, "unexpected call\n");
1426     return E_NOTIMPL;
1427 }
1428
1429 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
1430 {
1431     ok(0, "unexpected call\n");
1432     return E_NOTIMPL;
1433 }
1434
1435 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
1436 {
1437     return S_OK;
1438 }
1439
1440 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
1441 {
1442     return E_NOTIMPL;
1443 }
1444
1445 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
1446 {
1447     ok(0, "unexpected call\n");
1448     return E_NOTIMPL;
1449 }
1450
1451 static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
1452     InPlaceFrame_QueryInterface,
1453     InPlaceFrame_AddRef,
1454     InPlaceFrame_Release,
1455     InPlaceFrame_GetWindow,
1456     InPlaceFrame_ContextSensitiveHelp,
1457     InPlaceFrame_GetBorder,
1458     InPlaceFrame_RequestBorderSpace,
1459     InPlaceFrame_SetBorderSpace,
1460     InPlaceFrame_SetActiveObject,
1461     InPlaceFrame_InsertMenus,
1462     InPlaceFrame_SetMenu,
1463     InPlaceFrame_RemoveMenus,
1464     InPlaceFrame_SetStatusText,
1465     InPlaceFrame_EnableModeless,
1466     InPlaceFrame_TranslateAccelerator
1467 };
1468
1469 static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
1470
1471 static const IOleInPlaceFrameVtbl InPlaceUIWindowVtbl = {
1472     InPlaceFrame_QueryInterface,
1473     InPlaceFrame_AddRef,
1474     InPlaceFrame_Release,
1475     InPlaceFrame_GetWindow,
1476     InPlaceFrame_ContextSensitiveHelp,
1477     InPlaceFrame_GetBorder,
1478     InPlaceFrame_RequestBorderSpace,
1479     InPlaceFrame_SetBorderSpace,
1480     InPlaceUIWindow_SetActiveObject,
1481 };
1482
1483 static IOleInPlaceFrame InPlaceUIWindow = { &InPlaceUIWindowVtbl };
1484
1485 static HRESULT WINAPI InPlaceSite_QueryInterface(IOleInPlaceSite *iface, REFIID riid, void **ppv)
1486 {
1487     return cs_qi(riid, ppv);
1488 }
1489
1490 static ULONG WINAPI InPlaceSite_AddRef(IOleInPlaceSite *iface)
1491 {
1492     return 2;
1493 }
1494
1495 static ULONG WINAPI InPlaceSite_Release(IOleInPlaceSite *iface)
1496 {
1497     return 1;
1498 }
1499
1500 static HRESULT WINAPI InPlaceSite_GetWindow(IOleInPlaceSite *iface, HWND *phwnd)
1501 {
1502     *phwnd = container_hwnd;
1503     return S_OK;
1504 }
1505
1506 static HRESULT WINAPI InPlaceSite_ContextSensitiveHelp(IOleInPlaceSite *iface, BOOL fEnterMode)
1507 {
1508     ok(0, "unexpected call\n");
1509     return E_NOTIMPL;
1510 }
1511
1512 static HRESULT WINAPI InPlaceSite_CanInPlaceActivate(IOleInPlaceSite *iface)
1513 {
1514     return S_OK;
1515 }
1516
1517 static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSite *iface)
1518 {
1519     return S_OK;
1520 }
1521
1522 static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSite *iface)
1523 {
1524     return S_OK;
1525 }
1526
1527 static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSite *iface,
1528         IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
1529         LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
1530 {
1531     static const RECT rect = {0,0,500,500};
1532
1533     *ppFrame = &InPlaceFrame;
1534     *ppDoc = (IOleInPlaceUIWindow*)&InPlaceUIWindow;
1535     *lprcPosRect = rect;
1536     *lprcClipRect = rect;
1537
1538     lpFrameInfo->fMDIApp = FALSE;
1539     lpFrameInfo->hwndFrame = container_hwnd;
1540     lpFrameInfo->haccel = NULL;
1541     lpFrameInfo->cAccelEntries = 0;
1542
1543     return S_OK;
1544 }
1545
1546 static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSite *iface, SIZE scrollExtant)
1547 {
1548     return E_NOTIMPL;
1549 }
1550
1551 static HRESULT WINAPI InPlaceSite_OnUIDeactivate(IOleInPlaceSite *iface, BOOL fUndoable)
1552 {
1553     return S_OK;
1554 }
1555
1556 static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivate(IOleInPlaceSite *iface)
1557 {
1558     return S_OK;
1559 }
1560
1561 static HRESULT WINAPI InPlaceSite_DiscardUndoState(IOleInPlaceSite *iface)
1562 {
1563     return E_NOTIMPL;
1564 }
1565
1566 static HRESULT WINAPI InPlaceSite_DeactivateAndUndo(IOleInPlaceSite *iface)
1567 {
1568     return E_NOTIMPL;
1569 }
1570
1571 static HRESULT WINAPI InPlaceSite_OnPosRectChange(IOleInPlaceSite *iface, LPCRECT lprcPosRect)
1572 {
1573     return E_NOTIMPL;
1574 }
1575
1576 static const IOleInPlaceSiteVtbl InPlaceSiteVtbl = {
1577     InPlaceSite_QueryInterface,
1578     InPlaceSite_AddRef,
1579     InPlaceSite_Release,
1580     InPlaceSite_GetWindow,
1581     InPlaceSite_ContextSensitiveHelp,
1582     InPlaceSite_CanInPlaceActivate,
1583     InPlaceSite_OnInPlaceActivate,
1584     InPlaceSite_OnUIActivate,
1585     InPlaceSite_GetWindowContext,
1586     InPlaceSite_Scroll,
1587     InPlaceSite_OnUIDeactivate,
1588     InPlaceSite_OnInPlaceDeactivate,
1589     InPlaceSite_DiscardUndoState,
1590     InPlaceSite_DeactivateAndUndo,
1591     InPlaceSite_OnPosRectChange,
1592 };
1593
1594 static IOleInPlaceSite InPlaceSite = { &InPlaceSiteVtbl };
1595
1596 static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
1597 {
1598     return cs_qi(riid, ppv);
1599 }
1600
1601 static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
1602 {
1603     return 2;
1604 }
1605
1606 static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
1607 {
1608     return 1;
1609 }
1610
1611 static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
1612 {
1613     ok(0, "unexpected call\n");
1614     return E_NOTIMPL;
1615 }
1616
1617 static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker,
1618         IMoniker **ppmon)
1619 {
1620     ok(0, "unexpected call\n");
1621     return E_NOTIMPL;
1622 }
1623
1624 static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
1625 {
1626     return E_NOTIMPL;
1627 }
1628
1629 static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
1630 {
1631     ok(0, "unexpected call\n");
1632     return E_NOTIMPL;
1633 }
1634
1635 static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
1636 {
1637     ok(0, "unexpected call\n");
1638     return E_NOTIMPL;
1639 }
1640
1641 static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
1642 {
1643     ok(0, "unexpected call\n");
1644     return E_NOTIMPL;
1645 }
1646
1647 static const IOleClientSiteVtbl ClientSiteVtbl = {
1648     ClientSite_QueryInterface,
1649     ClientSite_AddRef,
1650     ClientSite_Release,
1651     ClientSite_SaveObject,
1652     ClientSite_GetMoniker,
1653     ClientSite_GetContainer,
1654     ClientSite_ShowObject,
1655     ClientSite_OnShowWindow,
1656     ClientSite_RequestNewObjectLayout
1657 };
1658
1659 static IOleClientSite ClientSite = { &ClientSiteVtbl };
1660
1661 static HRESULT WINAPI DocumentSite_QueryInterface(IOleDocumentSite *iface, REFIID riid, void **ppv)
1662 {
1663     return cs_qi(riid, ppv);
1664 }
1665
1666 static ULONG WINAPI DocumentSite_AddRef(IOleDocumentSite *iface)
1667 {
1668     return 2;
1669 }
1670
1671 static ULONG WINAPI DocumentSite_Release(IOleDocumentSite *iface)
1672 {
1673     return 1;
1674 }
1675
1676 static HRESULT WINAPI DocumentSite_ActivateMe(IOleDocumentSite *iface, IOleDocumentView *pViewToActivate)
1677 {
1678     RECT rect = {0,0,400,500};
1679     IOleDocument *document;
1680     HRESULT hres;
1681
1682     hres = IOleDocumentView_QueryInterface(pViewToActivate, &IID_IOleDocument, (void**)&document);
1683     ok(hres == S_OK, "could not get IOleDocument: %08x\n", hres);
1684
1685     hres = IOleDocument_CreateView(document, &InPlaceSite, NULL, 0, &view);
1686     IOleDocument_Release(document);
1687     ok(hres == S_OK, "CreateView failed: %08x\n", hres);
1688
1689     hres = IOleDocumentView_SetInPlaceSite(view, &InPlaceSite);
1690     ok(hres == S_OK, "SetInPlaceSite failed: %08x\n", hres);
1691
1692     hres = IOleDocumentView_UIActivate(view, TRUE);
1693     ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
1694
1695     hres = IOleDocumentView_SetRect(view, &rect);
1696     ok(hres == S_OK, "SetRect failed: %08x\n", hres);
1697
1698     hres = IOleDocumentView_Show(view, TRUE);
1699     ok(hres == S_OK, "Show failed: %08x\n", hres);
1700
1701     return S_OK;
1702 }
1703
1704 static const IOleDocumentSiteVtbl DocumentSiteVtbl = {
1705     DocumentSite_QueryInterface,
1706     DocumentSite_AddRef,
1707     DocumentSite_Release,
1708     DocumentSite_ActivateMe
1709 };
1710
1711 static IOleDocumentSite DocumentSite = { &DocumentSiteVtbl };
1712
1713 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface,
1714                                                      REFIID riid, void **ppv)
1715 {
1716     return cs_qi(riid, ppv);
1717 }
1718
1719 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
1720 {
1721     return 2;
1722 }
1723
1724 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
1725 {
1726     return 1;
1727 }
1728
1729 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService,
1730         REFIID riid, void **ppv)
1731 {
1732     if(IsEqualGUID(&CLSID_TestActiveX, guidService)) {
1733         CHECK_EXPECT(QueryService_TestActiveX);
1734         ok(IsEqualGUID(&IID_IUnknown, riid), "unexpected riid %s\n", debugstr_guid(riid));
1735         *ppv = &OleObject;
1736         return S_OK;
1737     }
1738
1739     *ppv = NULL;
1740     return E_NOINTERFACE;
1741 }
1742
1743 static const IServiceProviderVtbl ServiceProviderVtbl = {
1744     ServiceProvider_QueryInterface,
1745     ServiceProvider_AddRef,
1746     ServiceProvider_Release,
1747     ServiceProvider_QueryService
1748 };
1749
1750 static IServiceProvider ServiceProvider = { &ServiceProviderVtbl };
1751
1752 static HRESULT cs_qi(REFIID riid, void **ppv)
1753 {
1754     *ppv = NULL;
1755
1756     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IOleClientSite, riid))
1757         *ppv = &ClientSite;
1758     else if(IsEqualGUID(&IID_IOleDocumentSite, riid))
1759         *ppv = &DocumentSite;
1760     else if(IsEqualGUID(&IID_IOleWindow, riid) || IsEqualGUID(&IID_IOleInPlaceSite, riid))
1761         *ppv = &InPlaceSite;
1762     else if(IsEqualGUID(riid, &IID_IServiceProvider))
1763         *ppv = &ServiceProvider;
1764
1765     return *ppv ? S_OK : E_NOINTERFACE;
1766 }
1767
1768 static IHTMLDocument2 *notif_doc;
1769 static BOOL doc_complete;
1770
1771 static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
1772         REFIID riid, void**ppv)
1773 {
1774     if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
1775         *ppv = iface;
1776         return S_OK;
1777     }
1778
1779     ok(0, "unexpected call\n");
1780     return E_NOINTERFACE;
1781 }
1782
1783 static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
1784 {
1785     return 2;
1786 }
1787
1788 static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
1789 {
1790     return 1;
1791 }
1792
1793 static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
1794 {
1795     if(dispID == DISPID_READYSTATE){
1796         BSTR state;
1797         HRESULT hres;
1798
1799         static const WCHAR completeW[] = {'c','o','m','p','l','e','t','e',0};
1800
1801         hres = IHTMLDocument2_get_readyState(notif_doc, &state);
1802         ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
1803
1804         if(!lstrcmpW(state, completeW))
1805             doc_complete = TRUE;
1806
1807         SysFreeString(state);
1808     }
1809
1810     return S_OK;
1811 }
1812
1813 static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
1814 {
1815     ok(0, "unexpected call\n");
1816     return E_NOTIMPL;
1817 }
1818
1819 static IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
1820     PropertyNotifySink_QueryInterface,
1821     PropertyNotifySink_AddRef,
1822     PropertyNotifySink_Release,
1823     PropertyNotifySink_OnChanged,
1824     PropertyNotifySink_OnRequestEdit
1825 };
1826
1827 static IPropertyNotifySink PropertyNotifySink = { &PropertyNotifySinkVtbl };
1828
1829 static void doc_load_string(IHTMLDocument2 *doc, const char *str)
1830 {
1831     IPersistStreamInit *init;
1832     IStream *stream;
1833     HGLOBAL mem;
1834     SIZE_T len;
1835
1836     notif_doc = doc;
1837
1838     doc_complete = FALSE;
1839     len = strlen(str);
1840     mem = GlobalAlloc(0, len);
1841     memcpy(mem, str, len);
1842     CreateStreamOnHGlobal(mem, TRUE, &stream);
1843
1844     IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&init);
1845
1846     IPersistStreamInit_Load(init, stream);
1847     IPersistStreamInit_Release(init);
1848     IStream_Release(stream);
1849 }
1850
1851 static void do_advise(IUnknown *unk, REFIID riid, IUnknown *unk_advise)
1852 {
1853     IConnectionPointContainer *container;
1854     IConnectionPoint *cp;
1855     DWORD cookie;
1856     HRESULT hres;
1857
1858     hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&container);
1859     ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08x\n", hres);
1860
1861     hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
1862     IConnectionPointContainer_Release(container);
1863     ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
1864
1865     hres = IConnectionPoint_Advise(cp, unk_advise, &cookie);
1866     IConnectionPoint_Release(cp);
1867     ok(hres == S_OK, "Advise failed: %08x\n", hres);
1868 }
1869
1870 static void set_client_site(IHTMLDocument2 *doc, BOOL set)
1871 {
1872     IOleObject *oleobj;
1873     HRESULT hres;
1874
1875     if(!set && view) {
1876         IOleDocumentView_Show(view, FALSE);
1877         IOleDocumentView_CloseView(view, 0);
1878         IOleDocumentView_SetInPlaceSite(view, NULL);
1879         IOleDocumentView_Release(view);
1880         view = NULL;
1881     }
1882
1883     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
1884     ok(hres == S_OK, "Could not et IOleObject: %08x\n", hres);
1885
1886     hres = IOleObject_SetClientSite(oleobj, set ? &ClientSite : NULL);
1887     ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
1888
1889     if(set) {
1890         IHlinkTarget *hlink;
1891
1892         hres = IOleObject_QueryInterface(oleobj, &IID_IHlinkTarget, (void**)&hlink);
1893         ok(hres == S_OK, "Could not get IHlinkTarget iface: %08x\n", hres);
1894
1895         hres = IHlinkTarget_Navigate(hlink, 0, NULL);
1896         ok(hres == S_OK, "Navgate failed: %08x\n", hres);
1897
1898         IHlinkTarget_Release(hlink);
1899     }
1900
1901     IOleObject_Release(oleobj);
1902 }
1903 static IHTMLDocument2 *create_document(void)
1904 {
1905     IHTMLDocument2 *doc;
1906     HRESULT hres;
1907
1908     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
1909             &IID_IHTMLDocument2, (void**)&doc);
1910     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
1911
1912     return doc;
1913 }
1914
1915 static IHTMLDocument2 *create_doc(const char *str, BOOL *b)
1916 {
1917     IHTMLDocument2 *doc;
1918     MSG msg;
1919
1920     doc = create_document();
1921     set_client_site(doc, TRUE);
1922     doc_load_string(doc, str);
1923     do_advise((IUnknown*)doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
1924
1925     while((!doc_complete || (b && !*b)) && GetMessage(&msg, NULL, 0, 0)) {
1926         TranslateMessage(&msg);
1927         DispatchMessage(&msg);
1928     }
1929
1930     return doc;
1931 }
1932
1933 static void release_doc(IHTMLDocument2 *doc)
1934 {
1935     ULONG ref;
1936
1937     set_client_site(doc, FALSE);
1938     ref = IHTMLDocument2_Release(doc);
1939     ok(!ref, "ref = %d\n", ref);
1940
1941     if(client_site) {
1942         IOleClientSite_Release(client_site);
1943         client_site = NULL;
1944     }
1945
1946     if(plugin_hwnd) {
1947         DestroyWindow(plugin_hwnd);
1948         plugin_hwnd = NULL;
1949     }
1950 }
1951
1952 static void test_object_ax(void)
1953 {
1954     IHTMLDocument2 *doc;
1955
1956     /*
1957      * We pump messages until both document is loaded and plugin instance is created.
1958      * Pumping until document is loaded should be enough, but Gecko loads plugins
1959      * asynchronously and until we'll work around it, we need this hack.
1960      */
1961     SET_EXPECT(CreateInstance);
1962     SET_EXPECT(FreezeEvents_TRUE);
1963     SET_EXPECT(QuickActivate);
1964     SET_EXPECT(FreezeEvents_FALSE);
1965     SET_EXPECT(IPersistPropertyBag_Load);
1966     SET_EXPECT(Invoke_READYSTATE);
1967     SET_EXPECT(SetExtent);
1968     SET_EXPECT(GetExtent);
1969     SET_EXPECT(DoVerb);
1970
1971     doc = create_doc(object_ax_str, &called_CreateInstance);
1972
1973     CHECK_CALLED(CreateInstance);
1974     todo_wine
1975     CHECK_CALLED(FreezeEvents_TRUE);
1976     CHECK_CALLED(QuickActivate);
1977     todo_wine
1978     CHECK_CALLED(FreezeEvents_FALSE);
1979     CHECK_CALLED(IPersistPropertyBag_Load);
1980     CHECK_CALLED(Invoke_READYSTATE);
1981     todo_wine
1982     CHECK_CALLED(SetExtent);
1983     todo_wine
1984     CHECK_CALLED(GetExtent);
1985     CHECK_CALLED(DoVerb);
1986
1987     /* Set in DoVerb */
1988     CHECK_CALLED(InPlaceObject_GetWindow);
1989     CHECK_CALLED(SetObjectRects);
1990
1991     test_ui_activate();
1992     test_container(notif_doc);
1993     test_object_elem(notif_doc);
1994
1995     SET_EXPECT(UIDeactivate);
1996     SET_EXPECT(Invoke_ENABLED);
1997     SET_EXPECT(Invoke_VALID);
1998     SET_EXPECT(InPlaceDeactivate);
1999     SET_EXPECT(Close);
2000     SET_EXPECT(SetClientSite_NULL);
2001     release_doc(doc);
2002     CHECK_CALLED(UIDeactivate);
2003     todo_wine
2004     CHECK_CALLED(Invoke_ENABLED);
2005     todo_wine
2006     CHECK_CALLED(Invoke_VALID);
2007     CHECK_CALLED(InPlaceDeactivate);
2008     CHECK_CALLED(Close);
2009     CHECK_CALLED(SetClientSite_NULL);
2010 }
2011
2012 static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
2013 {
2014     return DefWindowProc(hwnd, msg, wParam, lParam);
2015 }
2016
2017 static HWND create_container_window(void)
2018 {
2019     static const WCHAR html_document_testW[] =
2020         {'H','T','M','L','D','o','c','u','m','e','n','t','T','e','s','t',0};
2021     static WNDCLASSEXW wndclass = {
2022         sizeof(WNDCLASSEXW),
2023         0,
2024         wnd_proc,
2025         0, 0, NULL, NULL, NULL, NULL, NULL,
2026         html_document_testW,
2027         NULL
2028     };
2029
2030     RegisterClassExW(&wndclass);
2031     return CreateWindowW(html_document_testW, html_document_testW,
2032             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
2033             515, 530, NULL, NULL, NULL, NULL);
2034 }
2035
2036 static BOOL init_key(const char *key_name, const char *def_value, BOOL init)
2037 {
2038     HKEY hkey;
2039     DWORD res;
2040
2041     if(!init) {
2042         RegDeleteKey(HKEY_CLASSES_ROOT, key_name);
2043         return TRUE;
2044     }
2045
2046     res = RegCreateKeyA(HKEY_CLASSES_ROOT, key_name, &hkey);
2047     if(res != ERROR_SUCCESS)
2048         return FALSE;
2049
2050     if(def_value)
2051         res = RegSetValueA(hkey, NULL, REG_SZ, def_value, strlen(def_value));
2052
2053     RegCloseKey(hkey);
2054
2055     return res == ERROR_SUCCESS;
2056 }
2057
2058 static BOOL init_registry(BOOL init)
2059 {
2060     return init_key("TestActiveX\\CLSID", TESTACTIVEX_CLSID, init)
2061         && init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95801-9882-11cf-9fa9-00aa006c42c4}",
2062                     NULL, init)
2063         && init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95802-9882-11cf-9fa9-00aa006c42c4}",
2064                     NULL, init);
2065 }
2066
2067 static BOOL register_activex(void)
2068 {
2069     DWORD regid;
2070     HRESULT hres;
2071
2072     if(!init_registry(TRUE)) {
2073         init_registry(FALSE);
2074         return FALSE;
2075     }
2076
2077     hres = CoRegisterClassObject(&CLSID_TestActiveX, (IUnknown*)&activex_cf,
2078             CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
2079     ok(hres == S_OK, "Could not register control: %08x\n", hres);
2080
2081     return TRUE;
2082 }
2083
2084 static BOOL check_ie(void)
2085 {
2086     IHTMLDocument5 *doc;
2087     HRESULT hres;
2088
2089     static const WCHAR xW[] = {'x',0};
2090     static const WCHAR yW[] = {'y',0};
2091
2092     if(!lstrcmpW(xW, yW))
2093         return FALSE;
2094
2095     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
2096             &IID_IHTMLDocument5, (void**)&doc);
2097     if(FAILED(hres))
2098         return FALSE;
2099
2100     IHTMLDocument5_Release(doc);
2101     return TRUE;
2102 }
2103
2104 START_TEST(activex)
2105 {
2106     CoInitialize(NULL);
2107
2108     if(!check_ie()) {
2109         CoUninitialize();
2110         win_skip("Too old IE\n");
2111         return;
2112     }
2113
2114     if(is_ie_hardened()) {
2115         CoUninitialize();
2116         win_skip("IE running in Enhanced Security Configuration\n");
2117         return;
2118     }
2119
2120     container_hwnd = create_container_window();
2121     ShowWindow(container_hwnd, SW_SHOW);
2122
2123     if(register_activex()) {
2124         test_object_ax();
2125         init_registry(FALSE);
2126     }else {
2127         skip("Could not register ActiveX\n");
2128     }
2129
2130     DestroyWindow(container_hwnd);
2131     CoUninitialize();
2132 }