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 "mshtmhst.h"
  33 #include "mshtml_test.h"
  34
  35 #define DEFINE_EXPECT(func) \
  36     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  37
  38 #define SET_EXPECT(func) \
  39     do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)
  40
  41 #define CHECK_EXPECT2(func) \
  42     do { \
  43         ok(expect_ ##func, "unexpected call " #func "\n"); \
  44         called_ ## func = TRUE; \
  45     }while(0)
  46
  47 #define CHECK_EXPECT(func) \
  48     do { \
  49         CHECK_EXPECT2(func); \
  50         expect_ ## func = FALSE; \
  51     }while(0)
  52
  53 #define CHECK_CALLED(func) \
  54     do { \
  55         ok(called_ ## func, "expected " #func "\n"); \
  56         expect_ ## func = called_ ## func = FALSE; \
  57     }while(0)
  58
  59 DEFINE_EXPECT(CreateInstance);
  60 DEFINE_EXPECT(FreezeEvents_TRUE);
  61 DEFINE_EXPECT(FreezeEvents_FALSE);
  62 DEFINE_EXPECT(QuickActivate);
  63
  64 static HWND container_hwnd;
  65
  66 #define TESTACTIVEX_CLSID "{178fc163-f585-4e24-9c13-4bb7f6680746}"
  67
  68 static const GUID CLSID_TestActiveX =
  69     {0x178fc163,0xf585,0x4e24,{0x9c,0x13,0x4b,0xb7,0xf6,0x68,0x07,0x46}};
  70
  71 static const char *debugstr_guid(REFIID riid)
  72 {
  73     static char buf[50];
  74
  75     sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
  76             riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
  77             riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
  78             riid->Data4[5], riid->Data4[6], riid->Data4[7]);
  79
  80     return buf;
  81 }
  82
  83 static const char object_ax_str[] =
  84     "<html><head></head><body>"
  85     "<object classid=\"clsid:" TESTACTIVEX_CLSID "\" width=\"300\" height=\"200\" id=\"objid\">"
  86     "<param name=\"param_name\" value=\"param_value\">"
  87     "</object>"
  88     "</body></html>";
  89
  90 static BOOL iface_cmp(IUnknown *iface1, IUnknown *iface2)
  91 {
  92     IUnknown *unk1, *unk2;
  93
  94     if(iface1 == iface2)
  95         return TRUE;
  96
  97     IUnknown_QueryInterface(iface1, &IID_IUnknown, (void**)&unk1);
  98     IUnknown_Release(unk1);
  99     IUnknown_QueryInterface(iface2, &IID_IUnknown, (void**)&unk2);
 100     IUnknown_Release(unk2);
 101
 102     return unk1 == unk2;
 103 }
 104
 105 static HRESULT ax_qi(REFIID,void**);
 106
 107 static HRESULT WINAPI OleControl_QueryInterface(IOleControl *iface, REFIID riid, void **ppv)
 108 {
 109     return ax_qi(riid, ppv);
 110 }
 111
 112 static ULONG WINAPI OleControl_AddRef(IOleControl *iface)
 113 {
 114     return 2;
 115 }
 116
 117 static ULONG WINAPI OleControl_Release(IOleControl *iface)
 118 {
 119     return 1;
 120 }
 121
 122 static HRESULT WINAPI OleControl_GetControlInfo(IOleControl *iface, CONTROLINFO *pCI)
 123 {
 124     ok(0, "unexpected call\n");
 125     return E_NOTIMPL;
 126 }
 127
 128 static HRESULT WINAPI OleControl_OnMnemonic(IOleControl *iface, MSG *mMsg)
 129 {
 130     ok(0, "unexpected call\n");
 131     return E_NOTIMPL;
 132 }
 133
 134 static HRESULT WINAPI OleControl_OnAmbientPropertyChange(IOleControl *iface, DISPID dispID)
 135 {
 136     ok(0, "unexpected call\n");
 137     return E_NOTIMPL;
 138 }
 139
 140 static HRESULT WINAPI OleControl_FreezeEvents(IOleControl *iface, BOOL bFreeze)
 141 {
 142     if(bFreeze)
 143         CHECK_EXPECT2(FreezeEvents_TRUE);
 144     else
 145         CHECK_EXPECT2(FreezeEvents_FALSE);
 146     return S_OK;
 147 }
 148
 149 static const IOleControlVtbl OleControlVtbl = {
 150     OleControl_QueryInterface,
 151     OleControl_AddRef,
 152     OleControl_Release,
 153     OleControl_GetControlInfo,
 154     OleControl_OnMnemonic,
 155     OleControl_OnAmbientPropertyChange,
 156     OleControl_FreezeEvents
 157 };
 158
 159 static IOleControl OleControl = { &OleControlVtbl };
 160
 161 static HRESULT WINAPI QuickActivate_QueryInterface(IQuickActivate *iface, REFIID riid, void **ppv)
 162 {
 163     return ax_qi(riid, ppv);
 164 }
 165
 166 static ULONG WINAPI QuickActivate_AddRef(IQuickActivate *iface)
 167 {
 168     return 2;
 169 }
 170
 171 static ULONG WINAPI QuickActivate_Release(IQuickActivate *iface)
 172 {
 173     return 1;
 174 }
 175
 176 static HRESULT WINAPI QuickActivate_QuickActivate(IQuickActivate *iface, QACONTAINER *container, QACONTROL *control)
 177 {
 178     CHECK_EXPECT(QuickActivate);
 179
 180     ok(container != NULL, "container == NULL\n");
 181     ok(container->cbSize == sizeof(*container), "container->cbSize = %d\n", container->cbSize);
 182     ok(container->pClientSite != NULL, "container->pClientSite == NULL\n");
 183     ok(container->pAdviseSink != NULL, "container->pAdviseSink == NULL\n");
 184     todo_wine
 185     ok(container->pPropertyNotifySink != NULL, "container->pPropertyNotifySink == NULL\n");
 186     ok(!container->pUnkEventSink, "container->pUnkEventSink != NULL\n");
 187     ok(container->dwAmbientFlags == (QACONTAINER_SUPPORTSMNEMONICS|QACONTAINER_MESSAGEREFLECT|QACONTAINER_USERMODE),
 188        "container->dwAmbientFlags = %x\n", container->dwAmbientFlags);
 189     ok(!container->colorFore, "container->colorFore == 0\n"); /* FIXME */
 190     todo_wine
 191     ok(container->colorBack, "container->colorBack == 0\n"); /* FIXME */
 192     todo_wine
 193     ok(container->pFont != NULL, "container->pFont == NULL\n");
 194     todo_wine
 195     ok(container->pUndoMgr != NULL, "container->pUndoMgr == NULL\n");
 196     ok(!container->dwAppearance, "container->dwAppearance = %x\n", container->dwAppearance);
 197     ok(!container->lcid, "container->lcid = %x\n", container->lcid);
 198     ok(!container->hpal, "container->hpal = %p\n", container->hpal);
 199     ok(!container->pBindHost, "container->pBindHost != NULL\n");
 200     ok(!container->pOleControlSite, "container->pOleControlSite != NULL\n");
 201     ok(!container->pServiceProvider, "container->pServiceProvider != NULL\n");
 202
 203     ok(control->cbSize == sizeof(*control), "control->cbSize = %d\n", control->cbSize);
 204     ok(!control->dwMiscStatus, "control->dwMiscStatus = %x\n", control->dwMiscStatus);
 205     ok(!control->dwViewStatus, "control->dwViewStatus = %x\n", control->dwViewStatus);
 206     ok(!control->dwEventCookie, "control->dwEventCookie = %x\n", control->dwEventCookie);
 207     ok(!control->dwPropNotifyCookie, "control->dwPropNotifyCookie = %x\n", control->dwPropNotifyCookie);
 208     ok(!control->dwPointerActivationPolicy, "control->dwPointerActivationPolicy = %x\n", control->dwPointerActivationPolicy);
 209
 210     ok(iface_cmp((IUnknown*)container->pClientSite, (IUnknown*)container->pAdviseSink),
 211        "container->pClientSite != container->pAdviseSink\n");
 212
 213     return S_OK;
 214 }
 215
 216 static HRESULT WINAPI QuickActivate_SetContentExtent(IQuickActivate *iface, LPSIZEL pSizel)
 217 {
 218     ok(0, "unexpected call\n");
 219     return E_NOTIMPL;
 220 }
 221
 222 static HRESULT WINAPI QuickActivate_GetContentExtent(IQuickActivate *iface, LPSIZEL pSizel)
 223 {
 224     ok(0, "unexpected call\n");
 225     return E_NOTIMPL;
 226 }
 227
 228 static const IQuickActivateVtbl QuickActivateVtbl = {
 229     QuickActivate_QueryInterface,
 230     QuickActivate_AddRef,
 231     QuickActivate_Release,
 232     QuickActivate_QuickActivate,
 233     QuickActivate_GetContentExtent,
 234     QuickActivate_SetContentExtent
 235 };
 236
 237 static IQuickActivate QuickActivate = { &QuickActivateVtbl };
 238
 239 static HRESULT ax_qi(REFIID riid, void **ppv)
 240 {
 241     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IOleControl)) {
 242         *ppv = &OleControl;
 243         return S_OK;
 244     }
 245
 246     if(IsEqualGUID(riid, &IID_IQuickActivate)) {
 247         *ppv = &QuickActivate;
 248         return S_OK;
 249     }
 250
 251     *ppv = NULL;
 252     return E_NOINTERFACE;
 253 }
 254
 255 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
 256 {
 257     *ppv = NULL;
 258
 259     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
 260         *ppv = iface;
 261         return S_OK;
 262     }
 263
 264     if(IsEqualGUID(&IID_IMarshal, riid))
 265         return E_NOINTERFACE;
 266     if(IsEqualGUID(&CLSID_IdentityUnmarshal, riid))
 267         return E_NOINTERFACE;
 268     if(IsEqualGUID(&IID_IClassFactoryEx, riid))
 269         return E_NOINTERFACE; /* TODO */
 270
 271     ok(0, "unexpected riid %s\n", debugstr_guid(riid));
 272     return E_NOTIMPL;
 273 }
 274
 275 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
 276 {
 277     return 2;
 278 }
 279
 280 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
 281 {
 282     return 1;
 283 }
 284
 285 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
 286 {
 287     CHECK_EXPECT(CreateInstance);
 288
 289     ok(!outer, "outer = %p\n", outer);
 290     ok(IsEqualGUID(riid, &IID_IUnknown), "riid = %s\n", debugstr_guid(riid));
 291
 292     *ppv = &OleControl;
 293     return S_OK;
 294 }
 295
 296 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
 297 {
 298     ok(0, "unexpected call\n");
 299     return S_OK;
 300 }
 301
 302 static const IClassFactoryVtbl ClassFactoryVtbl = {
 303     ClassFactory_QueryInterface,
 304     ClassFactory_AddRef,
 305     ClassFactory_Release,
 306     ClassFactory_CreateInstance,
 307     ClassFactory_LockServer
 308 };
 309
 310 static HRESULT cs_qi(REFIID,void **);
 311 static IOleDocumentView *view;
 312
 313 static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
 314 {
 315     static const GUID undocumented_frame_iid = {0xfbece6c9,0x48d7,0x4a37,{0x8f,0xe3,0x6a,0xd4,0x27,0x2f,0xdd,0xac}};
 316
 317     if(!IsEqualGUID(&undocumented_frame_iid, riid))
 318         ok(0, "unexpected riid %s\n", debugstr_guid(riid));
 319
 320     *ppv = NULL;
 321     return E_NOINTERFACE;
 322 }
 323
 324 static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface)
 325 {
 326     return 2;
 327 }
 328
 329 static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface)
 330 {
 331     return 1;
 332 }
 333
 334 static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
 335 {
 336     return E_NOTIMPL;
 337 }
 338
 339 static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
 340 {
 341     return E_NOTIMPL;
 342 }
 343
 344 static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
 345 {
 346     return E_NOTIMPL;
 347 }
 348
 349 static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface,
 350         LPCBORDERWIDTHS pborderwidths)
 351 {
 352     return E_NOTIMPL;
 353 }
 354
 355 static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface,
 356         LPCBORDERWIDTHS pborderwidths)
 357 {
 358     return S_OK;
 359 }
 360
 361 static HRESULT WINAPI InPlaceUIWindow_SetActiveObject(IOleInPlaceFrame *iface,
 362         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
 363 {
 364     return S_OK;
 365 }
 366
 367 static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
 368         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
 369 {
 370     return S_OK;
 371 }
 372
 373 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
 374         LPOLEMENUGROUPWIDTHS lpMenuWidths)
 375 {
 376     return E_NOTIMPL;
 377 }
 378
 379 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
 380         HOLEMENU holemenu, HWND hwndActiveObject)
 381 {
 382     ok(0, "unexpected call\n");
 383     return E_NOTIMPL;
 384 }
 385
 386 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
 387 {
 388     ok(0, "unexpected call\n");
 389     return E_NOTIMPL;
 390 }
 391
 392 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
 393 {
 394     return S_OK;
 395 }
 396
 397 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
 398 {
 399     return E_NOTIMPL;
 400 }
 401
 402 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
 403 {
 404     ok(0, "unexpected call\n");
 405     return E_NOTIMPL;
 406 }
 407
 408 static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
 409     InPlaceFrame_QueryInterface,
 410     InPlaceFrame_AddRef,
 411     InPlaceFrame_Release,
 412     InPlaceFrame_GetWindow,
 413     InPlaceFrame_ContextSensitiveHelp,
 414     InPlaceFrame_GetBorder,
 415     InPlaceFrame_RequestBorderSpace,
 416     InPlaceFrame_SetBorderSpace,
 417     InPlaceFrame_SetActiveObject,
 418     InPlaceFrame_InsertMenus,
 419     InPlaceFrame_SetMenu,
 420     InPlaceFrame_RemoveMenus,
 421     InPlaceFrame_SetStatusText,
 422     InPlaceFrame_EnableModeless,
 423     InPlaceFrame_TranslateAccelerator
 424 };
 425
 426 static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
 427
 428 static const IOleInPlaceFrameVtbl InPlaceUIWindowVtbl = {
 429     InPlaceFrame_QueryInterface,
 430     InPlaceFrame_AddRef,
 431     InPlaceFrame_Release,
 432     InPlaceFrame_GetWindow,
 433     InPlaceFrame_ContextSensitiveHelp,
 434     InPlaceFrame_GetBorder,
 435     InPlaceFrame_RequestBorderSpace,
 436     InPlaceFrame_SetBorderSpace,
 437     InPlaceUIWindow_SetActiveObject,
 438 };
 439
 440 static IOleInPlaceFrame InPlaceUIWindow = { &InPlaceUIWindowVtbl };
 441
 442 static HRESULT WINAPI InPlaceSite_QueryInterface(IOleInPlaceSite *iface, REFIID riid, void **ppv)
 443 {
 444     return cs_qi(riid, ppv);
 445 }
 446
 447 static ULONG WINAPI InPlaceSite_AddRef(IOleInPlaceSite *iface)
 448 {
 449     return 2;
 450 }
 451
 452 static ULONG WINAPI InPlaceSite_Release(IOleInPlaceSite *iface)
 453 {
 454     return 1;
 455 }
 456
 457 static HRESULT WINAPI InPlaceSite_GetWindow(IOleInPlaceSite *iface, HWND *phwnd)
 458 {
 459     *phwnd = container_hwnd;
 460     return S_OK;
 461 }
 462
 463 static HRESULT WINAPI InPlaceSite_ContextSensitiveHelp(IOleInPlaceSite *iface, BOOL fEnterMode)
 464 {
 465     ok(0, "unexpected call\n");
 466     return E_NOTIMPL;
 467 }
 468
 469 static HRESULT WINAPI InPlaceSite_CanInPlaceActivate(IOleInPlaceSite *iface)
 470 {
 471     return S_OK;
 472 }
 473
 474 static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSite *iface)
 475 {
 476     return S_OK;
 477 }
 478
 479 static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSite *iface)
 480 {
 481     return S_OK;
 482 }
 483
 484 static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSite *iface,
 485         IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
 486         LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
 487 {
 488     static const RECT rect = {0,0,500,500};
 489
 490     *ppFrame = &InPlaceFrame;
 491     *ppDoc = (IOleInPlaceUIWindow*)&InPlaceUIWindow;
 492     *lprcPosRect = rect;
 493     *lprcClipRect = rect;
 494
 495     lpFrameInfo->cb = sizeof(*lpFrameInfo);
 496     lpFrameInfo->fMDIApp = FALSE;
 497     lpFrameInfo->hwndFrame = container_hwnd;
 498     lpFrameInfo->haccel = NULL;
 499     lpFrameInfo->cAccelEntries = 0;
 500
 501     return S_OK;
 502 }
 503
 504 static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSite *iface, SIZE scrollExtant)
 505 {
 506     return E_NOTIMPL;
 507 }
 508
 509 static HRESULT WINAPI InPlaceSite_OnUIDeactivate(IOleInPlaceSite *iface, BOOL fUndoable)
 510 {
 511     return S_OK;
 512 }
 513
 514 static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivate(IOleInPlaceSite *iface)
 515 {
 516     return S_OK;
 517 }
 518
 519 static HRESULT WINAPI InPlaceSite_DiscardUndoState(IOleInPlaceSite *iface)
 520 {
 521     return E_NOTIMPL;
 522 }
 523
 524 static HRESULT WINAPI InPlaceSite_DeactivateAndUndo(IOleInPlaceSite *iface)
 525 {
 526     return E_NOTIMPL;
 527 }
 528
 529 static HRESULT WINAPI InPlaceSite_OnPosRectChange(IOleInPlaceSite *iface, LPCRECT lprcPosRect)
 530 {
 531     return E_NOTIMPL;
 532 }
 533
 534 static const IOleInPlaceSiteVtbl InPlaceSiteVtbl = {
 535     InPlaceSite_QueryInterface,
 536     InPlaceSite_AddRef,
 537     InPlaceSite_Release,
 538     InPlaceSite_GetWindow,
 539     InPlaceSite_ContextSensitiveHelp,
 540     InPlaceSite_CanInPlaceActivate,
 541     InPlaceSite_OnInPlaceActivate,
 542     InPlaceSite_OnUIActivate,
 543     InPlaceSite_GetWindowContext,
 544     InPlaceSite_Scroll,
 545     InPlaceSite_OnUIDeactivate,
 546     InPlaceSite_OnInPlaceDeactivate,
 547     InPlaceSite_DiscardUndoState,
 548     InPlaceSite_DeactivateAndUndo,
 549     InPlaceSite_OnPosRectChange,
 550 };
 551
 552 static IOleInPlaceSite InPlaceSite = { &InPlaceSiteVtbl };
 553
 554 static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
 555 {
 556     return cs_qi(riid, ppv);
 557 }
 558
 559 static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
 560 {
 561     return 2;
 562 }
 563
 564 static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
 565 {
 566     return 1;
 567 }
 568
 569 static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
 570 {
 571     ok(0, "unexpected call\n");
 572     return E_NOTIMPL;
 573 }
 574
 575 static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker,
 576         IMoniker **ppmon)
 577 {
 578     ok(0, "unexpected call\n");
 579     return E_NOTIMPL;
 580 }
 581
 582 static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
 583 {
 584     return E_NOTIMPL;
 585 }
 586
 587 static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
 588 {
 589     ok(0, "unexpected call\n");
 590     return E_NOTIMPL;
 591 }
 592
 593 static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
 594 {
 595     ok(0, "unexpected call\n");
 596     return E_NOTIMPL;
 597 }
 598
 599 static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
 600 {
 601     ok(0, "unexpected call\n");
 602     return E_NOTIMPL;
 603 }
 604
 605 static const IOleClientSiteVtbl ClientSiteVtbl = {
 606     ClientSite_QueryInterface,
 607     ClientSite_AddRef,
 608     ClientSite_Release,
 609     ClientSite_SaveObject,
 610     ClientSite_GetMoniker,
 611     ClientSite_GetContainer,
 612     ClientSite_ShowObject,
 613     ClientSite_OnShowWindow,
 614     ClientSite_RequestNewObjectLayout
 615 };
 616
 617 static IOleClientSite ClientSite = { &ClientSiteVtbl };
 618
 619 static HRESULT WINAPI DocumentSite_QueryInterface(IOleDocumentSite *iface, REFIID riid, void **ppv)
 620 {
 621     return cs_qi(riid, ppv);
 622 }
 623
 624 static ULONG WINAPI DocumentSite_AddRef(IOleDocumentSite *iface)
 625 {
 626     return 2;
 627 }
 628
 629 static ULONG WINAPI DocumentSite_Release(IOleDocumentSite *iface)
 630 {
 631     return 1;
 632 }
 633
 634 static HRESULT WINAPI DocumentSite_ActivateMe(IOleDocumentSite *iface, IOleDocumentView *pViewToActivate)
 635 {
 636     RECT rect = {0,0,400,500};
 637     IOleDocument *document;
 638     HRESULT hres;
 639
 640     hres = IOleDocumentView_QueryInterface(pViewToActivate, &IID_IOleDocument, (void**)&document);
 641     ok(hres == S_OK, "could not get IOleDocument: %08x\n", hres);
 642
 643     hres = IOleDocument_CreateView(document, &InPlaceSite, NULL, 0, &view);
 644     IOleDocument_Release(document);
 645     ok(hres == S_OK, "CreateView failed: %08x\n", hres);
 646
 647     hres = IOleDocumentView_SetInPlaceSite(view, &InPlaceSite);
 648     ok(hres == S_OK, "SetInPlaceSite failed: %08x\n", hres);
 649
 650     hres = IOleDocumentView_UIActivate(view, TRUE);
 651     ok(hres == S_OK, "UIActivate failed: %08x\n", hres);
 652
 653     hres = IOleDocumentView_SetRect(view, &rect);
 654     ok(hres == S_OK, "SetRect failed: %08x\n", hres);
 655
 656     hres = IOleDocumentView_Show(view, TRUE);
 657     ok(hres == S_OK, "Show failed: %08x\n", hres);
 658
 659     return S_OK;
 660 }
 661
 662 static const IOleDocumentSiteVtbl DocumentSiteVtbl = {
 663     DocumentSite_QueryInterface,
 664     DocumentSite_AddRef,
 665     DocumentSite_Release,
 666     DocumentSite_ActivateMe
 667 };
 668
 669 static IOleDocumentSite DocumentSite = { &DocumentSiteVtbl };
 670
 671 static HRESULT cs_qi(REFIID riid, void **ppv)
 672 {
 673     *ppv = NULL;
 674
 675     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IOleClientSite, riid))
 676         *ppv = &ClientSite;
 677     else if(IsEqualGUID(&IID_IOleDocumentSite, riid))
 678         *ppv = &DocumentSite;
 679     else if(IsEqualGUID(&IID_IOleWindow, riid) || IsEqualGUID(&IID_IOleInPlaceSite, riid))
 680         *ppv = &InPlaceSite;
 681
 682     return *ppv ? S_OK : E_NOINTERFACE;
 683 }
 684
 685 static IClassFactory activex_cf = { &ClassFactoryVtbl };
 686 static IHTMLDocument2 *notif_doc;
 687 static BOOL doc_complete;
 688
 689 static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
 690         REFIID riid, void**ppv)
 691 {
 692     if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
 693         *ppv = iface;
 694         return S_OK;
 695     }
 696
 697     ok(0, "unexpected call\n");
 698     return E_NOINTERFACE;
 699 }
 700
 701 static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
 702 {
 703     return 2;
 704 }
 705
 706 static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
 707 {
 708     return 1;
 709 }
 710
 711 static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
 712 {
 713     if(dispID == DISPID_READYSTATE){
 714         BSTR state;
 715         HRESULT hres;
 716
 717         static const WCHAR completeW[] = {'c','o','m','p','l','e','t','e',0};
 718
 719         hres = IHTMLDocument2_get_readyState(notif_doc, &state);
 720         ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
 721
 722         if(!lstrcmpW(state, completeW))
 723             doc_complete = TRUE;
 724
 725         SysFreeString(state);
 726     }
 727
 728     return S_OK;
 729 }
 730
 731 static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
 732 {
 733     ok(0, "unexpected call\n");
 734     return E_NOTIMPL;
 735 }
 736
 737 static IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
 738     PropertyNotifySink_QueryInterface,
 739     PropertyNotifySink_AddRef,
 740     PropertyNotifySink_Release,
 741     PropertyNotifySink_OnChanged,
 742     PropertyNotifySink_OnRequestEdit
 743 };
 744
 745 static IPropertyNotifySink PropertyNotifySink = { &PropertyNotifySinkVtbl };
 746
 747 static void doc_load_string(IHTMLDocument2 *doc, const char *str)
 748 {
 749     IPersistStreamInit *init;
 750     IStream *stream;
 751     HGLOBAL mem;
 752     SIZE_T len;
 753
 754     notif_doc = doc;
 755
 756     doc_complete = FALSE;
 757     len = strlen(str);
 758     mem = GlobalAlloc(0, len);
 759     memcpy(mem, str, len);
 760     CreateStreamOnHGlobal(mem, TRUE, &stream);
 761
 762     IHTMLDocument2_QueryInterface(doc, &IID_IPersistStreamInit, (void**)&init);
 763
 764     IPersistStreamInit_Load(init, stream);
 765     IPersistStreamInit_Release(init);
 766     IStream_Release(stream);
 767 }
 768
 769 static void do_advise(IUnknown *unk, REFIID riid, IUnknown *unk_advise)
 770 {
 771     IConnectionPointContainer *container;
 772     IConnectionPoint *cp;
 773     DWORD cookie;
 774     HRESULT hres;
 775
 776     hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&container);
 777     ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08x\n", hres);
 778
 779     hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
 780     IConnectionPointContainer_Release(container);
 781     ok(hres == S_OK, "FindConnectionPoint failed: %08x\n", hres);
 782
 783     hres = IConnectionPoint_Advise(cp, unk_advise, &cookie);
 784     IConnectionPoint_Release(cp);
 785     ok(hres == S_OK, "Advise failed: %08x\n", hres);
 786 }
 787
 788 static void set_client_site(IHTMLDocument2 *doc, BOOL set)
 789 {
 790     IOleObject *oleobj;
 791     HRESULT hres;
 792
 793     if(!set && view) {
 794         IOleDocumentView_Show(view, FALSE);
 795         IOleDocumentView_CloseView(view, 0);
 796         IOleDocumentView_SetInPlaceSite(view, NULL);
 797         IOleDocumentView_Release(view);
 798         view = NULL;
 799     }
 800
 801     hres = IHTMLDocument2_QueryInterface(doc, &IID_IOleObject, (void**)&oleobj);
 802     ok(hres == S_OK, "Could not et IOleObject: %08x\n", hres);
 803
 804     hres = IOleObject_SetClientSite(oleobj, set ? &ClientSite : NULL);
 805     ok(hres == S_OK, "SetClientSite failed: %08x\n", hres);
 806
 807     if(set) {
 808         IHlinkTarget *hlink;
 809
 810         hres = IOleObject_QueryInterface(oleobj, &IID_IHlinkTarget, (void**)&hlink);
 811         ok(hres == S_OK, "Could not get IHlinkTarget iface: %08x\n", hres);
 812
 813         hres = IHlinkTarget_Navigate(hlink, 0, NULL);
 814         ok(hres == S_OK, "Navgate failed: %08x\n", hres);
 815
 816         IHlinkTarget_Release(hlink);
 817     }
 818
 819     IOleObject_Release(oleobj);
 820 }
 821 static IHTMLDocument2 *create_document(void)
 822 {
 823     IHTMLDocument2 *doc;
 824     HRESULT hres;
 825
 826     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 827             &IID_IHTMLDocument2, (void**)&doc);
 828     ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
 829
 830     return doc;
 831 }
 832
 833 static IHTMLDocument2 *create_doc(const char *str, BOOL *b)
 834 {
 835     IHTMLDocument2 *doc;
 836     MSG msg;
 837
 838     doc = create_document();
 839     set_client_site(doc, TRUE);
 840     doc_load_string(doc, str);
 841     do_advise((IUnknown*)doc, &IID_IPropertyNotifySink, (IUnknown*)&PropertyNotifySink);
 842
 843     while((!doc_complete || (b && !*b)) && GetMessage(&msg, NULL, 0, 0)) {
 844         TranslateMessage(&msg);
 845         DispatchMessage(&msg);
 846     }
 847
 848     return doc;
 849 }
 850
 851 static void release_doc(IHTMLDocument2 *doc)
 852 {
 853     ULONG ref;
 854
 855     set_client_site(doc, FALSE);
 856     ref = IHTMLDocument2_Release(doc);
 857     ok(!ref, "ref = %d\n", ref);
 858 }
 859
 860 static void test_object_ax(void)
 861 {
 862     IHTMLDocument2 *doc;
 863
 864     /*
 865      * We pump messages until both document is loaded and plugin instance is created.
 866      * Pumping until document is loaded should be enough, but Gecko loads plugins
 867      * asynchronously and until we'll work around it, we need this hack.
 868      */
 869     SET_EXPECT(CreateInstance);
 870     SET_EXPECT(FreezeEvents_TRUE);
 871     SET_EXPECT(QuickActivate);
 872     SET_EXPECT(FreezeEvents_FALSE);
 873
 874     doc = create_doc(object_ax_str, &called_CreateInstance);
 875
 876     CHECK_CALLED(CreateInstance);
 877     todo_wine
 878     CHECK_CALLED(FreezeEvents_TRUE);
 879     CHECK_CALLED(QuickActivate);
 880     todo_wine
 881     CHECK_CALLED(FreezeEvents_FALSE);
 882
 883     release_doc(doc);
 884 }
 885
 886 static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 887 {
 888     return DefWindowProc(hwnd, msg, wParam, lParam);
 889 }
 890
 891 static HWND create_container_window(void)
 892 {
 893     static const WCHAR html_document_testW[] =
 894         {'H','T','M','L','D','o','c','u','m','e','n','t','T','e','s','t',0};
 895     static WNDCLASSEXW wndclass = {
 896         sizeof(WNDCLASSEXW),
 897         0,
 898         wnd_proc,
 899         0, 0, NULL, NULL, NULL, NULL, NULL,
 900         html_document_testW,
 901         NULL
 902     };
 903
 904     RegisterClassExW(&wndclass);
 905     return CreateWindowW(html_document_testW, html_document_testW,
 906             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
 907             515, 530, NULL, NULL, NULL, NULL);
 908 }
 909
 910 static BOOL init_key(const char *key_name, const char *def_value, BOOL init)
 911 {
 912     HKEY hkey;
 913     DWORD res;
 914
 915     if(!init) {
 916         RegDeleteKey(HKEY_CLASSES_ROOT, key_name);
 917         return TRUE;
 918     }
 919
 920     res = RegCreateKeyA(HKEY_CLASSES_ROOT, key_name, &hkey);
 921     if(res != ERROR_SUCCESS)
 922         return FALSE;
 923
 924     if(def_value)
 925         res = RegSetValueA(hkey, NULL, REG_SZ, def_value, strlen(def_value));
 926
 927     RegCloseKey(hkey);
 928
 929     return res == ERROR_SUCCESS;
 930 }
 931
 932 static BOOL init_registry(BOOL init)
 933 {
 934     return init_key("TestActiveX\\CLSID", TESTACTIVEX_CLSID, init)
 935         && init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95801-9882-11cf-9fa9-00aa006c42c4}",
 936                     NULL, init)
 937         && init_key("CLSID\\"TESTACTIVEX_CLSID"\\Implemented Categories\\{7dd95802-9882-11cf-9fa9-00aa006c42c4}",
 938                     NULL, init);
 939 }
 940
 941 static BOOL register_activex(void)
 942 {
 943     DWORD regid;
 944     HRESULT hres;
 945
 946     if(!init_registry(TRUE)) {
 947         init_registry(FALSE);
 948         return FALSE;
 949     }
 950
 951     hres = CoRegisterClassObject(&CLSID_TestActiveX, (IUnknown*)&activex_cf,
 952             CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
 953     ok(hres == S_OK, "Could not register control: %08x\n", hres);
 954
 955     return TRUE;
 956 }
 957
 958 static BOOL check_ie(void)
 959 {
 960     IHTMLDocument5 *doc;
 961     HRESULT hres;
 962
 963     static const WCHAR xW[] = {'x',0};
 964     static const WCHAR yW[] = {'y',0};
 965
 966     if(!lstrcmpW(xW, yW))
 967         return FALSE;
 968
 969     hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 970             &IID_IHTMLDocument5, (void**)&doc);
 971     if(FAILED(hres))
 972         return FALSE;
 973
 974     IHTMLDocument5_Release(doc);
 975     return TRUE;
 976 }
 977
 978 START_TEST(activex)
 979 {
 980     CoInitialize(NULL);
 981
 982     if(!check_ie()) {
 983         CoUninitialize();
 984         win_skip("Too old IE\n");
 985         return;
 986     }
 987
 988     if(is_ie_hardened()) {
 989         CoUninitialize();
 990         win_skip("IE running in Enhanced Security Configuration\n");
 991         return;
 992     }
 993
 994     container_hwnd = create_container_window();
 995     ShowWindow(container_hwnd, SW_SHOW);
 996
 997     if(register_activex()) {
 998         test_object_ax();
 999         init_registry(FALSE);
1000     }else {
1001         skip("Could not register ActiveX\n");
1002     }
1003
1004     DestroyWindow(container_hwnd);
1005     CoUninitialize();
1006 }