dlls/mshtml/tests/htmldoc.c

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