git.oblomov.eu Git - wine/blob - dlls/mshtml/tests/htmldoc.c

   1 /*
   2  * Copyright 2005 Jacek Caban
   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
  21 #include <wine/test.h>
  22 #include <stdarg.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "ole2.h"
  27 #include "mshtml.h"
  28 #include "docobj.h"
  29 #include "mshtmhst.h"
  30 #include "mshtmdid.h"
  31 #include "mshtmcid.h"
  32 #include "hlink.h"
  33 #include "idispids.h"
  34 #include "shlguid.h"
  35
  36 #include "initguid.h"
  37 DEFINE_SHLGUID(CGID_Undocumented, 0x000214D4L, 0, 0);
  38
  39 #define DEFINE_EXPECT(func) \
  40     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  41
  42 #define SET_EXPECT(func) \
  43     expect_ ## func = TRUE
  44
  45 #define CHECK_EXPECT(func) \
  46     do { \
  47         ok(expect_ ##func, "unexpected call " #func "\n"); \
  48         expect_ ## func = FALSE; \
  49         called_ ## func = TRUE; \
  50     }while(0)
  51
  52 #define CHECK_EXPECT2(func) \
  53     do { \
  54         ok(expect_ ##func, "unexpected call " #func "\n"); \
  55         called_ ## func = TRUE; \
  56     }while(0)
  57
  58 #define CHECK_CALLED(func) \
  59     do { \
  60         ok(called_ ## func, "expected " #func "\n"); \
  61         expect_ ## func = called_ ## func = FALSE; \
  62     }while(0)
  63
  64 static IOleDocumentView *view = NULL;
  65 static HWND container_hwnd = NULL, hwnd = NULL, last_hwnd = NULL;
  66
  67 DEFINE_EXPECT(LockContainer);
  68 DEFINE_EXPECT(SetActiveObject);
  69 DEFINE_EXPECT(GetWindow);
  70 DEFINE_EXPECT(CanInPlaceActivate);
  71 DEFINE_EXPECT(OnInPlaceActivate);
  72 DEFINE_EXPECT(OnUIActivate);
  73 DEFINE_EXPECT(GetWindowContext);
  74 DEFINE_EXPECT(OnUIDeactivate);
  75 DEFINE_EXPECT(OnInPlaceDeactivate);
  76 DEFINE_EXPECT(GetContainer);
  77 DEFINE_EXPECT(ShowUI);
  78 DEFINE_EXPECT(ActivateMe);
  79 DEFINE_EXPECT(GetHostInfo);
  80 DEFINE_EXPECT(HideUI);
  81 DEFINE_EXPECT(GetOptionKeyPath);
  82 DEFINE_EXPECT(GetOverrideKeyPath);
  83 DEFINE_EXPECT(SetStatusText);
  84 DEFINE_EXPECT(QueryStatus_SETPROGRESSTEXT);
  85 DEFINE_EXPECT(QueryStatus_OPEN);
  86 DEFINE_EXPECT(QueryStatus_NEW);
  87 DEFINE_EXPECT(Exec_SETPROGRESSMAX);
  88 DEFINE_EXPECT(Exec_SETPROGRESSPOS);
  89 DEFINE_EXPECT(Exec_HTTPEQUIV_DONE);
  90 DEFINE_EXPECT(Exec_SETDOWNLOADSTATE);
  91 DEFINE_EXPECT(Exec_ShellDocView_37);
  92 DEFINE_EXPECT(Exec_UPDATECOMMANDS);
  93 DEFINE_EXPECT(Exec_SETTITLE);
  94 DEFINE_EXPECT(Exec_HTTPEQUIV);
  95 DEFINE_EXPECT(Exec_MSHTML_2315);
  96 DEFINE_EXPECT(Invoke_AMBIENT_USERMODE);
  97 DEFINE_EXPECT(Invoke_AMBIENT_DLCONTROL);
  98 DEFINE_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
  99 DEFINE_EXPECT(Invoke_AMBIENT_SILENT);
 100 DEFINE_EXPECT(Invoke_AMBIENT_USERAGENT);
 101 DEFINE_EXPECT(Invoke_AMBIENT_PALETTE);
 102 DEFINE_EXPECT(GetDropTarget);
 103 DEFINE_EXPECT(UpdateUI);
 104 DEFINE_EXPECT(Navigate);
 105 DEFINE_EXPECT(OnFrameWindowActivate);
 106 DEFINE_EXPECT(OnChanged_READYSTATE);
 107
 108 static BOOL expect_LockContainer_fLock;
 109 static BOOL expect_SetActiveObject_active;
 110 static BOOL set_clientsite = FALSE, container_locked = FALSE;
 111 static enum load_state_t {
 112     LD_NO = 0,
 113     LD_DOLOAD,
 114     LD_LOADING,
 115     LD_LOADED
 116 } load_state;
 117
 118 static LPCOLESTR expect_status_text = NULL;
 119
 120 static HRESULT QueryInterface(REFIID riid, void **ppv);
 121
 122 static HRESULT WINAPI HlinkFrame_QueryInterface(IHlinkFrame *iface, REFIID riid, void **ppv)
 123 {
 124     ok(0, "unexpected call\n");
 125     return E_NOTIMPL;
 126 }
 127
 128 static ULONG WINAPI HlinkFrame_AddRef(IHlinkFrame *iface)
 129 {
 130     return 2;
 131 }
 132
 133 static ULONG WINAPI HlinkFrame_Release(IHlinkFrame *iface)
 134 {
 135     return 1;
 136 }
 137
 138 static HRESULT WINAPI HlinkFrame_SetBrowseContext(IHlinkFrame *iface,
 139                                                   IHlinkBrowseContext *pihlbc)
 140 {
 141     ok(0, "unexpected call\n");
 142     return E_NOTIMPL;
 143 }
 144
 145 static HRESULT WINAPI HlinkFrame_GetBrowseContext(IHlinkFrame *iface,
 146                                                   IHlinkBrowseContext **ppihlbc)
 147 {
 148     ok(0, "unexpected call\n");
 149     return E_NOTIMPL;
 150 }
 151
 152 static HRESULT WINAPI HlinkFrame_Navigate(IHlinkFrame *iface, DWORD grfHLNF, LPBC pbc,
 153                                           IBindStatusCallback *pibsc, IHlink *pihlNavigate)
 154 {
 155     HRESULT hres;
 156
 157     CHECK_EXPECT(Navigate);
 158
 159     ok(grfHLNF == 0, "grfHLNF=%ld, expected 0\n", grfHLNF);
 160     ok(pbc != NULL, "pbc == NULL\n");
 161     ok(pibsc != NULL, "pubsc == NULL\n");
 162     ok(pihlNavigate != NULL, "puhlNavigate == NULL\n");
 163
 164     if(pihlNavigate) {
 165         LPWSTR frame_name = (LPWSTR)0xdeadbeef;
 166         LPWSTR location = (LPWSTR)0xdeadbeef;
 167         IHlinkSite *site;
 168         IMoniker *mon = NULL;
 169         DWORD site_data = 0xdeadbeef;
 170
 171         hres = IHlink_GetTargetFrameName(pihlNavigate, &frame_name);
 172         ok(hres == S_FALSE, "GetTargetFrameName failed: %08lx\n", hres);
 173         ok(frame_name == NULL, "frame_name = %p\n", frame_name);
 174
 175         hres = IHlink_GetMonikerReference(pihlNavigate, 1, &mon, &location);
 176         ok(hres == S_OK, "GetMonikerReference failed: %08lx\n", hres);
 177         ok(location == NULL, "location = %p\n", location);
 178         ok(mon != NULL, "mon == NULL\n");
 179
 180         hres = IHlink_GetHlinkSite(pihlNavigate, &site, &site_data);
 181         ok(hres == S_OK, "GetHlinkSite failed: %08lx\n", hres);
 182         ok(site == NULL, "site = %p\n, expected NULL\n", site);
 183         ok(site_data == 0xdeadbeef, "site_data = %lx\n", site_data);
 184     }
 185
 186     return S_OK;
 187 }
 188
 189 static HRESULT WINAPI HlinkFrame_OnNavigate(IHlinkFrame *iface, DWORD grfHLNF,
 190         IMoniker *pimkTarget, LPCWSTR pwzLocation, LPCWSTR pwzFriendlyName, DWORD dwreserved)
 191 {
 192     ok(0, "unexpected call\n");
 193     return E_NOTIMPL;
 194 }
 195
 196 static HRESULT WINAPI HlinkFrame_UpdateHlink(IHlinkFrame *iface, ULONG uHLID,
 197         IMoniker *pimkTarget, LPCWSTR pwzLocation, LPCWSTR pwzFriendlyName)
 198 {
 199     ok(0, "unexpected call\n");
 200     return E_NOTIMPL;
 201 }
 202
 203 static const IHlinkFrameVtbl HlinkFrameVtbl = {
 204     HlinkFrame_QueryInterface,
 205     HlinkFrame_AddRef,
 206     HlinkFrame_Release,
 207     HlinkFrame_SetBrowseContext,
 208     HlinkFrame_GetBrowseContext,
 209     HlinkFrame_Navigate,
 210     HlinkFrame_OnNavigate,
 211     HlinkFrame_UpdateHlink
 212 };
 213
 214 static IHlinkFrame HlinkFrame = { &HlinkFrameVtbl };
 215
 216 static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
 217         REFIID riid, void**ppv)
 218 {
 219     if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
 220         *ppv = iface;
 221         return S_OK;
 222     }
 223
 224     ok(0, "unexpected call\n");
 225     return E_NOINTERFACE;
 226 }
 227
 228 static ULONG WINAPI PropertyNotifySink_AddRef(IPropertyNotifySink *iface)
 229 {
 230     return 2;
 231 }
 232
 233 static ULONG WINAPI PropertyNotifySink_Release(IPropertyNotifySink *iface)
 234 {
 235     return 1;
 236 }
 237
 238 static HRESULT WINAPI PropertyNotifySink_OnChanged(IPropertyNotifySink *iface, DISPID dispID)
 239 {
 240     switch(dispID) {
 241     case DISPID_READYSTATE:
 242         CHECK_EXPECT(OnChanged_READYSTATE);
 243         return S_OK;
 244     }
 245
 246     ok(0, "unexpected id %ld\n", dispID);
 247     return E_NOTIMPL;
 248 }
 249
 250 static HRESULT WINAPI PropertyNotifySink_OnRequestEdit(IPropertyNotifySink *iface, DISPID dispID)
 251 {
 252     ok(0, "unexpected call\n");
 253     return E_NOTIMPL;
 254 }
 255
 256 static IPropertyNotifySinkVtbl PropertyNotifySinkVtbl = {
 257     PropertyNotifySink_QueryInterface,
 258     PropertyNotifySink_AddRef,
 259     PropertyNotifySink_Release,
 260     PropertyNotifySink_OnChanged,
 261     PropertyNotifySink_OnRequestEdit
 262 };
 263
 264 static IPropertyNotifySink PropertyNotifySink = { &PropertyNotifySinkVtbl };
 265
 266 static HRESULT WINAPI OleContainer_QueryInterface(IOleContainer *iface, REFIID riid, void **ppv)
 267 {
 268     return QueryInterface(riid, ppv);
 269 }
 270
 271 static ULONG WINAPI OleContainer_AddRef(IOleContainer *iface)
 272 {
 273     return 2;
 274 }
 275
 276 static ULONG WINAPI OleContainer_Release(IOleContainer *iface)
 277 {
 278     return 1;
 279 }
 280
 281 static HRESULT WINAPI OleContainer_ParseDisplayName(IOleContainer *iface, IBindCtx *pbc,
 282         LPOLESTR pszDiaplayName, ULONG *pchEaten, IMoniker **ppmkOut)
 283 {
 284     ok(0, "unexpected call\n");
 285     return E_NOTIMPL;
 286 }
 287
 288 static HRESULT WINAPI OleContainer_EnumObjects(IOleContainer *iface, DWORD grfFlags,
 289         IEnumUnknown **ppenum)
 290 {
 291     ok(0, "unexpected call\n");
 292     return E_NOTIMPL;
 293 }
 294
 295 static HRESULT WINAPI OleContainer_LockContainer(IOleContainer *iface, BOOL fLock)
 296 {
 297     CHECK_EXPECT(LockContainer);
 298     ok(expect_LockContainer_fLock == fLock, "fLock=%x, expected %x\n", fLock, expect_LockContainer_fLock);
 299     return S_OK;
 300 }
 301
 302 static const IOleContainerVtbl OleContainerVtbl = {
 303     OleContainer_QueryInterface,
 304     OleContainer_AddRef,
 305     OleContainer_Release,
 306     OleContainer_ParseDisplayName,
 307     OleContainer_EnumObjects,
 308     OleContainer_LockContainer
 309 };
 310
 311 static IOleContainer OleContainer = { &OleContainerVtbl };
 312
 313 static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
 314 {
 315     return QueryInterface(riid, ppv);
 316 }
 317
 318 static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface)
 319 {
 320     return 2;
 321 }
 322
 323 static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface)
 324 {
 325     return 1;
 326 }
 327
 328 static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
 329 {
 330     ok(0, "unexpected call\n");
 331     return E_NOTIMPL;
 332 }
 333
 334 static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
 335 {
 336     ok(0, "unexpected call\n");
 337     return E_NOTIMPL;
 338 }
 339
 340 static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
 341 {
 342     ok(0, "unexpected call\n");
 343     return E_NOTIMPL;
 344 }
 345
 346 static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface,
 347         LPCBORDERWIDTHS pborderwidths)
 348 {
 349     ok(0, "unexpected call\n");
 350     return E_NOTIMPL;
 351 }
 352
 353 static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface,
 354         LPCBORDERWIDTHS pborderwidths)
 355 {
 356     ok(0, "unexpected call\n");
 357     return E_NOTIMPL;
 358 }
 359
 360 static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
 361         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
 362 {
 363     static const WCHAR wszHTML_Document[] =
 364         {'H','T','M','L',' ','D','o','c','u','m','e','n','t',0};
 365
 366     CHECK_EXPECT2(SetActiveObject);
 367
 368     if(expect_SetActiveObject_active) {
 369         ok(pActiveObject != NULL, "pActiveObject = NULL\n");
 370         if(pActiveObject && PRIMARYLANGID(GetSystemDefaultLangID()) == LANG_ENGLISH)
 371             ok(!lstrcmpW(wszHTML_Document, pszObjName), "pszObjName != \"HTML Document\"\n");
 372     }else {
 373         ok(pActiveObject == NULL, "pActiveObject=%p, expected NULL\n", pActiveObject);
 374         ok(pszObjName == NULL, "pszObjName=%p, expected NULL\n", pszObjName);
 375     }
 376
 377     return S_OK;
 378 }
 379
 380 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
 381         LPOLEMENUGROUPWIDTHS lpMenuWidths)
 382 {
 383     ok(0, "unexpected call\n");
 384     return E_NOTIMPL;
 385 }
 386
 387 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
 388         HOLEMENU holemenu, HWND hwndActiveObject)
 389 {
 390     ok(0, "unexpected call\n");
 391     return E_NOTIMPL;
 392 }
 393
 394 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
 395 {
 396     ok(0, "unexpected call\n");
 397     return E_NOTIMPL;
 398 }
 399
 400 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
 401 {
 402     CHECK_EXPECT2(SetStatusText);
 403     if(!expect_status_text)
 404         ok(pszStatusText == NULL, "pszStatusText=%p, expected NULL\n", pszStatusText);
 405     return S_OK;
 406 }
 407
 408 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
 409 {
 410     ok(0, "unexpected call\n");
 411     return E_NOTIMPL;
 412 }
 413
 414 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
 415 {
 416     ok(0, "unexpected call\n");
 417     return E_NOTIMPL;
 418 }
 419
 420 static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
 421     InPlaceFrame_QueryInterface,
 422     InPlaceFrame_AddRef,
 423     InPlaceFrame_Release,
 424     InPlaceFrame_GetWindow,
 425     InPlaceFrame_ContextSensitiveHelp,
 426     InPlaceFrame_GetBorder,
 427     InPlaceFrame_RequestBorderSpace,
 428     InPlaceFrame_SetBorderSpace,
 429     InPlaceFrame_SetActiveObject,
 430     InPlaceFrame_InsertMenus,
 431     InPlaceFrame_SetMenu,
 432     InPlaceFrame_RemoveMenus,
 433     InPlaceFrame_SetStatusText,
 434     InPlaceFrame_EnableModeless,
 435     InPlaceFrame_TranslateAccelerator
 436 };
 437
 438 static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
 439
 440 static HRESULT WINAPI InPlaceSite_QueryInterface(IOleInPlaceSite *iface, REFIID riid, void **ppv)
 441 {
 442     return QueryInterface(riid, ppv);
 443 }
 444
 445 static ULONG WINAPI InPlaceSite_AddRef(IOleInPlaceSite *iface)
 446 {
 447     return 2;
 448 }
 449
 450 static ULONG WINAPI InPlaceSite_Release(IOleInPlaceSite *iface)
 451 {
 452     return 1;
 453 }
 454
 455 static HRESULT WINAPI InPlaceSite_GetWindow(IOleInPlaceSite *iface, HWND *phwnd)
 456 {
 457     CHECK_EXPECT(GetWindow);
 458     ok(phwnd != NULL, "phwnd = NULL\n");
 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     CHECK_EXPECT(CanInPlaceActivate);
 472     return S_OK;
 473 }
 474
 475 static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSite *iface)
 476 {
 477     CHECK_EXPECT(OnInPlaceActivate);
 478     return S_OK;
 479 }
 480
 481 static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSite *iface)
 482 {
 483     CHECK_EXPECT(OnUIActivate);
 484     return S_OK;
 485 }
 486
 487 static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSite *iface,
 488         IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
 489         LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
 490 {
 491     static const RECT rect = {0,0,500,500};
 492
 493     CHECK_EXPECT(GetWindowContext);
 494
 495     ok(ppFrame != NULL, "ppFrame = NULL\n");
 496     if(ppFrame)
 497         *ppFrame = &InPlaceFrame;
 498     ok(ppDoc != NULL, "ppDoc = NULL\n");
 499     if(ppDoc)
 500         *ppDoc = NULL;
 501     ok(lprcPosRect != NULL, "lprcPosRect = NULL\n");
 502     if(lprcPosRect)
 503         memcpy(lprcPosRect, &rect, sizeof(RECT));
 504     ok(lprcClipRect != NULL, "lprcClipRect = NULL\n");
 505     if(lprcClipRect)
 506         memcpy(lprcClipRect, &rect, sizeof(RECT));
 507     ok(lpFrameInfo != NULL, "lpFrameInfo = NULL\n");
 508     if(lpFrameInfo) {
 509         lpFrameInfo->cb = sizeof(*lpFrameInfo);
 510         lpFrameInfo->fMDIApp = FALSE;
 511         lpFrameInfo->hwndFrame = container_hwnd;
 512         lpFrameInfo->haccel = NULL;
 513         lpFrameInfo->cAccelEntries = 0;
 514     }
 515
 516     return S_OK;
 517 }
 518
 519 static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSite *iface, SIZE scrollExtant)
 520 {
 521     ok(0, "unexpected call\n");
 522     return E_NOTIMPL;
 523 }
 524
 525 static HRESULT WINAPI InPlaceSite_OnUIDeactivate(IOleInPlaceSite *iface, BOOL fUndoable)
 526 {
 527     CHECK_EXPECT(OnUIDeactivate);
 528     ok(!fUndoable, "fUndoable = TRUE\n");
 529     return S_OK;
 530 }
 531
 532 static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivate(IOleInPlaceSite *iface)
 533 {
 534     CHECK_EXPECT(OnInPlaceDeactivate);
 535     return S_OK;
 536 }
 537
 538 static HRESULT WINAPI InPlaceSite_DiscardUndoState(IOleInPlaceSite *iface)
 539 {
 540     ok(0, "unexpected call\n");
 541     return E_NOTIMPL;
 542 }
 543
 544 static HRESULT WINAPI InPlaceSite_DeactivateAndUndo(IOleInPlaceSite *iface)
 545 {
 546     ok(0, "unexpected call\n");
 547     return E_NOTIMPL;
 548 }
 549
 550 static HRESULT WINAPI InPlaceSite_OnPosRectChange(IOleInPlaceSite *iface, LPCRECT lprcPosRect)
 551 {
 552     ok(0, "unexpected call\n");
 553     return E_NOTIMPL;
 554 }
 555
 556 static const IOleInPlaceSiteVtbl InPlaceSiteVtbl = {
 557     InPlaceSite_QueryInterface,
 558     InPlaceSite_AddRef,
 559     InPlaceSite_Release,
 560     InPlaceSite_GetWindow,
 561     InPlaceSite_ContextSensitiveHelp,
 562     InPlaceSite_CanInPlaceActivate,
 563     InPlaceSite_OnInPlaceActivate,
 564     InPlaceSite_OnUIActivate,
 565     InPlaceSite_GetWindowContext,
 566     InPlaceSite_Scroll,
 567     InPlaceSite_OnUIDeactivate,
 568     InPlaceSite_OnInPlaceDeactivate,
 569     InPlaceSite_DiscardUndoState,
 570     InPlaceSite_DeactivateAndUndo,
 571     InPlaceSite_OnPosRectChange
 572 };
 573
 574 static IOleInPlaceSite InPlaceSite = { &InPlaceSiteVtbl };
 575
 576 static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
 577 {
 578     return QueryInterface(riid, ppv);
 579 }
 580
 581 static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
 582 {
 583     return 2;
 584 }
 585
 586 static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
 587 {
 588     return 1;
 589 }
 590
 591 static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
 592 {
 593     ok(0, "unexpected call\n");
 594     return E_NOTIMPL;
 595 }
 596
 597 static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAsign, DWORD dwWhichMoniker,
 598         IMoniker **ppmon)
 599 {
 600     ok(0, "unexpected call\n");
 601     return E_NOTIMPL;
 602 }
 603
 604 static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
 605 {
 606     CHECK_EXPECT(GetContainer);
 607     ok(ppContainer != NULL, "ppContainer = NULL\n");
 608     *ppContainer = &OleContainer;
 609     return S_OK;
 610 }
 611
 612 static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
 613 {
 614     ok(0, "unexpected call\n");
 615     return E_NOTIMPL;
 616 }
 617
 618 static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
 619 {
 620     ok(0, "unexpected call\n");
 621     return E_NOTIMPL;
 622 }
 623
 624 static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
 625 {
 626     ok(0, "unexpected call\n");
 627     return E_NOTIMPL;
 628 }
 629
 630 static const IOleClientSiteVtbl ClientSiteVtbl = {
 631     ClientSite_QueryInterface,
 632     ClientSite_AddRef,
 633     ClientSite_Release,
 634     ClientSite_SaveObject,
 635     ClientSite_GetMoniker,
 636     ClientSite_GetContainer,
 637     ClientSite_ShowObject,
 638     ClientSite_OnShowWindow,
 639     ClientSite_RequestNewObjectLayout
 640 };
 641
 642 static IOleClientSite ClientSite = { &ClientSiteVtbl };
 643
 644 static HRESULT WINAPI DocumentSite_QueryInterface(IOleDocumentSite *iface, REFIID riid, void **ppv)
 645 {
 646     return QueryInterface(riid, ppv);
 647 }
 648
 649 static ULONG WINAPI DocumentSite_AddRef(IOleDocumentSite *iface)
 650 {
 651     return 2;
 652 }
 653
 654 static ULONG WINAPI DocumentSite_Release(IOleDocumentSite *iface)
 655 {
 656     return 1;
 657 }
 658
 659 static BOOL call_UIActivate = TRUE;
 660 static HRESULT WINAPI DocumentSite_ActivateMe(IOleDocumentSite *iface, IOleDocumentView *pViewToActivate)
 661 {
 662     IOleDocument *document;
 663     HRESULT hres;
 664
 665     CHECK_EXPECT(ActivateMe);
 666     ok(pViewToActivate != NULL, "pViewToActivate = NULL\n");
 667
 668     hres = IOleDocumentView_QueryInterface(pViewToActivate, &IID_IOleDocument, (void**)&document);
 669     ok(hres == S_OK, "could not get IOleDocument: %08lx\n", hres);
 670
 671     if(SUCCEEDED(hres)) {
 672         hres = IOleDocument_CreateView(document, &InPlaceSite, NULL, 0, &view);
 673         ok(hres == S_OK, "CreateView failed: %08lx\n", hres);
 674
 675         if(SUCCEEDED(hres)) {
 676             IOleInPlaceActiveObject *activeobj = NULL;
 677             IOleInPlaceSite *inplacesite = NULL;
 678             HWND tmp_hwnd = NULL;
 679             static RECT rect = {0,0,400,500};
 680
 681             hres = IOleDocumentView_GetInPlaceSite(view, &inplacesite);
 682             ok(hres == S_OK, "GetInPlaceSite failed: %08lx\n", hres);
 683             ok(inplacesite == &InPlaceSite, "inplacesite=%p, expected %p\n",
 684                     inplacesite, &InPlaceSite);
 685
 686             hres = IOleDocumentView_SetInPlaceSite(view, &InPlaceSite);
 687             ok(hres == S_OK, "SetInPlaceSite failed: %08lx\n", hres);
 688
 689             hres = IOleDocumentView_GetInPlaceSite(view, &inplacesite);
 690             ok(hres == S_OK, "GetInPlaceSite failed: %08lx\n", hres);
 691             ok(inplacesite == &InPlaceSite, "inplacesite=%p, expected %p\n",
 692                     inplacesite, &InPlaceSite);
 693
 694             hres = IOleDocumentView_QueryInterface(view, &IID_IOleInPlaceActiveObject, (void**)&activeobj);
 695             ok(hres == S_OK, "Could not get IOleInPlaceActiveObject: %08lx\n", hres);
 696
 697             if(activeobj) {
 698                 IOleInPlaceActiveObject_GetWindow(activeobj, &hwnd);
 699                 ok(hres == S_OK, "GetWindow failed: %08lx\n", hres);
 700                 ok(hwnd == NULL, "hwnd=%p, expeted NULL\n", hwnd);
 701             }
 702
 703             if(call_UIActivate) {
 704                 SET_EXPECT(CanInPlaceActivate);
 705                 SET_EXPECT(GetWindowContext);
 706                 SET_EXPECT(GetWindow);
 707                 SET_EXPECT(OnInPlaceActivate);
 708                 SET_EXPECT(SetStatusText);
 709                 SET_EXPECT(Exec_SETPROGRESSMAX);
 710                 SET_EXPECT(Exec_SETPROGRESSPOS);
 711                 SET_EXPECT(OnUIActivate);
 712                 SET_EXPECT(SetActiveObject);
 713                 SET_EXPECT(ShowUI);
 714                 expect_SetActiveObject_active = TRUE;
 715                 expect_status_text = NULL;
 716
 717                 hres = IOleDocumentView_UIActivate(view, TRUE);
 718
 719                 if(FAILED(hres)) {
 720                     trace("UIActivate failed: %08lx\n", hres);
 721                     return hres;
 722                 }
 723                 ok(hres == S_OK, "UIActivate failed: %08lx\n", hres);
 724
 725                 CHECK_CALLED(CanInPlaceActivate);
 726                 CHECK_CALLED(GetWindowContext);
 727                 CHECK_CALLED(GetWindow);
 728                 CHECK_CALLED(OnInPlaceActivate);
 729                 CHECK_CALLED(SetStatusText);
 730                 CHECK_CALLED(Exec_SETPROGRESSMAX);
 731                 CHECK_CALLED(Exec_SETPROGRESSPOS);
 732                 CHECK_CALLED(OnUIActivate);
 733                 CHECK_CALLED(SetActiveObject);
 734                 CHECK_CALLED(ShowUI);
 735
 736                 if(activeobj) {
 737                     hres = IOleInPlaceActiveObject_GetWindow(activeobj, &hwnd);
 738                     ok(hres == S_OK, "GetWindow failed: %08lx\n", hres);
 739                     ok(hwnd != NULL, "hwnd == NULL\n");
 740                     if(last_hwnd)
 741                         ok(hwnd == last_hwnd, "hwnd != last_hwnd\n");
 742                 }
 743
 744                 hres = IOleDocumentView_UIActivate(view, TRUE);
 745                 ok(hres == S_OK, "UIActivate failed: %08lx\n", hres);
 746
 747                 if(activeobj) {
 748                     hres = IOleInPlaceActiveObject_GetWindow(activeobj, &tmp_hwnd);
 749                     ok(hres == S_OK, "GetWindow failed: %08lx\n", hres);
 750                     ok(tmp_hwnd == hwnd, "tmp_hwnd=%p, expected %p\n", tmp_hwnd, hwnd);
 751                 }
 752             }
 753
 754             hres = IOleDocumentView_SetRect(view, &rect);
 755             ok(hres == S_OK, "SetRect failed: %08lx\n", hres);
 756
 757             if(call_UIActivate) {
 758                 hres = IOleDocumentView_Show(view, TRUE);
 759                 ok(hres == S_OK, "Show failed: %08lx\n", hres);
 760             }else {
 761                 SET_EXPECT(CanInPlaceActivate);
 762                 SET_EXPECT(GetWindowContext);
 763                 SET_EXPECT(GetWindow);
 764                 SET_EXPECT(OnInPlaceActivate);
 765                 SET_EXPECT(SetStatusText);
 766                 SET_EXPECT(Exec_SETPROGRESSMAX);
 767                 SET_EXPECT(Exec_SETPROGRESSPOS);
 768                 SET_EXPECT(OnUIActivate);
 769                 expect_status_text = (load_state == LD_LOADED ? (LPCOLESTR)0xdeadbeef : NULL);
 770
 771                 hres = IOleDocumentView_Show(view, TRUE);
 772                 ok(hres == S_OK, "Show failed: %08lx\n", hres);
 773
 774                 CHECK_CALLED(CanInPlaceActivate);
 775                 CHECK_CALLED(GetWindowContext);
 776                 CHECK_CALLED(GetWindow);
 777                 CHECK_CALLED(OnInPlaceActivate);
 778                 CHECK_CALLED(SetStatusText);
 779                 CHECK_CALLED(Exec_SETPROGRESSMAX);
 780                 CHECK_CALLED(Exec_SETPROGRESSPOS);
 781
 782                 if(activeobj) {
 783                     hres = IOleInPlaceActiveObject_GetWindow(activeobj, &hwnd);
 784                     ok(hres == S_OK, "GetWindow failed: %08lx\n", hres);
 785                     ok(hwnd != NULL, "hwnd == NULL\n");
 786                     if(last_hwnd)
 787                         ok(hwnd == last_hwnd, "hwnd != last_hwnd\n");
 788                 }
 789             }
 790
 791             if(activeobj)
 792                 IOleInPlaceActiveObject_Release(activeobj);
 793         }
 794
 795         IOleDocument_Release(document);
 796     }
 797
 798     return S_OK;
 799 }
 800
 801 static const IOleDocumentSiteVtbl DocumentSiteVtbl = {
 802     DocumentSite_QueryInterface,
 803     DocumentSite_AddRef,
 804     DocumentSite_Release,
 805     DocumentSite_ActivateMe
 806 };
 807
 808 static IOleDocumentSite DocumentSite = { &DocumentSiteVtbl };
 809
 810 static HRESULT WINAPI DocHostUIHandler_QueryInterface(IDocHostUIHandler2 *iface, REFIID riid, void **ppv)
 811 {
 812     return QueryInterface(riid, ppv);
 813 }
 814
 815 static ULONG WINAPI DocHostUIHandler_AddRef(IDocHostUIHandler2 *iface)
 816 {
 817     return 2;
 818 }
 819
 820 static ULONG WINAPI DocHostUIHandler_Release(IDocHostUIHandler2 *iface)
 821 {
 822     return 1;
 823 }
 824
 825 static HRESULT WINAPI DocHostUIHandler_ShowContextMenu(IDocHostUIHandler2 *iface, DWORD dwID, POINT *ppt,
 826         IUnknown *pcmdtReserved, IDispatch *pdicpReserved)
 827 {
 828     ok(0, "unexpected call\n");
 829     return E_NOTIMPL;
 830 }
 831
 832 static HRESULT WINAPI DocHostUIHandler_GetHostInfo(IDocHostUIHandler2 *iface, DOCHOSTUIINFO *pInfo)
 833 {
 834     CHECK_EXPECT(GetHostInfo);
 835     ok(pInfo != NULL, "pInfo=NULL\n");
 836     if(pInfo) {
 837         ok(pInfo->cbSize == sizeof(DOCHOSTUIINFO), "pInfo->cbSize=%lu\n", pInfo->cbSize);
 838         ok(!pInfo->dwFlags, "pInfo->dwFlags=%08lx, expected 0\n", pInfo->dwFlags);
 839         pInfo->dwFlags = DOCHOSTUIFLAG_DISABLE_HELP_MENU | DOCHOSTUIFLAG_DISABLE_SCRIPT_INACTIVE
 840             | DOCHOSTUIFLAG_ACTIVATE_CLIENTHIT_ONLY | DOCHOSTUIFLAG_ENABLE_INPLACE_NAVIGATION
 841             | DOCHOSTUIFLAG_IME_ENABLE_RECONVERSION;
 842         ok(!pInfo->dwDoubleClick, "pInfo->dwDoubleClick=%08lx, expected 0\n", pInfo->dwDoubleClick);
 843         ok(!pInfo->pchHostCss, "pInfo->pchHostCss=%p, expected NULL\n", pInfo->pchHostCss);
 844         ok(!pInfo->pchHostNS, "pInfo->pchhostNS=%p, expected NULL\n", pInfo->pchHostNS);
 845     }
 846     return S_OK;
 847 }
 848
 849 static HRESULT WINAPI DocHostUIHandler_ShowUI(IDocHostUIHandler2 *iface, DWORD dwID,
 850         IOleInPlaceActiveObject *pActiveObject, IOleCommandTarget *pCommandTarget,
 851         IOleInPlaceFrame *pFrame, IOleInPlaceUIWindow *pDoc)
 852 {
 853     CHECK_EXPECT(ShowUI);
 854
 855     ok(dwID == DOCHOSTUITYPE_BROWSE, "dwID=%ld, expected DOCHOSTUITYPE_BROWSE\n", dwID);
 856     ok(pActiveObject != NULL, "pActiveObject = NULL\n");
 857     ok(pCommandTarget != NULL, "pCommandTarget = NULL\n");
 858     ok(pFrame == &InPlaceFrame, "pFrame=%p, expected %p\n", pFrame, &InPlaceFrame);
 859     ok(pDoc == NULL, "pDoc=%p, expected NULL\n", pDoc);
 860
 861     return S_OK;
 862 }
 863
 864 static HRESULT WINAPI DocHostUIHandler_HideUI(IDocHostUIHandler2 *iface)
 865 {
 866     CHECK_EXPECT(HideUI);
 867     return S_OK;
 868 }
 869
 870 static HRESULT WINAPI DocHostUIHandler_UpdateUI(IDocHostUIHandler2 *iface)
 871 {
 872     CHECK_EXPECT(UpdateUI);
 873     return S_OK;
 874 }
 875
 876 static HRESULT WINAPI DocHostUIHandler_EnableModeless(IDocHostUIHandler2 *iface, BOOL fEnable)
 877 {
 878     ok(0, "unexpected call\n");
 879     return E_NOTIMPL;
 880 }
 881
 882 static HRESULT WINAPI DocHostUIHandler_OnDocWindowActivate(IDocHostUIHandler2 *iface, BOOL fActivate)
 883 {
 884     ok(0, "unexpected call\n");
 885     return E_NOTIMPL;
 886 }
 887
 888 static BOOL expect_OnFrameWindowActivate_fActivate;
 889 static HRESULT WINAPI DocHostUIHandler_OnFrameWindowActivate(IDocHostUIHandler2 *iface, BOOL fActivate)
 890 {
 891     CHECK_EXPECT2(OnFrameWindowActivate);
 892     ok(fActivate == expect_OnFrameWindowActivate_fActivate, "fActivate=%x\n", fActivate);
 893     return S_OK;
 894 }
 895
 896 static HRESULT WINAPI DocHostUIHandler_ResizeBorder(IDocHostUIHandler2 *iface, LPCRECT prcBorder,
 897         IOleInPlaceUIWindow *pUIWindow, BOOL fRameWindow)
 898 {
 899     ok(0, "unexpected call\n");
 900     return E_NOTIMPL;
 901 }
 902
 903 static HRESULT WINAPI DocHostUIHandler_TranslateAccelerator(IDocHostUIHandler2 *iface, LPMSG lpMsg,
 904         const GUID *pguidCmdGroup, DWORD nCmdID)
 905 {
 906     ok(0, "unexpected call\n");
 907     return E_NOTIMPL;
 908 }
 909
 910 static HRESULT WINAPI DocHostUIHandler_GetOptionKeyPath(IDocHostUIHandler2 *iface,
 911         LPOLESTR *pchKey, DWORD dw)
 912 {
 913     CHECK_EXPECT(GetOptionKeyPath);
 914     ok(pchKey != NULL, "pchKey = NULL\n");
 915     ok(!dw, "dw=%ld, expected 0\n", dw);
 916     if(pchKey)
 917         ok(!*pchKey, "*pchKey=%p, expected NULL\n", *pchKey);
 918     return S_OK;
 919 }
 920
 921 static HRESULT WINAPI DocHostUIHandler_GetDropTarget(IDocHostUIHandler2 *iface,
 922         IDropTarget *pDropTarget, IDropTarget **ppDropTarget)
 923 {
 924     CHECK_EXPECT(GetDropTarget);
 925     /* TODO */
 926     return E_NOTIMPL;
 927 }
 928
 929 static HRESULT WINAPI DocHostUIHandler_GetExternal(IDocHostUIHandler2 *iface, IDispatch **ppDispatch)
 930 {
 931     ok(0, "unexpected call\n");
 932     return E_NOTIMPL;
 933 }
 934
 935 static HRESULT WINAPI DocHostUIHandler_TranslateUrl(IDocHostUIHandler2 *iface, DWORD dwTranslate,
 936         OLECHAR *pchURLIn, OLECHAR **ppchURLOut)
 937 {
 938     ok(0, "unexpected call\n");
 939     return E_NOTIMPL;
 940 }
 941
 942 static HRESULT WINAPI DocHostUIHandler_FilterDataObject(IDocHostUIHandler2 *iface, IDataObject *pDO,
 943         IDataObject **ppPORet)
 944 {
 945     ok(0, "unexpected call\n");
 946     return E_NOTIMPL;
 947 }
 948
 949 static HRESULT WINAPI DocHostUIHandler_GetOverrideKeyPath(IDocHostUIHandler2 *iface,
 950         LPOLESTR *pchKey, DWORD dw)
 951 {
 952     CHECK_EXPECT(GetOverrideKeyPath);
 953     ok(pchKey != NULL, "pchKey = NULL\n");
 954     if(pchKey)
 955         ok(!*pchKey, "*pchKey=%p, expected NULL\n", *pchKey);
 956     ok(!dw, "dw=%ld, xepected 0\n", dw);
 957     return S_OK;
 958 }
 959
 960 static const IDocHostUIHandler2Vtbl DocHostUIHandlerVtbl = {
 961     DocHostUIHandler_QueryInterface,
 962     DocHostUIHandler_AddRef,
 963     DocHostUIHandler_Release,
 964     DocHostUIHandler_ShowContextMenu,
 965     DocHostUIHandler_GetHostInfo,
 966     DocHostUIHandler_ShowUI,
 967     DocHostUIHandler_HideUI,
 968     DocHostUIHandler_UpdateUI,
 969     DocHostUIHandler_EnableModeless,
 970     DocHostUIHandler_OnDocWindowActivate,
 971     DocHostUIHandler_OnFrameWindowActivate,
 972     DocHostUIHandler_ResizeBorder,
 973     DocHostUIHandler_TranslateAccelerator,
 974     DocHostUIHandler_GetOptionKeyPath,
 975     DocHostUIHandler_GetDropTarget,
 976     DocHostUIHandler_GetExternal,
 977     DocHostUIHandler_TranslateUrl,
 978     DocHostUIHandler_FilterDataObject,
 979     DocHostUIHandler_GetOverrideKeyPath
 980 };
 981
 982 static IDocHostUIHandler2 DocHostUIHandler = { &DocHostUIHandlerVtbl };
 983
 984 static HRESULT WINAPI OleCommandTarget_QueryInterface(IOleCommandTarget *iface,
 985         REFIID riid, void **ppv)
 986 {
 987     return QueryInterface(riid, ppv);
 988 }
 989
 990 static ULONG WINAPI OleCommandTarget_AddRef(IOleCommandTarget *iface)
 991 {
 992     return 2;
 993 }
 994
 995 static ULONG WINAPI OleCommandTarget_Release(IOleCommandTarget *iface)
 996 {
 997     return 1;
 998 }
 999
