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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 "hlink.h"
  32 #include "idispids.h"
  33 #include "shlguid.h"
  34
  35 #include "initguid.h"
  36 DEFINE_SHLGUID(CGID_Undocumented, 0x000214D4L, 0, 0);
  37 DEFINE_GUID(CGID_MSHTML, 0xDE4BA900,0x59CA,0x11CF,0x95,0x92, 0x44,0x45,0x53,0x54,0x00,0x00);
  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     ok(expect_ ##func, "unexpected call\n"); \
  47     expect_ ## func = FALSE; \
  48     called_ ## func = TRUE
  49
  50 #define CHECK_EXPECT2(func) \
  51     ok(expect_ ##func, "unexpected call\n"); \
  52     called_ ## func = TRUE
  53
  54 #define CHECK_CALLED(func) \
  55     ok(called_ ## func, "expected " #func "\n"); \
  56     expect_ ## func = called_ ## func = FALSE
  57
  58 static IOleDocumentView *view = NULL;
  59 static HWND container_hwnd = NULL, hwnd = NULL, last_hwnd = NULL;
  60
  61 DEFINE_EXPECT(LockContainer);
  62 DEFINE_EXPECT(SetActiveObject);
  63 DEFINE_EXPECT(GetWindow);
  64 DEFINE_EXPECT(CanInPlaceActivate);
  65 DEFINE_EXPECT(OnInPlaceActivate);
  66 DEFINE_EXPECT(OnUIActivate);
  67 DEFINE_EXPECT(GetWindowContext);
  68 DEFINE_EXPECT(OnUIDeactivate);
  69 DEFINE_EXPECT(OnInPlaceDeactivate);
  70 DEFINE_EXPECT(GetContainer);
  71 DEFINE_EXPECT(ShowUI);
  72 DEFINE_EXPECT(ActivateMe);
  73 DEFINE_EXPECT(GetHostInfo);
  74 DEFINE_EXPECT(HideUI);
  75 DEFINE_EXPECT(GetOptionKeyPath);
  76 DEFINE_EXPECT(GetOverrideKeyPath);
  77 DEFINE_EXPECT(SetStatusText);
  78 DEFINE_EXPECT(QueryStatus_SETPROGRESSTEXT);
  79 DEFINE_EXPECT(QueryStatus_OPEN);
  80 DEFINE_EXPECT(QueryStatus_NEW);
  81 DEFINE_EXPECT(Exec_SETPROGRESSMAX);
  82 DEFINE_EXPECT(Exec_SETPROGRESSPOS);
  83 DEFINE_EXPECT(Exec_HTTPEQUIV_DONE);
  84 DEFINE_EXPECT(Exec_SETDOWNLOADSTATE);
  85 DEFINE_EXPECT(Exec_ShellDocView_37);
  86 DEFINE_EXPECT(Exec_UPDATECOMMANDS);
  87 DEFINE_EXPECT(Exec_SETTITLE);
  88 DEFINE_EXPECT(Exec_HTTPEQUIV);
  89 DEFINE_EXPECT(Exec_MSHTML_2315);
  90 DEFINE_EXPECT(Invoke_AMBIENT_USERMODE);
  91 DEFINE_EXPECT(Invoke_AMBIENT_DLCONTROL);
  92 DEFINE_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
  93 DEFINE_EXPECT(Invoke_AMBIENT_SILENT);
  94 DEFINE_EXPECT(Invoke_AMBIENT_USERAGENT);
  95 DEFINE_EXPECT(Invoke_AMBIENT_PALETTE);
  96 DEFINE_EXPECT(GetDropTarget);
  97 DEFINE_EXPECT(UpdateUI);
  98
  99 static BOOL expect_LockContainer_fLock;
 100 static BOOL expect_SetActiveObject_active;
 101 static BOOL set_clientsite = FALSE, container_locked = FALSE;
 102 static enum {
 103     LD_NO = 0,
 104     LD_DOLOAD,
 105     LD_LOADING,
 106     LD_LOADED
 107 } load_state;
 108
 109 static LPCOLESTR expect_status_text = NULL;
 110
 111 static HRESULT QueryInterface(REFIID riid, void **ppv);
 112
 113 static HRESULT WINAPI OleContainer_QueryInterface(IOleContainer *iface, REFIID riid, void **ppv)
 114 {
 115     return QueryInterface(riid, ppv);
 116 }
 117
 118 static ULONG WINAPI OleContainer_AddRef(IOleContainer *iface)
 119 {
 120     return 2;
 121 }
 122
 123 static ULONG WINAPI OleContainer_Release(IOleContainer *iface)
 124 {
 125     return 1;
 126 }
 127
 128 static HRESULT WINAPI OleContainer_ParseDisplayName(IOleContainer *iface, IBindCtx *pbc,
 129         LPOLESTR pszDiaplayName, ULONG *pchEaten, IMoniker **ppmkOut)
 130 {
 131     ok(0, "unexpected call\n");
 132     return E_NOTIMPL;
 133 }
 134
 135 static HRESULT WINAPI OleContainer_EnumObjects(IOleContainer *iface, DWORD grfFlags,
 136         IEnumUnknown **ppenum)
 137 {
 138     ok(0, "unexpected call\n");
 139     return E_NOTIMPL;
 140 }
 141
 142 static HRESULT WINAPI OleContainer_LockContainer(IOleContainer *iface, BOOL fLock)
 143 {
 144     CHECK_EXPECT(LockContainer);
 145     ok(expect_LockContainer_fLock == fLock, "fLock=%x, expected %x\n", fLock, expect_LockContainer_fLock);
 146     return S_OK;
 147 }
 148
 149 static const IOleContainerVtbl OleContainerVtbl = {
 150     OleContainer_QueryInterface,
 151     OleContainer_AddRef,
 152     OleContainer_Release,
 153     OleContainer_ParseDisplayName,
 154     OleContainer_EnumObjects,
 155     OleContainer_LockContainer
 156 };
 157
 158 static IOleContainer OleContainer = { &OleContainerVtbl };
 159
 160 static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
 161 {
 162     return QueryInterface(riid, ppv);
 163 }
 164
 165 static ULONG WINAPI InPlaceFrame_AddRef(IOleInPlaceFrame *iface)
 166 {
 167     return 2;
 168 }
 169
 170 static ULONG WINAPI InPlaceFrame_Release(IOleInPlaceFrame *iface)
 171 {
 172     return 1;
 173 }
 174
 175 static HRESULT WINAPI InPlaceFrame_GetWindow(IOleInPlaceFrame *iface, HWND *phwnd)
 176 {
 177     ok(0, "unexpected call\n");
 178     return E_NOTIMPL;
 179 }
 180
 181 static HRESULT WINAPI InPlaceFrame_ContextSensitiveHelp(IOleInPlaceFrame *iface, BOOL fEnterMode)
 182 {
 183     ok(0, "unexpected call\n");
 184     return E_NOTIMPL;
 185 }
 186
 187 static HRESULT WINAPI InPlaceFrame_GetBorder(IOleInPlaceFrame *iface, LPRECT lprectBorder)
 188 {
 189     ok(0, "unexpected call\n");
 190     return E_NOTIMPL;
 191 }
 192
 193 static HRESULT WINAPI InPlaceFrame_RequestBorderSpace(IOleInPlaceFrame *iface,
 194         LPCBORDERWIDTHS pborderwidths)
 195 {
 196     ok(0, "unexpected call\n");
 197     return E_NOTIMPL;
 198 }
 199
 200 static HRESULT WINAPI InPlaceFrame_SetBorderSpace(IOleInPlaceFrame *iface,
 201         LPCBORDERWIDTHS pborderwidths)
 202 {
 203     ok(0, "unexpected call\n");
 204     return E_NOTIMPL;
 205 }
 206
 207 static HRESULT WINAPI InPlaceFrame_SetActiveObject(IOleInPlaceFrame *iface,
 208         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
 209 {
 210     static const WCHAR wszHTML_Document[] =
 211         {'H','T','M','L',' ','D','o','c','u','m','e','n','t',0};
 212
 213     ok(expect_SetActiveObject, "unexpected call\n");
 214     called_SetActiveObject = TRUE;
 215
 216     if(expect_SetActiveObject_active) {
 217         ok(pActiveObject != NULL, "pActiveObject = NULL\n");
 218         if(pActiveObject && PRIMARYLANGID(GetSystemDefaultLangID()) == LANG_ENGLISH)
 219             ok(!lstrcmpW(wszHTML_Document, pszObjName), "pszObjName != \"HTML Document\"\n");
 220     }else {
 221         ok(pActiveObject == NULL, "pActiveObject=%p, expected NULL\n", pActiveObject);
 222         ok(pszObjName == NULL, "pszObjName=%p, expected NULL\n", pszObjName);
 223     }
 224
 225     return S_OK;
 226 }
 227
 228 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
 229         LPOLEMENUGROUPWIDTHS lpMenuWidths)
 230 {
 231     ok(0, "unexpected call\n");
 232     return E_NOTIMPL;
 233 }
 234
 235 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
 236         HOLEMENU holemenu, HWND hwndActiveObject)
 237 {
 238     ok(0, "unexpected call\n");
 239     return E_NOTIMPL;
 240 }
 241
 242 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
 243 {
 244     ok(0, "unexpected call\n");
 245     return E_NOTIMPL;
 246 }
 247
 248 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
 249 {
 250     CHECK_EXPECT2(SetStatusText);
 251     if(!expect_status_text)
 252         ok(pszStatusText == NULL, "pszStatusText=%p, expected NULL\n", pszStatusText);
 253     return S_OK;
 254 }
 255
 256 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
 257 {
 258     ok(0, "unexpected call\n");
 259     return E_NOTIMPL;
 260 }
 261
 262 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
 263 {
 264     ok(0, "unexpected call\n");
 265     return E_NOTIMPL;
 266 }
 267
 268 static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
 269     InPlaceFrame_QueryInterface,
 270     InPlaceFrame_AddRef,
 271     InPlaceFrame_Release,
 272     InPlaceFrame_GetWindow,
 273     InPlaceFrame_ContextSensitiveHelp,
 274     InPlaceFrame_GetBorder,
 275     InPlaceFrame_RequestBorderSpace,
 276     InPlaceFrame_SetBorderSpace,
 277     InPlaceFrame_SetActiveObject,
 278     InPlaceFrame_InsertMenus,
 279     InPlaceFrame_SetMenu,
 280     InPlaceFrame_RemoveMenus,
 281     InPlaceFrame_SetStatusText,
 282     InPlaceFrame_EnableModeless,
 283     InPlaceFrame_TranslateAccelerator
 284 };
 285
 286 static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
 287
 288 static HRESULT WINAPI InPlaceSite_QueryInterface(IOleInPlaceSite *iface, REFIID riid, void **ppv)
 289 {
 290     return QueryInterface(riid, ppv);
 291 }
 292
 293 static ULONG WINAPI InPlaceSite_AddRef(IOleInPlaceSite *iface)
 294 {
 295     return 2;
 296 }
 297
 298 static ULONG WINAPI InPlaceSite_Release(IOleInPlaceSite *iface)
 299 {
 300     return 1;
 301 }
 302
 303 static HRESULT WINAPI InPlaceSite_GetWindow(IOleInPlaceSite *iface, HWND *phwnd)
 304 {
 305     CHECK_EXPECT(GetWindow);
 306     ok(phwnd != NULL, "phwnd = NULL\n");
 307     *phwnd = container_hwnd;
 308     return S_OK;
 309 }
 310
 311 static HRESULT WINAPI InPlaceSite_ContextSensitiveHelp(IOleInPlaceSite *iface, BOOL fEnterMode)
 312 {
 313     ok(0, "unexpected call\n");
 314     return E_NOTIMPL;
 315 }
 316
 317 static HRESULT WINAPI InPlaceSite_CanInPlaceActivate(IOleInPlaceSite *iface)
 318 {
 319     CHECK_EXPECT(CanInPlaceActivate);
 320     return S_OK;
 321 }
 322
 323 static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSite *iface)
 324 {
 325     CHECK_EXPECT(OnInPlaceActivate);
 326     return S_OK;
 327 }
 328
 329 static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSite *iface)
 330 {
 331     CHECK_EXPECT(OnUIActivate);
 332     return S_OK;
 333 }
 334
 335 static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSite *iface,
 336         IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
 337         LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
 338 {
 339     static const RECT rect = {0,0,500,500};
 340
 341     CHECK_EXPECT(GetWindowContext);
 342
 343     ok(ppFrame != NULL, "ppFrame = NULL\n");
 344     if(ppFrame)
 345         *ppFrame = &InPlaceFrame;
 346     ok(ppDoc != NULL, "ppDoc = NULL\n");
 347     if(ppDoc)
 348         *ppDoc = NULL;
 349     ok(lprcPosRect != NULL, "lprcPosRect = NULL\n");
 350     if(lprcPosRect)
 351         memcpy(lprcPosRect, &rect, sizeof(RECT));
 352     ok(lprcClipRect != NULL, "lprcClipRect = NULL\n");
 353     if(lprcClipRect)
 354         memcpy(lprcClipRect, &rect, sizeof(RECT));
 355     ok(lpFrameInfo != NULL, "lpFrameInfo = NULL\n");
 356     if(lpFrameInfo) {
 357         lpFrameInfo->cb = sizeof(*lpFrameInfo);
 358         lpFrameInfo->fMDIApp = FALSE;
 359         lpFrameInfo->hwndFrame = container_hwnd;
 360         lpFrameInfo->haccel = NULL;
 361         lpFrameInfo->cAccelEntries = 0;
 362     }
 363
 364     return S_OK;
 365 }
 366
 367 static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSite *iface, SIZE scrollExtant)
 368 {
 369     ok(0, "unexpected call\n");
 370     return E_NOTIMPL;
 371 }
 372
 373 static HRESULT WINAPI InPlaceSite_OnUIDeactivate(IOleInPlaceSite *iface, BOOL fUndoable)
 374 {
 375     CHECK_EXPECT(OnUIDeactivate);
 376     ok(!fUndoable, "fUndoable = TRUE\n");
 377     return S_OK;
 378 }
 379
 380 static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivate(IOleInPlaceSite *iface)
 381 {
 382     CHECK_EXPECT(OnInPlaceDeactivate);
 383     return S_OK;
 384 }
 385
 386 static HRESULT WINAPI InPlaceSite_DiscardUndoState(IOleInPlaceSite *iface)
 387 {
 388     ok(0, "unexpected call\n");
 389     return E_NOTIMPL;
 390 }
 391
 392 static HRESULT WINAPI InPlaceSite_DeactivateAndUndo(IOleInPlaceSite *iface)
 393 {
 394     ok(0, "unexpected call\n");
 395     return E_NOTIMPL;
 396 }
 397
 398 static HRESULT WINAPI InPlaceSite_OnPosRectChange(IOleInPlaceSite *iface, LPCRECT lprcPosRect)
 399 {
 400     ok(0, "unexpected call\n");
 401     return E_NOTIMPL;
 402 }
 403
 404 static const IOleInPlaceSiteVtbl InPlaceSiteVtbl = {
 405     InPlaceSite_QueryInterface,
 406     InPlaceSite_AddRef,
 407     InPlaceSite_Release,
 408     InPlaceSite_GetWindow,
 409     InPlaceSite_ContextSensitiveHelp,
 410     InPlaceSite_CanInPlaceActivate,
 411     InPlaceSite_OnInPlaceActivate,
 412     InPlaceSite_OnUIActivate,
 413     InPlaceSite_GetWindowContext,
 414     InPlaceSite_Scroll,
 415     InPlaceSite_OnUIDeactivate,
 416     InPlaceSite_OnInPlaceDeactivate,
 417     InPlaceSite_DiscardUndoState,
 418     InPlaceSite_DeactivateAndUndo,
 419     InPlaceSite_OnPosRectChange
 420 };
 421
 422 static IOleInPlaceSite InPlaceSite = { &InPlaceSiteVtbl };
 423
 424 static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
 425 {
 426     return QueryInterface(riid, ppv);
 427 }
 428
 429 static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
 430 {
 431     return 2;
 432 }
 433
 434 static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
 435 {
 436     return 1;
 437 }
 438
 439 static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
 440 {
 441     ok(0, "unexpected call\n");
 442     return E_NOTIMPL;
 443 }
 444
 445 static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAsign, DWORD dwWhichMoniker,
 446         IMoniker **ppmon)
 447 {
 448     ok(0, "unexpected call\n");
 449     return E_NOTIMPL;
 450 }
 451
 452 static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
 453 {
 454     CHECK_EXPECT(GetContainer);
 455     ok(ppContainer != NULL, "ppContainer = NULL\n");
 456     *ppContainer = &OleContainer;
 457     return S_OK;
 458 }
 459
 460 static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
 461 {
 462     ok(0, "unexpected call\n");
 463     return E_NOTIMPL;
 464 }
 465
 466 static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
 467 {
 468     ok(0, "unexpected call\n");
 469     return E_NOTIMPL;
 470 }
 471
 472 static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
 473 {
 474     ok(0, "unexpected call\n");
 475     return E_NOTIMPL;
 476 }
 477
 478 static const IOleClientSiteVtbl ClientSiteVtbl = {
 479     ClientSite_QueryInterface,
 480     ClientSite_AddRef,
 481     ClientSite_Release,
 482     ClientSite_SaveObject,
 483     ClientSite_GetMoniker,
 484     ClientSite_GetContainer,
 485     ClientSite_ShowObject,
 486     ClientSite_OnShowWindow,
 487     ClientSite_RequestNewObjectLayout
 488 };
 489
 490 static IOleClientSite ClientSite = { &ClientSiteVtbl };
 491
 492 static HRESULT WINAPI DocumentSite_QueryInterface(IOleDocumentSite *iface, REFIID riid, void **ppv)
 493 {
 494     return QueryInterface(riid, ppv);
 495 }
 496
 497 static ULONG WINAPI DocumentSite_AddRef(IOleDocumentSite *iface)
 498 {
 499     return 2;
 500 }
 501
 502 static ULONG WINAPI DocumentSite_Release(IOleDocumentSite *iface)
 503 {
 504     return 1;
 505 }
 506
 507 static BOOL call_UIActivate = TRUE;
 508 static HRESULT WINAPI DocumentSite_ActivateMe(IOleDocumentSite *iface, IOleDocumentView *pViewToActivate)
 509 {
 510     IOleDocument *document;
 511     HRESULT hres;
 512
 513     CHECK_EXPECT(ActivateMe);
 514     ok(pViewToActivate != NULL, "pViewToActivate = NULL\n");
 515
 516     hres = IOleDocumentView_QueryInterface(pViewToActivate, &IID_IOleDocument, (void**)&document);
 517     ok(hres == S_OK, "could not get IOleDocument: %08lx\n", hres);
 518
 519     if(SUCCEEDED(hres)) {
 520         hres = IOleDocument_CreateView(document, &InPlaceSite, NULL, 0, &view);
 521         ok(hres == S_OK, "CreateView failed: %08lx\n", hres);
 522
 523         if(SUCCEEDED(hres)) {
 524             IOleInPlaceActiveObject *activeobj = NULL;
 525             IOleInPlaceSite *inplacesite = NULL;
 526             HWND tmp_hwnd = NULL;
 527             static RECT rect = {0,0,400,500};
 528
 529             hres = IOleDocumentView_GetInPlaceSite(view, &inplacesite);
 530             ok(hres == S_OK, "GetInPlaceSite failed: %08lx\n", hres);
 531             ok(inplacesite == &InPlaceSite, "inplacesite=%p, expected %p\n",
 532                     inplacesite, &InPlaceSite);
 533
 534             hres = IOleDocumentView_SetInPlaceSite(view, &InPlaceSite);
 535             ok(hres == S_OK, "SetInPlaceSite failed: %08lx\n", hres);
 536
 537             hres = IOleDocumentView_GetInPlaceSite(view, &inplacesite);
 538             ok(hres == S_OK, "GetInPlaceSite failed: %08lx\n", hres);
 539             ok(inplacesite == &InPlaceSite, "inplacesite=%p, expected %p\n",
 540                     inplacesite, &InPlaceSite);
 541
 542             hres = IOleDocumentView_QueryInterface(view, &IID_IOleInPlaceActiveObject, (void**)&activeobj);
 543             ok(hres == S_OK, "Could not get IOleInPlaceActiveObject: %08lx\n", hres);
 544
 545             if(activeobj) {
 546                 IOleInPlaceActiveObject_GetWindow(activeobj, &hwnd);
 547                 ok(hres == S_OK, "GetWindow failed: %08lx\n", hres);
 548                 ok(hwnd == NULL, "hwnd=%p, expeted NULL\n", hwnd);
 549             }
 550
 551             if(call_UIActivate) {
 552                 SET_EXPECT(CanInPlaceActivate);
 553                 SET_EXPECT(GetWindowContext);
 554                 SET_EXPECT(GetWindow);
 555                 SET_EXPECT(OnInPlaceActivate);
 556                 SET_EXPECT(SetStatusText);
 557                 SET_EXPECT(Exec_SETPROGRESSMAX);
 558                 SET_EXPECT(Exec_SETPROGRESSPOS);
 559                 SET_EXPECT(OnUIActivate);
 560                 SET_EXPECT(SetActiveObject);
 561                 SET_EXPECT(ShowUI);
 562                 expect_SetActiveObject_active = TRUE;
 563                 expect_status_text = NULL;
 564
 565                 hres = IOleDocumentView_UIActivate(view, TRUE);
 566
 567                 if(FAILED(hres)) {
 568                     trace("UIActivate failed: %08lx\n", hres);
 569                     return hres;
 570                 }
 571                 ok(hres == S_OK, "UIActivate failed: %08lx\n", hres);
 572
 573                 CHECK_CALLED(CanInPlaceActivate);
 574                 CHECK_CALLED(GetWindowContext);
 575                 CHECK_CALLED(GetWindow);
 576                 CHECK_CALLED(OnInPlaceActivate);
 577                 CHECK_CALLED(SetStatusText);
 578                 CHECK_CALLED(Exec_SETPROGRESSMAX);
 579                 CHECK_CALLED(Exec_SETPROGRESSPOS);
 580                 CHECK_CALLED(OnUIActivate);
 581                 CHECK_CALLED(SetActiveObject);
 582                 CHECK_CALLED(ShowUI);
 583
 584                 if(activeobj) {
 585                     hres = IOleInPlaceActiveObject_GetWindow(activeobj, &hwnd);
 586                     ok(hres == S_OK, "GetWindow failed: %08lx\n", hres);
 587                     ok(hwnd != NULL, "hwnd == NULL\n");
 588                     if(last_hwnd)
 589                         ok(hwnd == last_hwnd, "hwnd != last_hwnd\n");
 590                 }
 591
 592                 hres = IOleDocumentView_UIActivate(view, TRUE);
 593                 ok(hres == S_OK, "UIActivate failed: %08lx\n", hres);
 594
 595                 if(activeobj) {
 596                     hres = IOleInPlaceActiveObject_GetWindow(activeobj, &tmp_hwnd);
 597                     ok(hres == S_OK, "GetWindow failed: %08lx\n", hres);
 598                     ok(tmp_hwnd == hwnd, "tmp_hwnd=%p, expected %p\n", tmp_hwnd, hwnd);
 599                 }
 600             }
 601
 602             hres = IOleDocumentView_SetRect(view, &rect);
 603             ok(hres == S_OK, "SetRect failed: %08lx\n", hres);
 604
 605             if(call_UIActivate) {
 606                 hres = IOleDocumentView_Show(view, TRUE);
 607                 ok(hres == S_OK, "Show failed: %08lx\n", hres);
 608             }else {
 609                 SET_EXPECT(CanInPlaceActivate);
 610                 SET_EXPECT(GetWindowContext);
 611                 SET_EXPECT(GetWindow);
 612                 SET_EXPECT(OnInPlaceActivate);
 613                 SET_EXPECT(SetStatusText);
 614                 SET_EXPECT(Exec_SETPROGRESSMAX);
 615                 SET_EXPECT(Exec_SETPROGRESSPOS);
 616                 SET_EXPECT(OnUIActivate);
 617                 expect_status_text = (load_state == LD_LOADED ? (LPCOLESTR)0xdeadbeef : NULL);
 618
 619                 hres = IOleDocumentView_Show(view, TRUE);
 620                 ok(hres == S_OK, "Show failed: %08lx\n", hres);
 621
 622                 CHECK_CALLED(CanInPlaceActivate);
 623                 CHECK_CALLED(GetWindowContext);
 624                 CHECK_CALLED(GetWindow);
 625                 CHECK_CALLED(OnInPlaceActivate);
 626                 CHECK_CALLED(SetStatusText);
 627                 CHECK_CALLED(Exec_SETPROGRESSMAX);
 628                 CHECK_CALLED(Exec_SETPROGRESSPOS);
 629
 630                 if(activeobj) {
 631                     hres = IOleInPlaceActiveObject_GetWindow(activeobj, &hwnd);
 632                     ok(hres == S_OK, "GetWindow failed: %08lx\n", hres);
 633                     ok(hwnd != NULL, "hwnd == NULL\n");
 634                     if(last_hwnd)
 635                         ok(hwnd == last_hwnd, "hwnd != last_hwnd\n");
 636                 }
 637             }
 638
 639             if(activeobj)
 640                 IOleInPlaceActiveObject_Release(activeobj);
 641         }
 642
 643         IOleDocument_Release(document);
 644     }
 645
 646     return S_OK;
 647 }
 648
 649 static const IOleDocumentSiteVtbl DocumentSiteVtbl = {
 650     DocumentSite_QueryInterface,
 651     DocumentSite_AddRef,
 652     DocumentSite_Release,
 653     DocumentSite_ActivateMe
 654 };
 655
 656 static IOleDocumentSite DocumentSite = { &DocumentSiteVtbl };
 657
 658 static HRESULT WINAPI DocHostUIHandler_QueryInterface(IDocHostUIHandler2 *iface, REFIID riid, void **ppv)
 659 {
 660     return QueryInterface(riid, ppv);
 661 }
 662
 663 static ULONG WINAPI DocHostUIHandler_AddRef(IDocHostUIHandler2 *iface)
 664 {
 665     return 2;
 666 }
 667
 668 static ULONG WINAPI DocHostUIHandler_Release(IDocHostUIHandler2 *iface)
 669 {
 670     return 1;
 671 }
 672
 673 static HRESULT WINAPI DocHostUIHandler_ShowContextMenu(IDocHostUIHandler2 *iface, DWORD dwID, POINT *ppt,
 674         IUnknown *pcmdtReserved, IDispatch *pdicpReserved)
 675 {
 676     ok(0, "unexpected call\n");
 677     return E_NOTIMPL;
 678 }
 679
 680 static HRESULT WINAPI DocHostUIHandler_GetHostInfo(IDocHostUIHandler2 *iface, DOCHOSTUIINFO *pInfo)
 681 {
 682     CHECK_EXPECT(GetHostInfo);
 683     ok(pInfo != NULL, "pInfo=NULL\n");
 684     if(pInfo) {
 685         ok(pInfo->cbSize == sizeof(DOCHOSTUIINFO), "pInfo->cbSize=%lu, expected %u\n",
 686                 pInfo->cbSize, sizeof(DOCHOSTUIINFO));
 687         ok(!pInfo->dwFlags, "pInfo->dwFlags=%08lx, expected 0\n", pInfo->dwFlags);
 688         pInfo->dwFlags = DOCHOSTUIFLAG_DISABLE_HELP_MENU | DOCHOSTUIFLAG_DISABLE_SCRIPT_INACTIVE
 689             | DOCHOSTUIFLAG_ACTIVATE_CLIENTHIT_ONLY | DOCHOSTUIFLAG_ENABLE_INPLACE_NAVIGATION
 690             | DOCHOSTUIFLAG_IME_ENABLE_RECONVERSION;
 691         ok(!pInfo->dwDoubleClick, "pInfo->dwDoubleClick=%08lx, expected 0\n", pInfo->dwDoubleClick);
 692         ok(!pInfo->pchHostCss, "pInfo->pchHostCss=%p, expected NULL\n", pInfo->pchHostCss);
 693         ok(!pInfo->pchHostNS, "pInfo->pchhostNS=%p, expected NULL\n", pInfo->pchHostNS);
 694     }
 695     return S_OK;
 696 }
 697
 698 static HRESULT WINAPI DocHostUIHandler_ShowUI(IDocHostUIHandler2 *iface, DWORD dwID,
 699         IOleInPlaceActiveObject *pActiveObject, IOleCommandTarget *pCommandTarget,
 700         IOleInPlaceFrame *pFrame, IOleInPlaceUIWindow *pDoc)
 701 {
 702     CHECK_EXPECT(ShowUI);
 703
 704     ok(dwID == 0, "dwID=%ld, expected 0\n", dwID);
 705     ok(pActiveObject != NULL, "pActiveObject = NULL\n");
 706     ok(pCommandTarget != NULL, "pCommandTarget = NULL\n");
 707     ok(pFrame == &InPlaceFrame, "pFrame=%p, expected %p\n", pFrame, &InPlaceFrame);
 708     ok(pDoc == NULL, "pDoc=%p, expected NULL\n", pDoc);
 709
 710     return S_OK;
 711 }
 712
 713 static HRESULT WINAPI DocHostUIHandler_HideUI(IDocHostUIHandler2 *iface)
 714 {
 715     CHECK_EXPECT(HideUI);
 716     return S_OK;
 717 }
 718
 719 static HRESULT WINAPI DocHostUIHandler_UpdateUI(IDocHostUIHandler2 *iface)
 720 {
 721     CHECK_EXPECT(UpdateUI);
 722     return S_OK;
 723 }
 724
 725 static HRESULT WINAPI DocHostUIHandler_EnableModeless(IDocHostUIHandler2 *iface, BOOL fEnable)
 726 {
 727     ok(0, "unexpected call\n");
 728     return E_NOTIMPL;
 729 }
 730
 731 static HRESULT WINAPI DocHostUIHandler_OnDocWindowActivate(IDocHostUIHandler2 *iface, BOOL fActivate)
 732 {
 733     ok(0, "unexpected call\n");
 734     return E_NOTIMPL;
 735 }
 736
 737 static HRESULT WINAPI DocHostUIHandler_OnFrameWindowActivate(IDocHostUIHandler2 *iface, BOOL fActivate)
 738 {
 739     ok(0, "unexpected call\n");
 740     return E_NOTIMPL;
 741 }
 742
 743 static HRESULT WINAPI DocHostUIHandler_ResizeBorder(IDocHostUIHandler2 *iface, LPCRECT prcBorder,
 744         IOleInPlaceUIWindow *pUIWindow, BOOL fRameWindow)
 745 {
 746     ok(0, "unexpected call\n");
 747     return E_NOTIMPL;
 748 }
 749
 750 static HRESULT WINAPI DocHostUIHandler_TranslateAccelerator(IDocHostUIHandler2 *iface, LPMSG lpMsg,
 751         const GUID *pguidCmdGroup, DWORD nCmdID)
 752 {
 753     ok(0, "unexpected call\n");
 754     return E_NOTIMPL;
 755 }
 756
 757 static HRESULT WINAPI DocHostUIHandler_GetOptionKeyPath(IDocHostUIHandler2 *iface,
 758         LPOLESTR *pchKey, DWORD dw)
 759 {
 760     CHECK_EXPECT(GetOptionKeyPath);
 761     ok(pchKey != NULL, "pchKey = NULL\n");
 762     ok(!dw, "dw=%ld, expected 0\n", dw);
 763     if(pchKey)
 764         ok(!*pchKey, "*pchKey=%p, expected NULL\n", *pchKey);
 765     return S_OK;
 766 }
 767
 768 static HRESULT WINAPI DocHostUIHandler_GetDropTarget(IDocHostUIHandler2 *iface,
 769         IDropTarget *pDropTarget, IDropTarget **ppDropTarget)
 770 {
 771     CHECK_EXPECT(GetDropTarget);
 772     /* TODO */
 773     return E_NOTIMPL;
 774 }
 775
 776 static HRESULT WINAPI DocHostUIHandler_GetExternal(IDocHostUIHandler2 *iface, IDispatch **ppDispatch)
 777 {
 778     ok(0, "unexpected call\n");
 779     return E_NOTIMPL;
 780 }
 781
 782 static HRESULT WINAPI DocHostUIHandler_TranslateUrl(IDocHostUIHandler2 *iface, DWORD dwTranslate,
 783         OLECHAR *pchURLIn, OLECHAR **ppchURLOut)
 784 {
 785     ok(0, "unexpected call\n");
 786     return E_NOTIMPL;
 787 }
 788
 789 static HRESULT WINAPI DocHostUIHandler_FilterDataObject(IDocHostUIHandler2 *iface, IDataObject *pDO,
 790         IDataObject **ppPORet)
 791 {
 792     ok(0, "unexpected call\n");
 793     return E_NOTIMPL;
 794 }
 795
 796 static HRESULT WINAPI DocHostUIHandler_GetOverrideKeyPath(IDocHostUIHandler2 *iface,
 797         LPOLESTR *pchKey, DWORD dw)
 798 {
 799     CHECK_EXPECT(GetOverrideKeyPath);
 800     ok(pchKey != NULL, "pchKey = NULL\n");
 801     if(pchKey)
 802         ok(!*pchKey, "*pchKey=%p, expected NULL\n", *pchKey);
 803     ok(!dw, "dw=%ld, xepected 0\n", dw);
 804     return S_OK;
 805 }
 806
 807 static const IDocHostUIHandler2Vtbl DocHostUIHandlerVtbl = {
 808     DocHostUIHandler_QueryInterface,
 809     DocHostUIHandler_AddRef,
 810     DocHostUIHandler_Release,
 811     DocHostUIHandler_ShowContextMenu,
 812     DocHostUIHandler_GetHostInfo,
 813     DocHostUIHandler_ShowUI,
 814     DocHostUIHandler_HideUI,
 815     DocHostUIHandler_UpdateUI,
 816     DocHostUIHandler_EnableModeless,
 817     DocHostUIHandler_OnDocWindowActivate,
 818     DocHostUIHandler_OnFrameWindowActivate,
 819     DocHostUIHandler_ResizeBorder,
 820     DocHostUIHandler_TranslateAccelerator,
 821     DocHostUIHandler_GetOptionKeyPath,
 822     DocHostUIHandler_GetDropTarget,
 823     DocHostUIHandler_GetExternal,
 824     DocHostUIHandler_TranslateUrl,
 825     DocHostUIHandler_FilterDataObject,
 826     DocHostUIHandler_GetOverrideKeyPath
 827 };
 828
 829 static IDocHostUIHandler2 DocHostUIHandler = { &DocHostUIHandlerVtbl };
 830
 831 static HRESULT WINAPI OleCommandTarget_QueryInterface(IOleCommandTarget *iface,
 832         REFIID riid, void **ppv)
 833 {
 834     return QueryInterface(riid, ppv);
 835 }
 836
 837 static ULONG WINAPI OleCommandTarget_AddRef(IOleCommandTarget *iface)
 838 {
 839     return 2;
 840 }
 841
 842 static ULONG WINAPI OleCommandTarget_Release(IOleCommandTarget *iface)
 843 {
 844     return 1;
 845 }
 846
 847 static HRESULT WINAPI OleCommandTarget_QueryStatus(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
 848         ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText)
 849 {
 850     ok(!pguidCmdGroup, "pguidCmdGroup != MULL\n");
 851     ok(cCmds == 1, "cCmds=%ld, expected 1\n", cCmds);
 852     ok(!pCmdText, "pCmdText != NULL\n");
 853
 854     switch(prgCmds[0].cmdID) {
 855     case OLECMDID_SETPROGRESSTEXT:
 856         CHECK_EXPECT(QueryStatus_SETPROGRESSTEXT);
 857         prgCmds[0].cmdf = OLECMDF_ENABLED;
 858         return S_OK;
 859     case OLECMDID_OPEN:
 860         CHECK_EXPECT(QueryStatus_OPEN);
 861         prgCmds[0].cmdf = 0;
 862         return S_OK;
 863     case OLECMDID_NEW:
 864         CHECK_EXPECT(QueryStatus_NEW);
 865         prgCmds[0].cmdf = 0;
 866         return S_OK;
 867     default:
 868         ok(0, "unexpected command %ld\n", prgCmds[0].cmdID);
 869     };
 870
 871     return E_FAIL;
 872 }
 873
 874 static HRESULT WINAPI OleCommandTarget_Exec(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
 875         DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 876 {
 877     if(!pguidCmdGroup) {
 878         switch(nCmdID) {
 879         case OLECMDID_SETPROGRESSMAX:
 880             CHECK_EXPECT2(Exec_SETPROGRESSMAX);
 881             ok(pvaIn != NULL, "pvaIn == NULL\n");
 882             if(pvaIn) {
 883                 ok(V_VT(pvaIn) == VT_I4, "V_VT(pvaIn)=%d, expected VT_I4\n", V_VT(pvaIn));
 884                 if(load_state == LD_NO)
 885                     ok(V_I4(pvaIn) == 0, "V_I4(pvaIn)=%ld, expected 0\n", V_I4(pvaIn));
 886             }
 887             ok(pvaOut == NULL, "pvaOut=%p, expected NULL\n", pvaOut);
 888             return S_OK;
 889         case OLECMDID_SETPROGRESSPOS:
 890             CHECK_EXPECT2(Exec_SETPROGRESSPOS);
 891             ok(pvaIn != NULL, "pvaIn == NULL\n");
 892             if(pvaIn) {
 893                 ok(V_VT(pvaIn) == VT_I4, "V_VT(pvaIn)=%d, expected VT_I4\n", V_VT(pvaIn));
 894                 if(load_state == LD_NO)
 895                     ok(V_I4(pvaIn) == 0, "V_I4(pvaIn)=%ld, expected 0\n", V_I4(pvaIn));
 896             }
 897             ok(pvaOut == NULL, "pvaOut=%p, expected NULL\n", pvaOut);
 898             return S_OK;
 899         case OLECMDID_HTTPEQUIV_DONE:
 900             CHECK_EXPECT(Exec_HTTPEQUIV_DONE);
 901             /* TODO */
 902             return S_OK;
 903         case OLECMDID_SETDOWNLOADSTATE:
 904             CHECK_EXPECT2(Exec_SETDOWNLOADSTATE);
 905             /* TODO */
 906             return S_OK;
 907         case OLECMDID_UPDATECOMMANDS:
 908             CHECK_EXPECT(Exec_UPDATECOMMANDS);
 909             /* TODO */
 910             return S_OK;
 911         case OLECMDID_SETTITLE:
 912             CHECK_EXPECT2(Exec_SETTITLE);
 913             /* TODO */
 914             return S_OK;
 915         case OLECMDID_HTTPEQUIV:
 916             CHECK_EXPECT2(Exec_HTTPEQUIV);
 917             /* TODO */
 918             return S_OK;
 919         default:
 920             ok(0, "unexpected command %ld\n", nCmdID);
 921             return E_FAIL;
 922         };
 923     }
 924
 925     if(IsEqualGUID(&CGID_ShellDocView, pguidCmdGroup)) {
 926         switch(nCmdID) {
 927         case 37:
 928             CHECK_EXPECT(Exec_ShellDocView_37);
 929             ok(pvaOut == NULL, "pvaOut=%p, expected NULL\n", pvaOut);
 930             ok(pvaIn != NULL, "pvaIn == NULL\n");
 931             if(pvaIn) {
 932                 ok(V_VT(pvaIn) == VT_I4, "V_VT(pvaIn)=%d, expected VT_I4\n", V_VT(pvaIn));
 933                 ok(V_I4(pvaIn) == 0, "V_I4(pvaIn)=%ld, expected 0\n", V_I4(pvaIn));
 934             }
 935             return S_OK;
 936         default:
 937             ok(0, "unexpected command %ld\n", nCmdID);
 938             return E_FAIL;
 939         };
 940     }
 941
 942     if(IsEqualGUID(&CGID_MSHTML, pguidCmdGroup)) {
 943         switch(nCmdID) {
 944         case 2315:
 945             CHECK_EXPECT(Exec_MSHTML_2315);
 946             /* TODO */
 947             return S_OK;
 948         default:
 949             ok(0, "unexpected command %ld\n", nCmdID);
 950         };
 951     }
 952
 953     if(IsEqualGUID(&CGID_Undocumented, pguidCmdGroup))
 954         return E_FAIL; /* TODO */
 955
 956     ok(0, "unexpected call\n");
 957     return E_NOTIMPL;
 958 }
 959
 960 static IOleCommandTargetVtbl OleCommandTargetVtbl = {
 961     OleCommandTarget_QueryInterface,
 962     OleCommandTarget_AddRef,
 963     OleCommandTarget_Release,
 964     OleCommandTarget_QueryStatus,
 965     OleCommandTarget_Exec
 966 };
 967
 968 static IOleCommandTarget OleCommandTarget = { &OleCommandTargetVtbl };
 969
 970 static HRESULT WINAPI Dispatch_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
 971 {
 972     return QueryInterface(riid, ppv);
 973 }
 974
 975 static ULONG WINAPI Dispatch_AddRef(IDispatch *iface)
 976 {
 977     return 2;
 978 }
 979
 980 static ULONG WINAPI Dispatch_Release(IDispatch *iface)
 981 {
 982     return 1;
 983 }
 984
 985 static HRESULT WINAPI Dispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
 986 {
 987     ok(0, "unexpected call\n");
 988     return E_NOTIMPL;
 989 }
 990
 991 static HRESULT WINAPI Dispatch_GetTypeInfo(IDispatch *iface, UINT iTInfo, LCID lcid,
 992         ITypeInfo **ppTInfo)
 993 {
 994     ok(0, "unexpected call\n");
 995     return E_NOTIMPL;
 996 }
 997
 998 static HRESULT WINAPI Dispatch_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *rgszNames,
 999         UINT cNames, LCID lcid, DISPID *rgDispId)
