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     CHECK_EXPECT2(SetActiveObject);
 214
 215     if(expect_SetActiveObject_active) {
 216         ok(pActiveObject != NULL, "pActiveObject = NULL\n");
 217         if(pActiveObject && PRIMARYLANGID(GetSystemDefaultLangID()) == LANG_ENGLISH)
 218             ok(!lstrcmpW(wszHTML_Document, pszObjName), "pszObjName != \"HTML Document\"\n");
 219     }else {
 220         ok(pActiveObject == NULL, "pActiveObject=%p, expected NULL\n", pActiveObject);
 221         ok(pszObjName == NULL, "pszObjName=%p, expected NULL\n", pszObjName);
 222     }
 223
 224     return S_OK;
 225 }
 226
 227 static HRESULT WINAPI InPlaceFrame_InsertMenus(IOleInPlaceFrame *iface, HMENU hmenuShared,
 228         LPOLEMENUGROUPWIDTHS lpMenuWidths)
 229 {
 230     ok(0, "unexpected call\n");
 231     return E_NOTIMPL;
 232 }
 233
 234 static HRESULT WINAPI InPlaceFrame_SetMenu(IOleInPlaceFrame *iface, HMENU hmenuShared,
 235         HOLEMENU holemenu, HWND hwndActiveObject)
 236 {
 237     ok(0, "unexpected call\n");
 238     return E_NOTIMPL;
 239 }
 240
 241 static HRESULT WINAPI InPlaceFrame_RemoveMenus(IOleInPlaceFrame *iface, HMENU hmenuShared)
 242 {
 243     ok(0, "unexpected call\n");
 244     return E_NOTIMPL;
 245 }
 246
 247 static HRESULT WINAPI InPlaceFrame_SetStatusText(IOleInPlaceFrame *iface, LPCOLESTR pszStatusText)
 248 {
 249     CHECK_EXPECT2(SetStatusText);
 250     if(!expect_status_text)
 251         ok(pszStatusText == NULL, "pszStatusText=%p, expected NULL\n", pszStatusText);
 252     return S_OK;
 253 }
 254
 255 static HRESULT WINAPI InPlaceFrame_EnableModeless(IOleInPlaceFrame *iface, BOOL fEnable)
 256 {
 257     ok(0, "unexpected call\n");
 258     return E_NOTIMPL;
 259 }
 260
 261 static HRESULT WINAPI InPlaceFrame_TranslateAccelerator(IOleInPlaceFrame *iface, LPMSG lpmsg, WORD wID)
 262 {
 263     ok(0, "unexpected call\n");
 264     return E_NOTIMPL;
 265 }
 266
 267 static const IOleInPlaceFrameVtbl InPlaceFrameVtbl = {
 268     InPlaceFrame_QueryInterface,
 269     InPlaceFrame_AddRef,
 270     InPlaceFrame_Release,
 271     InPlaceFrame_GetWindow,
 272     InPlaceFrame_ContextSensitiveHelp,
 273     InPlaceFrame_GetBorder,
 274     InPlaceFrame_RequestBorderSpace,
 275     InPlaceFrame_SetBorderSpace,
 276     InPlaceFrame_SetActiveObject,
 277     InPlaceFrame_InsertMenus,
 278     InPlaceFrame_SetMenu,
 279     InPlaceFrame_RemoveMenus,
 280     InPlaceFrame_SetStatusText,
 281     InPlaceFrame_EnableModeless,
 282     InPlaceFrame_TranslateAccelerator
 283 };
 284
 285 static IOleInPlaceFrame InPlaceFrame = { &InPlaceFrameVtbl };
 286
 287 static HRESULT WINAPI InPlaceSite_QueryInterface(IOleInPlaceSite *iface, REFIID riid, void **ppv)
 288 {
 289     return QueryInterface(riid, ppv);
 290 }
 291
 292 static ULONG WINAPI InPlaceSite_AddRef(IOleInPlaceSite *iface)
 293 {
 294     return 2;
 295 }
 296
 297 static ULONG WINAPI InPlaceSite_Release(IOleInPlaceSite *iface)
 298 {
 299     return 1;
 300 }
 301
 302 static HRESULT WINAPI InPlaceSite_GetWindow(IOleInPlaceSite *iface, HWND *phwnd)
 303 {
 304     CHECK_EXPECT(GetWindow);
 305     ok(phwnd != NULL, "phwnd = NULL\n");
 306     *phwnd = container_hwnd;
 307     return S_OK;
 308 }
 309
 310 static HRESULT WINAPI InPlaceSite_ContextSensitiveHelp(IOleInPlaceSite *iface, BOOL fEnterMode)
 311 {
 312     ok(0, "unexpected call\n");
 313     return E_NOTIMPL;
 314 }
 315
 316 static HRESULT WINAPI InPlaceSite_CanInPlaceActivate(IOleInPlaceSite *iface)
 317 {
 318     CHECK_EXPECT(CanInPlaceActivate);
 319     return S_OK;
 320 }
 321
 322 static HRESULT WINAPI InPlaceSite_OnInPlaceActivate(IOleInPlaceSite *iface)
 323 {
 324     CHECK_EXPECT(OnInPlaceActivate);
 325     return S_OK;
 326 }
 327
 328 static HRESULT WINAPI InPlaceSite_OnUIActivate(IOleInPlaceSite *iface)
 329 {
 330     CHECK_EXPECT(OnUIActivate);
 331     return S_OK;
 332 }
 333
 334 static HRESULT WINAPI InPlaceSite_GetWindowContext(IOleInPlaceSite *iface,
 335         IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect,
 336         LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
 337 {
 338     static const RECT rect = {0,0,500,500};
 339
 340     CHECK_EXPECT(GetWindowContext);
 341
 342     ok(ppFrame != NULL, "ppFrame = NULL\n");
 343     if(ppFrame)
 344         *ppFrame = &InPlaceFrame;
 345     ok(ppDoc != NULL, "ppDoc = NULL\n");
 346     if(ppDoc)
 347         *ppDoc = NULL;
 348     ok(lprcPosRect != NULL, "lprcPosRect = NULL\n");
 349     if(lprcPosRect)
 350         memcpy(lprcPosRect, &rect, sizeof(RECT));
 351     ok(lprcClipRect != NULL, "lprcClipRect = NULL\n");
 352     if(lprcClipRect)
 353         memcpy(lprcClipRect, &rect, sizeof(RECT));
 354     ok(lpFrameInfo != NULL, "lpFrameInfo = NULL\n");
 355     if(lpFrameInfo) {
 356         lpFrameInfo->cb = sizeof(*lpFrameInfo);
 357         lpFrameInfo->fMDIApp = FALSE;
 358         lpFrameInfo->hwndFrame = container_hwnd;
 359         lpFrameInfo->haccel = NULL;
 360         lpFrameInfo->cAccelEntries = 0;
 361     }
 362
 363     return S_OK;
 364 }
 365
 366 static HRESULT WINAPI InPlaceSite_Scroll(IOleInPlaceSite *iface, SIZE scrollExtant)
 367 {
 368     ok(0, "unexpected call\n");
 369     return E_NOTIMPL;
 370 }
 371
 372 static HRESULT WINAPI InPlaceSite_OnUIDeactivate(IOleInPlaceSite *iface, BOOL fUndoable)
 373 {
 374     CHECK_EXPECT(OnUIDeactivate);
 375     ok(!fUndoable, "fUndoable = TRUE\n");
 376     return S_OK;
 377 }
 378
 379 static HRESULT WINAPI InPlaceSite_OnInPlaceDeactivate(IOleInPlaceSite *iface)
 380 {
 381     CHECK_EXPECT(OnInPlaceDeactivate);
 382     return S_OK;
 383 }
 384
 385 static HRESULT WINAPI InPlaceSite_DiscardUndoState(IOleInPlaceSite *iface)
 386 {
 387     ok(0, "unexpected call\n");
 388     return E_NOTIMPL;
 389 }
 390
 391 static HRESULT WINAPI InPlaceSite_DeactivateAndUndo(IOleInPlaceSite *iface)
 392 {
 393     ok(0, "unexpected call\n");
 394     return E_NOTIMPL;
 395 }
 396
 397 static HRESULT WINAPI InPlaceSite_OnPosRectChange(IOleInPlaceSite *iface, LPCRECT lprcPosRect)
 398 {
 399     ok(0, "unexpected call\n");
 400     return E_NOTIMPL;
 401 }
 402
 403 static const IOleInPlaceSiteVtbl InPlaceSiteVtbl = {
 404     InPlaceSite_QueryInterface,
 405     InPlaceSite_AddRef,
 406     InPlaceSite_Release,
 407     InPlaceSite_GetWindow,
 408     InPlaceSite_ContextSensitiveHelp,
 409     InPlaceSite_CanInPlaceActivate,
 410     InPlaceSite_OnInPlaceActivate,
 411     InPlaceSite_OnUIActivate,
 412     InPlaceSite_GetWindowContext,
 413     InPlaceSite_Scroll,
 414     InPlaceSite_OnUIDeactivate,
 415     InPlaceSite_OnInPlaceDeactivate,
 416     InPlaceSite_DiscardUndoState,
 417     InPlaceSite_DeactivateAndUndo,
 418     InPlaceSite_OnPosRectChange
 419 };
 420
 421 static IOleInPlaceSite InPlaceSite = { &InPlaceSiteVtbl };
 422
 423 static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
 424 {
 425     return QueryInterface(riid, ppv);
 426 }
 427
 428 static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
 429 {
 430     return 2;
 431 }
 432
 433 static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
 434 {
 435     return 1;
 436 }
 437
 438 static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
 439 {
 440     ok(0, "unexpected call\n");
 441     return E_NOTIMPL;
 442 }
 443
 444 static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAsign, DWORD dwWhichMoniker,
 445         IMoniker **ppmon)
 446 {
 447     ok(0, "unexpected call\n");
 448     return E_NOTIMPL;
 449 }
 450
 451 static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
 452 {
 453     CHECK_EXPECT(GetContainer);
 454     ok(ppContainer != NULL, "ppContainer = NULL\n");
 455     *ppContainer = &OleContainer;
 456     return S_OK;
 457 }
 458
 459 static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
 460 {
 461     ok(0, "unexpected call\n");
 462     return E_NOTIMPL;
 463 }
 464
 465 static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
 466 {
 467     ok(0, "unexpected call\n");
 468     return E_NOTIMPL;
 469 }
 470
 471 static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
 472 {
 473     ok(0, "unexpected call\n");
 474     return E_NOTIMPL;
 475 }
 476
 477 static const IOleClientSiteVtbl ClientSiteVtbl = {
 478     ClientSite_QueryInterface,
 479     ClientSite_AddRef,
 480     ClientSite_Release,
 481     ClientSite_SaveObject,
 482     ClientSite_GetMoniker,
 483     ClientSite_GetContainer,
 484     ClientSite_ShowObject,
 485     ClientSite_OnShowWindow,
 486     ClientSite_RequestNewObjectLayout
 487 };
 488
 489 static IOleClientSite ClientSite = { &ClientSiteVtbl };
 490
 491 static HRESULT WINAPI DocumentSite_QueryInterface(IOleDocumentSite *iface, REFIID riid, void **ppv)
 492 {
 493     return QueryInterface(riid, ppv);
 494 }
 495
 496 static ULONG WINAPI DocumentSite_AddRef(IOleDocumentSite *iface)
 497 {
 498     return 2;
 499 }
 500
 501 static ULONG WINAPI DocumentSite_Release(IOleDocumentSite *iface)
 502 {
 503     return 1;
 504 }
 505
 506 static BOOL call_UIActivate = TRUE;
 507 static HRESULT WINAPI DocumentSite_ActivateMe(IOleDocumentSite *iface, IOleDocumentView *pViewToActivate)
 508 {
 509     IOleDocument *document;
 510     HRESULT hres;
 511
 512     CHECK_EXPECT(ActivateMe);
 513     ok(pViewToActivate != NULL, "pViewToActivate = NULL\n");
 514
 515     hres = IOleDocumentView_QueryInterface(pViewToActivate, &IID_IOleDocument, (void**)&document);
 516     ok(hres == S_OK, "could not get IOleDocument: %08lx\n", hres);
 517
 518     if(SUCCEEDED(hres)) {
 519         hres = IOleDocument_CreateView(document, &InPlaceSite, NULL, 0, &view);
 520         ok(hres == S_OK, "CreateView failed: %08lx\n", hres);
 521
 522         if(SUCCEEDED(hres)) {
 523             IOleInPlaceActiveObject *activeobj = NULL;
 524             IOleInPlaceSite *inplacesite = NULL;
 525             HWND tmp_hwnd = NULL;
 526             static RECT rect = {0,0,400,500};
 527
 528             hres = IOleDocumentView_GetInPlaceSite(view, &inplacesite);
 529             ok(hres == S_OK, "GetInPlaceSite failed: %08lx\n", hres);
 530             ok(inplacesite == &InPlaceSite, "inplacesite=%p, expected %p\n",
 531                     inplacesite, &InPlaceSite);
 532
 533             hres = IOleDocumentView_SetInPlaceSite(view, &InPlaceSite);
 534             ok(hres == S_OK, "SetInPlaceSite failed: %08lx\n", hres);
 535
 536             hres = IOleDocumentView_GetInPlaceSite(view, &inplacesite);
 537             ok(hres == S_OK, "GetInPlaceSite failed: %08lx\n", hres);
 538             ok(inplacesite == &InPlaceSite, "inplacesite=%p, expected %p\n",
 539                     inplacesite, &InPlaceSite);
 540
 541             hres = IOleDocumentView_QueryInterface(view, &IID_IOleInPlaceActiveObject, (void**)&activeobj);
 542             ok(hres == S_OK, "Could not get IOleInPlaceActiveObject: %08lx\n", hres);
 543
 544             if(activeobj) {
 545                 IOleInPlaceActiveObject_GetWindow(activeobj, &hwnd);
 546                 ok(hres == S_OK, "GetWindow failed: %08lx\n", hres);
 547                 ok(hwnd == NULL, "hwnd=%p, expeted NULL\n", hwnd);
 548             }
 549
 550             if(call_UIActivate) {
 551                 SET_EXPECT(CanInPlaceActivate);
 552                 SET_EXPECT(GetWindowContext);
 553                 SET_EXPECT(GetWindow);
 554                 SET_EXPECT(OnInPlaceActivate);
 555                 SET_EXPECT(SetStatusText);
 556                 SET_EXPECT(Exec_SETPROGRESSMAX);
 557                 SET_EXPECT(Exec_SETPROGRESSPOS);
 558                 SET_EXPECT(OnUIActivate);
 559                 SET_EXPECT(SetActiveObject);
 560                 SET_EXPECT(ShowUI);
 561                 expect_SetActiveObject_active = TRUE;
 562                 expect_status_text = NULL;
 563
 564                 hres = IOleDocumentView_UIActivate(view, TRUE);
 565
 566                 if(FAILED(hres)) {
 567                     trace("UIActivate failed: %08lx\n", hres);
 568                     return hres;
 569                 }
 570                 ok(hres == S_OK, "UIActivate failed: %08lx\n", hres);
 571
 572                 CHECK_CALLED(CanInPlaceActivate);
 573                 CHECK_CALLED(GetWindowContext);
 574                 CHECK_CALLED(GetWindow);
 575                 CHECK_CALLED(OnInPlaceActivate);
 576                 CHECK_CALLED(SetStatusText);
 577                 CHECK_CALLED(Exec_SETPROGRESSMAX);
 578                 CHECK_CALLED(Exec_SETPROGRESSPOS);
 579                 CHECK_CALLED(OnUIActivate);
 580                 CHECK_CALLED(SetActiveObject);
 581                 CHECK_CALLED(ShowUI);
 582
 583                 if(activeobj) {
 584                     hres = IOleInPlaceActiveObject_GetWindow(activeobj, &hwnd);
 585                     ok(hres == S_OK, "GetWindow failed: %08lx\n", hres);
 586                     ok(hwnd != NULL, "hwnd == NULL\n");
 587                     if(last_hwnd)
 588                         ok(hwnd == last_hwnd, "hwnd != last_hwnd\n");
 589                 }
 590
 591                 hres = IOleDocumentView_UIActivate(view, TRUE);
 592                 ok(hres == S_OK, "UIActivate failed: %08lx\n", hres);
 593
 594                 if(activeobj) {
 595                     hres = IOleInPlaceActiveObject_GetWindow(activeobj, &tmp_hwnd);
 596                     ok(hres == S_OK, "GetWindow failed: %08lx\n", hres);
 597                     ok(tmp_hwnd == hwnd, "tmp_hwnd=%p, expected %p\n", tmp_hwnd, hwnd);
 598                 }
 599             }
 600
 601             hres = IOleDocumentView_SetRect(view, &rect);
 602             ok(hres == S_OK, "SetRect failed: %08lx\n", hres);
 603
 604             if(call_UIActivate) {
 605                 hres = IOleDocumentView_Show(view, TRUE);
 606                 ok(hres == S_OK, "Show failed: %08lx\n", hres);
 607             }else {
 608                 SET_EXPECT(CanInPlaceActivate);
 609                 SET_EXPECT(GetWindowContext);
 610                 SET_EXPECT(GetWindow);
 611                 SET_EXPECT(OnInPlaceActivate);
 612                 SET_EXPECT(SetStatusText);
 613                 SET_EXPECT(Exec_SETPROGRESSMAX);
 614                 SET_EXPECT(Exec_SETPROGRESSPOS);
 615                 SET_EXPECT(OnUIActivate);
 616                 expect_status_text = (load_state == LD_LOADED ? (LPCOLESTR)0xdeadbeef : NULL);
 617
 618                 hres = IOleDocumentView_Show(view, TRUE);
 619                 ok(hres == S_OK, "Show failed: %08lx\n", hres);
 620
 621                 CHECK_CALLED(CanInPlaceActivate);
 622                 CHECK_CALLED(GetWindowContext);
 623                 CHECK_CALLED(GetWindow);
 624                 CHECK_CALLED(OnInPlaceActivate);
 625                 CHECK_CALLED(SetStatusText);
 626                 CHECK_CALLED(Exec_SETPROGRESSMAX);
 627                 CHECK_CALLED(Exec_SETPROGRESSPOS);
 628
 629                 if(activeobj) {
 630                     hres = IOleInPlaceActiveObject_GetWindow(activeobj, &hwnd);
 631                     ok(hres == S_OK, "GetWindow failed: %08lx\n", hres);
 632                     ok(hwnd != NULL, "hwnd == NULL\n");
 633                     if(last_hwnd)
 634                         ok(hwnd == last_hwnd, "hwnd != last_hwnd\n");
 635                 }
 636             }
 637
 638             if(activeobj)
 639                 IOleInPlaceActiveObject_Release(activeobj);
 640         }
 641
 642         IOleDocument_Release(document);
 643     }
 644
 645     return S_OK;
 646 }
 647
 648 static const IOleDocumentSiteVtbl DocumentSiteVtbl = {
 649     DocumentSite_QueryInterface,
 650     DocumentSite_AddRef,
 651     DocumentSite_Release,
 652     DocumentSite_ActivateMe
 653 };
 654
 655 static IOleDocumentSite DocumentSite = { &DocumentSiteVtbl };
 656
 657 static HRESULT WINAPI DocHostUIHandler_QueryInterface(IDocHostUIHandler2 *iface, REFIID riid, void **ppv)
 658 {
 659     return QueryInterface(riid, ppv);
 660 }
 661
 662 static ULONG WINAPI DocHostUIHandler_AddRef(IDocHostUIHandler2 *iface)
 663 {
 664     return 2;
 665 }
 666
 667 static ULONG WINAPI DocHostUIHandler_Release(IDocHostUIHandler2 *iface)
 668 {
 669     return 1;
 670 }
 671
 672 static HRESULT WINAPI DocHostUIHandler_ShowContextMenu(IDocHostUIHandler2 *iface, DWORD dwID, POINT *ppt,
 673         IUnknown *pcmdtReserved, IDispatch *pdicpReserved)
 674 {
 675     ok(0, "unexpected call\n");
 676     return E_NOTIMPL;
 677 }
 678
 679 static HRESULT WINAPI DocHostUIHandler_GetHostInfo(IDocHostUIHandler2 *iface, DOCHOSTUIINFO *pInfo)
 680 {
 681     CHECK_EXPECT(GetHostInfo);
 682     ok(pInfo != NULL, "pInfo=NULL\n");
 683     if(pInfo) {
 684         ok(pInfo->cbSize == sizeof(DOCHOSTUIINFO), "pInfo->cbSize=%lu, expected %u\n",
 685                 pInfo->cbSize, sizeof(DOCHOSTUIINFO));
 686         ok(!pInfo->dwFlags, "pInfo->dwFlags=%08lx, expected 0\n", pInfo->dwFlags);
 687         pInfo->dwFlags = DOCHOSTUIFLAG_DISABLE_HELP_MENU | DOCHOSTUIFLAG_DISABLE_SCRIPT_INACTIVE
 688             | DOCHOSTUIFLAG_ACTIVATE_CLIENTHIT_ONLY | DOCHOSTUIFLAG_ENABLE_INPLACE_NAVIGATION
 689             | DOCHOSTUIFLAG_IME_ENABLE_RECONVERSION;
 690         ok(!pInfo->dwDoubleClick, "pInfo->dwDoubleClick=%08lx, expected 0\n", pInfo->dwDoubleClick);
 691         ok(!pInfo->pchHostCss, "pInfo->pchHostCss=%p, expected NULL\n", pInfo->pchHostCss);
 692         ok(!pInfo->pchHostNS, "pInfo->pchhostNS=%p, expected NULL\n", pInfo->pchHostNS);
 693     }
 694     return S_OK;
 695 }
 696
 697 static HRESULT WINAPI DocHostUIHandler_ShowUI(IDocHostUIHandler2 *iface, DWORD dwID,
 698         IOleInPlaceActiveObject *pActiveObject, IOleCommandTarget *pCommandTarget,
 699         IOleInPlaceFrame *pFrame, IOleInPlaceUIWindow *pDoc)
 700 {
 701     CHECK_EXPECT(ShowUI);
 702
 703     ok(dwID == 0, "dwID=%ld, expected 0\n", dwID);
 704     ok(pActiveObject != NULL, "pActiveObject = NULL\n");
 705     ok(pCommandTarget != NULL, "pCommandTarget = NULL\n");
 706     ok(pFrame == &InPlaceFrame, "pFrame=%p, expected %p\n", pFrame, &InPlaceFrame);
 707     ok(pDoc == NULL, "pDoc=%p, expected NULL\n", pDoc);
 708
 709     return S_OK;
 710 }
 711
 712 static HRESULT WINAPI DocHostUIHandler_HideUI(IDocHostUIHandler2 *iface)
 713 {
 714     CHECK_EXPECT(HideUI);
 715     return S_OK;
 716 }
 717
 718 static HRESULT WINAPI DocHostUIHandler_UpdateUI(IDocHostUIHandler2 *iface)
 719 {
 720     CHECK_EXPECT(UpdateUI);
 721     return S_OK;
 722 }
 723
 724 static HRESULT WINAPI DocHostUIHandler_EnableModeless(IDocHostUIHandler2 *iface, BOOL fEnable)
 725 {
 726     ok(0, "unexpected call\n");
 727     return E_NOTIMPL;
 728 }
 729
 730 static HRESULT WINAPI DocHostUIHandler_OnDocWindowActivate(IDocHostUIHandler2 *iface, BOOL fActivate)
 731 {
 732     ok(0, "unexpected call\n");
 733     return E_NOTIMPL;
 734 }
 735
 736 static HRESULT WINAPI DocHostUIHandler_OnFrameWindowActivate(IDocHostUIHandler2 *iface, BOOL fActivate)
 737 {
 738     ok(0, "unexpected call\n");
 739     return E_NOTIMPL;
 740 }
 741
 742 static HRESULT WINAPI DocHostUIHandler_ResizeBorder(IDocHostUIHandler2 *iface, LPCRECT prcBorder,
 743         IOleInPlaceUIWindow *pUIWindow, BOOL fRameWindow)
 744 {
 745     ok(0, "unexpected call\n");
 746     return E_NOTIMPL;
 747 }
 748
 749 static HRESULT WINAPI DocHostUIHandler_TranslateAccelerator(IDocHostUIHandler2 *iface, LPMSG lpMsg,
 750         const GUID *pguidCmdGroup, DWORD nCmdID)
 751 {
 752     ok(0, "unexpected call\n");
 753     return E_NOTIMPL;
 754 }
 755
 756 static HRESULT WINAPI DocHostUIHandler_GetOptionKeyPath(IDocHostUIHandler2 *iface,
 757         LPOLESTR *pchKey, DWORD dw)
 758 {
 759     CHECK_EXPECT(GetOptionKeyPath);
 760     ok(pchKey != NULL, "pchKey = NULL\n");
 761     ok(!dw, "dw=%ld, expected 0\n", dw);
 762     if(pchKey)
 763         ok(!*pchKey, "*pchKey=%p, expected NULL\n", *pchKey);
 764     return S_OK;
 765 }
 766
 767 static HRESULT WINAPI DocHostUIHandler_GetDropTarget(IDocHostUIHandler2 *iface,
 768         IDropTarget *pDropTarget, IDropTarget **ppDropTarget)
 769 {
 770     CHECK_EXPECT(GetDropTarget);
 771     /* TODO */
 772     return E_NOTIMPL;
 773 }
 774
 775 static HRESULT WINAPI DocHostUIHandler_GetExternal(IDocHostUIHandler2 *iface, IDispatch **ppDispatch)
 776 {
 777     ok(0, "unexpected call\n");
 778     return E_NOTIMPL;
 779 }
 780
 781 static HRESULT WINAPI DocHostUIHandler_TranslateUrl(IDocHostUIHandler2 *iface, DWORD dwTranslate,
 782         OLECHAR *pchURLIn, OLECHAR **ppchURLOut)
 783 {
 784     ok(0, "unexpected call\n");
 785     return E_NOTIMPL;
 786 }
 787
 788 static HRESULT WINAPI DocHostUIHandler_FilterDataObject(IDocHostUIHandler2 *iface, IDataObject *pDO,
 789         IDataObject **ppPORet)
 790 {
 791     ok(0, "unexpected call\n");
 792     return E_NOTIMPL;
 793 }
 794
 795 static HRESULT WINAPI DocHostUIHandler_GetOverrideKeyPath(IDocHostUIHandler2 *iface,
 796         LPOLESTR *pchKey, DWORD dw)
 797 {
 798     CHECK_EXPECT(GetOverrideKeyPath);
 799     ok(pchKey != NULL, "pchKey = NULL\n");
 800     if(pchKey)
 801         ok(!*pchKey, "*pchKey=%p, expected NULL\n", *pchKey);
 802     ok(!dw, "dw=%ld, xepected 0\n", dw);
 803     return S_OK;
 804 }
 805
 806 static const IDocHostUIHandler2Vtbl DocHostUIHandlerVtbl = {
 807     DocHostUIHandler_QueryInterface,
 808     DocHostUIHandler_AddRef,
 809     DocHostUIHandler_Release,
 810     DocHostUIHandler_ShowContextMenu,
 811     DocHostUIHandler_GetHostInfo,
 812     DocHostUIHandler_ShowUI,
 813     DocHostUIHandler_HideUI,
 814     DocHostUIHandler_UpdateUI,
 815     DocHostUIHandler_EnableModeless,
 816     DocHostUIHandler_OnDocWindowActivate,
 817     DocHostUIHandler_OnFrameWindowActivate,
 818     DocHostUIHandler_ResizeBorder,
 819     DocHostUIHandler_TranslateAccelerator,
 820     DocHostUIHandler_GetOptionKeyPath,
 821     DocHostUIHandler_GetDropTarget,
 822     DocHostUIHandler_GetExternal,
 823     DocHostUIHandler_TranslateUrl,
 824     DocHostUIHandler_FilterDataObject,
 825     DocHostUIHandler_GetOverrideKeyPath
 826 };
 827
 828 static IDocHostUIHandler2 DocHostUIHandler = { &DocHostUIHandlerVtbl };
 829
 830 static HRESULT WINAPI OleCommandTarget_QueryInterface(IOleCommandTarget *iface,
 831         REFIID riid, void **ppv)
 832 {
 833     return QueryInterface(riid, ppv);
 834 }
 835
 836 static ULONG WINAPI OleCommandTarget_AddRef(IOleCommandTarget *iface)
 837 {
 838     return 2;
 839 }
 840
 841 static ULONG WINAPI OleCommandTarget_Release(IOleCommandTarget *iface)
 842 {
 843     return 1;
 844 }
 845
 846 static HRESULT WINAPI OleCommandTarget_QueryStatus(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
 847         ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText)
 848 {
 849     ok(!pguidCmdGroup, "pguidCmdGroup != MULL\n");
 850     ok(cCmds == 1, "cCmds=%ld, expected 1\n", cCmds);
 851     ok(!pCmdText, "pCmdText != NULL\n");
 852
 853     switch(prgCmds[0].cmdID) {
 854     case OLECMDID_SETPROGRESSTEXT:
 855         CHECK_EXPECT(QueryStatus_SETPROGRESSTEXT);
 856         prgCmds[0].cmdf = OLECMDF_ENABLED;
 857         return S_OK;
 858     case OLECMDID_OPEN:
 859         CHECK_EXPECT(QueryStatus_OPEN);
 860         prgCmds[0].cmdf = 0;
 861         return S_OK;
 862     case OLECMDID_NEW:
 863         CHECK_EXPECT(QueryStatus_NEW);
 864         prgCmds[0].cmdf = 0;
 865         return S_OK;
 866     default:
 867         ok(0, "unexpected command %ld\n", prgCmds[0].cmdID);
 868     };
 869
 870     return E_FAIL;
 871 }
 872
 873 static HRESULT WINAPI OleCommandTarget_Exec(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
 874         DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 875 {
 876     if(!pguidCmdGroup) {
 877         switch(nCmdID) {
 878         case OLECMDID_SETPROGRESSMAX:
 879             CHECK_EXPECT2(Exec_SETPROGRESSMAX);
 880             ok(pvaIn != NULL, "pvaIn == NULL\n");
 881             if(pvaIn) {
 882                 ok(V_VT(pvaIn) == VT_I4, "V_VT(pvaIn)=%d, expected VT_I4\n", V_VT(pvaIn));
 883                 if(load_state == LD_NO)
 884                     ok(V_I4(pvaIn) == 0, "V_I4(pvaIn)=%ld, expected 0\n", V_I4(pvaIn));
 885             }
 886             ok(pvaOut == NULL, "pvaOut=%p, expected NULL\n", pvaOut);
 887             return S_OK;
 888         case OLECMDID_SETPROGRESSPOS:
 889             CHECK_EXPECT2(Exec_SETPROGRESSPOS);
 890             ok(pvaIn != NULL, "pvaIn == NULL\n");
 891             if(pvaIn) {
 892                 ok(V_VT(pvaIn) == VT_I4, "V_VT(pvaIn)=%d, expected VT_I4\n", V_VT(pvaIn));
 893                 if(load_state == LD_NO)
 894                     ok(V_I4(pvaIn) == 0, "V_I4(pvaIn)=%ld, expected 0\n", V_I4(pvaIn));
 895             }
 896             ok(pvaOut == NULL, "pvaOut=%p, expected NULL\n", pvaOut);
 897             return S_OK;
 898         case OLECMDID_HTTPEQUIV_DONE:
 899             CHECK_EXPECT(Exec_HTTPEQUIV_DONE);
 900             /* TODO */
 901             return S_OK;
 902         case OLECMDID_SETDOWNLOADSTATE:
 903             CHECK_EXPECT2(Exec_SETDOWNLOADSTATE);
 904             /* TODO */
 905             return S_OK;
 906         case OLECMDID_UPDATECOMMANDS:
 907             CHECK_EXPECT(Exec_UPDATECOMMANDS);
 908             /* TODO */
 909             return S_OK;
 910         case OLECMDID_SETTITLE:
 911             CHECK_EXPECT2(Exec_SETTITLE);
 912             /* TODO */
 913             return S_OK;
 914         case OLECMDID_HTTPEQUIV:
 915             CHECK_EXPECT2(Exec_HTTPEQUIV);
 916             /* TODO */
 917             return S_OK;
 918         default:
 919             ok(0, "unexpected command %ld\n", nCmdID);
 920             return E_FAIL;
 921         };
 922     }
 923
 924     if(IsEqualGUID(&CGID_ShellDocView, pguidCmdGroup)) {
 925         switch(nCmdID) {
 926         case 37:
 927             CHECK_EXPECT(Exec_ShellDocView_37);
 928             ok(pvaOut == NULL, "pvaOut=%p, expected NULL\n", pvaOut);
 929             ok(pvaIn != NULL, "pvaIn == NULL\n");
 930             if(pvaIn) {
 931                 ok(V_VT(pvaIn) == VT_I4, "V_VT(pvaIn)=%d, expected VT_I4\n", V_VT(pvaIn));
 932                 ok(V_I4(pvaIn) == 0, "V_I4(pvaIn)=%ld, expected 0\n", V_I4(pvaIn));
 933             }
 934             return S_OK;
 935         default:
 936             ok(0, "unexpected command %ld\n", nCmdID);
 937             return E_FAIL;
 938         };
 939     }
 940
 941     if(IsEqualGUID(&CGID_MSHTML, pguidCmdGroup)) {
 942         switch(nCmdID) {
 943         case 2315:
 944             CHECK_EXPECT(Exec_MSHTML_2315);
 945             /* TODO */
 946             return S_OK;
 947         default:
 948             ok(0, "unexpected command %ld\n", nCmdID);
 949         };
 950     }
 951
 952     if(IsEqualGUID(&CGID_Undocumented, pguidCmdGroup))
 953         return E_FAIL; /* TODO */
 954
 955     ok(0, "unexpected call\n");
 956     return E_NOTIMPL;
 957 }
 958
 959 static IOleCommandTargetVtbl OleCommandTargetVtbl = {
 960     OleCommandTarget_QueryInterface,
 961     OleCommandTarget_AddRef,
 962     OleCommandTarget_Release,
 963     OleCommandTarget_QueryStatus,
 964     OleCommandTarget_Exec
 965 };
 966
 967 static IOleCommandTarget OleCommandTarget = { &OleCommandTargetVtbl };
 968
 969 static HRESULT WINAPI Dispatch_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
 970 {
 971     return QueryInterface(riid, ppv);
 972 }
 973
 974 static ULONG WINAPI Dispatch_AddRef(IDispatch *iface)
 975 {
 976     return 2;
 977 }
 978
 979 static ULONG WINAPI Dispatch_Release(IDispatch *iface)
 980 {
 981     return 1;
 982 }
 983
 984 static HRESULT WINAPI Dispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
 985 {
 986     ok(0, "unexpected call\n");
 987     return E_NOTIMPL;
 988 }
 989
 990 static HRESULT WINAPI Dispatch_GetTypeInfo(IDispatch *iface, UINT iTInfo, LCID lcid,
 991         ITypeInfo **ppTInfo)
 992 {
 993     ok(0, "unexpected call\n");
 994     return E_NOTIMPL;
 995 }
 996
 997 static HRESULT WINAPI Dispatch_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *rgszNames,
 998         UINT cNames, LCID lcid, DISPID *rgDispId)
 999 {
1000     ok(0, "unexpected call\n");
1001     return E_NOTIMPL;
1002 }
1003
1004 static HRESULT WINAPI Dispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,
1005         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
1006         EXCEPINFO *pExcepInfo, UINT *puArgErr)
1007 {
1008     ok(IsEqualGUID(&IID_NULL, riid), "riid != IID_NULL\n");
1009     ok(pDispParams != NULL, "pDispParams == NULL\n");
1010     ok(pExcepInfo == NULL, "pExcepInfo=%p, expected NULL\n", pExcepInfo);
1011     ok(puArgErr != NULL, "puArgErr == NULL\n");
1012     ok(V_VT(pVarResult) == 0, "V_VT(pVarResult)=%d, expected 0\n", V_VT(pVarResult));
1013     ok(wFlags == DISPATCH_PROPERTYGET, "wFlags=%08x, expected DISPATCH_PROPERTYGET\n", wFlags);
1014
1015     switch(dispIdMember) {
1016     case DISPID_AMBIENT_USERMODE:
1017         CHECK_EXPECT2(Invoke_AMBIENT_USERMODE);
1018         V_VT(pVarResult) = VT_BOOL;
1019         V_BOOL(pVarResult) = VARIANT_TRUE;
1020         return S_OK;
1021     case DISPID_AMBIENT_DLCONTROL:
1022         CHECK_EXPECT2(Invoke_AMBIENT_DLCONTROL);
1023         return E_FAIL;
1024     case DISPID_AMBIENT_OFFLINEIFNOTCONNECTED:
1025         CHECK_EXPECT2(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1026         return E_FAIL;
1027     case DISPID_AMBIENT_SILENT:
1028         CHECK_EXPECT2(Invoke_AMBIENT_SILENT);
1029         V_VT(pVarResult) = VT_BOOL;
1030         V_BOOL(pVarResult) = VARIANT_FALSE;
1031         return S_OK;
1032     case DISPID_AMBIENT_USERAGENT:
1033         CHECK_EXPECT(Invoke_AMBIENT_USERAGENT);
1034         return E_FAIL;
1035     case DISPID_AMBIENT_PALETTE:
1036         CHECK_EXPECT(Invoke_AMBIENT_PALETTE);
1037         return E_FAIL;
1038     };
1039
1040     ok(0, "unexpected dispid %ld\n", dispIdMember);
1041     return E_FAIL;
1042 }
1043
1044 static IDispatchVtbl DispatchVtbl = {
1045     Dispatch_QueryInterface,
1046     Dispatch_AddRef,
1047     Dispatch_Release,
1048     Dispatch_GetTypeInfoCount,
1049     Dispatch_GetTypeInfo,
1050     Dispatch_GetIDsOfNames,
1051     Dispatch_Invoke
1052 };
1053
1054 static IDispatch Dispatch = { &DispatchVtbl };
1055
1056 static HRESULT QueryInterface(REFIID riid, void **ppv)
1057 {
1058     *ppv = NULL;
1059
1060     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IOleClientSite, riid))
1061         *ppv = &ClientSite;
1062     else if(IsEqualGUID(&IID_IOleDocumentSite, riid))
1063         *ppv = &DocumentSite;
1064     else if(IsEqualGUID(&IID_IDocHostUIHandler, riid) || IsEqualGUID(&IID_IDocHostUIHandler2, riid))
1065         *ppv = &DocHostUIHandler;
1066     else if(IsEqualGUID(&IID_IOleContainer, riid))
1067         *ppv = &OleContainer;
1068     else if(IsEqualGUID(&IID_IOleWindow, riid) || IsEqualGUID(&IID_IOleInPlaceSite, riid))
1069         *ppv = &InPlaceSite;
1070     else if(IsEqualGUID(&IID_IOleInPlaceUIWindow, riid) || IsEqualGUID(&IID_IOleInPlaceFrame, riid))
1071         *ppv = &InPlaceFrame;
1072     else if(IsEqualGUID(&IID_IOleCommandTarget , riid))
1073         *ppv = &OleCommandTarget;
1074     else if(IsEqualGUID(&IID_IDispatch, riid))
1075         *ppv = &Dispatch;
1076
1077     /* TODO:
1078      * IServiceProvider
1079      * IOleInPlaceSiteEx
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 void test_exec_onunload(IUnknown *unk)
1369 {
1370     IOleCommandTarget *cmdtrg;
1371     VARIANT var;
1372     HRESULT hres;
1373
1374     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
1375     ok(hres == S_OK, "QueryInterface(IID_IOleCommandTarget) failed: %08lx\n", hres);
1376     if(FAILED(hres))
1377         return;
1378
1379     memset(&var, 0x0a, sizeof(var));
1380     hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_ONUNLOAD,
1381             OLECMDEXECOPT_DODEFAULT, NULL, &var);
1382     ok(hres == S_OK, "Exec(..., OLECMDID_ONUNLOAD, ...) failed: %08lx\n", hres);
1383     ok(V_VT(&var) == VT_BOOL, "V_VT(var)=%d, expected VT_BOOL\n", V_VT(&var));
1384     ok(V_BOOL(&var) == VARIANT_TRUE, "V_BOOL(var)=%x, expected VARIANT_TRUE\n", V_BOOL(&var));
1385
1386     hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_ONUNLOAD,
1387             OLECMDEXECOPT_DODEFAULT, NULL, NULL);
1388     ok(hres == S_OK, "Exec(..., OLECMDID_ONUNLOAD, ...) failed: %08lx\n", hres);
1389
1390     IOleCommandTarget_Release(cmdtrg);
1391 }
1392
1393 static HWND create_container_window(void)
1394 {
1395     static const WCHAR wszHTMLDocumentTest[] =
1396         {'H','T','M','L','D','o','c','u','m','e','n','t','T','e','s','t',0};
1397     static WNDCLASSEXW wndclass = {
1398         sizeof(WNDCLASSEXW),
1399         0,
1400         wnd_proc,
1401         0, 0, NULL, NULL, NULL, NULL, NULL,
1402         wszHTMLDocumentTest,
1403         NULL
1404     };
1405
1406     RegisterClassExW(&wndclass);
1407     return CreateWindowW(wszHTMLDocumentTest, wszHTMLDocumentTest,
1408             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
1409             CW_USEDEFAULT, NULL, NULL, NULL, NULL);
1410 }
1411
1412 static HRESULT test_DoVerb(IOleObject *oleobj)
1413 {
1414     RECT rect = {0,0,500,500};
1415     HRESULT hres;
1416
1417     if(!container_locked) {
1418         SET_EXPECT(GetContainer);
1419         SET_EXPECT(LockContainer);
1420     }
1421     SET_EXPECT(ActivateMe);
1422     expect_LockContainer_fLock = TRUE;
1423
1424     hres = IOleObject_DoVerb(oleobj, OLEIVERB_SHOW, NULL, &ClientSite, -1, container_hwnd, &rect);
1425     if(FAILED(hres))
1426         return hres;
1427     ok(hres == S_OK, "DoVerb failed: %08lx\n", hres);
1428
1429     if(!container_locked) {
1430         CHECK_CALLED(GetContainer);
1431         CHECK_CALLED(LockContainer);
1432         container_locked = TRUE;
1433     }
1434     CHECK_CALLED(ActivateMe);
1435
1436     return hres;
1437 }
1438
1439 #define CLIENTSITE_EXPECTPATH 0x00000001
1440 #define CLIENTSITE_SETNULL    0x00000002
1441 #define CLIENTSITE_DONTSET    0x00000004
1442
1443 static void test_ClientSite(IOleObject *oleobj, DWORD flags)
1444 {
1445     IOleClientSite *clientsite;
1446     HRESULT hres;
1447
1448     if(flags & CLIENTSITE_SETNULL) {
1449         hres = IOleObject_GetClientSite(oleobj, &clientsite);
1450         ok(clientsite == &ClientSite, "clientsite=%p, expected %p\n", clientsite, &ClientSite);
1451
1452         hres = IOleObject_SetClientSite(oleobj, NULL);
1453         ok(hres == S_OK, "SetClientSite failed: %08lx\n", hres);
1454
1455         set_clientsite = FALSE;
1456     }
1457
1458     if(flags & CLIENTSITE_DONTSET)
1459         return;
1460
1461     hres = IOleObject_GetClientSite(oleobj, &clientsite);
1462     ok(hres == S_OK, "GetClientSite failed: %08lx\n", hres);
1463     ok(clientsite == (set_clientsite ? &ClientSite : NULL), "GetClientSite() = %p, expected %p\n",
1464             clientsite, set_clientsite ? &ClientSite : NULL);
1465
1466     if(!set_clientsite) {
1467         SET_EXPECT(GetHostInfo);
1468         if(flags & CLIENTSITE_EXPECTPATH) {
1469             SET_EXPECT(GetOptionKeyPath);
1470             SET_EXPECT(GetOverrideKeyPath);
1471         }
1472         SET_EXPECT(GetWindow);
1473         SET_EXPECT(QueryStatus_SETPROGRESSTEXT);
1474         SET_EXPECT(Exec_SETPROGRESSMAX);
1475         SET_EXPECT(Exec_SETPROGRESSPOS);
1476         SET_EXPECT(Invoke_AMBIENT_USERMODE);
1477         SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1478         SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1479         SET_EXPECT(Invoke_AMBIENT_SILENT);
1480         SET_EXPECT(Invoke_AMBIENT_USERAGENT);
1481         SET_EXPECT(Invoke_AMBIENT_PALETTE);
1482
1483         hres = IOleObject_SetClientSite(oleobj, &ClientSite);
1484         ok(hres == S_OK, "SetClientSite failed: %08lx\n", hres);
1485
1486         CHECK_CALLED(GetHostInfo);
1487         if(flags & CLIENTSITE_EXPECTPATH) {
1488             CHECK_CALLED(GetOptionKeyPath);
1489             CHECK_CALLED(GetOverrideKeyPath);
1490         }
1491         CHECK_CALLED(GetWindow);
1492         CHECK_CALLED(QueryStatus_SETPROGRESSTEXT);
1493         CHECK_CALLED(Exec_SETPROGRESSMAX);
1494         CHECK_CALLED(Exec_SETPROGRESSPOS);
1495         CHECK_CALLED(Invoke_AMBIENT_USERMODE);
1496         CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1497         CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1498         CHECK_CALLED(Invoke_AMBIENT_SILENT);
1499         CHECK_CALLED(Invoke_AMBIENT_USERAGENT);
1500         CHECK_CALLED(Invoke_AMBIENT_PALETTE);
1501
1502         set_clientsite = TRUE;
1503     }
1504
1505     hres = IOleObject_SetClientSite(oleobj, &ClientSite);
1506     ok(hres == S_OK, "SetClientSite failed: %08lx\n", hres);
1507
1508     hres = IOleObject_GetClientSite(oleobj, &clientsite);
1509     ok(hres == S_OK, "GetClientSite failed: %08lx\n", hres);
1510     ok(clientsite == &ClientSite, "GetClientSite() = %p, expected %p\n", clientsite, &ClientSite);
1511 }
1512
1513 static void test_OnAmbientPropertyChange(IUnknown *unk)
1514 {
1515     IOleControl *control = NULL;
1516     HRESULT hres;
1517
1518     hres = IUnknown_QueryInterface(unk, &IID_IOleControl, (void**)&control);
1519     ok(hres == S_OK, "QueryInterface(IID_IOleControl failed: %08lx\n", hres);
1520     if(FAILED(hres))
1521         return;
1522
1523     SET_EXPECT(Invoke_AMBIENT_USERMODE);
1524     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_USERMODE);
1525     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1526     CHECK_CALLED(Invoke_AMBIENT_USERMODE);
1527
1528     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1529     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_DLCONTROL);
1530     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1531     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1532
1533     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1534     SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1535     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_OFFLINEIFNOTCONNECTED);
1536     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1537     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1538     CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1539
1540     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1541     SET_EXPECT(Invoke_AMBIENT_SILENT);
1542     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_SILENT);
1543     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1544     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1545     CHECK_CALLED(Invoke_AMBIENT_SILENT);
1546
1547     SET_EXPECT(Invoke_AMBIENT_USERAGENT);
1548     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_USERAGENT);
1549     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1550     CHECK_CALLED(Invoke_AMBIENT_USERAGENT);
1551
1552     SET_EXPECT(Invoke_AMBIENT_PALETTE);
1553     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_PALETTE);
1554     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1555     CHECK_CALLED(Invoke_AMBIENT_PALETTE);
1556
1557     IOleControl_Release(control);
1558 }
1559
1560
1561
1562 static void test_OnAmbientPropertyChange2(IUnknown *unk)
1563 {
1564     IOleControl *control = NULL;
1565     HRESULT hres;
1566
1567     hres = IUnknown_QueryInterface(unk, &IID_IOleControl, (void**)&control);
1568     ok(hres == S_OK, "QueryInterface(IID_IOleControl failed: %08lx\n", hres);
1569     if(FAILED(hres))
1570         return;
1571
1572     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_PALETTE);
1573     ok(hres == S_OK, "OnAmbientPropertyChange failed: %08lx\n", hres);
1574
1575     IOleControl_Release(control);
1576 }
1577
1578 static void test_Close(IUnknown *unk, BOOL set_client)
1579 {
1580     IOleObject *oleobj = NULL;
1581     HRESULT hres;
1582
1583     hres = IUnknown_QueryInterface(unk, &IID_IOleObject, (void**)&oleobj);
1584     ok(hres == S_OK, "QueryInterface(IID_IOleObject) failed: %08lx\n", hres);
1585     if(FAILED(hres))
1586         return;
1587
1588     SET_EXPECT(GetContainer);
1589     SET_EXPECT(LockContainer);
1590     expect_LockContainer_fLock = FALSE;
1591     hres = IOleObject_Close(oleobj, OLECLOSE_NOSAVE);
1592     ok(hres == S_OK, "Close failed: %08lx\n", hres);
1593     CHECK_CALLED(GetContainer);
1594     CHECK_CALLED(LockContainer);
1595     container_locked = FALSE;
1596
1597     if(set_client)
1598         test_ClientSite(oleobj, CLIENTSITE_SETNULL|CLIENTSITE_DONTSET);
1599
1600     IOleObject_Release(oleobj);
1601 }
1602
1603 static void test_InPlaceDeactivate(IUnknown *unk, BOOL expect_call)
1604 {
1605     IOleInPlaceObjectWindowless *windowlessobj = NULL;
1606     HRESULT hres;
1607
1608     hres = IUnknown_QueryInterface(unk, &IID_IOleInPlaceObjectWindowless,
1609             (void**)&windowlessobj);
1610     ok(hres == S_OK, "QueryInterface(IID_IOleInPlaceObjectWindowless) failed: %08lx\n", hres);
1611     if(FAILED(hres))
1612         return;
1613
1614     if(expect_call) SET_EXPECT(OnInPlaceDeactivate);
1615     hres = IOleInPlaceObjectWindowless_InPlaceDeactivate(windowlessobj);
1616     ok(hres == S_OK, "InPlaceDeactivate failed: %08lx\n", hres);
1617     if(expect_call) CHECK_CALLED(OnInPlaceDeactivate);
1618
1619     IOleInPlaceObjectWindowless_Release(windowlessobj);
1620 }
1621
1622 static HRESULT test_Activate(IUnknown *unk, DWORD flags)
1623 {
1624     IOleObject *oleobj = NULL;
1625     GUID guid;
1626     HRESULT hres;
1627
1628     last_hwnd = hwnd;
1629
1630     if(view)
1631         IOleDocumentView_Release(view);
1632     view = NULL;
1633
1634     hres = IUnknown_QueryInterface(unk, &IID_IOleObject, (void**)&oleobj);
1635     ok(hres == S_OK, "QueryInterface(IID_IOleObject) failed: %08lx\n", hres);
1636     if(FAILED(hres))
1637         return hres;
1638
1639     hres = IOleObject_GetUserClassID(oleobj, NULL);
1640     ok(hres == E_INVALIDARG, "GetUserClassID returned: %08lx, expected E_INVALIDARG\n", hres);
1641
1642     hres = IOleObject_GetUserClassID(oleobj, &guid);
1643     ok(hres == S_OK, "GetUserClassID failed: %08lx\n", hres);
1644     ok(IsEqualGUID(&guid, &CLSID_HTMLDocument), "guid != CLSID_HTMLDocument\n");
1645
1646     test_ClientSite(oleobj, flags);
1647     test_InPlaceDeactivate(unk, FALSE);
1648
1649     hres = test_DoVerb(oleobj);
1650
1651     IOleObject_Release(oleobj);
1652     return hres;
1653 }
1654
1655 static void test_Window(IUnknown *unk, BOOL expect_success)
1656 {
1657     IOleInPlaceActiveObject *activeobject = NULL;
1658     HWND tmp_hwnd;
1659     HRESULT hres;
1660
1661     hres = IOleDocumentView_QueryInterface(view, &IID_IOleInPlaceActiveObject, (void**)&activeobject);
1662     ok(hres == S_OK, "Could not get IOleInPlaceActiveObject interface: %08lx\n", hres);
1663     if(FAILED(hres))
1664         return;
1665
1666     hres = IOleInPlaceActiveObject_GetWindow(activeobject, &tmp_hwnd);
1667
1668     if(expect_success) {
1669         ok(hres == S_OK, "GetWindow failed: %08lx\n", hres);
1670         ok(tmp_hwnd == hwnd, "tmp_hwnd=%p, expected %p\n", tmp_hwnd, hwnd);
1671     }else {
1672         ok(hres == E_FAIL, "GetWindow returned %08lx, expected E_FAIL\n", hres);
1673         ok(IsWindow(hwnd), "hwnd is destroyed\n");
1674     }
1675
1676     IOleInPlaceActiveObject_Release(activeobject);
1677 }
1678
1679 static void test_CloseView(void)
1680 {
1681     IOleInPlaceSite *inplacesite = (IOleInPlaceSite*)0xff00ff00;
1682     HRESULT hres;
1683
1684     if(!view)
1685         return;
1686
1687     hres = IOleDocumentView_Show(view, FALSE);
1688     ok(hres == S_OK, "Show failed: %08lx\n", hres);
1689
1690     hres = IOleDocumentView_CloseView(view, 0);
1691     ok(hres == S_OK, "CloseView failed: %08lx\n", hres);
1692
1693     hres = IOleDocumentView_SetInPlaceSite(view, NULL);
1694     ok(hres == S_OK, "SetInPlaceSite failed: %08lx\n", hres);
1695
1696     hres = IOleDocumentView_GetInPlaceSite(view, &inplacesite);
1697     ok(hres == S_OK, "SetInPlaceSite failed: %08lx\n", hres);
1698     ok(inplacesite == NULL, "inplacesite=%p, expected NULL\n", inplacesite);
1699 }
1700
1701 static void test_UIDeactivate(void)
1702 {
1703     HRESULT hres;
1704
1705     if(call_UIActivate) {
1706         SET_EXPECT(SetActiveObject);
1707         SET_EXPECT(HideUI);
1708         SET_EXPECT(OnUIDeactivate);
1709     }
1710
1711     expect_SetActiveObject_active = FALSE;
1712     hres = IOleDocumentView_UIActivate(view, FALSE);
1713     ok(hres == S_OK, "UIActivate failed: %08lx\n", hres);
1714
1715     if(call_UIActivate) {
1716         CHECK_CALLED(SetActiveObject);
1717         CHECK_CALLED(HideUI);
1718         CHECK_CALLED(OnUIDeactivate);
1719     }
1720 }
1721
1722 static void test_Hide(void)
1723 {
1724     HRESULT hres;
1725
1726     if(!view)
1727         return;
1728
1729     hres = IOleDocumentView_Show(view, FALSE);
1730     ok(hres == S_OK, "Show failed: %08lx\n", hres);
1731 }
1732
1733 static HRESULT create_document(IUnknown **unk)
1734 {
1735     HRESULT hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
1736             &IID_IUnknown, (void**)unk);
1737     ok(hres == S_OK, "CoCreateInstance failed: %08lx\n", hres);
1738     return hres;
1739 }
1740
1741 static void test_Navigate(IUnknown *unk)
1742 {
1743     IHlinkTarget *hlink;
1744     HRESULT hres;
1745
1746     hres = IUnknown_QueryInterface(unk, &IID_IHlinkTarget, (void**)&hlink);
1747     ok(hres == S_OK, "QueryInterface(IID_IHlinkTarget) failed: %08lx\n", hres);
1748
1749     SET_EXPECT(ActivateMe);
1750     hres = IHlinkTarget_Navigate(hlink, 0, NULL);
1751     ok(hres == S_OK, "Navigate failed: %08lx\n", hres);
1752     CHECK_CALLED(ActivateMe);
1753
1754     IHlinkTarget_Release(hlink);
1755 }
1756
1757 static void test_HTMLDocument(void)
1758 {
1759     IUnknown *unk;
1760     HRESULT hres;
1761     ULONG ref;
1762
1763     hwnd = last_hwnd = NULL;
1764
1765     hres = create_document(&unk);
1766     if(FAILED(hres))
1767         return;
1768
1769     test_Persist(unk);
1770     if(load_state == LD_NO)
1771         test_OnAmbientPropertyChange2(unk);
1772
1773     hres = test_Activate(unk, CLIENTSITE_EXPECTPATH);
1774     if(FAILED(hres)) {
1775         IUnknown_Release(unk);
1776         return;
1777     }
1778
1779 #ifdef DOWNLOAD_TEST
1780     if(load_state == LD_DOLOAD)
1781         test_download();
1782 #endif
1783
1784     test_OleCommandTarget_fail(unk);
1785     test_OleCommandTarget(unk);
1786     test_OnAmbientPropertyChange(unk);
1787     test_Window(unk, TRUE);
1788     test_UIDeactivate();
1789     test_OleCommandTarget(unk);
1790     test_Window(unk, TRUE);
1791     test_InPlaceDeactivate(unk, TRUE);
1792
1793     /* Calling test_OleCommandTarget here couses Segmentation Fault with native
1794      * MSHTML. It doesn't with Wine. */
1795
1796     test_Window(unk, FALSE);
1797     test_Hide();
1798     test_InPlaceDeactivate(unk, FALSE);
1799     test_CloseView();
1800     test_Close(unk, FALSE);
1801
1802     /* Activate HTMLDocument again */
1803     test_Activate(unk, CLIENTSITE_SETNULL);
1804     test_Window(unk, TRUE);
1805     test_OleCommandTarget(unk);
1806     test_UIDeactivate();
1807     test_InPlaceDeactivate(unk, TRUE);
1808     test_Close(unk, FALSE);
1809
1810     /* Activate HTMLDocument again, this time without UIActivate */
1811     call_UIActivate = FALSE;
1812     test_Activate(unk, CLIENTSITE_SETNULL);
1813     test_Window(unk, TRUE);
1814     test_UIDeactivate();
1815     test_InPlaceDeactivate(unk, TRUE);
1816     test_CloseView();
1817     test_CloseView();
1818     test_Close(unk, TRUE);
1819     test_OnAmbientPropertyChange2(unk);
1820
1821     if(view)
1822         IOleDocumentView_Release(view);
1823     view = NULL;
1824
1825     ok(IsWindow(hwnd), "hwnd is destroyed\n");
1826
1827     ref = IUnknown_Release(unk);
1828     ok(ref == 0, "ref=%ld, expected 0\n", ref);
1829
1830     ok(!IsWindow(hwnd), "hwnd is not destroyed\n");
1831
1832 }
1833
1834 static void test_HTMLDocument_hlink(void)
1835 {
1836     IUnknown *unk;
1837     HRESULT hres;
1838     ULONG ref;
1839
1840     hwnd = last_hwnd = NULL;
1841
1842     hres = create_document(&unk);
1843     if(FAILED(hres))
1844         return;
1845
1846     test_Persist(unk);
1847     test_Navigate(unk);
1848
1849 #ifdef DOWNLOAD_TEST
1850     test_download();
1851 #endif
1852
1853     test_exec_onunload(unk);
1854     test_Window(unk, TRUE);
1855     test_InPlaceDeactivate(unk, TRUE);
1856     test_Close(unk, FALSE);
1857
1858     if(view)
1859         IOleDocumentView_Release(view);
1860     view = NULL;
1861
1862     ref = IUnknown_Release(unk);
1863     ok(ref == 0, "ref=%ld, expected 0\n", ref);
1864 }
1865
1866 START_TEST(htmldoc)
1867 {
1868     CoInitialize(NULL);
1869     container_hwnd = create_container_window();
1870
1871     load_state = LD_NO;
1872     test_HTMLDocument();
1873     load_state = LD_DOLOAD;
1874     test_HTMLDocument();
1875     load_state = LD_DOLOAD;
1876     test_HTMLDocument_hlink();
1877
1878     DestroyWindow(container_hwnd);
1879     CoUninitialize();
1880 }