1000 static HRESULT WINAPI OleCommandTarget_QueryStatus(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
1001         ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText)
1002 {
1003     ok(!pguidCmdGroup, "pguidCmdGroup != MULL\n");
1004     ok(cCmds == 1, "cCmds=%ld, expected 1\n", cCmds);
1005     ok(!pCmdText, "pCmdText != NULL\n");
1006
1007     switch(prgCmds[0].cmdID) {
1008     case OLECMDID_SETPROGRESSTEXT:
1009         CHECK_EXPECT(QueryStatus_SETPROGRESSTEXT);
1010         prgCmds[0].cmdf = OLECMDF_ENABLED;
1011         return S_OK;
1012     case OLECMDID_OPEN:
1013         CHECK_EXPECT(QueryStatus_OPEN);
1014         prgCmds[0].cmdf = 0;
1015         return S_OK;
1016     case OLECMDID_NEW:
1017         CHECK_EXPECT(QueryStatus_NEW);
1018         prgCmds[0].cmdf = 0;
1019         return S_OK;
1020     default:
1021         ok(0, "unexpected command %ld\n", prgCmds[0].cmdID);
1022     };
1023
1024     return E_FAIL;
1025 }
1026
1027 static HRESULT WINAPI OleCommandTarget_Exec(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
1028         DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
1029 {
1030     if(!pguidCmdGroup) {
1031         ok(nCmdexecopt == OLECMDEXECOPT_DONTPROMPTUSER, "nCmdexecopts=%08lx\n", nCmdexecopt);
1032
1033         switch(nCmdID) {
1034         case OLECMDID_SETPROGRESSMAX:
1035             CHECK_EXPECT2(Exec_SETPROGRESSMAX);
1036             ok(pvaIn != NULL, "pvaIn == NULL\n");
1037             if(pvaIn) {
1038                 ok(V_VT(pvaIn) == VT_I4, "V_VT(pvaIn)=%d, expected VT_I4\n", V_VT(pvaIn));
1039                 if(load_state == LD_NO)
1040                     ok(V_I4(pvaIn) == 0, "V_I4(pvaIn)=%ld, expected 0\n", V_I4(pvaIn));
1041             }
1042             ok(pvaOut == NULL, "pvaOut=%p, expected NULL\n", pvaOut);
1043             return S_OK;
1044         case OLECMDID_SETPROGRESSPOS:
1045             CHECK_EXPECT2(Exec_SETPROGRESSPOS);
1046             ok(pvaIn != NULL, "pvaIn == NULL\n");
1047             if(pvaIn) {
1048                 ok(V_VT(pvaIn) == VT_I4, "V_VT(pvaIn)=%d, expected VT_I4\n", V_VT(pvaIn));
1049                 if(load_state == LD_NO)
1050                     ok(V_I4(pvaIn) == 0, "V_I4(pvaIn)=%ld, expected 0\n", V_I4(pvaIn));
1051             }
1052             ok(pvaOut == NULL, "pvaOut=%p, expected NULL\n", pvaOut);
1053             return S_OK;
1054         case OLECMDID_HTTPEQUIV_DONE:
1055             CHECK_EXPECT(Exec_HTTPEQUIV_DONE);
1056             /* TODO */
1057             return S_OK;
1058         case OLECMDID_SETDOWNLOADSTATE:
1059             CHECK_EXPECT2(Exec_SETDOWNLOADSTATE);
1060             /* TODO */
1061             return S_OK;
1062         case OLECMDID_UPDATECOMMANDS:
1063             CHECK_EXPECT(Exec_UPDATECOMMANDS);
1064             ok(pvaIn == NULL, "pvaIn=%p\n", pvaIn);
1065             ok(pvaOut == NULL, "pvaOut=%p\n", pvaOut);
1066             return S_OK;
1067         case OLECMDID_SETTITLE:
1068             CHECK_EXPECT2(Exec_SETTITLE);
1069             /* TODO */
1070             return S_OK;
1071         case OLECMDID_HTTPEQUIV:
1072             CHECK_EXPECT2(Exec_HTTPEQUIV);
1073             /* TODO */
1074             return S_OK;
1075         default:
1076             ok(0, "unexpected command %ld\n", nCmdID);
1077             return E_FAIL;
1078         };
1079     }
1080
1081     if(IsEqualGUID(&CGID_ShellDocView, pguidCmdGroup)) {
1082         ok(nCmdexecopt == 0, "nCmdexecopts=%08lx\n", nCmdexecopt);
1083
1084         switch(nCmdID) {
1085         case 37:
1086             CHECK_EXPECT2(Exec_ShellDocView_37);
1087             ok(pvaOut == NULL, "pvaOut=%p, expected NULL\n", pvaOut);
1088             ok(pvaIn != NULL, "pvaIn == NULL\n");
1089             if(pvaIn) {
1090                 ok(V_VT(pvaIn) == VT_I4, "V_VT(pvaIn)=%d, expected VT_I4\n", V_VT(pvaIn));
1091                 ok(V_I4(pvaIn) == 0, "V_I4(pvaIn)=%ld, expected 0\n", V_I4(pvaIn));
1092             }
1093             return S_OK;
1094         default:
1095             ok(0, "unexpected command %ld\n", nCmdID);
1096             return E_FAIL;
1097         };
1098     }
1099
1100     if(IsEqualGUID(&CGID_MSHTML, pguidCmdGroup)) {
1101         ok(nCmdexecopt == 0, "nCmdexecopts=%08lx\n", nCmdexecopt);
1102
1103         switch(nCmdID) {
1104         case 2315:
1105             CHECK_EXPECT(Exec_MSHTML_2315);
1106             /* TODO */
1107             return S_OK;
1108         default:
1109             ok(0, "unexpected command %ld\n", nCmdID);
1110         };
1111     }
1112
1113     if(IsEqualGUID(&CGID_Undocumented, pguidCmdGroup))
1114         return E_FAIL; /* TODO */
1115
1116     ok(0, "unexpected call\n");
1117     return E_NOTIMPL;
1118 }
1119
1120 static IOleCommandTargetVtbl OleCommandTargetVtbl = {
1121     OleCommandTarget_QueryInterface,
1122     OleCommandTarget_AddRef,
1123     OleCommandTarget_Release,
1124     OleCommandTarget_QueryStatus,
1125     OleCommandTarget_Exec
1126 };
1127
1128 static IOleCommandTarget OleCommandTarget = { &OleCommandTargetVtbl };
1129
1130 static HRESULT WINAPI Dispatch_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
1131 {
1132     return QueryInterface(riid, ppv);
1133 }
1134
1135 static ULONG WINAPI Dispatch_AddRef(IDispatch *iface)
1136 {
1137     return 2;
1138 }
1139
1140 static ULONG WINAPI Dispatch_Release(IDispatch *iface)
1141 {
1142     return 1;
1143 }
1144
1145 static HRESULT WINAPI Dispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
1146 {
1147     ok(0, "unexpected call\n");
1148     return E_NOTIMPL;
1149 }
1150
1151 static HRESULT WINAPI Dispatch_GetTypeInfo(IDispatch *iface, UINT iTInfo, LCID lcid,
1152         ITypeInfo **ppTInfo)
1153 {
1154     ok(0, "unexpected call\n");
1155     return E_NOTIMPL;
1156 }
1157
1158 static HRESULT WINAPI Dispatch_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *rgszNames,
1159         UINT cNames, LCID lcid, DISPID *rgDispId)
1160 {
1161     ok(0, "unexpected call\n");
1162     return E_NOTIMPL;
1163 }
1164
1165 static HRESULT WINAPI Dispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,
1166         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
1167         EXCEPINFO *pExcepInfo, UINT *puArgErr)
1168 {
1169     ok(IsEqualGUID(&IID_NULL, riid), "riid != IID_NULL\n");
1170     ok(pDispParams != NULL, "pDispParams == NULL\n");
1171     ok(pExcepInfo == NULL, "pExcepInfo=%p, expected NULL\n", pExcepInfo);
1172     ok(puArgErr != NULL, "puArgErr == NULL\n");
1173     ok(V_VT(pVarResult) == 0, "V_VT(pVarResult)=%d, expected 0\n", V_VT(pVarResult));
1174     ok(wFlags == DISPATCH_PROPERTYGET, "wFlags=%08x, expected DISPATCH_PROPERTYGET\n", wFlags);
1175
1176     switch(dispIdMember) {
1177     case DISPID_AMBIENT_USERMODE:
1178         CHECK_EXPECT2(Invoke_AMBIENT_USERMODE);
1179         V_VT(pVarResult) = VT_BOOL;
1180         V_BOOL(pVarResult) = VARIANT_TRUE;
1181         return S_OK;
1182     case DISPID_AMBIENT_DLCONTROL:
1183         CHECK_EXPECT2(Invoke_AMBIENT_DLCONTROL);
1184         return E_FAIL;
1185     case DISPID_AMBIENT_OFFLINEIFNOTCONNECTED:
1186         CHECK_EXPECT2(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1187         return E_FAIL;
1188     case DISPID_AMBIENT_SILENT:
1189         CHECK_EXPECT2(Invoke_AMBIENT_SILENT);
1190         V_VT(pVarResult) = VT_BOOL;
1191         V_BOOL(pVarResult) = VARIANT_FALSE;
1192         return S_OK;
1193     case DISPID_AMBIENT_USERAGENT:
1194         CHECK_EXPECT(Invoke_AMBIENT_USERAGENT);
1195         return E_FAIL;
1196     case DISPID_AMBIENT_PALETTE:
1197         CHECK_EXPECT(Invoke_AMBIENT_PALETTE);
1198         return E_FAIL;
1199     };
1200
1201     ok(0, "unexpected dispid %ld\n", dispIdMember);
1202     return E_FAIL;
1203 }
1204
1205 static IDispatchVtbl DispatchVtbl = {
1206     Dispatch_QueryInterface,
1207     Dispatch_AddRef,
1208     Dispatch_Release,
1209     Dispatch_GetTypeInfoCount,
1210     Dispatch_GetTypeInfo,
1211     Dispatch_GetIDsOfNames,
1212     Dispatch_Invoke
1213 };
1214
1215 static IDispatch Dispatch = { &DispatchVtbl };
1216
1217 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface,
1218                                                      REFIID riid, void **ppv)
1219 {
1220     return QueryInterface(riid, ppv);
1221 }
1222
1223 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
1224 {
1225     return 2;
1226 }
1227
1228 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
1229 {
1230     return 1;
1231 }
1232
1233 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService,
1234                                     REFIID riid, void **ppv)
1235 {
1236     /*
1237      * Services used by HTMLDocument:
1238      *
1239      * IOleUndoManager
1240      * IInternetSecurityManager
1241      * ITargetFrame
1242      * {D5F78C80-5252-11CF-90FA-00AA0042106E}
1243      * HTMLFrameBase
1244      * IShellObject
1245      * {3050F312-98B5-11CF-BB82-00AA00BDCE0B}
1246      * {53A2D5B1-D2FC-11D0-84E0-006097C9987D}
1247      * {AD7F6C62-F6BD-11D2-959B-006097C553C8}
1248      * DefView (?)
1249      * {6D12FE80-7911-11CF-9534-0000C05BAE0B}
1250      * IElementBehaviorFactory
1251      * {3050F429-98B5-11CF-BB82-00AA00BDCE0B}
1252      * STopLevelBrowser
1253      * IHTMLWindow2
1254      * IInternetProtocol
1255      * IWebBrowserApp
1256      * UrlHostory
1257      * IHTMLEditHost
1258      * IHlinkFrame
1259      */
1260
1261     if(IsEqualGUID(&IID_IHlinkFrame, guidService)) {
1262         ok(IsEqualGUID(&IID_IHlinkFrame, riid), "unexpected riid\n");
1263         *ppv = &HlinkFrame;
1264         return S_OK;
1265     }
1266
1267     return E_NOINTERFACE;
1268 }
1269
1270 static const IServiceProviderVtbl ServiceProviderVtbl = {
1271     ServiceProvider_QueryInterface,
1272     ServiceProvider_AddRef,
1273     ServiceProvider_Release,
1274     ServiceProvider_QueryService
1275 };
1276
1277 static IServiceProvider ServiceProvider = { &ServiceProviderVtbl };
1278
1279 static HRESULT QueryInterface(REFIID riid, void **ppv)
1280 {
1281     *ppv = NULL;
1282
1283     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IOleClientSite, riid))
1284         *ppv = &ClientSite;
1285     else if(IsEqualGUID(&IID_IOleDocumentSite, riid))
1286         *ppv = &DocumentSite;
1287     else if(IsEqualGUID(&IID_IDocHostUIHandler, riid) || IsEqualGUID(&IID_IDocHostUIHandler2, riid))
1288         *ppv = &DocHostUIHandler;
1289     else if(IsEqualGUID(&IID_IOleContainer, riid))
1290         *ppv = &OleContainer;
1291     else if(IsEqualGUID(&IID_IOleWindow, riid) || IsEqualGUID(&IID_IOleInPlaceSite, riid))
1292         *ppv = &InPlaceSite;
1293     else if(IsEqualGUID(&IID_IOleInPlaceUIWindow, riid) || IsEqualGUID(&IID_IOleInPlaceFrame, riid))
1294         *ppv = &InPlaceFrame;
1295     else if(IsEqualGUID(&IID_IOleCommandTarget , riid))
1296         *ppv = &OleCommandTarget;
1297     else if(IsEqualGUID(&IID_IDispatch, riid))
1298         *ppv = &Dispatch;
1299     else if(IsEqualGUID(&IID_IServiceProvider, riid))
1300         *ppv = &ServiceProvider;
1301
1302     /* TODO:
1303      * IOleInPlaceSiteEx
1304      * {D48A6EC6-6A4A-11CF-94A7-444553540000}
1305      * {7BB0B520-B1A7-11D2-BB23-00C04F79ABCD}
1306      * {000670BA-0000-0000-C000-000000000046}
1307      */
1308
1309     if(*ppv)
1310         return S_OK;
1311     return E_NOINTERFACE;
1312 }
1313
1314 static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
1315 {
1316     return DefWindowProc(hwnd, msg, wParam, lParam);
1317 }
1318
1319 static void test_ConnectionPoint(IConnectionPointContainer *container, REFIID riid)
1320 {
1321     IConnectionPointContainer *tmp_container = NULL;
1322     IConnectionPoint *cp;
1323     IID iid;
1324     HRESULT hres;
1325
1326     hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
1327     ok(hres == S_OK, "FindConnectionPoint failed: %08lx\n", hres);
1328     if(FAILED(hres))
1329         return;
1330
1331     hres = IConnectionPoint_GetConnectionInterface(cp, &iid);
1332     ok(hres == S_OK, "GetConnectionInterface failed: %08lx\n", hres);
1333     ok(IsEqualGUID(riid, &iid), "wrong iid\n");
1334
1335     hres = IConnectionPoint_GetConnectionInterface(cp, NULL);
1336     ok(hres == E_POINTER, "GetConnectionInterface failed: %08lx, expected E_POINTER\n", hres);
1337
1338     hres = IConnectionPoint_GetConnectionPointContainer(cp, &tmp_container);
1339     ok(hres == S_OK, "GetConnectionPointContainer failed: %08lx\n", hres);
1340     ok(tmp_container == container, "container != tmp_container\n");
1341     if(SUCCEEDED(hres))
1342         IConnectionPointContainer_Release(tmp_container);
1343
1344     hres = IConnectionPoint_GetConnectionPointContainer(cp, NULL);
1345     ok(hres == E_POINTER, "GetConnectionPointContainer failed: %08lx, expected E_POINTER\n", hres);
1346
1347     if(IsEqualGUID(&IID_IPropertyNotifySink, riid)) {
1348         DWORD cookie;
1349
1350         hres = IConnectionPoint_Advise(cp, (IUnknown*)&PropertyNotifySink, &cookie);
1351         ok(hres == S_OK, "Advise failed: %08lx\n", hres);
1352     }
1353
1354     IConnectionPoint_Release(cp);
1355 }
1356
1357 static void test_ConnectionPointContainer(IUnknown *unk)
1358 {
1359     IConnectionPointContainer *container;
1360     HRESULT hres;
1361
1362     hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&container);
1363     ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08lx\n", hres);
1364     if(FAILED(hres))
1365         return;
1366
1367     test_ConnectionPoint(container, &IID_IPropertyNotifySink);
1368     test_ConnectionPoint(container, &DIID_HTMLDocumentEvents);
1369     test_ConnectionPoint(container, &DIID_HTMLDocumentEvents2);
1370
1371     IConnectionPointContainer_Release(container);
1372 }
1373
1374 static void test_Load(IPersistMoniker *persist)
1375 {
1376     IMoniker *mon;
1377     IBindCtx *bind;
1378     HRESULT hres;
1379
1380     static const WCHAR wszWineHQ[] =
1381         {'h','t','t','p',':','/','/','w','w','w','.','w','i','n','e','h','q','.','o','r','g','/',0};
1382
1383     hres = CreateURLMoniker(NULL, wszWineHQ, &mon);
1384     ok(hres == S_OK, "CreateURLMoniker failed: %08lx\n", hres);
1385     if(FAILED(hres))
1386         return;
1387
1388     CreateBindCtx(0, &bind);
1389     IBindCtx_RegisterObjectParam(bind, (LPOLESTR)SZ_HTML_CLIENTSITE_OBJECTPARAM,
1390                                  (IUnknown*)&ClientSite);
1391
1392     SET_EXPECT(GetHostInfo);
1393     SET_EXPECT(GetOptionKeyPath);
1394     SET_EXPECT(GetOverrideKeyPath);
1395     SET_EXPECT(GetWindow);
1396     SET_EXPECT(QueryStatus_SETPROGRESSTEXT);
1397     SET_EXPECT(Exec_SETPROGRESSMAX);
1398     SET_EXPECT(Exec_SETPROGRESSPOS);
1399     SET_EXPECT(Invoke_AMBIENT_USERMODE);
1400     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1401     SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1402     SET_EXPECT(Invoke_AMBIENT_SILENT);
1403     SET_EXPECT(Invoke_AMBIENT_USERAGENT);
1404     SET_EXPECT(Invoke_AMBIENT_PALETTE);
1405     SET_EXPECT(OnChanged_READYSTATE);
1406     SET_EXPECT(GetContainer);
1407     SET_EXPECT(LockContainer);
1408     SET_EXPECT(Exec_ShellDocView_37);
1409     expect_LockContainer_fLock = TRUE;
1410
1411     hres = IPersistMoniker_Load(persist, FALSE, mon, bind, 0x12);
1412 #if 0
1413     ok(hres == S_OK, "Load failed: %08lx\n", hres);
1414 #endif
1415
1416     CHECK_CALLED(GetHostInfo);
1417     CHECK_CALLED(GetOptionKeyPath);
1418     CHECK_CALLED(GetOverrideKeyPath);
1419     CHECK_CALLED(GetWindow);
1420     CHECK_CALLED(QueryStatus_SETPROGRESSTEXT);
1421     CHECK_CALLED(Exec_SETPROGRESSMAX);
1422     CHECK_CALLED(Exec_SETPROGRESSPOS);
1423     CHECK_CALLED(Invoke_AMBIENT_USERMODE);
1424     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1425     CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1426     CHECK_CALLED(Invoke_AMBIENT_SILENT);
1427     CHECK_CALLED(Invoke_AMBIENT_USERAGENT);
1428     CHECK_CALLED(Invoke_AMBIENT_PALETTE);
1429     CHECK_CALLED(OnChanged_READYSTATE);
1430     CHECK_CALLED(GetContainer);
1431     CHECK_CALLED(LockContainer);
1432     CHECK_CALLED(Exec_ShellDocView_37);
1433
1434     set_clientsite = container_locked = TRUE;
1435
1436     IBindCtx_Release(bind);
1437     IMoniker_Release(mon);
1438 }
1439
1440 #ifdef DOWNLOAD_TEST
1441
1442 static void test_download(void)
1443 {
1444     MSG msg;
1445
1446     load_state = LD_LOADING;
1447
1448     SET_EXPECT(Exec_SETDOWNLOADSTATE);
1449     SET_EXPECT(GetDropTarget);
1450     SET_EXPECT(SetStatusText);
1451     SET_EXPECT(UpdateUI);
1452     SET_EXPECT(Exec_UPDATECOMMANDS);
1453     SET_EXPECT(Exec_SETTITLE);
1454     SET_EXPECT(Exec_HTTPEQUIV);
1455     SET_EXPECT(Exec_SETPROGRESSMAX);
1456     SET_EXPECT(Exec_SETPROGRESSPOS);
1457     SET_EXPECT(Exec_MSHTML_2315);
1458     SET_EXPECT(Exec_HTTPEQUIV_DONE);
1459     expect_status_text = (LPCOLESTR)0xdeadbeef; /* TODO */
1460
1461     while(!called_Exec_HTTPEQUIV_DONE && GetMessage(&msg, NULL, 0, 0)) {
1462         TranslateMessage(&msg);
1463         DispatchMessage(&msg);
1464     }
1465
1466     CHECK_CALLED(Exec_SETDOWNLOADSTATE);
1467     CHECK_CALLED(GetDropTarget);
1468     CHECK_CALLED(SetStatusText);
1469     CHECK_CALLED(UpdateUI);
1470     CHECK_CALLED(Exec_UPDATECOMMANDS);
1471     CHECK_CALLED(Exec_SETTITLE);
1472     CHECK_CALLED(Exec_HTTPEQUIV);
1473     CHECK_CALLED(Exec_SETPROGRESSMAX);
1474     CHECK_CALLED(Exec_SETPROGRESSPOS);
1475     CHECK_CALLED(Exec_MSHTML_2315);
1476     CHECK_CALLED(Exec_HTTPEQUIV_DONE);
1477
1478     load_state = LD_LOADED;
1479 }
1480
1481 #endif
1482
1483 static void test_Persist(IUnknown *unk)
1484 {
1485     IPersistMoniker *persist_mon;
1486     IPersistFile *persist_file;
1487     GUID guid;
1488     HRESULT hres;
1489
1490     hres = IUnknown_QueryInterface(unk, &IID_IPersistFile, (void**)&persist_file);
1491     ok(hres == S_OK, "QueryInterface(IID_IPersist) failed: %08lx\n", hres);
1492     if(SUCCEEDED(hres)) {
1493         hres = IPersist_GetClassID(persist_file, NULL);
1494         ok(hres == E_INVALIDARG, "GetClassID returned: %08lx, expected E_INVALIDARG\n", hres);
1495
1496         hres = IPersist_GetClassID(persist_file, &guid);
1497         ok(hres == S_OK, "GetClassID failed: %08lx\n", hres);
1498         ok(IsEqualGUID(&CLSID_HTMLDocument, &guid), "guid != CLSID_HTMLDocument\n");
1499
1500         IPersist_Release(persist_file);
1501     }
1502
1503     hres = IUnknown_QueryInterface(unk, &IID_IPersistMoniker, (void**)&persist_mon);
1504     ok(hres == S_OK, "QueryInterface(IID_IPersistMoniker) failed: %08lx\n", hres);
1505     if(SUCCEEDED(hres)) {
1506         hres = IPersistMoniker_GetClassID(persist_mon, NULL);
1507         ok(hres == E_INVALIDARG, "GetClassID returned: %08lx, expected E_INVALIDARG\n", hres);
1508
1509         hres = IPersistMoniker_GetClassID(persist_mon, &guid);
1510         ok(hres == S_OK, "GetClassID failed: %08lx\n", hres);
1511         ok(IsEqualGUID(&CLSID_HTMLDocument, &guid), "guid != CLSID_HTMLDocument\n");
1512
1513         if(load_state == LD_DOLOAD)
1514             test_Load(persist_mon);
1515
1516         IPersistMoniker_Release(persist_mon);
1517     }
1518 }
1519
1520 static const OLECMDF expect_cmds[OLECMDID_GETPRINTTEMPLATE+1] = {
1521     0,
1522     OLECMDF_SUPPORTED,                  /* OLECMDID_OPEN */
1523     OLECMDF_SUPPORTED,                  /* OLECMDID_NEW */
1524     OLECMDF_SUPPORTED,                  /* OLECMDID_SAVE */
1525     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_SAVEAS */
1526     OLECMDF_SUPPORTED,                  /* OLECMDID_SAVECOPYAS */
1527     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PRINT */
1528     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PRINTPREVIEW */
1529     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PAGESETUP */
1530     OLECMDF_SUPPORTED,                  /* OLECMDID_SPELL */
1531     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PROPERTIES */
1532     OLECMDF_SUPPORTED,                  /* OLECMDID_CUT */
1533     OLECMDF_SUPPORTED,                  /* OLECMDID_COPY */
1534     OLECMDF_SUPPORTED,                  /* OLECMDID_PASTE */
1535     OLECMDF_SUPPORTED,                  /* OLECMDID_PASTESPECIAL */
1536     OLECMDF_SUPPORTED,                  /* OLECMDID_UNDO */
1537     OLECMDF_SUPPORTED,                  /* OLECMDID_REDO */
1538     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_SELECTALL */
1539     OLECMDF_SUPPORTED,                  /* OLECMDID_CLEARSELECTION */
1540     OLECMDF_SUPPORTED,                  /* OLECMDID_ZOOM */
1541     OLECMDF_SUPPORTED,                  /* OLECMDID_GETZOOMRANGE */
1542     0,
1543     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_REFRESH */
1544     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_STOP */
1545     0,0,0,0,0,0,
1546     OLECMDF_SUPPORTED,                  /* OLECMDID_STOPDOWNLOAD */
1547     0,0,
1548     OLECMDF_SUPPORTED,                  /* OLECMDID_DELETE */
1549     0,0,
1550     OLECMDF_SUPPORTED,                  /* OLECMDID_ENABLE_INTERACTION */
1551     OLECMDF_SUPPORTED,                  /* OLECMDID_ONUNLOAD */
1552     0,0,0,0,0,
1553     OLECMDF_SUPPORTED,                  /* OLECMDID_SHOWPAGESETUP */
1554     OLECMDF_SUPPORTED,                  /* OLECMDID_SHOWPRINT */
1555     0,0,
1556     OLECMDF_SUPPORTED,                  /* OLECMDID_CLOSE */
1557     0,0,0,
1558     OLECMDF_SUPPORTED,                  /* OLECMDID_SETPRINTTEMPLATE */
1559     OLECMDF_SUPPORTED                   /* OLECMDID_GETPRINTTEMPLATE */
1560 };
1561
1562 static void test_OleCommandTarget(IUnknown *unk)
1563 {
1564     IOleCommandTarget *cmdtrg;
1565     OLECMD cmds[OLECMDID_GETPRINTTEMPLATE];
1566     int i;
1567     HRESULT hres;
1568
1569     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
1570     ok(hres == S_OK, "QueryInterface(IIDIOleM=CommandTarget failed: %08lx\n", hres);
1571     if(FAILED(hres))
1572         return;
1573
1574     for(i=0; i<OLECMDID_GETPRINTTEMPLATE; i++) {
1575         cmds[i].cmdID = i+1;
1576         cmds[i].cmdf = 0xf0f0;
1577     }
1578
1579     SET_EXPECT(QueryStatus_OPEN);
1580     SET_EXPECT(QueryStatus_NEW);
1581     hres = IOleCommandTarget_QueryStatus(cmdtrg, NULL, sizeof(cmds)/sizeof(cmds[0]), cmds, NULL);
1582     ok(hres == S_OK, "QueryStatus failed: %08lx\n", hres);
1583     CHECK_CALLED(QueryStatus_OPEN);
1584     CHECK_CALLED(QueryStatus_NEW);
1585
1586     for(i=0; i<OLECMDID_GETPRINTTEMPLATE; i++) {
1587         ok(cmds[i].cmdID == i+1, "cmds[%d].cmdID canged to %lx\n", i, cmds[i].cmdID);
1588         ok(cmds[i].cmdf == expect_cmds[i+1], "cmds[%d].cmdf=%lx, expected %x\n",
1589                 i+1, cmds[i].cmdf, expect_cmds[i+1]);
1590     }
1591
1592     IOleCommandTarget_Release(cmdtrg);
1593 }
1594
1595 static void test_OleCommandTarget_fail(IUnknown *unk)
1596 {
1597     IOleCommandTarget *cmdtrg;
1598     int i;
1599     HRESULT hres;
1600
1601     OLECMD cmd[2] = {
1602         {OLECMDID_OPEN, 0xf0f0},
1603         {OLECMDID_GETPRINTTEMPLATE+1, 0xf0f0}
1604     };
1605
1606     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
1607     ok(hres == S_OK, "QueryInterface(IIDIOleM=CommandTarget failed: %08lx\n", hres);
1608     if(FAILED(hres))
1609         return;
1610
1611     hres = IOleCommandTarget_QueryStatus(cmdtrg, NULL, 0, NULL, NULL);
1612     ok(hres == S_OK, "QueryStatus failed: %08lx\n", hres);
1613
1614     SET_EXPECT(QueryStatus_OPEN);
1615     hres = IOleCommandTarget_QueryStatus(cmdtrg, NULL, 2, cmd, NULL);
1616     CHECK_CALLED(QueryStatus_OPEN);
1617
1618     ok(hres == OLECMDERR_E_NOTSUPPORTED,
1619             "QueryStatus failed: %08lx, expected OLECMDERR_E_NOTSUPPORTED\n", hres);
1620     ok(cmd[1].cmdID == OLECMDID_GETPRINTTEMPLATE+1,
1621             "cmd[0].cmdID=%ld, expected OLECMDID_GETPRINTTEMPLATE+1\n", cmd[0].cmdID);
1622     ok(cmd[1].cmdf == 0, "cmd[0].cmdf=%lx, expected 0\n", cmd[0].cmdf);
1623     ok(cmd[0].cmdf == OLECMDF_SUPPORTED,
1624             "cmd[1].cmdf=%lx, expected OLECMDF_SUPPORTED\n", cmd[1].cmdf);
1625
1626     hres = IOleCommandTarget_QueryStatus(cmdtrg, &IID_IHTMLDocument2, 2, cmd, NULL);
1627     ok(hres == OLECMDERR_E_UNKNOWNGROUP,
1628             "QueryStatus failed: %08lx, expected OLECMDERR_E_UNKNOWNGROUP\n", hres);
1629
1630     for(i=0; i<OLECMDID_GETPRINTTEMPLATE; i++) {
1631         if(!expect_cmds[i]) {
1632             hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_UPDATECOMMANDS,
1633                     OLECMDEXECOPT_DODEFAULT, NULL, NULL);
1634             ok(hres == OLECMDERR_E_NOTSUPPORTED,
1635                     "Exec failed: %08lx, expected OLECMDERR_E_NOTSUPPORTED\n", hres);
1636         }
1637     }
1638
1639     hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_GETPRINTTEMPLATE+1,
1640             OLECMDEXECOPT_DODEFAULT, NULL, NULL);
1641     ok(hres == OLECMDERR_E_NOTSUPPORTED,
1642             "Exec failed: %08lx, expected OLECMDERR_E_NOTSUPPORTED\n", hres);
1643
1644     IOleCommandTarget_Release(cmdtrg);
1645 }
1646
1647 static void test_exec_onunload(IUnknown *unk)
1648 {
1649     IOleCommandTarget *cmdtrg;
1650     VARIANT var;
1651     HRESULT hres;
1652
1653     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
1654     ok(hres == S_OK, "QueryInterface(IID_IOleCommandTarget) failed: %08lx\n", hres);
1655     if(FAILED(hres))
1656         return;
1657
1658     memset(&var, 0x0a, sizeof(var));
1659     hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_ONUNLOAD,
1660             OLECMDEXECOPT_DODEFAULT, NULL, &var);
1661     ok(hres == S_OK, "Exec(..., OLECMDID_ONUNLOAD, ...) failed: %08lx\n", hres);
1662     ok(V_VT(&var) == VT_BOOL, "V_VT(var)=%d, expected VT_BOOL\n", V_VT(&var));
1663     ok(V_BOOL(&var) == VARIANT_TRUE, "V_BOOL(var)=%x, expected VARIANT_TRUE\n", V_BOOL(&var));
1664
1665     hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_ONUNLOAD,
1666             OLECMDEXECOPT_DODEFAULT, NULL, NULL);
1667     ok(hres == S_OK, "Exec(..., OLECMDID_ONUNLOAD, ...) failed: %08lx\n", hres);
1668
1669     IOleCommandTarget_Release(cmdtrg);
1670 }
1671
1672 static void test_exec_editmode(IUnknown *unk)
1673 {
1674     IOleCommandTarget *cmdtrg;
1675     HRESULT hres;
1676
1677     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
1678     ok(hres == S_OK, "QueryInterface(IID_IOleCommandTarget) failed: %08lx\n", hres);
1679     if(FAILED(hres))
1680         return;
1681
1682     SET_EXPECT(SetStatusText);
1683     SET_EXPECT(Exec_ShellDocView_37);
1684     SET_EXPECT(GetHostInfo);
1685     SET_EXPECT(Invoke_AMBIENT_SILENT);
1686     SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1687     SET_EXPECT(OnChanged_READYSTATE);
1688     expect_status_text = NULL;
1689
1690     hres = IOleCommandTarget_Exec(cmdtrg, &CGID_MSHTML, IDM_EDITMODE,
1691             OLECMDEXECOPT_DODEFAULT, NULL, NULL);
1692     ok(hres == S_OK, "Exec failed: %08lx\n", hres);
1693
1694     CHECK_CALLED(SetStatusText);
1695     CHECK_CALLED(Exec_ShellDocView_37);
1696     CHECK_CALLED(GetHostInfo);
1697     CHECK_CALLED(Invoke_AMBIENT_SILENT);
1698     CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1699     CHECK_CALLED(OnChanged_READYSTATE);
1700
1701     IOleCommandTarget_Release(cmdtrg);
1702 }
1703
1704 static HWND create_container_window(void)
1705 {
1706     static const WCHAR wszHTMLDocumentTest[] =
1707         {'H','T','M','L','D','o','c','u','m','e','n','t','T','e','s','t',0};
1708     static WNDCLASSEXW wndclass = {
1709         sizeof(WNDCLASSEXW),
1710         0,
1711         wnd_proc,
1712         0, 0, NULL, NULL, NULL, NULL, NULL,
1713         wszHTMLDocumentTest,
1714         NULL
1715     };
1716
1717     RegisterClassExW(&wndclass);
1718     return CreateWindowW(wszHTMLDocumentTest, wszHTMLDocumentTest,
1719             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
1720             CW_USEDEFAULT, NULL, NULL, NULL, NULL);
1721 }
1722
1723 static HRESULT test_DoVerb(IOleObject *oleobj)
1724 {
1725     RECT rect = {0,0,500,500};
1726     HRESULT hres;
1727
1728     if(!container_locked) {
1729         SET_EXPECT(GetContainer);
1730         SET_EXPECT(LockContainer);
1731     }
1732     SET_EXPECT(ActivateMe);
1733     expect_LockContainer_fLock = TRUE;
1734
1735     hres = IOleObject_DoVerb(oleobj, OLEIVERB_SHOW, NULL, &ClientSite, -1, container_hwnd, &rect);
1736     if(FAILED(hres))
1737         return hres;
1738     ok(hres == S_OK, "DoVerb failed: %08lx\n", hres);
1739
1740     if(!container_locked) {
1741         CHECK_CALLED(GetContainer);
1742         CHECK_CALLED(LockContainer);
1743         container_locked = TRUE;
1744     }
1745     CHECK_CALLED(ActivateMe);
1746
1747     return hres;
1748 }
1749
1750 #define CLIENTSITE_EXPECTPATH 0x00000001
1751 #define CLIENTSITE_SETNULL    0x00000002
1752 #define CLIENTSITE_DONTSET    0x00000004
1753
1754 static void test_ClientSite(IOleObject *oleobj, DWORD flags)
1755 {
1756     IOleClientSite *clientsite;
1757     HRESULT hres;
1758
1759     if(flags & CLIENTSITE_SETNULL) {
1760         hres = IOleObject_GetClientSite(oleobj, &clientsite);
1761         ok(clientsite == &ClientSite, "clientsite=%p, expected %p\n", clientsite, &ClientSite);
1762
1763         hres = IOleObject_SetClientSite(oleobj, NULL);
1764         ok(hres == S_OK, "SetClientSite failed: %08lx\n", hres);
1765
1766         set_clientsite = FALSE;
1767     }
1768
1769     if(flags & CLIENTSITE_DONTSET)
1770         return;
1771
1772     hres = IOleObject_GetClientSite(oleobj, &clientsite);
1773     ok(hres == S_OK, "GetClientSite failed: %08lx\n", hres);
1774     ok(clientsite == (set_clientsite ? &ClientSite : NULL), "GetClientSite() = %p, expected %p\n",
1775             clientsite, set_clientsite ? &ClientSite : NULL);
1776
1777     if(!set_clientsite) {
1778         SET_EXPECT(GetHostInfo);
1779         if(flags & CLIENTSITE_EXPECTPATH) {
1780             SET_EXPECT(GetOptionKeyPath);
1781             SET_EXPECT(GetOverrideKeyPath);
1782         }
1783         SET_EXPECT(GetWindow);
1784         SET_EXPECT(QueryStatus_SETPROGRESSTEXT);
1785         SET_EXPECT(Exec_SETPROGRESSMAX);
1786         SET_EXPECT(Exec_SETPROGRESSPOS);
1787         SET_EXPECT(Invoke_AMBIENT_USERMODE);
1788         SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1789         SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1790         SET_EXPECT(Invoke_AMBIENT_SILENT);
1791         SET_EXPECT(Invoke_AMBIENT_USERAGENT);
1792         SET_EXPECT(Invoke_AMBIENT_PALETTE);
1793
1794         hres = IOleObject_SetClientSite(oleobj, &ClientSite);
1795         ok(hres == S_OK, "SetClientSite failed: %08lx\n", hres);
1796
1797         CHECK_CALLED(GetHostInfo);
1798         if(flags & CLIENTSITE_EXPECTPATH) {
1799             CHECK_CALLED(GetOptionKeyPath);
1800             CHECK_CALLED(GetOverrideKeyPath);
1801         }
1802         CHECK_CALLED(GetWindow);
1803         CHECK_CALLED(QueryStatus_SETPROGRESSTEXT);
1804         CHECK_CALLED(Exec_SETPROGRESSMAX);
1805         CHECK_CALLED(Exec_SETPROGRESSPOS);
1806         CHECK_CALLED(Invoke_AMBIENT_USERMODE);
1807         CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1808         CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1809         CHECK_CALLED(Invoke_AMBIENT_SILENT);
1810         CHECK_CALLED(Invoke_AMBIENT_USERAGENT);
1811         CHECK_CALLED(Invoke_AMBIENT_PALETTE);
1812
1813         set_clientsite = TRUE;
1814     }
1815
1816     hres = IOleObject_SetClientSite(oleobj, &ClientSite);
1817     ok(hres == S_OK, "SetClientSite failed: %08lx\n", hres);
1818
1819     hres = IOleObject_GetClientSite(oleobj, &clientsite);
1820     ok(hres == S_OK, "GetClientSite failed: %08lx\n", hres);
1821     ok(clientsite == &ClientSite, "GetClientSite() = %p, expected %p\n", clientsite, &ClientSite);
1822 }
1823
1824 static void test_OnAmbientPropertyChange(IUnknown *unk)
1825 {
1826     IOleControl *control = NULL;
1827     HRESULT hres;
1828
1829     hres = IUnknown_QueryInterface(unk, &IID_IOleControl, (void**)&control);
1830     ok(hres == S_OK, "QueryInterface(IID_IOleControl failed: %08lx\n", hres);
1831     if(FAILED(hres))
1832         return;
1833
1834     SET_EXPECT(Invoke_AMBIENT_USERMODE);
1835     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_USERMODE);
1836     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1837     CHECK_CALLED(Invoke_AMBIENT_USERMODE);
1838
1839     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1840     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_DLCONTROL);
1841     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1842     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1843
1844     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1845     SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1846     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_OFFLINEIFNOTCONNECTED);
1847     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1848     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1849     CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1850
1851     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1852     SET_EXPECT(Invoke_AMBIENT_SILENT);
1853     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_SILENT);
1854     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1855     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1856     CHECK_CALLED(Invoke_AMBIENT_SILENT);
1857
1858     SET_EXPECT(Invoke_AMBIENT_USERAGENT);
1859     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_USERAGENT);
1860     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1861     CHECK_CALLED(Invoke_AMBIENT_USERAGENT);
1862
1863     SET_EXPECT(Invoke_AMBIENT_PALETTE);
1864     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_PALETTE);
1865     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1866     CHECK_CALLED(Invoke_AMBIENT_PALETTE);
1867
1868     IOleControl_Release(control);
1869 }
1870
1871
1872
1873 static void test_OnAmbientPropertyChange2(IUnknown *unk)
1874 {
1875     IOleControl *control = NULL;
1876     HRESULT hres;
1877
1878     hres = IUnknown_QueryInterface(unk, &IID_IOleControl, (void**)&control);
1879     ok(hres == S_OK, "QueryInterface(IID_IOleControl failed: %08lx\n", hres);
1880     if(FAILED(hres))
1881         return;
1882
1883     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_PALETTE);
1884     ok(hres == S_OK, "OnAmbientPropertyChange failed: %08lx\n", hres);
1885
1886     IOleControl_Release(control);
1887 }
1888
1889 static void test_Close(IUnknown *unk, BOOL set_client)
1890 {
1891     IOleObject *oleobj = NULL;
1892     HRESULT hres;
1893
1894     hres = IUnknown_QueryInterface(unk, &IID_IOleObject, (void**)&oleobj);
1895     ok(hres == S_OK, "QueryInterface(IID_IOleObject) failed: %08lx\n", hres);
1896     if(FAILED(hres))
1897         return;
1898
1899     SET_EXPECT(GetContainer);
1900     SET_EXPECT(LockContainer);
1901     expect_LockContainer_fLock = FALSE;
1902     hres = IOleObject_Close(oleobj, OLECLOSE_NOSAVE);
1903     ok(hres == S_OK, "Close failed: %08lx\n", hres);
1904     CHECK_CALLED(GetContainer);
1905     CHECK_CALLED(LockContainer);
1906     container_locked = FALSE;
1907
1908     if(set_client)
1909         test_ClientSite(oleobj, CLIENTSITE_SETNULL|CLIENTSITE_DONTSET);
1910
1911     IOleObject_Release(oleobj);
1912 }
1913
1914 static void test_OnFrameWindowActivate(IUnknown *unk)
1915 {
1916     IOleInPlaceActiveObject *inplaceact;
1917     HRESULT hres;
1918
1919     hres = IUnknown_QueryInterface(unk, &IID_IOleInPlaceActiveObject, (void**)&inplaceact);
1920     ok(hres == S_OK, "QueryInterface(IID_IOleInPlaceActiveObject) failed: %08lx\n", hres);
1921     if(FAILED(hres))
1922         return;
1923
1924     if(set_clientsite) {
1925         expect_OnFrameWindowActivate_fActivate = TRUE;
1926         SET_EXPECT(OnFrameWindowActivate);
1927         hres = IOleInPlaceActiveObject_OnFrameWindowActivate(inplaceact, TRUE);
1928         ok(hres == S_OK, "OnFrameWindowActivate failed: %08lx\n", hres);
1929         CHECK_CALLED(OnFrameWindowActivate);
1930
1931         SET_EXPECT(OnFrameWindowActivate);
1932         hres = IOleInPlaceActiveObject_OnFrameWindowActivate(inplaceact, TRUE);
1933         ok(hres == S_OK, "OnFrameWindowActivate failed: %08lx\n", hres);
1934         CHECK_CALLED(OnFrameWindowActivate);
1935
1936         expect_OnFrameWindowActivate_fActivate = FALSE;
1937         SET_EXPECT(OnFrameWindowActivate);
1938         hres = IOleInPlaceActiveObject_OnFrameWindowActivate(inplaceact, FALSE);
1939         ok(hres == S_OK, "OnFrameWindowActivate failed: %08lx\n", hres);
1940         CHECK_CALLED(OnFrameWindowActivate);
1941
1942         expect_OnFrameWindowActivate_fActivate = TRUE;
1943         SET_EXPECT(OnFrameWindowActivate);
1944         hres = IOleInPlaceActiveObject_OnFrameWindowActivate(inplaceact, TRUE);
1945         ok(hres == S_OK, "OnFrameWindowActivate failed: %08lx\n", hres);
1946         CHECK_CALLED(OnFrameWindowActivate);
1947     }else {
1948         hres = IOleInPlaceActiveObject_OnFrameWindowActivate(inplaceact, FALSE);
1949         ok(hres == S_OK, "OnFrameWindowActivate failed: %08lx\n", hres);
1950
1951         hres = IOleInPlaceActiveObject_OnFrameWindowActivate(inplaceact, TRUE);
1952         ok(hres == S_OK, "OnFrameWindowActivate failed: %08lx\n", hres);
1953     }
1954
1955     IOleInPlaceActiveObject_Release(inplaceact);
1956 }
1957
1958 static void test_InPlaceDeactivate(IUnknown *unk, BOOL expect_call)
1959 {
1960     IOleInPlaceObjectWindowless *windowlessobj = NULL;
1961     HRESULT hres;
1962
1963     hres = IUnknown_QueryInterface(unk, &IID_IOleInPlaceObjectWindowless,
1964             (void**)&windowlessobj);
1965     ok(hres == S_OK, "QueryInterface(IID_IOleInPlaceObjectWindowless) failed: %08lx\n", hres);
1966     if(FAILED(hres))
1967         return;
1968
1969     if(expect_call) SET_EXPECT(OnInPlaceDeactivate);
1970     hres = IOleInPlaceObjectWindowless_InPlaceDeactivate(windowlessobj);
1971     ok(hres == S_OK, "InPlaceDeactivate failed: %08lx\n", hres);
1972     if(expect_call) CHECK_CALLED(OnInPlaceDeactivate);
1973
1974     IOleInPlaceObjectWindowless_Release(windowlessobj);
1975 }
1976
1977 static HRESULT test_Activate(IUnknown *unk, DWORD flags)
1978 {
1979     IOleObject *oleobj = NULL;
1980     GUID guid;
1981     HRESULT hres;
1982
1983     last_hwnd = hwnd;
1984
1985     if(view)
1986         IOleDocumentView_Release(view);
1987     view = NULL;
1988
1989     hres = IUnknown_QueryInterface(unk, &IID_IOleObject, (void**)&oleobj);
1990     ok(hres == S_OK, "QueryInterface(IID_IOleObject) failed: %08lx\n", hres);
1991     if(FAILED(hres))
1992         return hres;
1993
1994     hres = IOleObject_GetUserClassID(oleobj, NULL);
1995     ok(hres == E_INVALIDARG, "GetUserClassID returned: %08lx, expected E_INVALIDARG\n", hres);
1996
1997     hres = IOleObject_GetUserClassID(oleobj, &guid);
1998     ok(hres == S_OK, "GetUserClassID failed: %08lx\n", hres);
1999     ok(IsEqualGUID(&guid, &CLSID_HTMLDocument), "guid != CLSID_HTMLDocument\n");
2000
2001     test_OnFrameWindowActivate(unk);
2002
2003     test_ClientSite(oleobj, flags);
2004     test_InPlaceDeactivate(unk, FALSE);
2005
2006     hres = test_DoVerb(oleobj);
2007
2008     IOleObject_Release(oleobj);
2009
2010     test_OnFrameWindowActivate(unk);
2011
2012     return hres;
2013 }
2014
2015 static void test_Window(IUnknown *unk, BOOL expect_success)
2016 {
2017     IOleInPlaceActiveObject *activeobject = NULL;
2018     HWND tmp_hwnd;
2019     HRESULT hres;
2020
2021     hres = IOleDocumentView_QueryInterface(view, &IID_IOleInPlaceActiveObject, (void**)&activeobject);
2022     ok(hres == S_OK, "Could not get IOleInPlaceActiveObject interface: %08lx\n", hres);
2023     if(FAILED(hres))
2024         return;
2025
2026     hres = IOleInPlaceActiveObject_GetWindow(activeobject, &tmp_hwnd);
2027
2028     if(expect_success) {
2029         ok(hres == S_OK, "GetWindow failed: %08lx\n", hres);
2030         ok(tmp_hwnd == hwnd, "tmp_hwnd=%p, expected %p\n", tmp_hwnd, hwnd);
2031     }else {
2032         ok(hres == E_FAIL, "GetWindow returned %08lx, expected E_FAIL\n", hres);
2033         ok(IsWindow(hwnd), "hwnd is destroyed\n");
2034     }
2035
2036     IOleInPlaceActiveObject_Release(activeobject);
2037 }
2038
2039 static void test_CloseView(void)
2040 {
2041     IOleInPlaceSite *inplacesite = (IOleInPlaceSite*)0xff00ff00;
2042     HRESULT hres;
2043
2044     if(!view)
2045         return;
2046
2047     hres = IOleDocumentView_Show(view, FALSE);
2048     ok(hres == S_OK, "Show failed: %08lx\n", hres);
2049
2050     hres = IOleDocumentView_CloseView(view, 0);
2051     ok(hres == S_OK, "CloseView failed: %08lx\n", hres);
2052
2053     hres = IOleDocumentView_SetInPlaceSite(view, NULL);
2054     ok(hres == S_OK, "SetInPlaceSite failed: %08lx\n", hres);
2055
2056     hres = IOleDocumentView_GetInPlaceSite(view, &inplacesite);
2057     ok(hres == S_OK, "SetInPlaceSite failed: %08lx\n", hres);
2058     ok(inplacesite == NULL, "inplacesite=%p, expected NULL\n", inplacesite);
2059 }
2060
2061 static void test_UIDeactivate(void)
2062 {
2063     HRESULT hres;
2064
2065     if(call_UIActivate) {
2066         SET_EXPECT(SetActiveObject);
2067         SET_EXPECT(HideUI);
2068         SET_EXPECT(OnUIDeactivate);
2069     }
2070
2071     expect_SetActiveObject_active = FALSE;
2072     hres = IOleDocumentView_UIActivate(view, FALSE);
2073     ok(hres == S_OK, "UIActivate failed: %08lx\n", hres);
2074
2075     if(call_UIActivate) {
2076         CHECK_CALLED(SetActiveObject);
2077         CHECK_CALLED(HideUI);
2078         CHECK_CALLED(OnUIDeactivate);
2079     }
2080 }
2081
2082 static void test_Hide(void)
2083 {
2084     HRESULT hres;
2085
2086     if(!view)
2087         return;
2088
2089     hres = IOleDocumentView_Show(view, FALSE);
2090     ok(hres == S_OK, "Show failed: %08lx\n", hres);
2091 }
2092
2093 static HRESULT create_document(IUnknown **unk)
2094 {
2095     HRESULT hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
2096             &IID_IUnknown, (void**)unk);
2097     ok(hres == S_OK, "CoCreateInstance failed: %08lx\n", hres);
2098     return hres;
2099 }
2100
2101 static void test_Navigate(IUnknown *unk)
2102 {
2103     IHlinkTarget *hlink;
2104     HRESULT hres;
2105
2106     hres = IUnknown_QueryInterface(unk, &IID_IHlinkTarget, (void**)&hlink);
2107     ok(hres == S_OK, "QueryInterface(IID_IHlinkTarget) failed: %08lx\n", hres);
2108
2109     SET_EXPECT(ActivateMe);
2110     hres = IHlinkTarget_Navigate(hlink, 0, NULL);
2111     ok(hres == S_OK, "Navigate failed: %08lx\n", hres);
2112     CHECK_CALLED(ActivateMe);
2113
2114     IHlinkTarget_Release(hlink);
2115 }
2116
2117 static void init_test(enum load_state_t ls) {
2118     hwnd = last_hwnd = NULL;
2119     set_clientsite = FALSE;
2120     call_UIActivate = FALSE;
2121     load_state = ls;
2122 }
2123
2124 static void test_HTMLDocument(enum load_state_t ls)
2125 {
2126     IUnknown *unk;
2127     HRESULT hres;
2128     ULONG ref;
2129
2130     init_test(ls);
2131
2132     hres = create_document(&unk);
2133     if(FAILED(hres))
2134         return;
2135
2136     test_ConnectionPointContainer(unk);
2137     test_Persist(unk);
2138     if(load_state == LD_NO)
2139         test_OnAmbientPropertyChange2(unk);
2140
2141     hres = test_Activate(unk, CLIENTSITE_EXPECTPATH);
2142     if(FAILED(hres)) {
2143         IUnknown_Release(unk);
2144         return;
2145     }
2146
2147 #ifdef DOWNLOAD_TEST
2148     if(load_state == LD_DOLOAD)
2149         test_download();
2150 #endif
2151
2152     test_OleCommandTarget_fail(unk);
2153     test_OleCommandTarget(unk);
2154     test_OnAmbientPropertyChange(unk);
2155     test_Window(unk, TRUE);
2156     test_UIDeactivate();
2157     test_OleCommandTarget(unk);
2158     test_Window(unk, TRUE);
2159     test_InPlaceDeactivate(unk, TRUE);
2160
2161     /* Calling test_OleCommandTarget here couses Segmentation Fault with native
2162      * MSHTML. It doesn't with Wine. */
2163
2164     test_Window(unk, FALSE);
2165     test_Hide();
2166     test_InPlaceDeactivate(unk, FALSE);
2167     test_CloseView();
2168     test_Close(unk, FALSE);
2169
2170     /* Activate HTMLDocument again */
2171     test_Activate(unk, CLIENTSITE_SETNULL);
2172     test_Window(unk, TRUE);
2173     test_OleCommandTarget(unk);
2174     test_UIDeactivate();
2175     test_InPlaceDeactivate(unk, TRUE);
2176     test_Close(unk, FALSE);
2177
2178     /* Activate HTMLDocument again, this time without UIActivate */
2179     call_UIActivate = FALSE;
2180     test_Activate(unk, CLIENTSITE_SETNULL);
2181     test_Window(unk, TRUE);
2182     test_UIDeactivate();
2183     test_InPlaceDeactivate(unk, TRUE);
2184     test_CloseView();
2185     test_CloseView();
2186     test_Close(unk, TRUE);
2187     test_OnAmbientPropertyChange2(unk);
2188
2189     if(view)
2190         IOleDocumentView_Release(view);
2191     view = NULL;
2192
2193     ok(IsWindow(hwnd), "hwnd is destroyed\n");
2194
2195     ref = IUnknown_Release(unk);
2196     ok(ref == 0, "ref=%ld, expected 0\n", ref);
2197
2198     ok(!IsWindow(hwnd), "hwnd is not destroyed\n");
2199
2200 }
2201
2202 static void test_HTMLDocument_hlink(void)
2203 {
2204     IUnknown *unk;
2205     HRESULT hres;
2206     ULONG ref;
2207
2208     init_test(LD_DOLOAD);
2209
2210     hres = create_document(&unk);
2211     if(FAILED(hres))
2212         return;
2213
2214     test_ConnectionPointContainer(unk);
2215     test_Persist(unk);
2216     test_Navigate(unk);
2217
2218 #ifdef DOWNLOAD_TEST
2219     test_download();
2220 #endif
2221
2222     test_exec_onunload(unk);
2223     test_Window(unk, TRUE);
2224     test_InPlaceDeactivate(unk, TRUE);
2225     test_Close(unk, FALSE);
2226
2227     if(view)
2228         IOleDocumentView_Release(view);
2229     view = NULL;
2230
2231     ref = IUnknown_Release(unk);
2232     ok(ref == 0, "ref=%ld, expected 0\n", ref);
2233 }
2234
2235 static void test_editing_mode(void)
2236 {
2237     IUnknown *unk;
2238     IOleObject *oleobj;
2239     HRESULT hres;
2240     ULONG ref;
2241
2242     init_test(LD_DOLOAD);
2243
2244     hres = create_document(&unk);
2245     if(FAILED(hres))
2246         return;
2247
2248     hres = IUnknown_QueryInterface(unk, &IID_IOleObject, (void**)&oleobj);
2249     ok(hres == S_OK, "Could not get IOleObject: %08lx\n", hres);
2250
2251     test_ConnectionPointContainer(unk);
2252     test_ClientSite(oleobj, CLIENTSITE_EXPECTPATH);
2253     test_DoVerb(oleobj);
2254
2255     IOleObject_Release(oleobj);
2256
2257     test_exec_editmode(unk);
2258
2259     test_UIDeactivate();
2260     test_InPlaceDeactivate(unk, TRUE);
2261     test_Close(unk, FALSE);
2262
2263     if(view) {
2264         IOleDocumentView_Release(view);
2265         view = NULL;
2266     }
2267
2268     ref = IUnknown_Release(unk);
2269     ok(ref == 0, "ref=%ld, expected 0\n", ref);
2270 }
2271
2272 static void gecko_installer_workaround(BOOL disable)
2273 {
2274     HKEY hkey;
2275     DWORD res;
2276
2277     static BOOL has_url = FALSE;
2278     static char url[2048];
2279
2280     if(!disable && !has_url)
2281         return;
2282
2283     res = RegOpenKey(HKEY_CURRENT_USER, "Software\\Wine\\MSHTML", &hkey);
2284     if(res != ERROR_SUCCESS)
2285         return;
2286
2287     if(disable) {
2288         DWORD type, size = sizeof(url);
2289
2290         res = RegQueryValueEx(hkey, "GeckoUrl", NULL, &type, (PVOID)url, &size);
2291         if(res == ERROR_SUCCESS && type == REG_SZ)
2292             has_url = TRUE;
2293
2294         RegDeleteValue(hkey, "GeckoUrl");
2295     }else {
2296         RegSetValueEx(hkey, "GeckoUrl", 0, REG_SZ, (PVOID)url, lstrlenA(url)+1);
2297     }
2298
2299     RegCloseKey(hkey);
2300 }
2301
2302 START_TEST(htmldoc)
2303 {
2304     gecko_installer_workaround(TRUE);
2305
2306     CoInitialize(NULL);
2307     container_hwnd = create_container_window();
2308
2309     test_HTMLDocument(LD_NO);
2310     test_HTMLDocument(LD_DOLOAD);
2311     test_HTMLDocument_hlink();
2312     test_editing_mode();
2313
2314     DestroyWindow(container_hwnd);
2315     CoUninitialize();
2316
2317     gecko_installer_workaround(FALSE);
2318 }