1000 {
1001     ok(0, "unexpected call\n");
1002     return E_NOTIMPL;
1003 }
1004
1005 static HRESULT WINAPI Dispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,
1006         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
1007         EXCEPINFO *pExcepInfo, UINT *puArgErr)
1008 {
1009     ok(IsEqualGUID(&IID_NULL, riid), "riid != IID_NULL\n");
1010     ok(pDispParams != NULL, "pDispParams == NULL\n");
1011     ok(pExcepInfo == NULL, "pExcepInfo=%p, expected NULL\n", pExcepInfo);
1012     ok(puArgErr != NULL, "puArgErr == NULL\n");
1013     ok(V_VT(pVarResult) == 0, "V_VT(pVarResult)=%d, expected 0\n", V_VT(pVarResult));
1014     ok(wFlags == DISPATCH_PROPERTYGET, "wFlags=%08x, expected DISPATCH_PROPERTYGET\n", wFlags);
1015
1016     switch(dispIdMember) {
1017     case DISPID_AMBIENT_USERMODE:
1018         CHECK_EXPECT2(Invoke_AMBIENT_USERMODE);
1019         V_VT(pVarResult) = VT_BOOL;
1020         V_BOOL(pVarResult) = VARIANT_TRUE;
1021         return S_OK;
1022     case DISPID_AMBIENT_DLCONTROL:
1023         CHECK_EXPECT2(Invoke_AMBIENT_DLCONTROL);
1024         return E_FAIL;
1025     case DISPID_AMBIENT_OFFLINEIFNOTCONNECTED:
1026         CHECK_EXPECT2(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1027         return E_FAIL;
1028     case DISPID_AMBIENT_SILENT:
1029         CHECK_EXPECT2(Invoke_AMBIENT_SILENT);
1030         V_VT(pVarResult) = VT_BOOL;
1031         V_BOOL(pVarResult) = VARIANT_FALSE;
1032         return S_OK;
1033     case DISPID_AMBIENT_USERAGENT:
1034         CHECK_EXPECT(Invoke_AMBIENT_USERAGENT);
1035         return E_FAIL;
1036     case DISPID_AMBIENT_PALETTE:
1037         CHECK_EXPECT(Invoke_AMBIENT_PALETTE);
1038         return E_FAIL;
1039     };
1040
1041     ok(0, "unexpected dispid %ld\n", dispIdMember);
1042     return E_FAIL;
1043 }
1044
1045 static IDispatchVtbl DispatchVtbl = {
1046     Dispatch_QueryInterface,
1047     Dispatch_AddRef,
1048     Dispatch_Release,
1049     Dispatch_GetTypeInfoCount,
1050     Dispatch_GetTypeInfo,
1051     Dispatch_GetIDsOfNames,
1052     Dispatch_Invoke
1053 };
1054
1055 static IDispatch Dispatch = { &DispatchVtbl };
1056
1057 static HRESULT QueryInterface(REFIID riid, void **ppv)
1058 {
1059     *ppv = NULL;
1060
1061     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IOleClientSite, riid))
1062         *ppv = &ClientSite;
1063     else if(IsEqualGUID(&IID_IOleDocumentSite, riid))
1064         *ppv = &DocumentSite;
1065     else if(IsEqualGUID(&IID_IDocHostUIHandler, riid) || IsEqualGUID(&IID_IDocHostUIHandler2, riid))
1066         *ppv = &DocHostUIHandler;
1067     else if(IsEqualGUID(&IID_IOleContainer, riid))
1068         *ppv = &OleContainer;
1069     else if(IsEqualGUID(&IID_IOleWindow, riid) || IsEqualGUID(&IID_IOleInPlaceSite, riid))
1070         *ppv = &InPlaceSite;
1071     else if(IsEqualGUID(&IID_IOleInPlaceUIWindow, riid) || IsEqualGUID(&IID_IOleInPlaceFrame, riid))
1072         *ppv = &InPlaceFrame;
1073     else if(IsEqualGUID(&IID_IOleCommandTarget , riid))
1074         *ppv = &OleCommandTarget;
1075     else if(IsEqualGUID(&IID_IDispatch, riid))
1076         *ppv = &Dispatch;
1077
1078     /* TODO:
1079      * IServiceProvider
1080      * {D48A6EC6-6A4A-11CF-94A7-444553540000}
1081      * {7BB0B520-B1A7-11D2-BB23-00C04F79ABCD}
1082      * {000670BA-0000-0000-C000-000000000046}
1083      */
1084
1085     if(*ppv)
1086         return S_OK;
1087     return E_NOINTERFACE;
1088 }
1089
1090 static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
1091 {
1092     return DefWindowProc(hwnd, msg, wParam, lParam);
1093 }
1094
1095 static void test_Load(IPersistMoniker *persist)
1096 {
1097     IMoniker *mon;
1098     IBindCtx *bind;
1099     HRESULT hres;
1100
1101     static WCHAR wszClientSiteParam[] = {'{','d','4','d','b','6','8','5','0','-',
1102         '5','3','8','5','-','1','1','d','0','-','8','9','e','9','-','0','0','a',
1103         '0','c','9','0','a','9','0','a','c','}',0};
1104     static const WCHAR wszWineHQ[] =
1105         {'h','t','t','p',':','/','/','w','w','w','.','w','i','n','e','h','q','.','o','r','g','/',0};
1106
1107     hres = CreateURLMoniker(NULL, wszWineHQ, &mon);
1108     ok(hres == S_OK, "CreateURLMoniker failed: %08lx\n", hres);
1109     if(FAILED(hres))
1110         return;
1111
1112     CreateBindCtx(0, &bind);
1113     IBindCtx_RegisterObjectParam(bind, wszClientSiteParam, (IUnknown*)&ClientSite);
1114
1115     SET_EXPECT(GetHostInfo);
1116     SET_EXPECT(GetOptionKeyPath);
1117     SET_EXPECT(GetOverrideKeyPath);
1118     SET_EXPECT(GetWindow);
1119     SET_EXPECT(QueryStatus_SETPROGRESSTEXT);
1120     SET_EXPECT(Exec_SETPROGRESSMAX);
1121     SET_EXPECT(Exec_SETPROGRESSPOS);
1122     SET_EXPECT(Invoke_AMBIENT_USERMODE);
1123     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1124     SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1125     SET_EXPECT(Invoke_AMBIENT_SILENT);
1126     SET_EXPECT(Invoke_AMBIENT_USERAGENT);
1127     SET_EXPECT(Invoke_AMBIENT_PALETTE);
1128     SET_EXPECT(GetContainer);
1129     SET_EXPECT(LockContainer);
1130     SET_EXPECT(Exec_ShellDocView_37);
1131     expect_LockContainer_fLock = TRUE;
1132
1133     hres = IPersistMoniker_Load(persist, FALSE, mon, bind, 0x12);
1134 #if 0
1135     ok(hres == S_OK, "Load failed: %08lx\n", hres);
1136 #endif
1137
1138     CHECK_CALLED(GetHostInfo);
1139     CHECK_CALLED(GetOptionKeyPath);
1140     CHECK_CALLED(GetOverrideKeyPath);
1141     CHECK_CALLED(GetWindow);
1142     CHECK_CALLED(QueryStatus_SETPROGRESSTEXT);
1143     CHECK_CALLED(Exec_SETPROGRESSMAX);
1144     CHECK_CALLED(Exec_SETPROGRESSPOS);
1145     CHECK_CALLED(Invoke_AMBIENT_USERMODE);
1146     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1147     CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1148     CHECK_CALLED(Invoke_AMBIENT_SILENT);
1149     CHECK_CALLED(Invoke_AMBIENT_USERAGENT);
1150     CHECK_CALLED(Invoke_AMBIENT_PALETTE);
1151     CHECK_CALLED(GetContainer);
1152     CHECK_CALLED(LockContainer);
1153     CHECK_CALLED(Exec_ShellDocView_37);
1154
1155     set_clientsite = container_locked = TRUE;
1156
1157     IBindCtx_Release(bind);
1158     IMoniker_Release(mon);
1159 }
1160
1161 #ifdef DOWNLOAD_TEST
1162
1163 static void test_download(void)
1164 {
1165     MSG msg;
1166
1167     load_state = LD_LOADING;
1168
1169     SET_EXPECT(Exec_SETDOWNLOADSTATE);
1170     SET_EXPECT(GetDropTarget);
1171     SET_EXPECT(SetStatusText);
1172     SET_EXPECT(UpdateUI);
1173     SET_EXPECT(Exec_UPDATECOMMANDS);
1174     SET_EXPECT(Exec_SETTITLE);
1175     SET_EXPECT(Exec_HTTPEQUIV);
1176     SET_EXPECT(Exec_SETPROGRESSMAX);
1177     SET_EXPECT(Exec_SETPROGRESSPOS);
1178     SET_EXPECT(Exec_MSHTML_2315);
1179     SET_EXPECT(Exec_HTTPEQUIV_DONE);
1180     expect_status_text = (LPCOLESTR)0xdeadbeef; /* TODO */
1181
1182     while(!called_Exec_HTTPEQUIV_DONE && GetMessage(&msg, NULL, 0, 0)) {
1183         TranslateMessage(&msg);
1184         DispatchMessage(&msg);
1185     }
1186
1187     CHECK_CALLED(Exec_SETDOWNLOADSTATE);
1188     CHECK_CALLED(GetDropTarget);
1189     CHECK_CALLED(SetStatusText);
1190     CHECK_CALLED(UpdateUI);
1191     CHECK_CALLED(Exec_UPDATECOMMANDS);
1192     CHECK_CALLED(Exec_SETTITLE);
1193     CHECK_CALLED(Exec_HTTPEQUIV);
1194     CHECK_CALLED(Exec_SETPROGRESSMAX);
1195     CHECK_CALLED(Exec_SETPROGRESSPOS);
1196     CHECK_CALLED(Exec_MSHTML_2315);
1197     CHECK_CALLED(Exec_HTTPEQUIV_DONE);
1198
1199     load_state = LD_LOADED;
1200 }
1201
1202 #endif
1203
1204 static void test_Persist(IUnknown *unk)
1205 {
1206     IPersistMoniker *persist_mon;
1207     IPersistFile *persist_file;
1208     GUID guid;
1209     HRESULT hres;
1210
1211     hres = IUnknown_QueryInterface(unk, &IID_IPersistFile, (void**)&persist_file);
1212     ok(hres == S_OK, "QueryInterface(IID_IPersist) failed: %08lx\n", hres);
1213     if(SUCCEEDED(hres)) {
1214         hres = IPersist_GetClassID(persist_file, NULL);
1215         ok(hres == E_INVALIDARG, "GetClassID returned: %08lx, expected E_INVALIDARG\n", hres);
1216
1217         hres = IPersist_GetClassID(persist_file, &guid);
1218         ok(hres == S_OK, "GetClassID failed: %08lx\n", hres);
1219         ok(IsEqualGUID(&CLSID_HTMLDocument, &guid), "guid != CLSID_HTMLDocument\n");
1220
1221         IPersist_Release(persist_file);
1222     }
1223
1224     hres = IUnknown_QueryInterface(unk, &IID_IPersistMoniker, (void**)&persist_mon);
1225     ok(hres == S_OK, "QueryInterface(IID_IPersistMoniker) failed: %08lx\n", hres);
1226     if(SUCCEEDED(hres)) {
1227         hres = IPersistMoniker_GetClassID(persist_mon, NULL);
1228         ok(hres == E_INVALIDARG, "GetClassID returned: %08lx, expected E_INVALIDARG\n", hres);
1229
1230         hres = IPersistMoniker_GetClassID(persist_mon, &guid);
1231         ok(hres == S_OK, "GetClassID failed: %08lx\n", hres);
1232         ok(IsEqualGUID(&CLSID_HTMLDocument, &guid), "guid != CLSID_HTMLDocument\n");
1233
1234         if(load_state == LD_DOLOAD)
1235             test_Load(persist_mon);
1236
1237         IPersistMoniker_Release(persist_mon);
1238     }
1239 }
1240
1241 static const OLECMDF expect_cmds[OLECMDID_GETPRINTTEMPLATE+1] = {
1242     0,
1243     OLECMDF_SUPPORTED,                  /* OLECMDID_OPEN */
1244     OLECMDF_SUPPORTED,                  /* OLECMDID_NEW */
1245     OLECMDF_SUPPORTED,                  /* OLECMDID_SAVE */
1246     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_SAVEAS */
1247     OLECMDF_SUPPORTED,                  /* OLECMDID_SAVECOPYAS */
1248     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PRINT */
1249     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PRINTPREVIEW */
1250     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PAGESETUP */
1251     OLECMDF_SUPPORTED,                  /* OLECMDID_SPELL */
1252     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PROPERTIES */
1253     OLECMDF_SUPPORTED,                  /* OLECMDID_CUT */
1254     OLECMDF_SUPPORTED,                  /* OLECMDID_COPY */
1255     OLECMDF_SUPPORTED,                  /* OLECMDID_PASTE */
1256     OLECMDF_SUPPORTED,                  /* OLECMDID_PASTESPECIAL */
1257     OLECMDF_SUPPORTED,                  /* OLECMDID_UNDO */
1258     OLECMDF_SUPPORTED,                  /* OLECMDID_REDO */
1259     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_SELECTALL */
1260     OLECMDF_SUPPORTED,                  /* OLECMDID_CLEARSELECTION */
1261     OLECMDF_SUPPORTED,                  /* OLECMDID_ZOOM */
1262     OLECMDF_SUPPORTED,                  /* OLECMDID_GETZOOMRANGE */
1263     0,
1264     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_REFRESH */
1265     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_STOP */
1266     0,0,0,0,0,0,
1267     OLECMDF_SUPPORTED,                  /* OLECMDID_STOPDOWNLOAD */
1268     0,0,
1269     OLECMDF_SUPPORTED,                  /* OLECMDID_DELETE */
1270     0,0,
1271     OLECMDF_SUPPORTED,                  /* OLECMDID_ENABLE_INTERACTION */
1272     OLECMDF_SUPPORTED,                  /* OLECMDID_ONUNLOAD */
1273     0,0,0,0,0,
1274     OLECMDF_SUPPORTED,                  /* OLECMDID_SHOWPAGESETUP */
1275     OLECMDF_SUPPORTED,                  /* OLECMDID_SHOWPRINT */
1276     0,0,
1277     OLECMDF_SUPPORTED,                  /* OLECMDID_CLOSE */
1278     0,0,0,
1279     OLECMDF_SUPPORTED,                  /* OLECMDID_SETPRINTTEMPLATE */
1280     OLECMDF_SUPPORTED                   /* OLECMDID_GETPRINTTEMPLATE */
1281 };
1282
1283 static void test_OleCommandTarget(IUnknown *unk)
1284 {
1285     IOleCommandTarget *cmdtrg;
1286     OLECMD cmds[OLECMDID_GETPRINTTEMPLATE];
1287     int i;
1288     HRESULT hres;
1289
1290     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
1291     ok(hres == S_OK, "QueryInterface(IIDIOleM=CommandTarget failed: %08lx\n", hres);
1292     if(FAILED(hres))
1293         return;
1294
1295     for(i=0; i<OLECMDID_GETPRINTTEMPLATE; i++) {
1296         cmds[i].cmdID = i+1;
1297         cmds[i].cmdf = 0xf0f0;
1298     }
1299
1300     SET_EXPECT(QueryStatus_OPEN);
1301     SET_EXPECT(QueryStatus_NEW);
1302     hres = IOleCommandTarget_QueryStatus(cmdtrg, NULL, sizeof(cmds)/sizeof(cmds[0]), cmds, NULL);
1303     ok(hres == S_OK, "QueryStatus failed: %08lx\n", hres);
1304     CHECK_CALLED(QueryStatus_OPEN);
1305     CHECK_CALLED(QueryStatus_NEW);
1306
1307     for(i=0; i<OLECMDID_GETPRINTTEMPLATE; i++) {
1308         ok(cmds[i].cmdID == i+1, "cmds[%d].cmdID canged to %lx\n", i, cmds[i].cmdID);
1309         ok(cmds[i].cmdf == expect_cmds[i+1], "cmds[%d].cmdf=%lx, expected %x\n",
1310                 i+1, cmds[i].cmdf, expect_cmds[i+1]);
1311     }
1312
1313     IOleCommandTarget_Release(cmdtrg);
1314 }
1315
1316 static void test_OleCommandTarget_fail(IUnknown *unk)
1317 {
1318     IOleCommandTarget *cmdtrg;
1319     int i;
1320     HRESULT hres;
1321
1322     OLECMD cmd[2] = {
1323         {OLECMDID_OPEN, 0xf0f0},
1324         {OLECMDID_GETPRINTTEMPLATE+1, 0xf0f0}
1325     };
1326
1327     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
1328     ok(hres == S_OK, "QueryInterface(IIDIOleM=CommandTarget failed: %08lx\n", hres);
1329     if(FAILED(hres))
1330         return;
1331
1332     hres = IOleCommandTarget_QueryStatus(cmdtrg, NULL, 0, NULL, NULL);
1333     ok(hres == S_OK, "QueryStatus failed: %08lx\n", hres);
1334
1335     SET_EXPECT(QueryStatus_OPEN);
1336     hres = IOleCommandTarget_QueryStatus(cmdtrg, NULL, 2, cmd, NULL);
1337     CHECK_CALLED(QueryStatus_OPEN);
1338
1339     ok(hres == OLECMDERR_E_NOTSUPPORTED,
1340             "QueryStatus failed: %08lx, expected OLECMDERR_E_NOTSUPPORTED\n", hres);
1341     ok(cmd[1].cmdID == OLECMDID_GETPRINTTEMPLATE+1,
1342             "cmd[0].cmdID=%ld, expected OLECMDID_GETPRINTTEMPLATE+1\n", cmd[0].cmdID);
1343     ok(cmd[1].cmdf == 0, "cmd[0].cmdf=%lx, expected 0\n", cmd[0].cmdf);
1344     ok(cmd[0].cmdf == OLECMDF_SUPPORTED,
1345             "cmd[1].cmdf=%lx, expected OLECMDF_SUPPORTED\n", cmd[1].cmdf);
1346
1347     hres = IOleCommandTarget_QueryStatus(cmdtrg, &IID_IHTMLDocument2, 2, cmd, NULL);
1348     ok(hres == OLECMDERR_E_UNKNOWNGROUP,
1349             "QueryStatus failed: %08lx, expected OLECMDERR_E_UNKNOWNGROUP\n", hres);
1350
1351     for(i=0; i<OLECMDID_GETPRINTTEMPLATE; i++) {
1352         if(!expect_cmds[i]) {
1353             hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_UPDATECOMMANDS,
1354                     OLECMDEXECOPT_DODEFAULT, NULL, NULL);
1355             ok(hres == OLECMDERR_E_NOTSUPPORTED,
1356                     "Exec failed: %08lx, expected OLECMDERR_E_NOTSUPPORTED\n", hres);
1357         }
1358     }
1359
1360     hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_GETPRINTTEMPLATE+1,
1361             OLECMDEXECOPT_DODEFAULT, NULL, NULL);
1362     ok(hres == OLECMDERR_E_NOTSUPPORTED,
1363             "Exec failed: %08lx, expected OLECMDERR_E_NOTSUPPORTED\n", hres);
1364
1365     IOleCommandTarget_Release(cmdtrg);
1366 }
1367
1368 static HWND create_container_window(void)
1369 {
1370     static const WCHAR wszHTMLDocumentTest[] =
1371         {'H','T','M','L','D','o','c','u','m','e','n','t','T','e','s','t',0};
1372     static WNDCLASSEXW wndclass = {
1373         sizeof(WNDCLASSEXW),
1374         0,
1375         wnd_proc,
1376         0, 0, NULL, NULL, NULL, NULL, NULL,
1377         wszHTMLDocumentTest,
1378         NULL
1379     };
1380
1381     RegisterClassExW(&wndclass);
1382     return CreateWindowW(wszHTMLDocumentTest, wszHTMLDocumentTest,
1383             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
1384             CW_USEDEFAULT, NULL, NULL, NULL, NULL);
1385 }
1386
1387 static HRESULT test_DoVerb(IOleObject *oleobj)
1388 {
1389     RECT rect = {0,0,500,500};
1390     HRESULT hres;
1391
1392     if(!container_locked) {
1393         SET_EXPECT(GetContainer);
1394         SET_EXPECT(LockContainer);
1395     }
1396     SET_EXPECT(ActivateMe);
1397     expect_LockContainer_fLock = TRUE;
1398
1399     hres = IOleObject_DoVerb(oleobj, OLEIVERB_SHOW, NULL, &ClientSite, -1, container_hwnd, &rect);
1400     if(FAILED(hres))
1401         return hres;
1402     ok(hres == S_OK, "DoVerb failed: %08lx\n", hres);
1403
1404     if(!container_locked) {
1405         CHECK_CALLED(GetContainer);
1406         CHECK_CALLED(LockContainer);
1407         container_locked = TRUE;
1408     }
1409     CHECK_CALLED(ActivateMe);
1410
1411     return hres;
1412 }
1413
1414 #define CLIENTSITE_EXPECTPATH 0x00000001
1415 #define CLIENTSITE_SETNULL    0x00000002
1416 #define CLIENTSITE_DONTSET    0x00000004
1417
1418 static void test_ClientSite(IOleObject *oleobj, DWORD flags)
1419 {
1420     IOleClientSite *clientsite;
1421     HRESULT hres;
1422
1423     if(flags & CLIENTSITE_SETNULL) {
1424         hres = IOleObject_GetClientSite(oleobj, &clientsite);
1425         ok(clientsite == &ClientSite, "clientsite=%p, expected %p\n", clientsite, &ClientSite);
1426
1427         hres = IOleObject_SetClientSite(oleobj, NULL);
1428         ok(hres == S_OK, "SetClientSite failed: %08lx\n", hres);
1429
1430         set_clientsite = FALSE;
1431     }
1432
1433     if(flags & CLIENTSITE_DONTSET)
1434         return;
1435
1436     hres = IOleObject_GetClientSite(oleobj, &clientsite);
1437     ok(hres == S_OK, "GetClientSite failed: %08lx\n", hres);
1438     ok(clientsite == (set_clientsite ? &ClientSite : NULL), "GetClientSite() = %p, expected %p\n",
1439             clientsite, set_clientsite ? &ClientSite : NULL);
1440
1441     if(!set_clientsite) {
1442         SET_EXPECT(GetHostInfo);
1443         if(flags & CLIENTSITE_EXPECTPATH) {
1444             SET_EXPECT(GetOptionKeyPath);
1445             SET_EXPECT(GetOverrideKeyPath);
1446         }
1447         SET_EXPECT(GetWindow);
1448         SET_EXPECT(QueryStatus_SETPROGRESSTEXT);
1449         SET_EXPECT(Exec_SETPROGRESSMAX);
1450         SET_EXPECT(Exec_SETPROGRESSPOS);
1451         SET_EXPECT(Invoke_AMBIENT_USERMODE);
1452         SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1453         SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1454         SET_EXPECT(Invoke_AMBIENT_SILENT);
1455         SET_EXPECT(Invoke_AMBIENT_USERAGENT);
1456         SET_EXPECT(Invoke_AMBIENT_PALETTE);
1457
1458         hres = IOleObject_SetClientSite(oleobj, &ClientSite);
1459         ok(hres == S_OK, "SetClientSite failed: %08lx\n", hres);
1460
1461         CHECK_CALLED(GetHostInfo);
1462         if(flags & CLIENTSITE_EXPECTPATH) {
1463             CHECK_CALLED(GetOptionKeyPath);
1464             CHECK_CALLED(GetOverrideKeyPath);
1465         }
1466         CHECK_CALLED(GetWindow);
1467         CHECK_CALLED(QueryStatus_SETPROGRESSTEXT);
1468         CHECK_CALLED(Exec_SETPROGRESSMAX);
1469         CHECK_CALLED(Exec_SETPROGRESSPOS);
1470         CHECK_CALLED(Invoke_AMBIENT_USERMODE);
1471         CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1472         CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1473         CHECK_CALLED(Invoke_AMBIENT_SILENT);
1474         CHECK_CALLED(Invoke_AMBIENT_USERAGENT);
1475         CHECK_CALLED(Invoke_AMBIENT_PALETTE);
1476
1477         set_clientsite = TRUE;
1478     }
1479
1480     hres = IOleObject_SetClientSite(oleobj, &ClientSite);
1481     ok(hres == S_OK, "SetClientSite failed: %08lx\n", hres);
1482
1483     hres = IOleObject_GetClientSite(oleobj, &clientsite);
1484     ok(hres == S_OK, "GetClientSite failed: %08lx\n", hres);
1485     ok(clientsite == &ClientSite, "GetClientSite() = %p, expected %p\n", clientsite, &ClientSite);
1486 }
1487
1488 static void test_OnAmbientPropertyChange(IUnknown *unk)
1489 {
1490     IOleControl *control = NULL;
1491     HRESULT hres;
1492
1493     hres = IUnknown_QueryInterface(unk, &IID_IOleControl, (void**)&control);
1494     ok(hres == S_OK, "QueryInterface(IID_IOleControl failed: %08lx\n", hres);
1495     if(FAILED(hres))
1496         return;
1497
1498     SET_EXPECT(Invoke_AMBIENT_USERMODE);
1499     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_USERMODE);
1500     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1501     CHECK_CALLED(Invoke_AMBIENT_USERMODE);
1502
1503     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1504     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_DLCONTROL);
1505     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1506     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1507
1508     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1509     SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1510     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_OFFLINEIFNOTCONNECTED);
1511     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1512     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1513     CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1514
1515     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1516     SET_EXPECT(Invoke_AMBIENT_SILENT);
1517     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_SILENT);
1518     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1519     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1520     CHECK_CALLED(Invoke_AMBIENT_SILENT);
1521
1522     SET_EXPECT(Invoke_AMBIENT_USERAGENT);
1523     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_USERAGENT);
1524     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1525     CHECK_CALLED(Invoke_AMBIENT_USERAGENT);
1526
1527     SET_EXPECT(Invoke_AMBIENT_PALETTE);
1528     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_PALETTE);
1529     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1530     CHECK_CALLED(Invoke_AMBIENT_PALETTE);
1531
1532     IOleControl_Release(control);
1533 }
1534
1535
1536
1537 static void test_OnAmbientPropertyChange2(IUnknown *unk)
1538 {
1539     IOleControl *control = NULL;
1540     HRESULT hres;
1541
1542     hres = IUnknown_QueryInterface(unk, &IID_IOleControl, (void**)&control);
1543     ok(hres == S_OK, "QueryInterface(IID_IOleControl failed: %08lx\n", hres);
1544     if(FAILED(hres))
1545         return;
1546
1547     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_PALETTE);
1548     ok(hres == S_OK, "OnAmbientPropertyChange failed: %08lx\n", hres);
1549
1550     IOleControl_Release(control);
1551 }
1552
1553 static void test_Close(IUnknown *unk, BOOL set_client)
1554 {
1555     IOleObject *oleobj = NULL;
1556     HRESULT hres;
1557
1558     hres = IUnknown_QueryInterface(unk, &IID_IOleObject, (void**)&oleobj);
1559     ok(hres == S_OK, "QueryInterface(IID_IOleObject) failed: %08lx\n", hres);
1560     if(FAILED(hres))
1561         return;
1562
1563     SET_EXPECT(GetContainer);
1564     SET_EXPECT(LockContainer);
1565     expect_LockContainer_fLock = FALSE;
1566     hres = IOleObject_Close(oleobj, OLECLOSE_NOSAVE);
1567     ok(hres == S_OK, "Close failed: %08lx\n", hres);
1568     CHECK_CALLED(GetContainer);
1569     CHECK_CALLED(LockContainer);
1570     container_locked = FALSE;
1571
1572     if(set_client)
1573         test_ClientSite(oleobj, CLIENTSITE_SETNULL|CLIENTSITE_DONTSET);
1574
1575     IOleObject_Release(oleobj);
1576 }
1577
1578 static void test_InPlaceDeactivate(IUnknown *unk, BOOL expect_call)
1579 {
1580     IOleInPlaceObjectWindowless *windowlessobj = NULL;
1581     HRESULT hres;
1582
1583     hres = IUnknown_QueryInterface(unk, &IID_IOleInPlaceObjectWindowless,
1584             (void**)&windowlessobj);
1585     ok(hres == S_OK, "QueryInterface(IID_IOleInPlaceObjectWindowless) failed: %08lx\n", hres);
1586     if(FAILED(hres))
1587         return;
1588
1589     if(expect_call) SET_EXPECT(OnInPlaceDeactivate);
1590     hres = IOleInPlaceObjectWindowless_InPlaceDeactivate(windowlessobj);
1591     ok(hres == S_OK, "InPlaceDeactivate failed: %08lx\n", hres);
1592     if(expect_call) CHECK_CALLED(OnInPlaceDeactivate);
1593
1594     IOleInPlaceObjectWindowless_Release(windowlessobj);
1595 }
1596
1597 static HRESULT test_Activate(IUnknown *unk, DWORD flags)
1598 {
1599     IOleObject *oleobj = NULL;
1600     GUID guid;
1601     HRESULT hres;
1602
1603     last_hwnd = hwnd;
1604
1605     if(view)
1606         IOleDocumentView_Release(view);
1607     view = NULL;
1608
1609     hres = IUnknown_QueryInterface(unk, &IID_IOleObject, (void**)&oleobj);
1610     ok(hres == S_OK, "QueryInterface(IID_IOleObject) failed: %08lx\n", hres);
1611     if(FAILED(hres))
1612         return hres;
1613
1614     hres = IOleObject_GetUserClassID(oleobj, NULL);
1615     ok(hres == E_INVALIDARG, "GetUserClassID returned: %08lx, expected E_INVALIDARG\n", hres);
1616
1617     hres = IOleObject_GetUserClassID(oleobj, &guid);
1618     ok(hres == S_OK, "GetUserClassID failed: %08lx\n", hres);
1619     ok(IsEqualGUID(&guid, &CLSID_HTMLDocument), "guid != CLSID_HTMLDocument\n");
1620
1621     test_ClientSite(oleobj, flags);
1622     test_InPlaceDeactivate(unk, FALSE);
1623
1624     hres = test_DoVerb(oleobj);
1625
1626     IOleObject_Release(oleobj);
1627     return hres;
1628 }
1629
1630 static void test_Window(IUnknown *unk, BOOL expect_success)
1631 {
1632     IOleInPlaceActiveObject *activeobject = NULL;
1633     HWND tmp_hwnd;
1634     HRESULT hres;
1635
1636     hres = IOleDocumentView_QueryInterface(view, &IID_IOleInPlaceActiveObject, (void**)&activeobject);
1637     ok(hres == S_OK, "Could not get IOleInPlaceActiveObject interface: %08lx\n", hres);
1638     if(FAILED(hres))
1639         return;
1640
1641     hres = IOleInPlaceActiveObject_GetWindow(activeobject, &tmp_hwnd);
1642
1643     if(expect_success) {
1644         ok(hres == S_OK, "GetWindow failed: %08lx\n", hres);
1645         ok(tmp_hwnd == hwnd, "tmp_hwnd=%p, expected %p\n", tmp_hwnd, hwnd);
1646     }else {
1647         ok(hres == E_FAIL, "GetWindow returned %08lx, expected E_FAIL\n", hres);
1648         ok(IsWindow(hwnd), "hwnd is destroyed\n");
1649     }
1650
1651     IOleInPlaceActiveObject_Release(activeobject);
1652 }
1653
1654 static void test_CloseView(void)
1655 {
1656     IOleInPlaceSite *inplacesite = (IOleInPlaceSite*)0xff00ff00;
1657     HRESULT hres;
1658
1659     if(!view)
1660         return;
1661
1662     hres = IOleDocumentView_Show(view, FALSE);
1663     ok(hres == S_OK, "Show failed: %08lx\n", hres);
1664
1665     hres = IOleDocumentView_CloseView(view, 0);
1666     ok(hres == S_OK, "CloseView failed: %08lx\n", hres);
1667
1668     hres = IOleDocumentView_SetInPlaceSite(view, NULL);
1669     ok(hres == S_OK, "SetInPlaceSite failed: %08lx\n", hres);
1670
1671     hres = IOleDocumentView_GetInPlaceSite(view, &inplacesite);
1672     ok(hres == S_OK, "SetInPlaceSite failed: %08lx\n", hres);
1673     ok(inplacesite == NULL, "inplacesite=%p, expected NULL\n", inplacesite);
1674 }
1675
1676 static void test_UIDeactivate(void)
1677 {
1678     HRESULT hres;
1679
1680     if(call_UIActivate) {
1681         SET_EXPECT(SetActiveObject);
1682         SET_EXPECT(HideUI);
1683         SET_EXPECT(OnUIDeactivate);
1684     }
1685
1686     expect_SetActiveObject_active = FALSE;
1687     hres = IOleDocumentView_UIActivate(view, FALSE);
1688     ok(hres == S_OK, "UIActivate failed: %08lx\n", hres);
1689
1690     if(call_UIActivate) {
1691         CHECK_CALLED(SetActiveObject);
1692         CHECK_CALLED(HideUI);
1693         CHECK_CALLED(OnUIDeactivate);
1694     }
1695 }
1696
1697 static void test_Hide(void)
1698 {
1699     HRESULT hres;
1700
1701     if(!view)
1702         return;
1703
1704     hres = IOleDocumentView_Show(view, FALSE);
1705     ok(hres == S_OK, "Show failed: %08lx\n", hres);
1706 }
1707
1708 static HRESULT create_document(IUnknown **unk)
1709 {
1710     HRESULT hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
1711             &IID_IUnknown, (void**)unk);
1712     ok(hres == S_OK, "CoCreateInstance failed: %08lx\n", hres);
1713     return hres;
1714 }
1715
1716 static void test_Navigate(IUnknown *unk)
1717 {
1718     IHlinkTarget *hlink;
1719     HRESULT hres;
1720
1721     hres = IUnknown_QueryInterface(unk, &IID_IHlinkTarget, (void**)&hlink);
1722     ok(hres == S_OK, "QueryInterface(IID_IHlinkTarget) failed: %08lx\n", hres);
1723
1724     SET_EXPECT(ActivateMe);
1725     hres = IHlinkTarget_Navigate(hlink, 0, NULL);
1726     ok(hres == S_OK, "Navigate failed: %08lx\n", hres);
1727     CHECK_CALLED(ActivateMe);
1728
1729     IHlinkTarget_Release(hlink);
1730 }
1731
1732 static void test_HTMLDocument(void)
1733 {
1734     IUnknown *unk;
1735     HRESULT hres;
1736     ULONG ref;
1737
1738     hwnd = last_hwnd = NULL;
1739
1740     hres = create_document(&unk);
1741     if(FAILED(hres))
1742         return;
1743
1744     test_Persist(unk);
1745     if(load_state == LD_NO)
1746         test_OnAmbientPropertyChange2(unk);
1747
1748     hres = test_Activate(unk, CLIENTSITE_EXPECTPATH);
1749     if(FAILED(hres)) {
1750         IUnknown_Release(unk);
1751         return;
1752     }
1753
1754 #ifdef DOWNLOAD_TEST
1755     if(load_state == LD_DOLOAD)
1756         test_download();
1757 #endif
1758
1759     test_OleCommandTarget_fail(unk);
1760     test_OleCommandTarget(unk);
1761     test_OnAmbientPropertyChange(unk);
1762     test_Window(unk, TRUE);
1763     test_UIDeactivate();
1764     test_OleCommandTarget(unk);
1765     test_Window(unk, TRUE);
1766     test_InPlaceDeactivate(unk, TRUE);
1767
1768     /* Calling test_OleCommandTarget here couses Segmentation Fault with native
1769      * MSHTML. It doesn't with Wine. */
1770
1771     test_Window(unk, FALSE);
1772     test_Hide();
1773     test_InPlaceDeactivate(unk, FALSE);
1774     test_CloseView();
1775     test_Close(unk, FALSE);
1776
1777     /* Activate HTMLDocument again */
1778     test_Activate(unk, CLIENTSITE_SETNULL);
1779     test_Window(unk, TRUE);
1780     test_OleCommandTarget(unk);
1781     test_UIDeactivate();
1782     test_InPlaceDeactivate(unk, TRUE);
1783     test_Close(unk, FALSE);
1784
1785     /* Activate HTMLDocument again, this time without UIActivate */
1786     call_UIActivate = FALSE;
1787     test_Activate(unk, CLIENTSITE_SETNULL);
1788     test_Window(unk, TRUE);
1789     test_UIDeactivate();
1790     test_InPlaceDeactivate(unk, TRUE);
1791     test_CloseView();
1792     test_CloseView();
1793     test_Close(unk, TRUE);
1794     test_OnAmbientPropertyChange2(unk);
1795
1796     if(view)
1797         IOleDocumentView_Release(view);
1798     view = NULL;
1799
1800     ok(IsWindow(hwnd), "hwnd is destroyed\n");
1801
1802     ref = IUnknown_Release(unk);
1803     ok(ref == 0, "ref=%ld, expected 0\n", ref);
1804
1805     ok(!IsWindow(hwnd), "hwnd is not destroyed\n");
1806
1807 }
1808
1809 static void test_HTMLDocument_hlink(void)
1810 {
1811     IUnknown *unk;
1812     HRESULT hres;
1813     ULONG ref;
1814
1815     hwnd = last_hwnd = NULL;
1816
1817     hres = create_document(&unk);
1818     if(FAILED(hres))
1819         return;
1820
1821     test_Persist(unk);
1822     test_Navigate(unk);
1823
1824 #ifdef DOWNLOAD_TEST
1825     test_download();
1826 #endif
1827
1828     test_Window(unk, TRUE);
1829     test_InPlaceDeactivate(unk, TRUE);
1830     test_Close(unk, FALSE);
1831
1832     if(view)
1833         IOleDocumentView_Release(view);
1834     view = NULL;
1835
1836     ref = IUnknown_Release(unk);
1837     ok(ref == 0, "ref=%ld, expected 0\n", ref);
1838
1839 }
1840
1841 START_TEST(htmldoc)
1842 {
1843     CoInitialize(NULL);
1844     container_hwnd = create_container_window();
1845
1846     load_state = LD_NO;
1847     test_HTMLDocument();
1848     load_state = LD_DOLOAD;
1849     test_HTMLDocument();
1850     load_state = LD_DOLOAD;
1851     test_HTMLDocument_hlink();
1852
1853     DestroyWindow(container_hwnd);
1854     CoUninitialize();
1855 }