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